/// <summary>
/// Add an interval to this representation.
/// </summary>
/// <param name="interval">The interval to add.</param>
/// <param name="direction">Which direction to go - up or down.</param>
/// <returns>Null if there is no supported enharmonically correct representation of the requested interval. For example,
/// adding a minor second to a Bb should return a Cb, but this is not supported so the result will be null. If there is
/// a valid representation (for example, A# plus a minor second correctly yields B) it will be returned.</returns>
public NoteRepresentation AddInterval(Interval interval, IntervalDirection direction = IntervalDirection.Up)
{
var coefficient = direction == IntervalDirection.Up ? 1 : -1;
var newNoteNumber = this.Note.Number + (interval.NumberOfSemitones() * coefficient);
var newNoteName = this.Name.AddNoteNames(interval.NumberOfNoteNames() * coefficient);
var result = new Note(newNoteNumber).GetRepresentations().SingleOrDefault(r => r.Name == newNoteName);
return result;
}
/// <summary>
/// Creates a representation for a natural.
/// </summary>
/// <param name="naturalNote">Can't be an accidental.</param>
internal NoteRepresentation(Note naturalNote)
{
if (naturalNote.IsAccidental())
throw new Exception("Only a natural can be passed to this constructor.");
Note = naturalNote;
Name = GetNaturalNoteName(naturalNote);
Accidental = AccidentalType.Natural;
}
public static NoteName GetNaturalNoteName(Note naturalNote)
{
if (naturalNote.IsAccidental())
throw new Exception("Argument must be a natural.");
return (NoteName)(Array.IndexOf(Note.GetNaturals(), naturalNote) % 7);
}
/// <summary>
/// Creates a new note representation.
/// </summary>
internal NoteRepresentation(Note note, AccidentalType accidental, NoteName name)
{
Note = note;
Accidental = accidental;
Name = name;
}
