Musical structures

[walterbender]

There are some structures in music that we should capture in the design. (In Music Blocks 1.0, there were afterthoughts and hence they are not well reflected in the internal structure of the code, adding lots of unneed complexity and computation.

Key/Mode --- We should always have a key and mode defined and in that definition, we determine things like intervals, inversion, accidental preferences, etc. Right now, all of that is calculated on the fly for every note.

Temperament --- We default to equal temperament, which is fine, but to change to another temperament is onerous because there are so many things hardwired to equal temperament (e.g., the number of half-steps in an octave, the hertz associated with a note name, etc.) A temperament object could subsume all of this and make it much easier to work with non-equal temperaments.

Tempo and meter -- These are also better handled as a class rather than as globals. This will make concepts such as measure and beat much easier to expose/manage.

Timbre -- We may want to rethink how we do this. Right now, you can add drums to a note, but not change the timbre (or have multiple instruments playing at once) except by adding multiple turtles. This leads to come complexity in maintaining timing.

[meganindya]

Tone.js has a class called PolySynth which can manage multiple voices easily. Maybe something we can use while handling the timbre.

[walterbender]

I am not sure you can use polysynth for different timbres but worth exploring.

[walterbender]

I have some decent Python code for temperament and key signature now that, when converted to JavaScript, could replace much of the code in musicutils.js

Still trying to work out how to best adapt the non-equal-temperament tuning to our key/mode structure.

[meganindya]

I was trying to get some states sorted. Realized that we need a good idea of what and exactly how the key, mode, and scales come together. Perhaps we should have a diatonic scale representation and work on top of that; I think all we should need is an array of notes (pitch in hertz) and everything else just uses the indices of that array. But, I'm very confused with the key/mode.

[walterbender]

Still trying to wrap my head around that as well... stay tuned.

[walterbender]

I have a plan... hope to be able to show you something soon.

[walterbender]

t = Temperament()
ks = KeySignature(mode="major", key="c")
ks.set_note_names(t.get_note_names())
print(t.get_freq_by_generic_note_name_and_octave(ks.letter_name_to_note_name("a")[0], 4))
439.95700446074324

[meganindya]

what does the letter_name_to_note_name(...) return?

[walterbender]

We can use the generic note names directly when the temperament has more than 12 notes...

[walterbender]

Whenever you generate a new temperament, you need to specify the number of steps in the octave. A generic note name is calculated for each step: "n0", "n1",... "n11" for a 12-semitone temperament.

The temperaments with 12 steps also get assigned letter names, e.g., C# and Db. We need to convert those to the generic names to map to the temperament and get the frequencies.

[walterbender]

I'm still cleaning up the key signature code so that you can define modes for non-12-step temperaments. But I have a simple framework now for doing that :)

[walterbender]

I need to do more testing, but I think it is all basically working now. You can create custom modes for any temperament, navigate intervals, both scalar and semitone, and get back hertz for any note.

I am not sure how to handle cents for most temperaments. I need to wrap my head around the math.
And I have not added accidental support for the generic note names. That should be pretty easy.

[walterbender]

I also want to add some inverse functions: frequency to generic note name and generic note name to letter name.

[meganindya]

is that useful?

[walterbender]

It will at least be useful for writing tests.
And converters if/when we introduce them -- it is instructive to show the various ways to represent the same concept.

[walterbender]

class Temperament(builtins.object)
| Temperament(name='equal')
|
| In musical tuning, temperament is a tuning system that defines the
| notes (semitones) in an octave. Most modern Western musical
| instruments are tuned in the equal temperament system based on the
| 1/12 root of 2 (12 semitones per octave). Many traditional
| temperaments are based on ratios.
|
| Methods defined here:
|
| init(self, name='equal')
| Initialize the class. A temperament will be generated but it can
| subsequently be overriden.
|

Parameters

|
| name : str
| The name of a temperament, e.g., "equal", "just intonation". etc.
|
| str(self)

Returns
str
The list of frequencies

|
| generate(self, name)
| Generate creates one of the predefined temperaments based on the
| rules for generating the frequencies and the selected intervals used
| to determine which frequencies to include in the temperament.
| A rule might be to use a series of ratios between steps, as in the
| Pythagorean temperament, or to use a fixed ratio, such as the
| twelth root of two when calculating equal temperament.
|
| The base frequency used when applying the rules is defined in
| self.base_frequency
| The number of times to apply the rules is determined by
| self.number_of_octaves
| The resultant frequencies are stored in self.freqs
| The resultant number of notes per octave is stored in
| self.octave_length
|

Parameters
name : str
The name of one of the predefined temperaments

|
| generate_custom(self, intervals, ratios, name='custom')
| A custom temperament can be defined with arbitrary rules.
|

Parameters
intervals : list
An ordered list of interval names to define per octave

|
| ratios : dict
| A dictionary of ratios to apply when generating the note
| frequencies in an octave. The dictionary keys are defined
| in the intervals list. Each ratio (between 1 and 2) is applied
| to the base frequency of the octave. The final frequency
| should always be equal to 2.
|
| name : str
| The name associated with the custom temperament
|
| generate_equal_temperament(self, number_of_steps)
| Equal temperaments can be generated for different numbers of steps
| between the notes in an octave. The predefined equal temperament
| defines 12 steps per octave, which is perhaps the most common
| tuning system in modern Western music. But any number of steps can
| be used.
|

Parameters
number_of_steps : int
The number of equal steps into which to divide an octave.

|
| generate_generic_note_names(self)
| A generic name is defined for each note in the octave.
| The convention is n0, n1, etc. These notes can be used by
| the get_freq_by_generic_note_name_and_octave method to retrieve
| a frequency by note name and octave.
|
| get_base_frequency(self)

Returns
float
The base frequency (in Hertz) used to seed the calculations

|
| get_freq_by_generic_note_name_and_octave(self, note_name, octave)
| Note name can be used to calculate an index the notes in an octave.
|

Parameters
note_name : str
The name of the note

|
| octave : int
| Which octave to access
|

Returns
float
The frequency that corresponds to the index and octave (in Hertz)

|
| get_freq_by_index(self, pitch_index)

Parameters
pitch_index : int
The index into the frequency list

|

Returns
float
Returns the frequency (in Hertz) of a note by index

|
| get_freq_by_modal_index_and_octave(self, modal_index, octave)
| Modal index is an index into the notes in a octave.
|

Parameters
modal_index : int
The index of the note within an octave

|
| octave : int
| Which octave to access
|

Returns
float
The frequency that corresponds to the index and octave (in Hertz)

|
| get_freqs(self)
| freqs is the list of all of the frequencies in the temperament.
|

Returns
list
A list of frequencies in Hertz (float)

|
| get_name(self)

Returns
str
The name of the temperament

|
| get_note_names(self)
| Generic note names are assigned to define a chromatic scale.
|

Returns
list
A list of note names (str)

|
| get_number_of_octaves(self)

Returns
int
The number of octaves in the temperament.

|
| get_number_of_semitones_in_octave(self)

Returns
int
The number of notes defined per octave

|
| set_base_frequency(self, base_frequency)
| The base frequency is used as the starting point for generating
| the notes.
|

Parameters
base_frequency : float
The frequency (in Hertz) used to seed the calculation of the
notes used in the temperament.

|
| set_number_of_octaves(self, number_of_octaves=8)
| How many octaves are defined for the temperament?
|

Parameters
number_of_octaves : int
The number of octaves in the temperament. (8 octaves in
equal temperament would span 96 notes).

|

class KeySignature(builtins.object)
| KeySignature(mode='major', key='c', number_of_semitones=12)
|
| A key signature is a set of sharp, flat, and natural symbols.
|
| Methods defined here:
|
| init(self, mode='major', key='c', number_of_semitones=12)
| In defining a scale, we need to know the key, the mode, and the
| number of notes in the temperament used to define the scale.
|

Parameters
mode : str
One of the modes defined in self.MUSIC_MODES

|
| key : str
| Any pitch defined by in the temperament. (Note that currently
| the only notation supported is for temperaments with up to 12
| steps.
|
| number_of_semitones : int
| The number of semitones defined in the temperament
|
| NOTE: many of the class methods assume that the temperament has
| 12 steps.
|
| str(self)
| Return the key, mode, number of half steps, and the scale.
|
| closest_note(self, target)
| Given a target pitch, what is the closest note in the current
| key signature (key and mode)?
|

Parameters
target : str
target pitch specified as a pitch letter, e.g., c#, fb

|

Returns
str
The closest pitch to the target pitch in the scale.
int
The scalar index value of the closest pitch in the scale
(If the target is midway between two scalar pitches, the
lower pitch is returned.)
int
The distance in semitones (half-steps) from the target
pitch to the scalar pitch (If the target is higher than
the scalar pitch, then distance > 0. If the target is
lower than the scalar pitch then distance < 0. If the
target matches a scale pitch, then distance = 0.)
int
error code (0 means success)

|
| NOTE: This only works for temperaments with 12 semitones
|
| get_mode_length(self)
| How many notes are in the scale?
|

Returns
int
The number of (scalar) notes in the scale.

|
| get_number_of_semitones(self)
| How many semitones (half-steps) are in the temperament used to
| define this key/mode?
|

Returns
int
The number of semitones in the temperament used to define
the scale

|
| get_scale(self)
| The (scalar) notes in the scale.
|

Returns
list
The (scalar) notes in the scale.

|
| NOTE: The internal definition of the scale includes the octave.
|
| letter_name_to_note_name(self, pitch_name)
| Convert from letter names used by 12-semitone temperaments to
| a generic note name as defined by the temperament.
| NOTE: Only for temperaments with 12 semitones.
|
| modal_pitch_to_letter(self, modal_index)
| Given a modal number, return the corresponding pitch in the scale
| (and any change in octave).
|

Parameters
modal_index : int
The modal index specifies an index into the scale. If the
index is >= mode length or < 0, a relative change in octave
is also calculated.

|

Returns
str
The pitch that is the result of indexing the scale by the
modal index.

|
| int
| The relative change in octave due to mapping the modal index
| to the mode length
|
| note_in_scale(self, target)
| Given a pitch, check to see if it is in the scale.
|

Parameters
target : str
The target pitch specified as a pitch letter, e.g., c#, fb.

|

Returns
boolean
True if the note is in the scale

|
| scalar_transform(self, starting_pitch, number_of_scalar_steps)
| Given a starting pitch, add a scalar transform and return
| the resultant pitch (and any change in octave).
|

Parameters
starting_pitch : str
The starting pitch specified as a pitch letter, e.g., c#, fb.
Note that the starting pitch may or may not be in the scale.

|
| number_of_scalar_steps : int
| Scalar steps are steps in the scale (as opposed to half-steps)
|

Returns
str
The pitch that is the number of scalar steps from the starting
pitch.

|
| int
| The relative change in octave between the starting pitch and the
| new pitch.
|
| int
| error code
|
| semitone_transform(self, starting_pitch, number_of_half_steps)
| Given a starting pitch, add a semitone transform and return
| the resultant pitch (and any change in octave).
|

Parameters
starting_pitch : str
The starting pitch specified as a pitch letter, e.g., c#, fb.

|
| number_of_half_steps : int
| Half steps are steps in the notes defined by the temperament
|

Returns
str
The pitch that is the number of half steps from the starting
pitch.

|
| int
| The relative change in octave between the starting pitch and the
| new pitch.
|
| int
| error code
|
| set_note_names(self, note_names)
| Generic note names are defined by the temperament.
|

[walterbender]

Almost everything is now in place.

• solfege modal mapping
• conversion from solfege (et al.) to note name
• semitone transposition for solfege (et al.)

To do:

• support for closest note for solfege (et al.)
• support for scalar transposition for solfege (et al.)
• conversion from note name to solfege (et al.)

[walterbender]

    t = Temperament()
    ks = KeySignature()
    ks.set_custom_note_names(
        ["charlie", "delta", "echo", "foxtrot", "golf", "alfa", "bravo"]
    )

    print(t.get_freq_by_generic_note_name_and_octave(ks.letter_name_to_note_name("g")[0], 4))

392.0290500506298

    print(t.get_freq_by_generic_note_name_and_octave(ks.letter_name_to_note_name("sol")[0], 4))

392.0290500506298

    print(t.get_freq_by_generic_note_name_and_octave(ks.letter_name_to_note_name("5")[0], 4))

392.0290500506298

    print(t.get_freq_by_generic_note_name_and_octave(ks.letter_name_to_note_name("pa")[0], 4))

392.0290500506298

    print(t.get_freq_by_generic_note_name_and_octave(ks.letter_name_to_note_name("golf")[0], 4))

392.0290500506298

[meganindya]

Really cool. How are you calculating the frequencies? I mean the decimal accuracies, are those some standard constants or are there some mathematical formulas?

[walterbender]

The only constant is the base frequency for the temperament (C in octave 0 by default). The rest of the frequencies are defined per octave based on the formula(s) associated with each temperament.

I do have to add an offset in situations where you change the base frequency to, say, G.

[walterbender]

I've got a little tweaking to do on the scale generation. Then I think it would make sense to make two more classes: one for the scale itself and one for a pitch name. Those will help clarify some of the code.

[pikurasa]

Should we add Tuning to your list at the top of this discussion?

Not "Temperament Tuning", but "What do I tune my A string or Bb trumpet to" kind of tuning. This, I think, is a kind of meta, that may need to be embedded deep into code construct.

This is the open-issue on the subject: sugarlabs/musicblocks#2460

[walterbender]

I guess the way I think about tuning -- correct me if I am wrong -- is that is should essentially impact the base pitch used for the generation of the mode. So for example, if you want to tune A4 to 440, then you are essentially saying, what base frequency do I need such that when I calculate A4, I get 440. Use that base frequency for all of my calculations. I should be able to figure that out in some closed formula. (But it suggests that when tuning, you need to specify an octave as well as a pitch.)

[pikurasa]

For octaves, the following is true:

When A4 is "tuned" to 440, then A5 is 880 and A3 is 220
When A4 is tuned to 441, then A5 is 882 and A3 is 220.5

[walterbender]

I added support for tuning. And the code for generating the scales is much more robust.