Transposition.h

#ifndef MCC_INTERVAL_TRANSPOSITION_H
#define MCC_INTERVAL_TRANSPOSITION_H
 
#include <MCC_BuildSettings.h>
 
#include <stdint.h>
 
#include <Foundation/Math/Arithmetic.h>
 
#include <MCC/Interval/Interval.h>
#include <MCC/Pitch/Accidental.h>
#include <MCC/Pitch/Letter.h>
#include <MCC/Pitch/NoteName.h>
#include <MCC/Pitch/Pitch.h>
 
namespace MCC {

MCC_CONSTEXPR14 Interval IntervalBetween(Pitch from, Pitch to) noexcept {
    if (!from.IsValid() || !to.IsValid()) {
        return Interval::Invalid();
    }
    return Interval::FromSteps(
        static_cast<int32_t>(to.DiatonicIndex()) - from.DiatonicIndex(),
        static_cast<int32_t>(to.ChromaticIndex().Value()) -
            from.ChromaticIndex().Value());
}

MCC_CONSTEXPR14 Interval IntervalBetween(NoteName from, NoteName to) noexcept {
    if (!from.IsValid() || !to.IsValid()) {
        return Interval::Invalid();
    }
    const int32_t fromIndex = DiatonicIndex(from.Letter());
    const int32_t toIndex = DiatonicIndex(to.Letter());
    const int32_t steps = Foundation::Math::FloorMod(toIndex - fromIndex, LetterCount);
    const int32_t wrap = (toIndex < fromIndex) ? 12 : 0;
    const int32_t semitones =
        NaturalSemitone(to.Letter()) + to.Accidental().Semitones() + wrap -
        NaturalSemitone(from.Letter()) - from.Accidental().Semitones();
    return Interval::FromSteps(steps, semitones);
}

MCC_CONSTEXPR14 Pitch operator+(Pitch pitch, Interval interval) noexcept {
    if (!pitch.IsValid() || !interval.IsValid()) {
        return Pitch::Invalid();
    }
    const int32_t diatonic =
        static_cast<int32_t>(pitch.DiatonicIndex()) + interval.DiatonicSteps();
    const int32_t chromatic =
        static_cast<int32_t>(pitch.ChromaticIndex().Value()) + interval.Semitones();
    const Letter letter =
        static_cast<Letter>(Foundation::Math::FloorMod(diatonic, LetterCount));
    const int32_t octave = Foundation::Math::FloorDiv(diatonic, LetterCount);
    const int32_t natural = (octave + 1) * 12 + NaturalSemitone(letter);
    return Pitch(letter, Accidental(chromatic - natural), octave);
}

MCC_CONSTEXPR14 Pitch operator-(Pitch pitch, Interval interval) noexcept {
    return pitch + interval.Reversed();
}

MCC_CONSTEXPR14 NoteName operator+(NoteName noteName, Interval interval) noexcept {
    if (!noteName.IsValid() || !interval.IsValid()) {
        return NoteName::Invalid();
    }
    // Write the note name in octave 0, transpose it by the simple interval
    // (at most one octave, so the octave stays in range) and drop the
    // octave. An accidental overflow yields the invalid pitch, whose note
    // name is invalid.
    return (Pitch(noteName, 0) + interval.Simple()).NoteName();
}

MCC_CONSTEXPR14 NoteName operator-(NoteName noteName, Interval interval) noexcept {
    return noteName + interval.Reversed();
}
 
} // namespace MCC
 
#endif // MCC_INTERVAL_TRANSPOSITION_H