Tunes

https://docs.rs/tunes/latest
Admin
Tunes is a comprehensive music composition, synthesis, and audio generation library designed for...
Tokens:9,267,920
Snippets:54,450
Trust Score:9.7
Update:9 months ago
Show doc for...
Tokens:
Raw
### SpectralGate Initialization Example (Rust)

Source: https://docs.rs/tunes/latest/tunes/synthesis/spectral/struct.SpectralGate

A concise example of creating a new `SpectralGate` instance with specified FFT size, hop size, window type, and sample rate. This is the first step before configuring and using the gate.

```Rust
let gate = SpectralGate::new(2048, 512, WindowType::Hann, 44100.0);
```

--------------------------------

### Setup and Run Live Coding with Custom File (Rust)

Source: https://docs.rs/tunes/latest/tunes/live_coding/index

Guides through setting up and running live coding with a custom Rust file. Involves copying a template, updating crate imports, and then starting the live coding process. Changes in the custom file are reflected in real-time audio playback.

```rust
cp src/templates/live_template.rs my_live.rs
# Update imports from `crate::` to `tunes::`
cargo run --release --bin tunes-live my_live.rs
```

--------------------------------

### Get SampleSlice Start Time (Rust)

Source: https://docs.rs/tunes/latest/tunes/synthesis/slice/struct.SampleSlice

A method to retrieve the start time of a SampleSlice in seconds, relative to the parent sample's timeline.

```rust
pub fn start_time(&self) -> f32
```

--------------------------------

### SpectralPanner Initialization Example

Source: https://docs.rs/tunes/latest/tunes/synthesis/spectral/struct.SpectralPanner

Shows a basic example of how to initialize the SpectralPanner with common default values for FFT size, hop size, window type, and sample rate.

```rust
let panner = SpectralPanner::new(2048, 512, WindowType::Hann, 44100.0);
```

--------------------------------

### SpectralMorph Initialization and Configuration Example

Source: https://docs.rs/tunes/latest/tunes/synthesis/spectral/struct.SpectralMorph_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to create and configure a SpectralMorph instance. This includes setting the FFT size, hop size, window type, sample rate, target spectral shape, and morph amount.

```rust
let mut morph = SpectralMorph::new(2048, 512, WindowType::Hann, 44100.0);
morph.set_target(MorphTarget::Robot);
morph.set_morph_amount(0.7);
```

--------------------------------

### TrackIdGenerator: Struct Definition and Usage Example

Source: https://docs.rs/tunes/latest/tunes/track/ids/struct.TrackIdGenerator

Defines the TrackIdGenerator struct and provides an example of its usage for generating sequential track IDs. This generator starts IDs from 0 and increments with each call to next_id().

```rust
pub struct TrackIdGenerator { /* private fields */ }

// Example Usage:
use tunes::track::ids::TrackIdGenerator;

let mut gen = TrackIdGenerator::new();
assert_eq!(gen.next_id(), 0);
assert_eq!(gen.next_id(), 1);
assert_eq!(gen.next_id(), 2);
```

--------------------------------

### GET /octave

Source: https://docs.rs/tunes/latest/tunes/theory/microtonal/struct.Edo_search=u32+-%3E+bool

Retrieves all notes in one octave starting from a base frequency.

```APIDOC
## GET /octave

### Description
Get all notes in one octave starting from a base frequency.

### Method
GET

### Endpoint
`/octave`

### Parameters
#### Query Parameters
- **base_freq** (f32) - Required - The base frequency to start the octave from.

### Request Example
GET /octave?base_freq=440.0

### Response
#### Success Response (200)
- **notes** (Vec<f32>) - A vector of frequencies representing the notes in one octave.
```

--------------------------------

### STFT Initialization and Processing Example

Source: https://docs.rs/tunes/latest/tunes/synthesis/spectral/struct.STFT_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to initialize and use the STFT processor. It shows creating a new STFT instance with specified FFT and hop sizes, and then processing an audio frame by providing a callback function to modify the spectral data.

```rust
let mut stft = STFT::new(2048, 512, WindowType::Hann);

// Process audio frame by frame
let mut output = vec![0.0; 512];
stft.process(&mut output, |spectrum| {
    // Modify spectrum here (e.g., freeze, filter, etc.)
    // spectrum is a &mut [Complex<f32>] in frequency domain
});
```

--------------------------------

### SpectralDelay Initialization and Usage Example

Source: https://docs.rs/tunes/latest/tunes/synthesis/spectral/struct.SpectralDelay_search=std%3A%3Avec

Demonstrates how to create, configure, and use the SpectralDelay for audio processing. It shows setting base delay, feedback, frequency scaling, and mix, followed by processing an audio buffer. Requires the 'tunes' crate.

```rust
use tunes::synthesis::spectral::SpectralDelay;

// Create a new spectral delay instance
let mut delay = SpectralDelay::new(2048, 512, 44100.0);

// Configure delay parameters
delay.set_delay_time(200.0);      // 200ms base delay
delay.set_feedback(0.5);          // 50% feedback
delay.set_frequency_scale(0.5);   // Highs delay slightly more
delay.set_mix(0.5);               // 50% wet

// Prepare input and output buffers
let input = vec![0.0; 512];
let mut output = vec![0.0; 512];

// Process audio through the spectral delay
delay.process(&mut output, &input);
```

--------------------------------

### Simulate Approaching Sound (Rust)

Source: https://docs.rs/tunes/latest/tunes/engine/struct.AudioEngine_search=u32+-%3E+bool

This example simulates a sound approaching the listener from a distance, getting progressively louder. It uses `play_mixer_realtime` to start a sound composition and then iteratively updates the sound's Z-position using `set_sound_position` to move it from 50 meters to 2 meters away. The loop controls the speed of the approach, and `thread::sleep` adds a delay between position updates.

```rust
let sound_id = engine.play_mixer_realtime(&distance_comp.into_mixer())?;

// Move sound from far away (50m) to close (2m)
for i in 0..40 {
    let z = 50.0 - (i as f32 * 48.0 / 40.0);  // 50 to 2
    engine.set_sound_position(sound_id, 0.0, 0.0, z)?;
    thread::sleep(Duration::from_millis(100));
}

println!("  ✓ Sound approached from distance");
```

--------------------------------

### Print Next Steps and Examples in Rust

Source: https://docs.rs/tunes/latest/tunes/sequences/mathematical/powers_of_two/fn.generate_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides suggestions for further exploration by printing commands to run other examples, such as 'chaotic_sequences' and 'musical_sequences'. This guides the user on how to continue experimenting with the 'rs_tunes' project.

```rust
148    println!("\n📚 Try Next:");
149    println!("   cargo run --example chaotic_sequences");
150    println!("   cargo run --example musical_sequences\n");
```

--------------------------------

### Initialize and Process with SpectralRobotize

Source: https://docs.rs/tunes/latest/tunes/synthesis/spectral/struct.SpectralRobotize_search=

Demonstrates how to create a new SpectralRobotize instance, configure its mix level, and process an audio input buffer to produce a robotized output. Requires the 'tunes' crate and its 'synthesis::spectral' module.

```Rust
use tunes::synthesis::spectral::SpectralRobotize;
use tunes::WindowType;

// Initialize the effect
let mut robotize = SpectralRobotize::new(2048, 512, WindowType::Hann);
robotize.set_mix(1.0); // Set to 100% robotized

// Prepare input and output buffers
let input = vec![0.0; 512];
let mut output = vec![0.0; 512];

// Process the audio
robotize.process(&mut output, &input);
```

--------------------------------

### Basic SpectralGate Usage Example (Rust)

Source: https://docs.rs/tunes/latest/tunes/synthesis/spectral/struct.SpectralGate_search=std%3A%3Avec

A comprehensive example showing the initialization, threshold, attack, release, and processing steps for the SpectralGate. This provides a practical overview of its usage.

```rust
// Create spectral gate with 2048 FFT, 512 hop
let mut gate = SpectralGate::new(2048, 512, WindowType::Hann, 44100.0);

// Set threshold to -40 dB (bins below this get gated)
gate.set_threshold(-40.0);

// Fast attack, medium release
gate.set_attack(0.001);  // 1ms
gate.set_release(0.050); // 50ms

// Process audio - removes noise below -40 dB per frequency bin
let input = vec![0.0; 512];
let mut output = vec![0.0; 512];
gate.process(&mut output, &input);
```

--------------------------------

### GET /websites/rs_tunes/ascending

Source: https://docs.rs/tunes/latest/tunes/sequences/mathematical/arithmetic/fn.ascending

Generates an ascending arithmetic sequence starting from 1 with 12 terms.

```APIDOC
## GET /websites/rs_tunes/ascending

### Description
Generates an ascending arithmetic sequence.

### Method
GET

### Endpoint
/websites/rs_tunes/ascending

### Parameters
No parameters available.

### Request Example
```
(No request body for GET request)
```

### Response
#### Success Response (200)
- **sequence** (array of u32) - An array containing the ascending sequence.

#### Response Example
```json
{
  "sequence": [
    1,
    2,
    3,
    4,
    5,
    6,
    7,
    8,
    9,
    10,
    11,
    12
  ]
}
```
```

--------------------------------

### Create Guitar Arpeggio Pattern in Rust

Source: https://docs.rs/tunes/latest/tunes/instruments/struct.Instrument_search=

This example sets up a guitar instrument to perform an arpeggio. Similar to the harp example, it defines the instrument, its stereo panning, the start time, and the chord to be arpeggiated, along with the duration per note.

```Rust
comp.instrument("guitar_arp", &Instrument::harpsichord())
    .pan(0.0)
    .at(11.5)
    .arpeggiate(D4_MAJOR, 0.12);
```

--------------------------------

### SpectralWiden example usage

Source: https://docs.rs/tunes/latest/tunes/synthesis/spectral/struct.SpectralWiden_search=

Demonstrates how to create and configure a SpectralWiden instance. It shows initialization with parameters and setting the stereo width.

```rust
let mut widen = SpectralWiden::new(2048, 512, WindowType::Hann, 44100.0);
widen.set_width(1.5);
```

--------------------------------

### SpectralExciter Initialization and Usage Example

Source: https://docs.rs/tunes/latest/tunes/synthesis/spectral/struct.SpectralExciter

Demonstrates how to create a new SpectralExciter instance and configure its core parameters for audio processing. It shows setting the crossover frequency, drive, and mix levels.

```rust
let mut exciter = SpectralExciter::new(2048, 512, WindowType::Hann, 44100.0);
exciter.set_frequency(3000.0);  // Excite above 3kHz
exciter.set_drive(2.0);          // Moderate harmonic drive
exciter.set_mix(0.5);            // 50% wet
```

--------------------------------

### Example of Track and Composition Setup (Rust)

Source: https://docs.rs/tunes/latest/src/tunes/track/mod.rs_search=

Demonstrates how to create a new track, set its volume and panning, and then use it within a Composition to add notes. This example showcases basic track manipulation and composition building.

```rust
# use tunes::prelude::*;
# use tunes::track::*;
let mut track = Track::new();
track.volume = 0.8;
track.pan = -0.3;  // Slightly left

// Tracks are typically created through Composition
let mut comp = Composition::new(Tempo::new(120.0));
comp.track("melody")
    .volume(0.8)
    .notes(&[C4, E4, G4], 0.5);
```

--------------------------------

### Organic Bass Line Example (Rust)

Source: https://docs.rs/tunes/latest/src/tunes/sequences/generative/random_walk.rs

An example demonstrating how to use the `random_walk::generate` function to create a wandering bass line around a specific frequency. It utilizes the `tunes` crate for composition and instrument setup.

```Rust
use tunes::prelude::*;
use tunes::sequences;

let mut comp = Composition::new(Tempo::new(120.0));

// Wandering bass around 110 Hz (A2)
let bass_walk = sequences::random_walk::generate(110.0, 8.0, 16);

comp.instrument("bass", &Instrument::sub_bass())
    .notes(&bass_walk, 0.5);
```

--------------------------------

### SpectralInvert Initialization and Configuration Example

Source: https://docs.rs/tunes/latest/tunes/synthesis/spectral/struct.SpectralInvert_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to create a new instance of SpectralInvert with specified parameters and set its wet/dry mix. The `new` function takes FFT size, hop size, window type, and sample rate as arguments.

```rust
let mut invert = SpectralInvert::new(2048, 512, WindowType::Hann, 44100.0);
invert.set_mix(0.8);  // 80% inverted
```

--------------------------------

### SpectralDelay: Create and Configure

Source: https://docs.rs/tunes/latest/tunes/synthesis/spectral/struct.SpectralDelay

Demonstrates the creation and configuration of a SpectralDelay instance. It shows how to set base delay time, feedback, frequency scaling, and wet/dry mix. The input and output buffers are also prepared for processing.

```Rust
let mut delay = SpectralDelay::new(2048, 512, 44100.0);
delay.set_delay_time(200.0);      // 200ms base delay
delay.set_feedback(0.5);          // 50% feedback
delay.set_frequency_scale(0.5);   // Highs delay slightly more
delay.set_mix(0.5);               // 50% wet

let input = vec![0.0; 512];
let mut output = vec![0.0; 512];
```

--------------------------------

### Run Mathematical Sequences Example in Rust

Source: https://docs.rs/tunes/latest/src/generative_sequences/generative_sequences.rs

This command executes the 'mathematical_sequences' example from the rs_tunes project, likely demonstrating algorithms like Recamán or Van der Corput for generative music. It requires the Rust toolchain to be installed.

```bash
cargo run --example mathematical_sequences
```

--------------------------------

### Initialize and Process with SpectralGate

Source: https://docs.rs/tunes/latest/tunes/synthesis/spectral/struct.SpectralGate_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates creating a SpectralGate instance, configuring its parameters like threshold and attack/release times, and processing an audio buffer. Requires the `tunes` crate.

```rust
use tunes::synthesis::spectral::SpectralGate;
use tunes::WindowType;

// Create spectral gate with 2048 FFT, 512 hop
let mut gate = SpectralGate::new(2048, 512, WindowType::Hann, 44100.0);

// Set threshold to -40 dB (bins below this get gated)
gate.set_threshold(-40.0);

// Fast attack, medium release
gate.set_attack(0.001);  // 1ms
gate.set_release(0.050); // 50ms

// Process audio - removes noise below -40 dB per frequency bin
let input = vec![0.0; 512];
let mut output = vec![0.0; 512];
gate.process(&mut output, &input);
```

--------------------------------

### Rust AdditiveSynth: Example Usage

Source: https://docs.rs/tunes/latest/src/tunes/synthesis/additive.rs_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to initialize an AdditiveSynth, add a harmonic partial, and generate one second of audio at a specified sample rate. This example serves as a basic integration test and usage guide for the synthesis functionality.

```rust
use tunes::synthesis::additive::{AdditiveSynth, Partial};

let mut synth = AdditiveSynth::new(440.0, 44100.0)
    .add_partial(Partial::harmonic(1, 1.0));

let one_second = synth.generate(44100);
```

--------------------------------

### SpectralGate Initialization and Basic Usage (Rust)

Source: https://docs.rs/tunes/latest/tunes/synthesis/spectral/struct.SpectralGate

Demonstrates how to create, configure, and process audio with the SpectralGate. This includes setting parameters like FFT size, hop size, window type, sample rate, threshold, attack, and release times.

```Rust
use tunes::synthesis::spectral::{SpectralGate, WindowType};

// Create spectral gate with 2048 FFT, 512 hop
let mut gate = SpectralGate::new(2048, 512, WindowType::Hann, 44100.0);

// Set threshold to -40 dB (bins below this get gated)
gate.set_threshold(-40.0);

// Fast attack, medium release
gate.set_attack(0.001);  // 1ms
gate.set_release(0.050); // 50ms

// Process audio - removes noise below -40 dB per frequency bin
let input = vec![0.0; 512];
let mut output = vec![0.0; 512];
gate.process(&mut output, &input);
```

--------------------------------

### Run Chaotic Sequences Example in Rust

Source: https://docs.rs/tunes/latest/src/generative_sequences/generative_sequences.rs

This command executes the 'chaotic_sequences' example from the rs_tunes project, which probably showcases cellular automata rules like Rule 30 for chaotic sound generation. It requires the Rust toolchain to be installed.

```bash
cargo run --example chaotic_sequences
```

--------------------------------

### GET /websites/rs_tunes/octave

Source: https://docs.rs/tunes/latest/tunes/theory/microtonal/struct.Edo_search=

Retrieves all notes within one octave starting from a specified base frequency.

```APIDOC
## GET /websites/rs_tunes/octave

### Description
This endpoint returns a list of frequencies representing all notes within a single octave, calculated from a provided base frequency. The tuning system used for calculation is determined by the context in which this function is called (e.g., an active `Edo` object).

### Method
GET

### Endpoint
`/websites/rs_tunes/octave`

### Query Parameters
- **base_freq** (f32) - Required - The starting frequency (in Hz) for the octave.

### Response
#### Success Response (200)
- **notes** (Vec<f32>) - A vector of frequencies representing the notes in the octave.

#### Response Example
```json
{
  "notes": [
    440.0,
    466.16,
    493.88,
    523.25,
    554.37,
    587.33,
    622.25,
    659.25,
    698.46,
    739.99,
    783.99,
    830.61,
    880.0
  ]
}
```
```

--------------------------------

### SpectralFreeze Constructor Example (Rust)

Source: https://docs.rs/tunes/latest/tunes/synthesis/spectral/struct.SpectralFreeze

Shows how to instantiate the SpectralFreeze struct with specified FFT size, hop size, and window type. The arguments determine the spectral analysis resolution and overlap.

```rust
use tunes::synthesis::spectral::SpectralFreeze;
use tunes::WindowType;

let freeze = SpectralFreeze::new(2048, 512, WindowType::Hann);
```

--------------------------------

### SpectralShift Initialization with Parameters (Rust)

Source: https://docs.rs/tunes/latest/tunes/synthesis/spectral/struct.SpectralShift

Demonstrates how to create a new SpectralShift instance using the `new` constructor. It outlines the necessary parameters: FFT size, hop size, window type, and sample rate, which are crucial for audio processing.

```Rust
let shift = SpectralShift::new(2048, 512, WindowType::Hann, 44100.0);
```

--------------------------------

### GET /collatz/medium

Source: https://docs.rs/tunes/latest/tunes/sequences/mathematical/collatz/fn.medium_search=

Retrieves the 'medium' Collatz sequence, which starts with 19 and has 20 steps. This sequence is designed to have a balanced melodic contour.

```APIDOC
## GET /collatz/medium

### Description
Retrieves the 'medium' Collatz sequence, which starts with 19 and has 20 steps. This sequence is designed to have a balanced melodic contour.

### Method
GET

### Endpoint
/collatz/medium

### Parameters
No parameters are required for this endpoint.

### Request Example
Not applicable for GET requests without parameters.

### Response
#### Success Response (200)
- **sequence** (array of u32) - The 'medium' Collatz sequence.

#### Response Example
```json
{
  "sequence": [
    19,
    58,
    29,
    88,
    44,
    22,
    11,
    34,
    17,
    52,
    26,
    13,
    40,
    20,
    10,
    5,
    16,
    8,
    4,
    2,
    1
  ]
}
```
```

--------------------------------

### SpectralBlur Initialization and Configuration Example (Rust)

Source: https://docs.rs/tunes/latest/tunes/synthesis/spectral/struct.SpectralBlur_search=

Demonstrates how to create a new SpectralBlur instance and configure its blur amount and feedback for a strong, long-decaying reverb-like effect.

```rust
let mut blur = SpectralBlur::new(2048, 512, WindowType::Hann, 44100.0);
blur.set_blur_amount(0.7);  // Strong blur
blur.set_feedback(0.8);      // Long decay
```

--------------------------------

### Set and Get SpectralWiden Cutoff Frequencies

Source: https://docs.rs/tunes/latest/tunes/synthesis/effects/spectral/struct.SpectralWiden

Explains how to modify and query the low and high frequency cutoffs for the SpectralWiden effect. This allows precise control over the frequency range affected by the stereo widening. Includes examples for setting and getting both `low_cutoff` and `high_cutoff`.

```rust
let mut widen = SpectralWiden::new(1.5, 200.0, 16000.0, 44100.0);

// Set low cutoff frequency
widen.set_low_cutoff(250.0);
let current_low_cutoff = widen.low_cutoff();

// Set high cutoff frequency
widen.set_high_cutoff(12000.0);
let current_high_cutoff = widen.high_cutoff();

```

--------------------------------

### Example: Melody in Range using Bounded Walk

Source: https://docs.rs/tunes/latest/src/tunes/sequences/generative/bounded_walk.rs

Demonstrates how to use the `bounded_walk::generate` function to create a musical melody. The example generates a sequence of 32 notes within a two-octave range, starting at A4 with steps up to 35 Hz, and assigns it to a 'lead' instrument with delay effects.

```rust
use tunes::prelude::*;
use tunes::sequences;

let mut comp = Composition::new(Tempo::new(120.0));

// Wandering melody in 2-octave range
let melody = sequences::bounded_walk::generate(
    440.0,   // Start at A4
    35.0,    // Steps of up to 35 Hz
    220.0,   // Min: A3
    880.0,   // Max: A5
    32       // 32 notes
);

comp.instrument("lead", &Instrument::synth_lead())
    .delay(Delay::new(0.375, 0.3, 0.5))
    .notes(&melody, 0.25);
```

--------------------------------

### Create and Configure SpectralGate (Rust)

Source: https://docs.rs/tunes/latest/tunes/synthesis/spectral/struct.SpectralGate_search=u32+-%3E+bool

Demonstrates how to create a new SpectralGate instance with specified FFT size, hop size, window type, and sample rate. It also shows how to set the gating threshold, attack, and release times.

```rust
// Create spectral gate with 2048 FFT, 512 hop
let mut gate = SpectralGate::new(2048, 512, WindowType::Hann, 44100.0);

// Set threshold to -40 dB (bins below this get gated)
gate.set_threshold(-40.0);

// Fast attack, medium release
gate.set_attack(0.001);  // 1ms
gate.set_release(0.050); // 50ms
```

--------------------------------

### STFT Constructor Example

Source: https://docs.rs/tunes/latest/src/tunes/synthesis/spectral/mod.rs_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how to instantiate the STFT processor with specific FFT size, hop size, and window type. It includes assertions to ensure the FFT size is a power of two and the hop size is valid.

```rust
# use tunes::synthesis::spectral::{STFT, WindowType};
// 2048-point FFT, 75% overlap (hop = fft_size/4)
let stft = STFT::new(2048, 512, WindowType::Hann);
```

--------------------------------

### GET /websites/rs_tunes/sequences/mathematical/collatz/sparse

Source: https://docs.rs/tunes/latest/tunes/sequences/mathematical/collatz/fn.sparse_search=std%3A%3Avec

Retrieves a sparse representation of the Collatz sequence starting with 27. This sequence is intentionally dramatic but shorter than the full sequence.

```APIDOC
## GET /websites/rs_tunes/sequences/mathematical/collatz/sparse

### Description
Retrieves a sparse representation of the Collatz sequence starting with 27. This sequence is intentionally dramatic but shorter than the full sequence.

### Method
GET

### Endpoint
/websites/rs_tunes/sequences/mathematical/collatz/sparse

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **sequence** (array of u32) - A vector containing the sparse Collatz sequence.

#### Response Example
{
  "sequence": [
    27,
    82,
    41,
    124,
    62,
    31,
    94,
    47,
    142,
    71,
    214,
    107,
    322,
    161,
    484,
    242,
    121,
    364,
    182,
    91,
    274,
    137,
    412,
    206,
    103,
    310,
    155,
    466,
    233,
    700,
    350,
    175,
    526,
    263,
    790,
    395,
    1186,
    593,
    1780,
    890,
    445,
    1336,
    668,
    334,
    167,
    502,
    251,
    754,
    377,
    1132,
    566,
    283,
    850,
    425,
    1276,
    638,
    319,
    958,
    479,
    1438,
    719,
    2158,
    1079,
    3238,
    1619,
    4858,
    2429,
    7288,
    3644,
    1822,
    911,
    2734,
    1367,
    4102,
    2051,
    6154,
    3077,
    9232,
    4616,
    2308,
    1154,
    577,
    1732,
    866,
    433,
    1300,
    650,
    325,
    976,
    488,
    244,
    122,
    61,
    184,
    92,
    46,
    23,
    70,
    35,
    106,
    53,
    160,
    80,
    40,
    20,
    10,
    5,
    16,
    8,
    4,
    2,
    1
  ]
}
```

--------------------------------

### GET /sequences/mathematical/arithmetic/ascending

Source: https://docs.rs/tunes/latest/tunes/sequences/mathematical/arithmetic/fn.ascending_search=std%3A%3Avec

Retrieves an ascending arithmetic sequence. This endpoint generates a sequence of numbers starting from 1 and increasing by 1 for 12 terms.

```APIDOC
## GET /sequences/mathematical/arithmetic/ascending

### Description
Retrieves an ascending arithmetic sequence (1, 2, 3, 4, 5...) with 12 terms.

### Method
GET

### Endpoint
/sequences/mathematical/arithmetic/ascending

### Parameters
No parameters are required for this endpoint.

### Request Example
No request body is needed for a GET request.

### Response
#### Success Response (200)
- **sequence** (array of u32) - A list of unsigned 32-bit integers representing the ascending sequence.

#### Response Example
```json
{
  "sequence": [
    1,
    2,
    3,
    4,
    5,
    6,
    7,
    8,
    9,
    10,
    11,
    12
  ]
}
```
```

--------------------------------

### SpectralDelay Initialization

Source: https://docs.rs/tunes/latest/tunes/synthesis/spectral/struct.SpectralDelay_search=

Demonstrates how to create a new SpectralDelay instance with default or custom parameters.

```APIDOC
## SpectralDelay Initialization

### Description
Initializes a SpectralDelay effect. You can create an instance with default parameters or provide custom values for delay time, feedback, frequency scaling, and mix.

### Methods

#### `SpectralDelay::new(fft_size: usize, hop_size: usize, sample_rate: f32) -> Self`
Creates a new spectral delay with default parameters (100ms delay, 0.3 feedback, no frequency scaling, 0.5 mix).

#### `SpectralDelay::with_params(
    fft_size: usize,
    hop_size: usize,
    sample_rate: f32,
    delay_time: f32,
    feedback: f32,
    frequency_scale: f32,
    mix: f32,
) -> Self`
Creates a new spectral delay with custom parameters.

##### Arguments
* `delay_time` (f32) - Base delay in milliseconds.
* `feedback` (f32) - Feedback amount (0.0-1.0).
* `frequency_scale` (f32) - Frequency-dependent scaling (-1.0 to 1.0).
  * `0.0`: All frequencies delay equally.
  * `1.0`: High frequencies delay 2x as much (shimmer up).
  * `-1.0`: Low frequencies delay 2x as much (shimmer down).
* `mix` (f32) - Dry/wet mix (0.0-1.0).

### Example
```rust
// Using default parameters
let mut delay_default = SpectralDelay::new(2048, 512, 44100.0);

// Using custom parameters
let mut delay_custom = SpectralDelay::with_params(
    2048, 
    512, 
    44100.0, 
    200.0, // 200ms base delay
    0.5,   // 50% feedback
    0.5,   // Highs delay slightly more
    0.5    // 50% wet
);
```
```

--------------------------------

### RS Tunes: Basic Bounce Generator Example

Source: https://docs.rs/tunes/latest/src/bounce_demo/bounce_demo.rs_search=std%3A%3Avec

Demonstrates the fundamental usage of the `bounce()` generator function with specified start and stop frequencies, damping ratio, number of bounces, steps per segment, and step duration. This example sets up a basic falling pitch with a few bounces.

```Rust
use tunes::prelude::*;

fn main() -> anyhow::Result<()> {
    let mut comp = Composition::new(Tempo::new(120.0));
    let engine = AudioEngine::new()?;

    println!("🏀 Bounce Generator Demo\n");

    // ==================== BASIC BOUNCE ====================
    println!("⬇️  Basic Bounce");
    println!("   Drop from A4 (440Hz) to A3 (220Hz), bounce twice at 50% damping\n");

    comp.instrument("basic", &Instrument::synth_lead())
        .bounce(440.0, 220.0, 0.5, 2, 6, 0.0833);
        // start, stop, ratio, bounces, steps_per_segment, step_duration

    // ==================== HIGH DAMPING ====================
    println!("🎯 High Damping (ratio=0.3)");
    println!("   Bounces quickly settle - tight, controlled pattern\n");

    comp.instrument("tight", &Instrument::electric_piano())
        .wait(1.5)
        .bounce(523.25, 261.63, 0.3, 3, 4, 0.125);  // C5 to C4, high damping

    // ==================== LOW DAMPING ====================
    println!("🌊 Low Damping (ratio=0.8)");
    println!("   Bounces stay high - slower settling, more energetic\n");

    comp.instrument("bouncy", &Instrument::synth_lead())
        .wait(3.0)
        .bounce(392.0, 196.0, 0.8, 4, 8, 0.0625);  // G4 to G3, low damping

    // ==================== SINGLE DROP (no bounces) ====================
    println!("💧 Single Drop");
    println!("   Zero bounces - just a falling pitch (portamento effect)\n");

    comp.instrument("drop", &Instrument::synth_lead())
        .wait(5.5)
        .bounce(880.0, 440.0, 0.5, 0, 12, 0.0625);  // A5 to A4, no bounce

    // ==================== RAPID BOUNCES ====================
    println!("⚡ Rapid Bounces");
    println!("   Many bounces with few steps - quick, staccato feel\n");

    comp.instrument("rapid", &Instrument::pluck())
        .wait(6.5)
        .bounce(330.0, 165.0, 0.6, 5, 3, 0.05);  // E4 to E3, rapid

    // ==================== WITH GENERATOR NAMESPACE ====================
    println!("📦 Using .generator() Namespace");
    println!("   Clean, organized syntax\n");

    comp.instrument("namespace", &Instrument::synth_lead())
        .wait(8.0)
        .generator(|g|
            g.bounce(493.88, 246.94, 0.55, 3, 6, 0.08)  // B4 to B3
        );

    // ==================== COMBINED WITH TRANSFORMS ====================
    println!("🔗 Bounce + Transforms");
    println!("   Generate bouncing pattern, then apply effects\n");

    comp.instrument("transformed", &Instrument::electric_piano())
        .wait(10.0)
        .generator(|g|
            g.bounce(659.25, 329.63, 0.65, 4, 4, 0.0833)  // E5 to E4
        )
        .transform(|t|
            t.humanize(0.005, 0.03)   // Add organic feel
             .magnetize(&[E4, G4, A4, B4, D5, E5])  // Snap to E minor pentatonic
        );

    // ==================== LAYERED BOUNCES ====================
    println!("🎼 Layered Bounces");
    println!("   Multiple bounce patterns at different intervals\n");

    comp.instrument("layer1", &Instrument::synth_lead())
        .wait(12.0)
        .bounce(523.25, 261.63, 0.5, 3, 5, 0.1);  // C5 to C4

    comp.instrument("layer2", &Instrument::electric_piano())
        .wait(12.5)
        .bounce(392.0, 196.0, 0.6, 2, 6, 0.0833);  // G4 to G3

    // ==================== REVERSE BOUNCE (rise then settle) ====================
    println!("⬆️  Reverse Bounce");
    println!("   Start low, rise high, then bounce downward\n");

    comp.instrument("reverse", &Instrument::synth_lead())
        .wait(14.5)
        .bounce(220.0, 440.0, 0.5, 2, 8, 0.0625);  // Swap start/stop for reverse

    // Play everything
    println!("\n▶️  Playing bounce demo...\n");
    let mixer = comp.into_mixer();
    engine.play_mixer(&mixer)?;

    println!("✅ Demo complete!\n");
    println!("💡 Bounce parameters:");
    println!("   start: Starting frequency (e.g., 440.0 for A4)");
    println!("   stop: Floor frequency where bounces occur (e.g., 220.0 for A3)");
    println!("   ratio: Damping ratio (0.0-1.0, e.g., 0.5 = each bounce is 50% of previous)");
    println!("   bounces: Number of times to bounce back up (0 = just fall)");
    println!("   steps_per_segment: Number of notes in each rise/fall");
    println!("   step_duration: Length of each note in seconds");
    println!("\n🎵 Musical uses:");
    println!("   • Percussive melodic phrases");
    println!("   • Glitch/IDM style pitch drops");
    println!("   • Generative 'settling' patterns");
    println!("   • Sound effects (ball bounces, drops)");
    Ok(())
}

```

--------------------------------

### SpectralGate Release Time Setting Example (Rust)

Source: https://docs.rs/tunes/latest/tunes/synthesis/spectral/struct.SpectralGate

Shows how to set the release time in seconds for the `SpectralGate`. This parameter determines how quickly the gate closes when the signal level drops below the threshold.

```Rust
let mut gate = SpectralGate::new(2048, 512, WindowType::Hann, 44100.0);
gate.set_release(0.050);  // 50ms
```

--------------------------------

### SpectralShift Constructor Example (Rust)

Source: https://docs.rs/tunes/latest/tunes/synthesis/spectral/struct.SpectralShift_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how to instantiate the SpectralShift effect using its `new` constructor. This requires specifying the FFT size, hop size, window type, and sample rate.

```Rust
use tunes::synthesis::spectral::SpectralShift;
use tunes::WindowType;

// Example of creating a new SpectralShift instance
// fft_size: typically 2048 or 4096 (power of 2)
// hop_size: typically fft_size/4 for 75% overlap
// window_type: e.g., WindowType::Hann
// sample_rate: audio sample rate in Hz
let shift = SpectralShift::new(2048, 512, WindowType::Hann, 44100.0);
```

--------------------------------

### RsTunes Spatial Audio API Usage Example

Source: https://docs.rs/tunes/latest/tunes/engine/struct.AudioEngine_search=

Demonstrates how to use the RsTunes spatial audio API to set sound positions, move sounds in real-time, control listener position and orientation, and configure spatial parameters. This example assumes the necessary setup for the 'engine' and 'comp' objects.

```rust
    // Set position during composition
    comp.track("guitar")
        .spatial_position(2.0, 0.0, 5.0)  // 2m right, 5m forward
        .note(&[C4], 1.0);

    // Move sound in real-time
    let sound_id = engine.play_mixer_realtime(&mixer)?;
    engine.set_sound_position(sound_id, x, y, z)?;

    // Control listener
    engine.set_listener_position(0.0, 1.7, 0.0)?;  // Standing height
    engine.set_listener_forward(0.0, 0.0, 1.0)?;  // Face forward

    // Configure spatial parameters
    let mut params = SpatialParams::default();
    params.max_distance = 50.0;
    engine.set_spatial_params(params)?;
```

--------------------------------

### SpectralShift Constructor and Settings

Source: https://docs.rs/tunes/latest/tunes/synthesis/spectral/struct.SpectralShift_search=

Documentation for creating a new SpectralShift instance and configuring its parameters.

```APIDOC
## SpectralShift::new

### Description

Create a new spectral shift effect.

### Method

`new`

### Arguments

*   **fft_size** (usize) - Required - FFT size (must be power of 2, typically 2048 or 4096)
*   **hop_size** (usize) - Required - Hop size in samples (typically fft_size/4 for 75% overlap)
*   **window_type** (WindowType) - Required - Window function type
*   **sample_rate** (f32) - Required - Audio sample rate in Hz

### Example

```rust
let shift = SpectralShift::new(2048, 512, WindowType::Hann, 44100.0);
```

## SpectralShift::set_shift_hz

### Description

Set frequency shift in Hz. Positive values shift up, negative shift down.

### Method

`set_shift_hz`

### Arguments

*   **shift_hz** (f32) - Required - Frequency shift in Hz (e.g., 100.0, -50.0)

### Example

```rust
let mut shift = SpectralShift::new(2048, 512, WindowType::Hann, 44100.0);
shift.set_shift_hz(100.0);   // Shift up 100 Hz
shift.set_shift_hz(-50.0);   // Shift down 50 Hz
```

## SpectralShift::set_mix

### Description

Set wet/dry mix.

### Method

`set_mix`

### Arguments

*   **mix** (f32) - Required - Mix amount (0.0 = dry, 1.0 = wet)

### Example

```rust
let mut shift = SpectralShift::new(2048, 512, WindowType::Hann, 44100.0);
shift.set_mix(0.5);  // 50% wet
```
```

--------------------------------

### Example: Creating Tracks on Different Buses

Source: https://docs.rs/tunes/latest/src/tunes/track/bus.rs_search=u32+-%3E+bool

This example demonstrates how to create a new `Composition` and then add tracks to specific buses. It shows how to route a 'kick' drum track to the 'drums' bus and a 'lead' melody track to the 'melody' bus, showcasing the basic setup for organizing tracks by bus.

```rust
# use tunes::prelude::*
# use tunes::track::Bus;
let mut comp = Composition::new(Tempo::new(120.0));

// Create tracks on different buses
comp.track("kick")
    .bus("drums")
    .drum(DrumType::Kick, 0.0);

comp.track("lead")
    .bus("melody")
    .notes(&[C4, E4, G4], 0.5);
```

--------------------------------

### SpectralInvert Initialization and Configuration (Rust)

Source: https://docs.rs/tunes/latest/tunes/synthesis/spectral/struct.SpectralInvert

Demonstrates how to create and configure a SpectralInvert effect. It shows setting the mix level and provides an example of initializing the struct with specific parameters.

```rust
use tunes::synthesis::spectral::SpectralInvert;
use tunes::synthesis::WindowType;

// Example of initializing SpectralInvert
let mut invert = SpectralInvert::new(2048, 512, WindowType::Hann, 44100.0);
invert.set_mix(0.8); // Sets the mix to 80%

// Example of using presets
let moderate_invert = SpectralInvert::moderate();
```

--------------------------------

### Get Time Range of Automation

Source: https://docs.rs/tunes/latest/tunes/synthesis/automation/struct.Automation

Returns the total time span covered by this automation. The output is a tuple containing the start time and end time in seconds.

```rust
pub fn time_range(&self) -> (f32, f32)
```

--------------------------------

### Get Loop Points of Sample

Source: https://docs.rs/tunes/latest/src/tunes/synthesis/sample.rs_search=u32+-%3E+bool

Returns the loop start and end points in frames, if looping is enabled for the sample. Returns None if looping is not enabled.

```rust
pub fn loop_points(&self) -> Option<(usize, usize)> {
        match (self.loop_start, self.loop_end) {
            (Some(start), Some(end)) => Some((start, end)),
            _ => None,
        }
    }
```

--------------------------------

### Create and Configure SpectralBlur Instance

Source: https://docs.rs/tunes/latest/tunes/synthesis/spectral/struct.SpectralBlur_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to instantiate and configure the SpectralBlur effect. Initialization requires FFT size, hop size, window type, and sample rate. Parameters like blur amount, feedback (decay), and mix (wet/dry) can be adjusted to fine-tune the effect.

```rust
let mut blur = SpectralBlur::new(2048, 512, WindowType::Hann, 44100.0);
blur.set_blur_amount(0.7);
blur.set_feedback(0.8);
```

--------------------------------

### Window::apply

Source: https://docs.rs/tunes/latest/tunes/synthesis/spectral/struct.Window

Applies the window function to an audio buffer using SIMD acceleration for significant speedups.

```APIDOC
## Function Window::apply

### Description
Apply window to audio buffer using SIMD acceleration.
Multiplies each sample by the corresponding window coefficient. Uses true SIMD operations for 4-8x speedup on modern CPUs.

### Method
`pub fn apply(&self, buffer: &mut [f32])`

### Arguments
- **buffer** (&mut [f32]) - Required - Audio buffer to window (modified in-place).

### Panics
Panics if buffer length doesn’t match window size.

### Example
```rust
let window = Window::new(WindowType::Hann, 1024);
let mut audio = vec![1.0; 1024];
window.apply(&mut audio); // SIMD-accelerated windowing
```

```
Tokens:
Raw