public void NameConstructor()
{
PitchClass pc = new PitchClass('A', Accidental.Flat);
Assert.AreEqual('A', pc.Name);
Assert.AreEqual("Ab", pc.ToString());
}
public void Bx()
{
PitchClass pc = new PitchClass(6, Accidental.DoubleSharp);
Assert.AreEqual('B', pc.Name);
Assert.AreEqual("Bx", pc.ToString());
}
public void Eb()
{
PitchClass pc = new PitchClass(2, Accidental.Flat);
Assert.AreEqual('E', pc.Name);
Assert.AreEqual("Eb", pc.ToString());
}
public void C()
{
PitchClass pc = new PitchClass(0, Accidental.Natural);
Assert.AreEqual('C', pc.Name);
Assert.AreEqual("C", pc.ToString());
}
public override Scale CreateScale(PitchClass key)
{
switch (key)
{
case PitchClass.C: return(new CMajorScale(key));
case PitchClass.G: return(new GMajorScale(key));
default: return(null);
}
}
public override Scale CreateScale(PitchClass key)
{
switch (key)
{
case PitchClass.A: return(new AMinorScale(key));
case PitchClass.E: return(new EMinorScale(key));
default: return(null);
}
}
public GMajorScale(PitchClass key)
{
Tonic = PitchClass.G;
Supertonic = PitchClass.A;
Mediant = PitchClass.H;
Subdominant = PitchClass.C;
Dominant = PitchClass.D;
Submediant = PitchClass.E;
LeadingTone = PitchClass.Fis;
Key = key;
}
public AMinorScale(PitchClass key)
{
Tonic = PitchClass.A;
Supertonic = PitchClass.H;
Mediant = PitchClass.C;
Subdominant = PitchClass.D;
Dominant = PitchClass.E;
Submediant = PitchClass.F;
LeadingTone = PitchClass.G;
Key = key;
}
private HarmonicEffect ReadHarmonic(Note note)
{
/*Harmonic is encoded in :ref:`signed-byte`. Values correspond to:
*
* - *1*: natural harmonic
* - *3*: tapped harmonic
* - *4*: pinch harmonic
* - *5*: semi-harmonic
* - *15*: artificial harmonic on (*n + 5*)th fret
* - *17*: artificial harmonic on (*n + 7*)th fret
* - *22*: artificial harmonic on (*n + 12*)th fret
*/
var harmonicType = GpBase.ReadSignedByte()[0];
HarmonicEffect harmonic = null;
switch (harmonicType)
{
case 1:
harmonic = new NaturalHarmonic(); break;
case 3:
harmonic = new TappedHarmonic(); break;
case 4:
harmonic = new PinchHarmonic(); break;
case 5:
harmonic = new SemiHarmonic(); break;
case 15:
var pitch = new PitchClass((note.RealValue() + 7) % 12, -1, "", "", 7.0f);
var octave = Octaves.Ottava;
harmonic = new ArtificialHarmonic(pitch, octave);
break;
case 17:
pitch = new PitchClass(note.RealValue(), -1, "", "", 12.0f);
octave = Octaves.Quindicesima;
harmonic = new ArtificialHarmonic(pitch, octave);
break;
case 22:
pitch = new PitchClass(note.RealValue(), -1, "", "", 5.0f);
octave = Octaves.Ottava;
harmonic = new ArtificialHarmonic(pitch, octave);
break;
}
return(harmonic);
}
public void ConstructorRange()
{
PitchClass pc = new PitchClass(7, Accidental.Sharp);
}
public static double GetFrequency(PitchClass pitchClass, int octave)
{
int pianoKeyNumber = GetPianoKeyNumber(pitchClass.PitchClassNumber, octave);
return(Math.Pow(2, (pianoKeyNumber - 49) / 12.0) * 440);
}
public ArtificialHarmonic(PitchClass pitch = null, Octaves octave = 0) : base(2)
{
Pitch = pitch;
Octave = octave;
}
public void NameConstructorRange()
{
PitchClass pc = new PitchClass('H', Accidental.Flat);
}
public ArtificialHarmonic(PitchClass pitch = null, Octave octave = 0)
{
this.pitch = pitch;
this.octave = octave;
this.type = 2;
}
Pitch MakeNatural(PitchClass pitchClass, Octave octave)
{
return(new Pitch(octave, pitchClass));
}
// todo: add support for flats/sharps
Pitch MakeSharp(PitchClass pitchClass, Octave octave)
{
throw new NotImplementedException();
}
public abstract Scale CreateScale(PitchClass key);
public void Format_WithSuspendedSecondChordNoAdditionalTones_ShouldReturnPitchClassInUpperCaseWithAccidental(PitchClass pitchClass, Accidental accidental, string expectedValue)
{
// ARRANGE
var westernChordStringFormatter = new WesternChordStringFormatter();
var chordClass = new ChordClass(new PitchClassWithAccidental(pitchClass, accidental), TriadPattern.SuspendedSecond, ImmutableList <ChordAddedNote> .Empty);
// ACT
string actualValue = westernChordStringFormatter.Format(chordClass);
// ASSERT
actualValue.Should().Be(expectedValue);
}
