chord.h

#pragma once
#include <functional>
#include <numeric>  // std::accumulate
#include <tuple>    // std::tuple
#include <vector>
#include <algorithm> // std::transform
 
#include "maiacore/interval.h"
#include "maiacore/key.h"
#include "maiacore/note.h"
 
struct NoteData {
    Note note = Note("rest");
    bool wasEnharmonized = false;
    int enharmonicDiatonicDistance = 0;
 
    NoteData() : note(Note("rest")), wasEnharmonized(false), enharmonicDiatonicDistance(0) {}
 
    NoteData(const Note& _originalNotes, const bool _wasEnhar, const int _enharDiat)
        : note(_originalNotes),
          wasEnharmonized(_wasEnhar),
          enharmonicDiatonicDistance(_enharDiat){};
 
    friend bool operator<(const NoteData& lhs, const NoteData& rhs) {
        return lhs.note.getMidiNumber() < rhs.note.getMidiNumber();
    }
};
 
 
// NoteDataHeap Type [Vector of NotesData]
typedef std::vector<NoteData> NoteDataHeap;
// HeapData Type [NoteDataHeap, stackMatchValue]
typedef std::tuple<NoteDataHeap, float> HeapData;
 
bool operator<(const HeapData& a, const HeapData& b);
 
void printHeap(const NoteDataHeap& heap);
 
void sortHeapOctaves(NoteDataHeap* heap);
 
typedef std::tuple<int, float, std::string, int, float, int, float, std::string, int, float, float,
                   float, float>
    SetharesDissonanceTableRow;
typedef std::vector<SetharesDissonanceTableRow> SetharesDissonanceTable;
 
class Chord {
   private:
    std::vector<Note> _originalNotes;
 
    std::vector<Note> _openStack;
 
    std::vector<Note> _closeStack;
 
    std::vector<HeapData> _stackedHeaps;
 
    std::vector<Interval> _closeStackintervals;
 
    Note _bassNote;
 
    bool _isStackedInThirds;
 
    void computeIntervals();
 
    void stackInThirds(const bool enharmonyNotes = false);
 
    HeapData stackInThirdsTemplateMatch(const NoteDataHeap& heap) const;
 
    std::vector<NoteDataHeap> computeEnharmonicUnitsGroups() const;
 
    std::vector<NoteDataHeap> computeEnharmonicHeaps(const std::vector<NoteDataHeap>& heaps) const;
 
    std::vector<NoteDataHeap> removeHeapsWithDuplicatedPitchSteps(
        std::vector<NoteDataHeap>& heaps) const;
 
    std::vector<NoteDataHeap> computeAllHeapInversions(NoteDataHeap& heap) const;
 
    std::vector<NoteDataHeap> filterTertianHeapsOnly(const std::vector<NoteDataHeap>& heaps) const;
 
    std::vector<Note> computeBestOpenStackHeap(std::vector<HeapData>& stackedHeaps);
 
    void computeCloseStack(const std::vector<Note>& openStack);
 
    template <typename T>
    float computeStandardDeviation(const std::vector<T>& v) const {
        const float sum = std::accumulate(v.begin(), v.end(), 0);
        const float mean = sum / v.size();
 
        std::vector<float> diff(v.size());
        std::transform(v.begin(), v.end(), diff.begin(), [mean](double x) { return x - mean; });
        const float sq_sum = std::inner_product(diff.begin(), diff.end(), diff.begin(), 0.0);
        const float stdev = std::sqrt(sq_sum / v.size());
 
        return stdev;
    }
 
   public:
    Chord();
 
    explicit Chord(const std::vector<Note>& notes, const RhythmFigure rhythmFigure = RhythmFigure::QUARTER);
 
    explicit Chord(const std::vector<std::string>& pitches, const RhythmFigure rhythmFigure = RhythmFigure::QUARTER);
 
    ~Chord();
 
    void clear();
 
    void addNote(const Note& note);
 
    void addNote(const std::string& pitch);
 
    void removeTopNote();
 
    void insertNote(Note& insertNote, int positionNote = 0);
 
    void removeNote(int noteIndex);
 
    void setDuration(const Duration& duration);
 
    void setDuration(const float quarterDuration, const int divisionsPerQuarterNote = 256);
 
    void toInversion(int inversionNumber);
 
    void transpose(const int semiTonesNumber);
 
    void transposeStackOnly(const int semiTonesNumber);
 
    void removeDuplicateNotes();
 
    std::vector<HeapData> getStackedHeaps(const bool enharmonyNotes = false);
 
    std::string getDuration() const;
 
    float getQuarterDuration() const;
 
    int getDurationTicks() const;
 
    Note& getNote(int noteIndex);
 
    const Note& getNote(const int noteIndex) const;
 
    const Note& getRoot();
 
    std::string getName();
 
    const Note& getBassNote();
 
    const std::vector<Note>& getNotes() const;
 
    float getCloseStackHarmonicComplexity(const bool useEnharmony = false);
 
    float getHarmonicDensity(int lowerBoundMIDI = -1, int higherBoundMIDI = -1) const;
 
    float getHarmonicDensity(const std::string& lowerBoundPitch = {},
                             const std::string& higherBoundPitch = {}) const;
 
    bool haveMajorInterval(const bool useEnharmony = false) const;
 
    bool haveMinorInterval(const bool useEnharmony = false) const;
 
    bool havePerfectInterval(const bool useEnharmony = false) const;
 
    bool haveDiminishedInterval(const bool useEnharmony = false) const;
 
    bool haveAugmentedInterval(const bool useEnharmony = false) const;
 
    // ===== ABSTRACTION 1 ===== //
    bool haveDiminishedUnisson(const bool useEnharmony = false) const;
 
    bool havePerfectUnisson(const bool useEnharmony = false) const;
 
    bool haveAugmentedUnisson(const bool useEnharmony = false) const;
 
    bool haveMinorSecond(const bool useEnharmony = false);
 
    bool haveMajorSecond(const bool useEnharmony = false);
 
    bool haveMinorThird(const bool useEnharmony = false);
 
    bool haveMajorThird(const bool useEnharmony = false);
 
    bool havePerfectFourth(const bool useEnharmony = false);
 
    bool haveAugmentedFourth(const bool useEnharmony = false);
 
    bool haveDiminishedFifth(const bool useEnharmony = false);
 
    bool havePerfectFifth(const bool useEnharmony = false);
 
    bool haveAugmentedFifth(const bool useEnharmony = false);
 
    bool haveMinorSixth(const bool useEnharmony = false);
 
    bool haveMajorSixth(const bool useEnharmony = false);
 
    bool haveDiminishedSeventh(const bool useEnharmony = false);
 
    bool haveMinorSeventh(const bool useEnharmony = false);
 
    bool haveMajorSeventh(const bool useEnharmony = false);
 
    bool haveDiminishedOctave(const bool useEnharmony = false);
 
    bool havePerfectOctave(const bool useEnharmony = false);
 
    bool haveAugmentedOctave(const bool useEnharmony = false);
 
    bool haveMinorNinth(const bool useEnharmony = false);
 
    bool haveMajorNinth(const bool useEnharmony = false);
 
    bool havePerfectEleventh(const bool useEnharmony = false);
 
    bool haveSharpEleventh(const bool useEnharmony = false);
 
    bool haveMinorThirdteenth(const bool useEnharmony = false);
 
    bool haveMajorThirdteenth(const bool useEnharmony = false);
 
    // ===== ABSTRACTION 2 ===== //
 
    bool haveSecond(const bool useEnharmony = false) const;
 
    bool haveThird(const bool useEnharmony = false) const;
 
    bool haveFourth(const bool useEnharmony = false) const;
 
    bool haveFifth(const bool useEnharmony = false) const;
 
    bool haveSixth(const bool useEnharmony = false) const;
 
    bool haveSeventh(const bool useEnharmony = false) const;
 
    bool haveOctave(const bool useEnharmony = false) const;
 
    bool haveNinth(const bool useEnharmony = false) const;
 
    bool haveEleventh(const bool useEnharmony = false) const;
 
    bool haveThirdteenth(const bool useEnharmony = false) const;
 
    // ===== ABSTRACTION 3 ===== //
 
    bool haveAnyOctaveMinorSecond(const bool useEnharmony = false) const;
 
    bool haveAnyOctaveMajorSecond(const bool useEnharmony = false) const;
 
    bool haveAnyOctaveMinorThird(const bool useEnharmony = false) const;
 
    bool haveAnyOctaveMajorThird(const bool useEnharmony = false) const;
 
    bool haveAnyOctavePerfectFourth(const bool useEnharmony = false) const;
 
    bool haveAnyOctaveAugmentedFourth(const bool useEnharmony = false) const;
 
    bool haveAnyOctaveDiminishedFifth(const bool useEnharmony = false) const;
 
    bool haveAnyOctavePerfectFifth(const bool useEnharmony = false) const;
 
    bool haveAnyOctaveAugmentedFifth(const bool useEnharmony = false) const;
 
    bool haveAnyOctaveMinorSixth(const bool useEnharmony = false) const;
 
    bool haveAnyOctaveMajorSixth(const bool useEnharmony = false) const;
 
    bool haveAnyOctaveDiminishedSeventh(const bool useEnharmony = false) const;
 
    bool haveAnyOctaveMinorSeventh(const bool useEnharmony = false) const;
 
    bool haveAnyOctaveMajorSeventh(const bool useEnharmony = false) const;
 
    bool haveAnyOctaveDiminishedOctave(const bool useEnharmony = false) const;
 
    bool haveAnyOctavePerfectOctave(const bool useEnharmony = false) const;
 
    bool haveAnyOctaveAugmentedOctave(const bool useEnharmony = false) const;
 
    // ===== ABSTRACTION 4 ===== //
 
    bool haveAnyOctaveSecond() const;
 
    bool haveAnyOctaveThird() const;
 
    bool haveAnyOctaveFourth() const;
 
    bool haveAnyOctaveFifth() const;
 
    bool haveAnyOctaveSixth() const;
 
    bool haveAnyOctaveSeventh() const;
 
    bool haveAnyOctaveOctave() const;
 
    bool isDyad();
 
    bool isSus();
 
    bool isMajorChord();
 
    bool isMinorChord();
 
    bool isAugmentedChord();
 
    bool isDiminishedChord();
 
    bool isHalfDiminishedChord();
 
    bool isWholeDiminishedChord();
 
    bool isDominantSeventhChord();
 
    std::string getQuality();
 
    bool isSorted() const;
 
    bool isTonal(std::function<bool(const Chord& chord)> model = nullptr);
 
    bool isInRootPosition();
 
    std::vector<int> getMidiIntervals(const bool firstNoteAsReference = false) const;
 
    std::vector<Interval> getIntervals(const bool firstNoteAsReference = false) const;
 
    std::vector<Interval> getIntervalsFromOriginalSortedNotes() const;
 
    std::vector<Interval> getOpenStackIntervals(const bool firstNoteAsReference = false);
 
    std::vector<Interval> getCloseStackIntervals(const bool firstNoteAsReference = false);
 
    std::vector<Note> getOpenStackNotes();
 
    int size() const;
 
    int stackSize();
 
    void print() const;
 
    void printStack() const;
 
    void info();
 
    Chord getOpenStackChord(const bool enharmonyNotes = false);
 
    Chord getCloseStackChord(const bool enharmonyNotes = false);
 
    Chord getCloseChord(const bool enharmonyNotes = false);
 
    void sortNotes();
 
    std::vector<int> toCents() const;
 
    int getDegree(const Key& key, bool enharmonyNotes = false);
 
    std::string getRomanDegree(const Key& key, bool enharmonyNotes = false);
 
    float getMeanFrequency(const float freqA4 = 440.0f) const;
 
    float getMeanOfExtremesFrequency(const float freqA4 = 440.0f) const;
 
    float getFrequencyStd(const float freqA4 = 440.0f) const;
 
    int getMeanMidiValue() const;
 
    int getMeanOfExtremesMidiValue() const;
 
    float getMidiValueStd() const;
 
    std::string getMeanPitch(const std::string& accType = {}) const;
 
    std::string getMeanOfExtremesPitch(const std::string& accType = {}) const;
 
    std::pair<std::vector<float>, std::vector<float>> getHarmonicSpectrum(
        const int numPartialsPerNote = 6,
        const std::function<std::vector<float>(std::vector<float>)> amplCallback = nullptr,
        const float partialsDecayExpRate = 0.88f) const;
 
    SetharesDissonanceTable getSetharesDyadsDissonanceValue(
        const int numPartials = 6, const bool useMinModel = true,
        const std::function<std::vector<float>(std::vector<float>)> amplCallback = nullptr,
        const float partialsDecayExpRate = 0.88f) const;
 
    float getSetharesDissonance(
        const int numPartialsPerNote = 6, const bool useMinModel = true,
        const std::function<std::vector<float>(std::vector<float>)> amplCallback = nullptr,
        const float partialsDecayExpRate = 0.88f,
        const std::function<float(std::vector<float>)> dissCallback = nullptr) const;
 
    const Note& operator[](size_t index) const { return _originalNotes.at(index); }
 
    Note& operator[](size_t index) { return _originalNotes.at(index); }
 
    bool operator==(const Chord& otherChord) const {
        size_t sizeA = this->size();
        size_t sizeB = otherChord.size();
 
        if (sizeA != sizeB) {
            return false;
        }
 
        for (size_t i = 0; i < sizeA; i++) {
            if (_originalNotes[i] != otherChord.getNote(i)) {
                return false;
            }
        }
 
        return true;
    }
 
    bool operator!=(const Chord& otherChord) const {
        size_t sizeA = this->size();
        size_t sizeB = otherChord.size();
 
        if (sizeA != sizeB) {
            return true;
        }
 
        for (size_t i = 0; i < sizeA; i++) {
            if (_originalNotes[i] != otherChord.getNote(i)) {
                return true;
            }
        }
 
        return false;
    }
 
    Chord operator+(const Chord& otherChord) const {
        Chord x = *this;
 
        const size_t sizeChord = otherChord.size();
        for (size_t i = 0; i < sizeChord; i++) {
            x.addNote(otherChord[i]);
        }
 
        return x;
    }
 
    std::vector<Note>::iterator begin() { return _originalNotes.begin(); }
 
    std::vector<Note>::iterator end() { return _originalNotes.end(); }
 
    friend std::ostream& operator<<(std::ostream& os, const Chord& chord);
};