The Math2Music system has evolved into a sophisticated multi-tier architecture supporting polyphonic music generation, professional audio output, and rich harmonic processing.
┌─────────────────────┐ ┌──────────────────────────┐ ┌──────────────────────┐
│ Enhanced UI │───▶│ Processing Pipeline │───▶│ Multi-Output │
│ (Program.cs) │ │ │ │ System │
│ • Configuration │ │ ┌─────────────────────┐ │ │ ┌──────────────────┐ │
│ • Timber Selection │ │ │ ExpressionParser │ │ │ │ WAV File Output │ │
│ • Format Selection │ │ │ (123+456 parsing) │ │ │ │ (Professional) │ │
│ • Base Freq/Duration│ │ └─────────────────────┘ │ │ └──────────────────┘ │
└─────────────────────┘ │ │ │ │ ┌──────────────────┐ │
│ │ ▼ │ │ │ BeepOutput │ │
▼ │ ┌─────────────────────┐ │ │ │ (Console Audio) │ │
┌─────────────────────┐ │ │ Processor Selection │ │ │ └──────────────────┘ │
│ Input Processing │ │ │ • SingleTrack │ │ │ ┌──────────────────┐ │
│ • Format Detection │────┼──│ • ReachSingleTrack │─┼────┤ │ Fluent API │ │
│ • Base32 Support │ │ │ • MultiTrack │ │ │ │ .OpenFile() │ │
│ • Constant Lookup │ │ └─────────────────────┘ │ │ │ .OpenLocation() │ │
│ • Polyphonic Parse │ │ │ │ │ └──────────────────┘ │
└─────────────────────┘ │ ▼ │ └──────────────────────┘
│ │ ┌─────────────────────┐ │ │
▼ │ │ Timber Processing │ │ ▼
┌─────────────────────┐ │ │ (Optional) │ │ ┌──────────────────────┐
│ Mathematical │ │ │ • 18+ Profiles │ │ │ Results Management │
│ Constants │ │ │ • Harmonic Shaping │ │ │ • File Organization │
│ (CommonNumbers) │ │ └─────────────────────┘ │ │ • Cross-Platform │
└─────────────────────┘ └──────────────────────────┘ │ • Auto-Launch │
└──────────────────────┘
ITonesProcessor
△
│
┌────────────────┼────────────────┐
│ │ │
SingleTrackProcessor ReachSingleTrack MultiTrackProcessor
│ Processor │
│ │ │ uses
└────────────────┼─────────────────┘
│
▼
┌─────────────────────┐
│ ExpressionParser │ (Static)
└─────────────────────┘
│
▼
ITonesOutput
△
┌──────────────┼──────────────┐
│ │ │
BeepOutput ITonesFileOutput TestOutput
△
│
┌────────────┼────────────┐
│ │ │
WavFileOutput OpenFileOutput OpenLocationOutput
│ │
└────────┬─────────────────┘
│
FileOutputExtensions (Fluent API)
│
▼
┌─────────────────┐
│ TimberProfiles │ (Static)
└─────────────────┘
│
▼
┌─────────────────────────┐
│ TimberSequenceProcessor │
└─────────────────────────┘
│
▼
┌─────────────────┐
│ Data Models │
│ ┌─────────────┐ │
│ │ Sequiention │◄┼─── contains ───┐
│ └─────────────┘ │ │
│ ┌─────────────┐ │ │
│ │ Tone │◄┼────────────────┘
│ └─────────────┘ │
│ ┌─────────────┐ │
│ │NumberFormats│ │ (Enum: Bin,Qad,Oct,Dec,Hex,Base32)
│ └─────────────┘ │
└─────────────────┘
│
▼
┌─────────────────┐
│ Utilities │
│ ┌─────────────┐ │
│ │CommonNumbers│ │ (Mathematical Constants)
│ └─────────────┘ │
│ ┌─────────────┐ │
│ │NumberConvert│ │ (Base Conversions)
│ └─────────────┘ │
└─────────────────┘
User Input → Configuration Setup → Expression Analysis → Processing Route Selection
│ │ │ │
│ ▼ ▼ │
│ ┌─────────────┐ ┌──────────────┐ │
│ │ Base Freq │ │ Polyphonic │ │
│ │ Duration │ │ Detection │ │
│ │ Timber │ │ (+ operator) │ │
│ └─────────────┘ └──────────────┘ │
│ │ │
▼ ▼ ▼
Format Detection ──────────────────► Expression Parsing ──────► Processor Selection
│ │ │
▼ ▼ ▼
Constant Lookup Individual Sequences [SingleTrack | ReachSingleTrack | MultiTrack]
(PI100, E1000, etc.) ["123", "456", "789"]
Selected Processor → Sequence Generation → Optional Timber Processing → Output Generation
│ │ │ │
│ ▼ ▼ │
│ ┌──────────────────┐ ┌─────────────────┐ │
│ │ Frequency Mapping│ │ Harmonic Shaping│ │
│ │ • Base32 Support │ │ • 18+ Profiles │ │
│ │ • Multi-Octave │ │ • Overtone Gen │ │
│ │ • Harmonic Groups│ │ • Timber Coeffs │ │
│ └──────────────────┘ └─────────────────┘ │
│ │ │ │
▼ ▼ ▼ ▼
┌─────────────┐ ┌──────────────┐ ┌──────────────┐ ┌─────────────┐
│SingleTrack │ │ReachSingle │ │MultiTrack │ │WAV File Gen │
│• Basic Mono │ │• Multi-Octave│ │• Polyphonic │ │• Stereo Mix │
│• Direct Map │ │• 4 Oct Groups│ │• Sync Timing │ │• Professional│
└─────────────┘ └──────────────┘ └──────────────┘ └─────────────┘
│ │ │ │
└────────────────────┼─────────────────────────┘ │
│ │
▼ ▼
┌──────────────────┐ ┌─────────────┐
│ Sequence Objects │ │Final Output │
│ • Tone Lists │ │• WAV Files │
│ • Duration Data │ │• Console │
│ • Timber Info │──────────────────────────────▶│• Auto-Open │
└──────────────────┘ └─────────────┘
Audio Sequences → Stereo Processing → Quality Enhancement → File Generation → Post-Processing
│ │ │ │ │
▼ ▼ ▼ ▼ ▼
┌─────────────┐ ┌─────────────┐ ┌──────────────────┐ ┌─────────────┐ ┌─────────────┐
│Polyphonic │ │Stereo Field │ │• Normalization │ │44.1kHz │ │.OpenFile() │
│Sync & Mix │ │Distribution │ │• Clipping Protect│ │16-bit Stereo│ │.OpenLocation│
│Multi-Track │ │Left/Right │ │• Freq Amplitude │ │WAV Format │ │Chain Methods│
└─────────────┘ └─────────────┘ └──────────────────┘ └─────────────┘ └─────────────┘
ITonesProcessorinterface with multiple sophisticated implementations:SingleTrackProcessor: Basic monophonic processingReachSingleTrackProcessor: Multi-octave harmonic processingMultiTrackProcessor: Polyphonic composition with synchronization
ITonesOutputandITonesFileOutputfor flexible output handling- Easy extensibility for new processing algorithms and output formats
- Output Decorators:
OpenFileOutput,OpenFileLocationOutput - Chainable Operations:
.OpenFile().OpenFileLocation()via extension methods - Wrapper Pattern: Decorators wrap base
WavFileOutputfunctionality - Cross-Platform Graceful Degradation: Windows-specific features with fallbacks
- Dynamic processor creation based on user choice and input analysis
- Expression-Based Selection: Automatic
MultiTrackProcessorfor polyphonic inputs - User-Controlled Selection: Choice between
SingleTrackandReachSingleTrack - Configuration-Driven: Timber profiles and audio parameters
- Base Processing Structure: Common tone generation pipeline
- Specialized Steps: Each processor implements specific frequency mapping logic
- Hook Methods: Optional timber processing and format conversion steps
- Consistent Interface: All processors follow same
Process()contract
TimberProfiles: Static collection of predefined instrument profilesCommonNumbers: Static mathematical constants collectionNumberFormats: Enum-based format definitions with Base32 support- Efficient Resource Access: No instantiation required for shared resources
public IList<Sequiention> Process(string input, NumberFormats outputFormat, NumberFormats inputFormat)
{
for each character in input:
if toneMap.ContainsKey(character):
frequency = baseToneHz * toneMap[character]
tone = new Tone(frequency, baseDurationMs)
sequenceBuilder.AddTone(tone)
return new List<Sequiention> { CreateSequiention(tones) }
}public IList<Sequiention> Process(string input, NumberFormats outputFormat, NumberFormats inputFormat)
{
var octaveGroups = new Dictionary<OctaveGroup, List<Tone>>();
for each character in input:
digitValue = GetDigitValue(character)
// Distribute across octave groups based on digit value
if (digitValue >= 0 && digitValue <= 3)
AddToOctaveGroup(OctaveGroup.Low, character)
else if (digitValue >= 4 && digitValue <= 7)
AddToOctaveGroup(OctaveGroup.MidLow, character)
else if (digitValue >= 8 && digitValue <= 11)
AddToOctaveGroup(OctaveGroup.MidHigh, character)
else if (digitValue >= 12)
AddToOctaveGroup(OctaveGroup.High, character)
return CreateSynchronizedSequences(octaveGroups)
}public IList<Sequiention> Process(string expression, NumberFormats outputFormat, NumberFormats inputFormat)
{
// Parse "123+456+789" into ["123", "456", "789"]
string[] sequences = ExpressionParser.ParseExpression(expression)
var polyphonicSequences = new List<Sequiention>()
foreach (string sequence in sequences):
var monoSequence = singleTrackProcessor.Process(sequence, outputFormat, inputFormat)
polyphonicSequences.AddRange(monoSequence)
return SynchronizeSequences(polyphonicSequences) // Time-align all sequences
}public Sequiention Process(Sequiention input)
{
var processedTones = new List<Tone>()
foreach (Tone originalTone in input.Tones):
var obertonFrequencies = new List<double>()
// Generate overtones using timber coefficients
for (int i = 0; i < timberCoefficients.Length; i++):
if (timberCoefficients[i] > 0):
overtonFreq = originalTone.BaseTone * (i + 1) // Harmonic series
obertonFrequencies.Add(overtonFreq)
processedTone = new Tone(obertonFrequencies.ToArray(), originalTone.Duration)
processedTones.Add(processedTone)
return new Sequiention { Tones = processedTones, Timber = timberCoefficients }
}private void GeneratePolyphonicWav(IList<Sequiention> sequences, string filePath)
{
// Calculate stereo positioning for each sequence
var stereoCoefficients = CalculateStereoCoefficients(sequences.Count)
// Dynamic amplitude scaling to prevent clipping
double sequenceScaling = CalculateSequenceAmplitudeScaling(sequences.Count)
// Mix all sequences with stereo positioning and frequency-based amplitude
for (int seqIndex = 0; seqIndex < sequences.Count; seqIndex++):
ApplyStereoPositioning(sequences[seqIndex], stereoCoefficients[seqIndex])
ApplyFrequencyBasedAmplitude(sequences[seqIndex])
MixIntoStereoChannels(leftChannel, rightChannel, sequences[seqIndex])
// Professional audio post-processing
NormalizeAudioData(leftChannel, rightChannel) // Prevent clipping
WriteWavFile(filePath, leftChannel, rightChannel)
}- Input Storage: O(n) where n = input string length
- Tone Generation:
- SingleTrack: O(n) for single sequence
- ReachSingleTrack: O(4n) for 4 octave groups
- MultiTrack: O(kn) where k = number of polyphonic sequences
- WAV Generation: O(duration × sampleRate) for audio buffer storage
- Timber Processing: O(n × overtones) for harmonic expansion
- Constant Lookup: O(1) hashtable access for mathematical constants
- Direct Mapping: O(n) - single pass through input characters
- Multi-Octave Processing: O(n) - still linear but with octave group distribution
- Polyphonic Processing: O(kn) where k = number of
+separated sequences - Binary/Base Conversion: O(n/groupSize) - efficient grouping algorithm
- WAV Generation: O(totalSamples) - linear audio processing
- Stereo Processing: O(sequences × samples) - polyphonic mixing
- Sample Rate: 44.1kHz professional quality
- Bit Depth: 16-bit signed PCM for compatibility and quality balance
- Stereo Processing: Intelligent left/right channel distribution
- Dynamic Range: Advanced normalization prevents clipping while preserving dynamics
- Frequency Response: Low-frequency amplitude boost for audibility
- Anti-Aliasing: Natural through mathematical sine wave generation
- 100-digit PI: ~30 seconds audio, ~2.7MB WAV file
- Polyphonic "123+456+789": 3 synchronized sequences, stereo positioned
- ReachSingleTrack with "ABCDEF": 4 octave groups, rich harmonic content
- Large Input (1000+ digits): Linear scaling, efficient memory management
- Timber Processing: Minimal overhead, real-time coefficient application
- Memory Efficiency: Linear growth with input size, no exponential blowup
- Processing Speed: Real-time generation for typical input sizes (< 1000 digits)
- File I/O: Efficient streaming WAV generation, no memory buffering of entire audio
- Cross-Platform: Identical performance characteristics across Windows/Linux/macOS
// Musical scale-based processor
public class ScaleProcessor : ITonesProcessor
{
// Map numbers to Pentatonic, Chromatic, or custom scales
// Support for key signatures and modal variations
// Automatic chord progression generation
}
// Rhythm and time signature processor
public class RhythmicProcessor : ITonesProcessor
{
// Apply time signatures (4/4, 3/4, 7/8)
// Generate rhythmic patterns from numerical input
// Support for swing timing and syncopation
}// MIDI file generation
public class MIDIOutput : ITonesFileOutput
{
// Generate MIDI sequences compatible with DAWs
// Support for multiple instruments and channels
// Musical notation export capability
}
// Real-time audio streaming
public class StreamingOutput : ITonesOutput
{
// Low-latency real-time audio output
// Cross-platform audio library integration (NAudio, PortAudio)
// Support for audio effects and filters
}// Timber profile system - easily extensible
TimberProfiles.Profiles.Add("CustomInstrument", new float[] { 1.0f, 0.8f, 0.3f })
// Mathematical constants - runtime extensible
CommonNumbers.Collection.Add("CUSTOM100", "your_100_digit_constant_here")
// Fluent API pattern - chainable operations
public static ITonesFileOutput CustomPostProcess(this ITonesFileOutput output)
{
return new CustomPostProcessOutput(output);
}// Advanced mathematical operators
public static class AdvancedExpressionParser
{
// Support for -, *, /, ^ operators
// Parentheses grouping: (123+456)*789
// Mathematical functions: sin(123), log(456)
// Conditional logic: 123>456?789:ABC
}The application now features a sophisticated runtime configuration system:
// Runtime configuration during application startup
Console.WriteLine("=== SESSION CONFIGURATION ===");
Console.Write("Enter base tone frequency in Hz (current: 180): ");
// User can customize base frequency
Console.Write("Enter base duration in milliseconds (current: 300): ");
// User can customize tone duration
// Timber profile selection from 18+ available profiles
var availableProfiles = TimberProfiles.GetAvailableProfiles();
// User selects from Piano, Guitar, Violin, Sawtooth, etc.- Base Frequency: User-adjustable via startup configuration (default: 180Hz)
- Tone Duration: User-adjustable via startup configuration (default: 300ms)
- Timber Profiles: Runtime selection from 18+ predefined profiles
- Processor Type: Choice between SingleTrack and ReachSingleTrack processors
- Input/Output Formats: Dynamic format selection including Base32
- Mathematical Constants: Extensive predefined collection with easy lookup
- No Configuration Files: All settings managed through interactive UI
- Session-Based: Configuration persists for entire application session
- Type-Safe: Enum-based format selection prevents invalid configurations
- Extensible: Easy to add new timber profiles and mathematical constants
- User-Friendly: Clear prompts with current values and available options
// Potential configuration file system
public class AudioSettings
{
public double BaseFrequency { get; set; } = 180;
public int ToneDuration { get; set; } = 300;
public string DefaultTimberProfile { get; set; } = "Piano";
public bool AutoOpenFiles { get; set; } = true;
public string OutputDirectory { get; set; } = "Results";
}
## Error Handling Strategy
### Current Robust Implementation ✅
The application now features comprehensive error handling across all components:
```csharp
// WAV file generation error handling
try
{
WriteWavFile(filePath, leftChannel, rightChannel);
Console.WriteLine($"WAV file saved: {filePath}");
}
catch (Exception ex)
{
Console.WriteLine($"Failed to create WAV file: {ex.Message}");
}
// Cross-platform graceful degradation
if (OperatingSystem.IsWindows())
{
Process.Start("explorer.exe", arguments);
Console.WriteLine($"Opened file location in Explorer");
}
else
{
Console.WriteLine("Opening file location is only supported on Windows.");
}
- Input Validation: Comprehensive null/empty input checking with user feedback
- Platform Compatibility: Graceful degradation for Windows-specific features
- File I/O Safety: Exception handling for WAV file creation and directory access
- Format Validation: Type-safe enum usage prevents invalid number format selection
- Timber Profile Validation: Profile existence checking with fallback messaging
- Mathematical Constant Lookup: Safe dictionary access with clear error messages
- Invalid Input Handling: 217 passing tests validate robust input processing
- Cross-Platform Behavior: Graceful Windows-specific feature fallback on Linux/macOS
- File System Errors: Directory creation and file writing error handling
- Memory Management: Safe handling of large input sequences without crashes
The application features extensive automated testing across all components:
-
All Processors Tested:
SingleTrackProcessor.Process()- Core conversion logic with multiple scenariosReachSingleTrackProcessor- Multi-octave processing and synchronizationMultiTrackProcessor- Polyphonic processing and timing validationTimberSequenceProcessor- Harmonic coefficient application
-
Audio Output Testing:
WavFileOutput- Professional audio generation with quality validationFluentAPI- Chainable operation testing with mock file system- Cross-platform behavior validation for Windows-specific features
-
Format and Parsing Testing:
NumberConverter- All base conversions including new Base32 supportExpressionParser- Polyphonic expression parsing with edge casesCommonNumbers- Mathematical constant lookup and substitution
-
Integration Testing (Implemented):
- End-to-end Processing: Complete input → processing → WAV output workflows
- Polyphonic Integration: Multi-track synchronization and stereo positioning
- Format Compatibility: All number format combinations with Base32
- Timber Profile Integration: Instrument simulation with harmonic generation
-
Performance and Duration Testing:
- Timing Accuracy: Validates exact audio duration calculations (30s for 100 digits)
- Memory Efficiency: Large input handling (1000+ digit sequences)
- Synchronization: Multi-octave and polyphonic timing precision
- Cross-Platform Performance: Identical behavior across operating systems
- 217 Tests Passing: Comprehensive coverage across all components
- Zero Failures: All implemented features thoroughly validated
- Edge Case Coverage: Null inputs, invalid formats, empty sequences handled
- Performance Validation: Large input sequences tested for memory and timing
- Cross-Platform Verification: Windows and non-Windows behavior validated