HS_Score

This functor provides many constrains and score classes which facilitate the definition of a theory of harmony. For example, this functor defines constraints between pitches, pitch classes and degrees on the one hand, and classes such as Interval, Chord, Scale, and an extended Note class on the other hand.

The functor defines most class extensions as mixins, so they can be combined with other classes (e.g., you can extend your own extension of the Note class provided by the Strasheela core with the mixin PitchClassMixin). In addition, the functor also uses these mixins in class definitions (e.g., the class Note2 inherits from both the core class Score.note and PitchClassMixin). The functor defines many class variants combining the mixins. Selecting the class with the minimal set of additional parameters which meets your needs reduces the memory requirement of your score. However, you may consider defining your CSP with the most extensive classes first (e.g., using FullNote, ScaleDegreeChord, and Scale), and optimise later only if necessary.

This harmony model is designed to cooperate with other Strasheela extensions. For example, it can be used together with the motif model (contribution Motif) or the meter model (contribution Measure).

Moreover, the classes can be used in a score whose hierarchic structure is constrained with the contribution ConstrainTimingTree (CTT). Consequently, many class definitions in this functor enforce their constrains only after they know that the score object in question "exists" (i.e. its duration > 0). Therefore, the distribution strategy should usually determine the duration of a score object early on in the search process.

Functor

/Users/torsten/oz/music/Strasheela/strasheela/trunk/strasheela/contributions/anders/HarmonisedScore/source/Score.oz

Import

FD
FS
Combinator
System
Search
Browser(browse:Browse)
Select at "x-ozlib://duchier/cp/Select.ozf"
GUtils at "x-ozlib://anders/strasheela/source/GeneralUtils.ozf"
LUtils at "x-ozlib://anders/strasheela/source/ListUtils.ozf"
MUtils at "x-ozlib://anders/strasheela/source/MusicUtils.ozf"
Score at "x-ozlib://anders/strasheela/source/ScoreCore.ozf"
SDistro at "x-ozlib://anders/strasheela/source/ScoreDistribution.ozf"
Pattern at "x-ozlib://anders/strasheela/Pattern/Pattern.ozf"
CTT at "x-ozlib://anders/strasheela/ConstrainTimingTree/ConstrainTimingTree.ozf"
Measure at "x-ozlib://anders/strasheela/Measure/Measure.ozf"
DB at "Database.ozf"
Rules at "Rules.ozf"

Export

<P/2:PitchClassToPitch>
<P/2:PitchClassToPitch2>
<P/2:RatioToInterval>
<P/3:TransposePC>
<P/3:DegreeToPC>
<P/2:CMajorDegreeToPC>
<P/4:TransposeDegree>
<P/4:GetDegree>
<P/2:AbsoluteToOffsetAccidental>
<P/2:OffsetToAbsoluteAccidental>
<P/3:PcSetToSequence>
<P/3:GetAdaptiveJIPitch>
<P/5:GetAdaptiveJIPitch2>
<P/3:MinimalCadentialSets>
<P/3:MinimalCadentialSets2>
<P/3:MakeAllContextScales>
<C:Interval>
<P/2:IsInterval>
<P/4:NoteInterval>
<P/3:TransposeNote>
<C:PitchClassMixin>
<P/2:IsPitchClassMixin>
<C:RegularTemperamentMixinForNote>
<P/2:IsRegularTemperamentMixinForNote>
<C:InChordMixinForNote>
<P/2:IsInChordMixinForNote>
<C:InScaleMixinForNote>
<P/2:IsInScaleMixinForNote>
<C:EnharmonicSpellingMixinForNote>
<P/2:IsEnharmonicSpellingMixinForNote>
<C:ScaleDegreeMixinForNote>
<P/2:IsScaleDegreeMixinForNote>
<C:ChordDegreeMixinForNote>
<P/2:IsChordDegreeMixinForNote>
<C:Note>
<C:Note2>
<C:RegularTemperamentNote>
<C:FullNote>
<C:EnharmonicNote>
<C:ScaleDegreeNote>
<C:ChordDegreeNote>
<C:ScaleNote>
<C:ChordNote>
<C:PitchClassCollection>
<P/2:IsPitchClassCollection>
<C:Chord>
<P/2:IsChord>
<C:Scale>
<P/2:IsScale>
<C:InScaleMixinForChord>
<P/2:IsInScaleMixinForChord>
<P/2:MakeInScaleChordClass>
DiatonicChord
<C:ScaleDegreeMixinForChord>
<P/2:IsScaleDegreeMixinForChord>
<P/2:MakeScaleDegreeChordClass>
ScaleDegreeChord
<C:InversionMixinForChord>
<P/2:IsInversionMixinForChord>
<P/2:MakeInversionChordClass>
InversionChord
FullChord
<C:ChordStartMixin>
<P/2:StartChordWithMarker>
<C:PitchClass>
<P/2:IsPitchClass>
MakeChords
MakeScales
<P/5:HarmoniseScore>
<P/5:HarmoniseScore2>
<P/2:HarmoniseMotifs>
<P/3:HarmonicRhythmFollowsMarkers>
<P/3:ChordsToScore>
<P/3:ChordsToScore_Script>

Define



proc{PitchClassToPitch PitchClass#Octave Pitch}

 Defines the relation between an absolute pitch number Pitch (FD int) and its PitchClass (FD int) plus Octave component (FD int). Middle c has octave 4, according to conventions (cf. http://en.wikipedia.org/wiki/Scientific_pitch_notation). So (for PitchesPerOctave=12), octave=0 corresponds to Midi pitch 12, and Midi pitch 127 falls in octave 9.

 The domain of PitchClass is implicitly restricted to 0#{DB.getPitchesPerOctave}.

 Pitch is implicitly declared to a FD int, so PitchClassToPitch can also be used like a deterministic function.


proc{PitchClassToPitch2 PitchClass#Octave Pitch}

 Same as PitchClassToPitch. However, Middle c has octave 5 so that if Pitch = PitchClass, Octave = 0. This is in contrast to PitchClassToPitch, where Pitch is always >= PitchesPerOctave and thus always Pitch > PitchClass (even if Octave = 0). PitchClassToPitch2 is used with intervals, whereas PitchClassToPitch is used with pitches.

 The domain of PitchClass is implicitly restricted to 0#{DB.getPitchesPerOctave}.

 Pitch is implicitly declared to a FD int, so PitchClassToPitch2 can also be used like a deterministic function.


fun{RatioToInterval Ratio}

 Transforms Ratio (either a float or a fraction specification in the form #) into the corresponding keynumber interval (an int) of the presently set pitches per octave.


proc{TransposePC UnTranspPC TranspositionPC TranspPC}

 Transposes the pitch class UnTranspPC by the interval TranspositionPC such that the resulting pitch TranspPC is still a pitch class, that is a pitch without an octave component. A pitch class is a FD int with the domain 0#(PitchesPerOctave-1). 

 What the actual value of a pitch class means depends on DB.getPitchesPerOctave (see also termonology explanation in the top-level functor).

 NB: The transposition interval is limited to a PC (i.e. the domain 0#(PitchesPerOctave-1)) to improve propagation. To transpose by a larger interval, constrain the relation of the (larger) Transposition and TranspositionPC by {PitchClassToPitch TranspositionPC#_ Transposition}.

  All PC arguments are implicitly declared to FD ints with the domain 0#(PitchesPerOctave-1).


proc{DegreeToPC CollectionPCs Degree#Accidental PC}

 Defines the relation between two pitch representations without octave component: the pitch class PC (FD int) and the compound representation consisting in Degree (FD int) and Accidental (FD int) -- depending on CollectionPCs (vector of FD ints).

 The Degree denotes quasi an index into CollectionPCs, e.g., the pitches of a scale: if Accidental denotes a neutral (i.e. {AbsoluteToOffsetAccidental 0}), PC is the pitch class in CollectionPCs at position Degree. However, the Accidental can alternate (increase or decrease) PC to a 'chromatic' pitch class not necessarily contained in CollectionPCs.

 The meaning of Accidental's actual numeric value is a bit complicated and depends on a two factors: (i) the maximum number of 'accumulated' accidentals (such as bb or x) which may be chosen dependent on the possible pitch classes between the elements in CollectionPCs, and (ii) because Oz FD integers must be non-negative an offset must be added which depends also on (i). For common praxis, this accidentalOffset defaults 2, thus the common accidentals are numerically encoded as such: bb=0, b=1, neutral=2, #=3, x=4.

 What the actual numeric value of a pitch class (and the interval denote by Accidental) means depends on DB.getPitchesPerOctave.

 To allow the user more flexibility, the accidentalOffset is not automatically set when the user sets the pitchesPerOctave value. Instead, the accidentalOffset can be set independently (see DB.setDB).

 In case of determined accidentals in the CSP definition, the user should avoid complicating the definition with accidentals encoded this way. Instead, the use of the accidental conversions Score.absoluteToOffsetAccidental or Score.offsetToAbsoluteAccidental is recommended.

 CollectionPCs should be ordered to avoid confusing the meaning of Degree, although this is not formally necessary. Regardless, PC and all elements in CollectionPCs should have the domain of a pitch class (you may use {HarmonisedScore.dB.makePitchClassFDInt}). Be careful to correctly define the Accidental domain. For instance, if the Accidental domain spans an entire octave, Degree can be any degree in CollectionPCs (you may use {HarmonisedScore.dB.makeAccidentalFDInt} which in turn uses the accidentalOffset).

 See also the terminology explanation in the top-level functor.



 BTW: To define the relation between a pitch class and the respective numeric 'note name' (i.e. the degrees in C-major) plus their accidentals, you could use DegreeToPC with the CollectionPCs for C-major.

 BTW: Similarily, DegreeToPC can also be used to define the relation between a (possibly micro-tonal) pitch class PC and its Degree + Accidental in dimensions of the net of harmonic relations, e.g., the spiral/circle of just fifth. In this usage, the variable name Degree is slightly missleading -- it actually means, e.g., a fifth-index (i.e. in case the Joe Monzo's 'array-pitch-representation' is used, Degree denotes the exponent for the respective ratio-dimension, e.g., the exponent for the 3 that is the fifths. However, it should be noted that the denoted pitch class is still rounded to integers, unlike the fractions denoted by real 'monzos'). For this usage, the order of CollectionPCs should reflect the order of the ratios depending on their exponent (e.g. in the order of the spiral of fifth).

 See ../testing/Score-test.oz for an [unfinished but seemingly conceptually clean] way to do something like MonzoToPC.


proc{CMajorDegreeToPC Degree#Accidental PC}

 Constrains the relation between the FD ints Degree, Accidental, and PC with respect to the just C-major scale. The closest approximation of the Pythagorean C-major scale [1/1 9/8 81/64 4/3 3/2 27/16 243/128] within the present setting of PitchesPerOctave is considered.

 CMajorDegreeToPC is the same as DegreeToPC, but with a predefined CollectionPCs (the Pythagorean C-major scale). See DegreeToPC for further details.



 NOTE: this constraint is used to derive an enharmonic notation, even for PitchesPerOctave \= 12. However, this constraint presents only one possible interpretation of the "white piano keys", namely as Pythagorean C-major scale degrees. All pitches with accidentals are understood as deviations of the Pythagorean C-major scale. Other interpretations of the "white piano keys" are possible (e.g., a just intonation of the C-major scale). For different PitchesPerOctave (e.g., if PitchesPerOctave=1200), different interpretations (i.e. different CollectionPCs used as a reference) will result in different accidentals or even different degrees for a given pitch class.


proc{TransposeDegree CollectionPCsFS UntransposedDegree#UntransposedPC TranspositionDegree#TranspositionPC TransposedDegree#TransposedPC}

 Constrains the transposition of the degree-represented pitch UntransposedDegree#UntransposedPC by TranspositionDegree#TranspositionPC to reach the degree-represented pitch TransposedDegree#TransposedPC. The transposition interval is specified by a combination of a degree distance (e.g. in the C major scale 5 represents a fifth) plus the pitch class of this interval (BTW: a similar representation is also used in MusES for an enharmonic representation).

 For example, in case CollectionPCs is C major: II# + fifth = VI# (i.e. d# + fifth = a#)

   {TransposeDegree {GUtils.intsToFS [0 2 4 5 7 9 11]}

    2#3

    5#7

    6#10}

 If CollectionPCs is a diatonic scale (e.g. C major), then the TranspositionDegree values correspond to the interval names from conventional music theory.

   1 -> prime

   2 -> second

   3 -> third

   4 -> fourth

   5 -> fifth

   6 -> sixth

   7 -> seventh

 Please note that the prime (i.e. pitch repetition) is represented by 1 (and not 0). 



 NB: TransposeDegree expects that the relation between each Degree#PC pair (and the respective Accidental) is also constrained. The necessary constraint (i.e. DegreeToPC) is not applied within TransposeDegree to avoid superfluous propagators (usually, the relation between these variables is already constrained elsewhere). 



 NB: The transposition interval is limited to a PC (i.e. an octave-less transposition: TranspositionPC is in the domain 0#(PitchesPerOctave-1)) to improve propagation. Intervals larger then a seventh 'fold back' into the intervals stated above.



 In case an octave component is important, then introduce variables for the absolute TranspositionInterval and its TranspositionOctave and constrain their relation by {IntervalPCToInterval TranspositionPC#TranspositionOctave Transposition}.


fun{GetDegree PitchClass MyPCColl Args}

 Returns the chord/scale degree (FD int) for PitchClass (FD int). MyPCColl is the chord/scale object to which the degree corresponds.



 Args:

 'accidentalRange' (int) specifies how many pitch class steps PitchClasses can be "off" (if AccidentalRange==0, then all PitClasses must be in the chord/scale).



 Note: very weak propagation -- MyPCColl must first be determined.


fun{AbsoluteToOffsetAccidental X}

 Converts a determined and possibly negative 'absolute accidental' (int) into a non-negative 'offset accidental' (int) used in CSPs. The absolute accidental 0 always denotes no pitch inflection of a scale degree (or noteName), negative values denote a 'decreasing' and positive an 'increasing' chromatic accidental. 

 For common praxis, where DB.getAccidentalOffset returns 2, 'absolute accidentals' are encoded like bb=~2, b=~1, neutral=0, #=1, x=2 and 'offset accidentals' as bb=0, b=1, neutral=2, #=3, x=4.


fun{OffsetToAbsoluteAccidental X}

 Converts a determined 'offset accidental' (int) used in CSPs into a possibly negative 'absolute accidental' (int). The absolute accidental 0 always denotes no pitch inflection of a scale degree (or noteName), negative values denote a 'decreasing' and positive an 'increasing' accidental. 

 For common praxis, where DB.getAccidentalOffset returns 2, 'absolute accidentals' are encoded like bb=~2, b=~1, neutral=0, #=1, x=2 and 'offset accidentals' as bb=0, b=1, neutral=2, #=3, x=4.


fun{PcSetToSequence PCFS Root}

 Expects a set of pitch classes from a scale or chord (PCFS, a determined FS) and a Root (an determined FD) and returns a list of ints in ascending order starting with the root (if root is present in PCFS). If root is not present in PCFS, then the returned list starts with the pitch class which would follow root.  

 PCSetToSequence is useful for creating an ordered PC collection to constrain the degree of some PC (e.g., with DegreeToPC). For example, the PC set of the E major scale is {1, 3, 4, 6, 8, 9, 11} and the root is 4: PCSetToSequence returns the ordered sequence [4 6 8 9 11 1 3]. 



 NB: PcSetToSequence blocks until its arguments PCFS and Root are determined.


fun{GetAdaptiveJIPitch MyNote Args}

 Returns an adaptive just intonation pitch (midi float) of MyNote (HS.score.note instance), where the tuning depends on the harmonic context (i.e. the chord object related to MyNote).



 If MyNote is a chord tone (i.e. getInChordB returns 1) and the related chord of MyNote is specified by ratios in the chord database, then the corresponding chord ratio is used for tuning. The chord root is tuned according to the current tuning table, or to the equal temperament defined by its pitch unit if no tuning table is specified.



 Args:

 'tuneNonharmonicNotes' (default true): If true, non-harmonic tones are tuned as the ratio defined in the current interval DB for the PC interval between MyNote and the root of the related chord. Otherwise, the result is {MyNote getPitchInMidi($)} (i.e. either the pitch of the tuning table or the ET depending on the pitch unit).



 Note that you need to define chord/scale databases using ratios (integer pairs) for adaptive JI. Presently, only the predefined chord and scale databases in ET31 and ET22 are defined by ratios.  In the default chord database, chords and scales are (currently) defined by pitch class integers and thus GetAdaptiveJIPitch returns the same pitch as the note method getPitchInMidi.


fun{GetAdaptiveJIPitch2 MyNote MyNoteRatio MyChord Args}

 Returns the adapted JI pitch of MyNote as Midi float. MyNoteRatio (pair of ints) is the ratio over the root of MyChord which corresponds to the pitch of MyNote.



 Args currently unused, intended for later extensions.


fun{MinimalCadentialSets MyScale ContextScale}


fun{MinimalCadentialSets2 MyScaleFS ContextScaleFSs}


fun{MakeAllContextScales ScaleIndices Transpositions}

 Returns the list of all scales with the given scale indices and transpositions (two lists of integers), more specifically the cartesian product of all the scales with these parameters is created.

Index
HarmonisedScore
DB
HS_Score
Rules
DBs
HS_Distro
HS_Out
HS
Schoenberg
Default
Jazz
Partch
Johnston
Harrison
Chalmers
Catler
ArithmeticalSeriesChords

Functor

Import

Export

Define

End