Unlike pitch_at, the transposition has already been applied.

Pitch without the transposition applied. You have to use this if you create an event with a pitch based on this pitch, otherwise the transposition will be applied twice.

Get the symbolic version of the transposed pitch. Since it's transposed, if you turn it back to a DeriveT.Pitch, you should use with_transposed_pitch.

Replace the dynamic with the given one.

Get symbolic pitch manipulating functions for the current scale. This is for calls that want to work with symbolic pitches.

Evaluate a Pitch.Pitch. It returns a transposed pitch since a Pitch.Pitch is assumed to have been transposed (e.g. get_parsed_pitch uses a transposed pitch so range calculation works).

Evaluate a symbolic pitch. Like eval_pitch, I assume the Note was Transposed, or at least should be an absolute pitch.

Generate a single note, from 0 to 1.

Like note, but the note reuses the Context, which means it will inherit the caller's start and duration as well as sub-tracks and thus may apply inversion.

This is appropriate when adding a wrapper around the default note call, but not if you don't want to be overridden by sub-tracks. See placed_note if you want to inherit the time, but not the rest.

Override the pitch signal and generate a single note.

Add an attribute and generate a single note.

A zero-duration note.

Derive with transformed Attributes.

Get an infinite list of random numbers. These are deterministic in that they depend only on the random seed, but the random seed is hashed with each stack entry. So if you fix the random seed at a certain point, you should get consistent results below it.

It's a class because both Doubles and Ints are useful and I'd like to use the same function name for both.

Get a random Double or Int. Ints will lose precision if converted to double!

If the chance is 1, return true all the time, if it's 0.5, return it half of the time.

Like pick_weighted when all the weights are equal.

Approximation to a normal distribution between 0 and 1, inclusive. I can't use an actual normal distribution because I need it to be bounded.

Get the real duration of time val at the given point in time. RealTime is linear, so 1 second is always 1 second no matter where it is, but ScoreTime will map to different amounts of RealTime depending on where it is.

Like real_duration, but get the duration in ScoreTime. If you are manipulating deriver abstractly instead of directly emitting events then you will place them via Internal.at and family, which are in ScoreTime.

A time range from the event start until a given duration.

Like duration_from_start, but subtract a duration from the end.

This is real_duration, but takes a ScoreT.Typed Signal.Y.

Take the given number of steps. Negative means step back.

Get the timestep duration from the given point. This tries first to step forward, and then back. This is because typically you use this to configure duration for a call, and it's confusing when the call stops working at the end of the block.

Duration of a single timestep, starting here.

This is for arguments which can be high or low.