1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
|
//! CLI tool to generate all valid meta-affine sequences of a given length.
//!
//! Usage: generate [options] <length>
//!
//! Example:
//! generate 5
//! generate --pretty 5
//! generate 5 --neg-first-outer --backward
//! generate 5 --render --output-dir output
//!
//! This will list all valid meta-affine sequences of length 5 and print the total count.
//! With --pretty, values are displayed in nested bracket notation.
//! With --render, sequences are rendered to SVG files using LilyPond.
use morphology::sequence::{
generate_all_sequences, SequenceOptions, PrecedenceOrder, SortingMethod,
SortingDirection, LengthSorting
};
use std::env;
use std::process;
fn main() {
// Parse command-line arguments
let args: Vec<String> = env::args().collect();
// Check for flags
let pretty = args.contains(&"--pretty".to_string());
let neg_first_outer = args.contains(&"--neg-first-outer".to_string());
let neg_first_inner = args.contains(&"--neg-first-inner".to_string());
let breadth_first = args.contains(&"--breadth-first".to_string());
let backward = args.contains(&"--backward".to_string());
let interpolate_length = args.contains(&"--interpolate-length".to_string());
// Rendering flags
let render = args.contains(&"--render".to_string());
let keep_temp = args.contains(&"--keep-temp".to_string());
let parallel = args.contains(&"--parallel".to_string());
// Extract --output-dir value
let output_dir = args.iter()
.position(|arg| arg == "--output-dir")
.and_then(|pos| args.get(pos + 1))
.map(|s| s.as_str())
.unwrap_or("output");
// Extract --max-batch-size value
let max_batch_size: Option<usize> = args.iter()
.position(|arg| arg == "--max-batch-size")
.and_then(|pos| args.get(pos + 1))
.and_then(|s| s.parse().ok());
// Filter out flags to get positional arguments
// Also filter out values that come after flags with parameters
let mut skip_next = false;
let positional: Vec<&String> = args.iter()
.skip(1) // Skip program name
.filter(|arg| {
if skip_next {
skip_next = false;
return false;
}
if *arg == "--output-dir" || *arg == "--max-batch-size" {
skip_next = true;
return false;
}
!arg.starts_with("--")
})
.collect();
if positional.len() != 1 {
eprintln!("Usage: {} [options] <length>", args[0]);
eprintln!("\nGenerates all valid meta-affine sequences of the specified length.");
eprintln!("\nOptions:");
eprintln!(" --pretty Display values in nested bracket notation");
eprintln!("\nSorting options:");
eprintln!(" --neg-first-outer Use IncreasingNegativeFirst for outer precedence");
eprintln!(" --neg-first-inner Use IncreasingNegativeFirst for inner precedence");
eprintln!(" --breadth-first Use BreadthFirst sorting method");
eprintln!(" --backward Sort sequences backward (last to first)");
eprintln!(" --interpolate-length Interpolate sequences of different lengths");
eprintln!("\nRendering options:");
eprintln!(" --render Render sequences to SVG files using LilyPond");
eprintln!(" --output-dir <DIR> Output directory for SVG files (default: output)");
eprintln!(" --keep-temp Keep temporary .ly files for debugging");
eprintln!(" --parallel Enable parallel rendering for better performance");
eprintln!(" --max-batch-size <N> Maximum sequences per batch (avoids overwhelming filesystem)");
eprintln!("\nExamples:");
eprintln!(" {} 5", args[0]);
eprintln!(" {} --pretty 5", args[0]);
eprintln!(" {} 5 --neg-first-outer --backward", args[0]);
eprintln!(" {} 5 --breadth-first --interpolate-length", args[0]);
eprintln!(" {} 5 --render --output-dir output", args[0]);
eprintln!(" {} 5 --render --parallel --max-batch-size 50", args[0]);
process::exit(1);
}
let length: usize = match positional[0].parse() {
Ok(n) => n,
Err(_) => {
eprintln!("Error: Length must be a positive integer");
eprintln!("Usage: {} [--pretty] <length>", args[0]);
process::exit(1);
}
};
if length == 0 {
println!("No valid sequences of length 0.");
println!("\nTotal sequences: 0");
return;
}
println!("Generating all valid meta-affine sequences of length {}...\n", length);
// Build sorting options from flags
let mut options = SequenceOptions::new();
if neg_first_outer {
options = options.outer_order(PrecedenceOrder::IncreasingNegativeFirst);
}
if neg_first_inner {
options = options.inner_order(PrecedenceOrder::IncreasingNegativeFirst);
}
if breadth_first {
options = options.sorting_method(SortingMethod::BreadthFirst);
}
if backward {
options = options.sorting_direction(SortingDirection::Backward);
}
if interpolate_length {
options = options.length_sorting(LengthSorting::InterpolateLength);
}
// Generate all sequences with specified options
let sequences = generate_all_sequences(length, Some(options));
if render {
// Render sequences to SVG files
println!("Rendering {} sequences to SVG files...", sequences.len());
// Build rendering configuration
let mut config = morphology_img::RenderConfig::new(output_dir)
.keep_temp_files(keep_temp)
.parallel(parallel);
if let Some(batch_size) = max_batch_size {
config = config.max_batch_size(batch_size);
}
// Render sequences
match morphology_img::render_sequences(&sequences, &config) {
Ok(svg_paths) => {
println!("\nSuccessfully generated {} SVG files in '{}'", svg_paths.len(), output_dir);
println!("\nSVG files:");
for (i, path) in svg_paths.iter().enumerate() {
println!(" {}. {}", i + 1, path.display());
}
println!("\n{}", "=".repeat(70));
println!("Total sequences rendered: {}", sequences.len());
println!("{}", "=".repeat(70));
}
Err(e) => {
eprintln!("\nError rendering sequences: {}", e);
eprintln!("\nMake sure LilyPond is installed:");
eprintln!(" macOS: brew install lilypond");
eprintln!(" Ubuntu: sudo apt-get install lilypond");
eprintln!(" Windows: https://lilypond.org/download.html");
process::exit(1);
}
}
} else {
// Print sequences to stdout (original behavior)
let (open, close) = if pretty { ("", "") } else { ("[", "]") };
for (i, sequence) in sequences.iter().enumerate() {
print!("{}. {}", i + 1, open);
for (j, value) in sequence.values().iter().enumerate() {
if pretty {
print!("{}", value.pretty_print());
} else {
print!("{}", value);
}
if j < sequence.values().len() - 1 {
print!(", ");
}
}
println!("{}", close);
}
// Print summary
println!("\n{}", "=".repeat(70));
println!("Total sequences of length {}: {}", length, sequences.len());
println!("{}", "=".repeat(70));
}
}
|