Interval.h

#ifndef MCC_INTERVAL_INTERVAL_H
#define MCC_INTERVAL_INTERVAL_H
 
#include <MCC_BuildSettings.h>
 
#include <stdint.h>
 
#include <MCC/Interval/IntervalDirection.h>
#include <MCC/Interval/IntervalNumber.h>
#include <MCC/Interval/IntervalQuality.h>
 
namespace MCC {

class Interval {
public:
    static constexpr int16_t MaximumSteps = IntervalNumber::Maximum - 1;

    static constexpr int16_t MaximumSemitones = 3079;

    static constexpr int16_t InvalidSteps = 32767;
 
private:
    int16_t _steps;
    int16_t _semitones;
 
    // Semitones of the perfect or major simple interval for 0-6 steps
    // (0 2 4 5 7 9 11). Computed rather than tabled so AVR keeps no lookup
    // table in RAM.
    static constexpr int32_t ReferenceSemitones(int32_t simpleSteps) noexcept {
        return simpleSteps * 2 - (simpleSteps >= 3 ? 1 : 0);
    }
 
    static constexpr bool IsPerfectSteps(int32_t simpleSteps) noexcept {
        return simpleSteps == 0 || simpleSteps == 3 || simpleSteps == 4;
    }
 
    static constexpr int32_t Magnitude(int32_t value) noexcept {
        return value < 0 ? -value : value;
    }
 
    // Deviation of the semitones from the perfect/major reference of the
    // same number, measured in the interval's direction.
    MCC_CONSTEXPR14 int32_t Deviation() const noexcept {
        const int32_t sign = Sign();
        const int32_t steps = sign * _steps;
        const int32_t semitones = sign * _semitones;
        return semitones - (steps / 7) * 12 - ReferenceSemitones(steps % 7);
    }
 
    constexpr int32_t Sign() const noexcept {
        return (_steps != 0)
            ? (_steps > 0 ? 1 : -1)
            : (_semitones < 0 ? -1 : 1);
    }
 
    static MCC_CONSTEXPR14 IntervalQuality QualityFor(int32_t steps,
                                                int32_t deviation) noexcept {
        if (IsPerfectSteps(steps % 7)) {
            if (deviation == 0) {
                return IntervalQuality::Perfect();
            }
            return deviation > 0
                ? IntervalQuality::Augmented(deviation)
                : IntervalQuality::Diminished(-deviation);
        }
        if (deviation == 0) {
            return IntervalQuality::Major();
        }
        if (deviation == -1) {
            return IntervalQuality::Minor();
        }
        return deviation > 0
            ? IntervalQuality::Augmented(deviation)
            : IntervalQuality::Diminished(-deviation - 1);
    }
 
public:
    constexpr Interval() noexcept : _steps(InvalidSteps), _semitones(0) {}

    static MCC_CONSTEXPR14 Interval FromSteps(int32_t diatonicSteps,
                                        int32_t semitones) noexcept {
        // Compare against both bounds: negating INT32_MIN would overflow.
        if (diatonicSteps < -MaximumSteps || diatonicSteps > MaximumSteps ||
            semitones < -MaximumSemitones || semitones > MaximumSemitones) {
            return Interval();
        }
        Interval candidate;
        candidate._steps = static_cast<int16_t>(diatonicSteps);
        candidate._semitones = static_cast<int16_t>(semitones);
        return candidate.Quality().IsValid() ? candidate : Interval();
    }

    MCC_CONSTEXPR14 Interval(IntervalQuality quality, IntervalNumber number,
                       IntervalDirection direction = IntervalDirection::Ascending) noexcept
        : Interval(Build(quality, number, direction)) {}

    static constexpr Interval Invalid() noexcept { return Interval(); }

    static MCC_CONSTEXPR14 Interval Unison() noexcept { return FromSteps(0, 0); }

    constexpr bool IsValid() const noexcept { return _steps != InvalidSteps; }

    constexpr int16_t DiatonicSteps() const noexcept { return _steps; }

    constexpr int16_t Semitones() const noexcept { return _semitones; }

    MCC_CONSTEXPR14 IntervalDirection Direction() const noexcept {
        if (!IsValid() || (_steps == 0 && _semitones == 0)) {
            return IntervalDirection::Unison;
        }
        return Sign() > 0 ? IntervalDirection::Ascending
                          : IntervalDirection::Descending;
    }

    MCC_CONSTEXPR14 IntervalNumber Number() const noexcept {
        if (!IsValid()) {
            return IntervalNumber::Invalid();
        }
        return IntervalNumber(Magnitude(_steps) + 1);
    }

    MCC_CONSTEXPR14 IntervalQuality Quality() const noexcept {
        if (!IsValid()) {
            return IntervalQuality::Invalid();
        }
        return QualityFor(Magnitude(_steps), Deviation());
    }

    MCC_CONSTEXPR14 bool IsSimple() const noexcept { return Number().IsSimple(); }

    MCC_CONSTEXPR14 bool IsCompound() const noexcept { return Number().IsCompound(); }

    MCC_CONSTEXPR14 Interval Simple() const noexcept {
        if (!IsValid() || Magnitude(_steps) <= 7) {
            return *this;
        }
        const int32_t sign = Sign();
        const int32_t octaves = (Magnitude(_steps) - 1) / 7;
        return FromSteps(_steps - sign * octaves * 7,
                         _semitones - sign * octaves * 12);
    }

    MCC_CONSTEXPR14 Interval Inverted() const noexcept {
        if (!IsValid()) {
            return Invalid();
        }
        const Interval simple = Simple();
        const int32_t sign = simple.Sign();
        return FromSteps(sign * 7 - simple._steps, sign * 12 - simple._semitones);
    }

    MCC_CONSTEXPR14 Interval Reversed() const noexcept {
        if (!IsValid()) {
            return Invalid();
        }
        return FromSteps(-static_cast<int32_t>(_steps),
                         -static_cast<int32_t>(_semitones));
    }

    friend MCC_CONSTEXPR14 Interval operator+(Interval a, Interval b) noexcept {
        if (!a.IsValid() || !b.IsValid()) {
            return Invalid();
        }
        return FromSteps(static_cast<int32_t>(a._steps) + b._steps,
                         static_cast<int32_t>(a._semitones) + b._semitones);
    }

    friend constexpr bool operator==(Interval a, Interval b) noexcept {
        return a._steps == b._steps && a._semitones == b._semitones;
    }
 
    friend constexpr bool operator!=(Interval a, Interval b) noexcept {
        return !(a == b);
    }
 
private:
    static MCC_CONSTEXPR14 Interval Build(IntervalQuality quality, IntervalNumber number,
                                    IntervalDirection direction) noexcept {
        if (!quality.IsValid() || !number.IsValid()) {
            return Interval();
        }
        const int32_t steps = number.Value() - 1;
        const int32_t simpleSteps = steps % 7;
        const IntervalQualityKind kind = quality.Kind();
        const int32_t count = quality.Count();
 
        int32_t deviation = 0;
        if (IsPerfectSteps(simpleSteps)) {
            if (kind == IntervalQualityKind::Major ||
                kind == IntervalQualityKind::Minor) {
                return Interval();
            }
            deviation = (kind == IntervalQualityKind::Augmented) ? count
                : (kind == IntervalQualityKind::Diminished) ? -count
                : 0;
        } else {
            if (kind == IntervalQualityKind::Perfect) {
                return Interval();
            }
            deviation = (kind == IntervalQualityKind::Augmented) ? count
                : (kind == IntervalQualityKind::Minor) ? -1
                : (kind == IntervalQualityKind::Diminished) ? -count - 1
                : 0;
        }
 
        if (steps == 0) {
            if (deviation < 0) {
                return Interval();  // No diminished unison (SPEC-INT-5).
            }
            if (deviation == 0) {
                return Unison();
            }
            if (direction == IntervalDirection::Unison) {
                return Interval();
            }
        } else if (direction == IntervalDirection::Unison) {
            return Interval();
        }
 
        const int32_t sign = (direction == IntervalDirection::Descending) ? -1 : 1;
        const int32_t semitones =
            (steps / 7) * 12 + ReferenceSemitones(simpleSteps) + deviation;
        return FromSteps(sign * steps, sign * semitones);
    }
};

constexpr bool IsEnharmonic(Interval a, Interval b) noexcept {
    return a.IsValid() && b.IsValid() && a.Semitones() == b.Semitones();
}
 
} // namespace MCC
 
#endif // MCC_INTERVAL_INTERVAL_H