Struct Rules 

pub struct Rules {

    pub forbid_incomplete_possibilities: bool,
    pub upper_parts_max_semitone_separation: Option<IntegerType>,
    pub forbid_voice_crossing: bool,
    pub forbid_parallel_fifths: bool,
    pub forbid_parallel_octaves: bool,
    pub forbid_hidden_fifths: bool,
    pub forbid_hidden_octaves: bool,
    pub forbid_voice_overlap: bool,
    pub part_movement_limits: Vec<(usize, IntegerType)>,
    pub resolve_dominant_seventh_properly: bool,
    pub resolve_diminished_seventh_properly: bool,
    pub resolve_augmented_sixth_properly: bool,
    pub doubled_root_in_dim7: bool,
    pub apply_single_possib_rules_to_resolution: bool,
    pub apply_consecutive_possib_rules_to_resolution: bool,
    pub restrict_doublings_in_italian_a6_resolution: bool,
    pub upper_parts_remain_same: bool,
    pub part_pitch_limits: Vec<(usize, Pitch)>,
    pub parts_to_check: Vec<usize>,
}

The rules a realization keeps, each on or off: which voicings of one chord are acceptable, which moves from one chord to the next are, and how the chords that must resolve a particular way are resolved.

Every rule starts out as music21’s does.

Fields

forbid_incomplete_possibilities: bool

Refuse a voicing that leaves out a note of its chord.

upper_parts_max_semitone_separation: Option<IntegerType>

How far apart, in semitones, the upper parts may lie; None lets them lie anywhere.

forbid_voice_crossing: bool

Refuse a voicing where a part sings above a part over it.

forbid_parallel_fifths: bool

Refuse parallel fifths.

forbid_parallel_octaves: bool

Refuse parallel octaves.

forbid_hidden_fifths: bool

Refuse hidden fifths between the outer parts.

forbid_hidden_octaves: bool

Refuse hidden octaves between the outer parts.

forbid_voice_overlap: bool

Refuse a part moving past where a neighbouring part was.

part_movement_limits: Vec<(usize, IntegerType)>

How far each part named may move, in semitones: (part, semitones), counting the highest part as one.

resolve_dominant_seventh_properly: bool

Resolve a dominant seventh as a dominant seventh resolves.

resolve_diminished_seventh_properly: bool

Resolve a diminished seventh as a diminished seventh resolves.

resolve_augmented_sixth_properly: bool

Resolve an augmented sixth as an augmented sixth resolves.

doubled_root_in_dim7: bool

Resolve a diminished seventh to the tonic with its root doubled, rather than its third, where the inversions do not decide it.

apply_single_possib_rules_to_resolution: bool

Hold a special resolution to the rules for single voicings too.

apply_consecutive_possib_rules_to_resolution: bool

Hold a special resolution to the rules for moving between voicings too.

restrict_doublings_in_italian_a6_resolution: bool

In resolving an Italian sixth, let the root resolve only once and the third not be doubled.

upper_parts_remain_same: bool

Keep every part but the bass where it was: music21’s _upperPartsRemainSame, which a realizer sets for a bass note that only moves.

part_pitch_limits: Vec<(usize, Pitch)>

Hold each part named to a pitch: (part, pitch), counting the highest part as one. music21’s _partPitchLimits.

parts_to_check: Vec<usize>

The parts that must keep their pitch from one voicing to the next: music21’s _partsToCheck.

Trait Implementations

impl Clone for Rules

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Rules

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Rules

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Rules

Available on crate feature serde only.

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Rules

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Rules

Available on crate feature serde only.

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Rules