C:/Musimathics_local/Musimat/include/Pitch.h

Go to the documentation of this file.

/* $Revision: 1.4 $ $Date: 2006/09/12 17:37:40 $ $Author: dgl $ $Name:  $ $Id: _pitch_8h-source.html,v 1.4 2006/09/12 17:37:40 dgl Exp $ */
#ifndef PITCH_H
#define PITCH_H

// The Musimat Tutorial © 2006 Gareth Loy
// Derived from Chapter 9 and Appendix B of "Musimathics Vol. 1" © 2006 Gareth Loy 
// and published exclusively by The MIT Press.
// This program is released WITHOUT ANY WARRANTY; without even the implied 
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
// For information on usage and redistribution, and for a DISCLAIMER OF ALL
// WARRANTIES, see the file, "LICENSE.txt," in this distribution.
// "Musimathics" is available here:     http://mitpress.mit.edu/catalog/item/default.asp?ttype=2&tid=10916
// Gareth Loy's Musimathics website:    http://www.musimathics.com/
// The Musimat website:                 http://www.musimat.com/
// This program is released under the terms of the GNU General Public License
// available here:                      http://www.gnu.org/licenses/gpl.txt


#include <stdio.h>
#include <stdlib.h>
#include <iostream>
using namespace std;
#include <math.h>


class Pitch
{
        friend ostream& operator<<(ostream&, Pitch&);
        friend istream& operator>>(istream&, Pitch&);

        friend Bool operator==(Integer& i, Pitch& p) { Return i == p.degree(); }
        friend Bool operator==(Pitch& p, Integer& i) { Return p.degree() == i; }
        friend Bool operator!=(Integer& i, Pitch& p) { Return i != p.degree(); }
        friend Bool operator!=(Pitch& p, Integer& i) { Return p.degree() != i; }
        friend Bool operator>=(Pitch& p, Integer& r) { Return p.degree() >= r; }
        friend Bool operator>=(Integer& i, Pitch& p) { Return i >= p.degree(); }
        friend Bool operator>(Pitch& p, Integer& i) { Return p.degree() > i; }
        friend Bool operator>(Integer& i, Pitch& p) { Return i > p.degree(); }
        friend Bool operator<=(Pitch& p, Integer& i) { Return p.degree() <= i; }
        friend Bool operator<=(Integer& i, Pitch& p) { Return i <= p.degree(); }

        friend Bool operator==(Real& r, Pitch& p) { Return r == p.hertz(); }
        friend Bool operator==(Pitch& p, Real& r) { Return p.hertz() == r; }
        friend Bool operator!=(Real& r, Pitch& p) { Return r != p.hertz(); }
        friend Bool operator!=(Pitch& p, Real& r){ Return p.hertz() != r; }
        friend Bool operator>=(Pitch& p, Real& r) { Return p.hertz() >= r; }
        friend Bool operator>=(Real& r, Pitch& p) { Return r >= p.hertz(); }
        friend Bool operator>(Pitch& p, Real& r) { Return p.hertz() > r; }
        friend Bool operator>(Real& r, Pitch& p) { Return r > p.hertz(); }
        friend Bool operator<=(Pitch& p, Real& r) { Return p.hertz() <= r; }
        friend Bool operator<=(Real& r, Pitch& p) { Return r <= p.hertz(); }

public:

        operator Integer() { Return degree(); }
        operator Real() { Return hertz(); }

        Pitch() : m_pc(0), m_acc(0), m_oct(0) { }

        Pitch(Integer degree) : m_pc(0), m_acc(0), m_oct(0) { 
                transpose( degree, m_pc, m_acc, m_oct ); 
        }

        Pitch(Integer pitchClass, Integer accidental, Integer octave) : m_pc(pitchClass), m_acc(accidental), m_oct(octave) { }

        Pitch(String s);

        Pitch(Real hz) : m_pc(0), m_acc(0), m_oct(0) {
                For(Integer pc = s_lowestDegree; pc < s_lowestDegree+s_highestDegree; pc++) {
                        Pitch p = Pitch(pc);
                        Real x = p.hertz(); // get the Hz equivalent of this pitch
                        If ( x > hz) {                          // have we passed our target?
                                pc -= 1;
                                *this = Pitch(pc); // return the pitch
                                Return;
                        }
                }
                // If we get here, the hz value is out of range
                *this = Pitch(s_highestDegree); // Pitch is out of range, clip at top of range
        }

        Integer degree() Const {
                Return( degree(m_pc, m_acc, m_oct) ); 
        }

        Integer degree(Integer pc, Integer acc, Integer oct) Const {
                Return((pc + acc) + s_nDegrees * oct); 
        }

        Integer pianoKey() Const {
                Return( pianoKey(m_pc, m_acc, m_oct) ); 
        }

        Integer pianoKey(Integer pc, Integer acc, Integer oct) Const {
                Return((pc + acc) + s_nDegrees * (oct - 1) + 3); 
        }

        Void transpose(Integer x, Integer& pc, Integer& acc, Integer& oct) {
                pc += acc + x;  // add the pitch, its accidental and the transposition to get raw semitones
                acc = 0; // clear the accidental
                While ( pc >= s_nDegrees ) { pc = pc - s_nDegrees; oct++; }
                While ( pc < 0 ) { pc = pc + s_nDegrees; oct--; }
                // cvt. to diatonic
                switch (pc) {                   // adjust for enharmonic spelling
                case 0: Break;                                                                                                  // C
                case 1: If (x>0) { pc--; acc++; } Else { pc++; acc--; } Break;  // C# Db
                case 2: Break;                                                                                                  // D
                case 3: If (x>0) { pc--; acc++; } Else { pc++; acc--; } Break;  // D# Eb
                case 4: Break;                                                                                                  // E
                case 5: Break;                                                                                                  // F
                case 6: If (x>0) { pc--; acc++; } Else { pc++; acc--; } Break;  // F# Gb
                case 7: Break;                                                                                                  // G
                case 8: If (x>0) { pc--; acc++; } Else { pc++; acc--; } Break;  // G# Ab
                case 9: Break;                                                                                                  // A
                case 10:If (x>0) { pc--; acc++; } Else { pc++; acc--; } Break;  // A# Bb
                case 11: Break;                                                                                                 // B
                }
        }

        Void transModuloOctave(Integer x) {
                Integer o = m_oct;
                transpose( x, m_pc, m_acc, m_oct );
                m_oct = o;
        }

        Void invert() {
                Integer p = Mod( m_pc + m_acc, s_nDegrees );
                p = Mod( s_nDegrees - p, s_nDegrees );
                transpose( p, m_pc = 0, m_acc = 0, m_oct );
        }

        Bool operator==(Const Pitch& x) Const {
                Return degree() == x.degree();
        }

        Bool operator==(Const Integer& x) Const {
                Return degree() == x;
        }

        Bool operator==(Const Real& x) Const {
                Return hertz() == x;
        }

        Bool operator!=(Const Pitch& x) Const {
                Return degree() != x.degree();
        }

        Bool operator!=(Const Integer& x) Const {
                Return degree() != x;
        }

        Bool operator!=(Const Real& x) Const {
                Return hertz() != x;
        }

        Bool operator>=(Const Pitch& x) Const {
                Return degree() >= x.degree();
        }

        Bool operator>=(Const Integer& x) Const {
                Return degree() >= x;
        }

        Bool operator>=(Const Real& x) Const {
                Return hertz() >= x;
        }

        Bool operator>(Const Pitch& x) Const {
                Return degree() > x.degree();
        }

        Bool operator>(Const Integer& x) Const {
                Return degree() > x;
        }

        Bool operator>(Const Real& x) Const {
                Return hertz() > x;
        }

        Bool operator<(Const Pitch& x) Const {
                Return degree() < x.degree();
        }

        Bool operator<(Const Integer& x) Const {
                Return degree() < x;
        }

        Bool operator<(Const Real& x) Const {
                Return hertz() < x;
        }

        Bool operator<=(Const Pitch& x) Const {
                Return degree() <= x.degree();
        }

        Bool operator<=(Const Integer& x) Const {
                Return degree() <= x;
        }

        Bool operator<=(Const Real& x) Const {
                Return hertz() <= x;
        }

        Pitch& operator+=(Const Pitch x) {
                transpose( x.degree(), m_pc, m_acc, m_oct );
                Return( *this );
        }

        Pitch& operator+=(Const Integer x) {
                transpose( x, m_pc, m_acc, m_oct );
                Return( *this );
        }

        Pitch& operator+=(Const Real x) {
                Real hz = hertz() + x;
                *this = Pitch( hz );
                Return( *this );
        }

        Pitch& operator-=(Const Pitch x) {
                transpose( -x.degree(), m_pc, m_acc, m_oct );
                Return( *this );
        }

        Pitch& operator-=(Const Integer x) {
                transpose( -x, m_pc, m_acc, m_oct );
                Return( *this );
        }

        Pitch& operator-=(Const Real x) {
                Real hz = hertz() - x;
                Return( *this = Pitch( hz ) );
        }

        Pitch& operator*=(Const Pitch x) {
                Integer d = degree() * x.degree();
                Return( *this = Pitch(d) );
        }

        Pitch& operator*=(Const Integer x) {
                Integer d = degree() * x;
                Return( *this = Pitch(d) );
        }

        Pitch& operator*=(Const Real x) {
                Real hz = hertz() * x;
                Return( *this = Pitch(hz) );
        }

        Pitch& operator/=(Const Pitch x) {
                Integer d = degree() / x.degree();
                Return( *this = Pitch(d) );
        }

        Pitch& operator/=(Const Integer x) {
                Integer d = degree() / x;
                Return( *this = Pitch(d) );

        }

        Pitch& operator/=(Const Real x) {
                Real hz = hertz() / x;
                Return( *this = Pitch(hz) );
        }

        Pitch operator+(Const Pitch& x) {
                Return( degree() + x.degree() );
        }

        Pitch operator+(Const Integer x) {
                Return( degree() + x );
        }

        Pitch operator+(Const Real x) {
                Real hz = hertz() * x;
                Return( Pitch(hz) );
        }

        Pitch operator-(Const Pitch& x) {
                Return( degree() - x.degree() );
        }

        Pitch operator-(Const Integer x) {
                Return( degree() - x );
        }

        Pitch operator-(Const Real x) {
                Real hz = hertz() - x;
                Return( hz );
        }

        Pitch operator*(Const Pitch& x) {
                Return( degree() * x.degree() );
        }

        Pitch operator*(Const Integer x) {
                Return( degree() * x );
        }

        Pitch operator*(Const Real x) {
                Return( hertz() * x );
        }

        Pitch operator/(Const Pitch& x) {
                Return( degree() / x.degree() );
        }

        Pitch operator/(Const Integer x) {
                Return( degree() / x );
        }

        Pitch operator/(Const Real x) {
                Real hz = hertz() / x;
                Return( Pitch(hz) );
        }

        Pitch operator%(Const Pitch x) {
                Integer d = Mod(degree(), x.degree());
                Return( d );
        }

        Pitch operator%(Const Integer x) {
                Integer d = Mod(degree(), x);
                Return( d );
        }

        Pitch operator%(Const Real x) {
                Real hz = Mod(hertz(), x);
                Return( Pitch(hz) );
        }

        String print(String s = 0) Const {
                If (s)
                        cout << s;
                Character pc = s_pcNames[ m_pc ];
                Character acc;
                switch (m_acc) {
                case 0: acc = 0; Break;                 // natural
                case 1: acc = 's'; Break;               // sharp
                case -1: acc = 'b'; Break;              // flat
                case 2: acc = 'x'; Break;               // double-sharp
                case -2: acc = 'v'; Break;              // double-flat
                default: acc = 0; Break;                // natural
                }
                If (acc)
                        sprintf(s_buf, "%c%c%d", pc, acc, m_oct);
                Else
                        sprintf(s_buf, "%c%d", pc, m_oct);
                Return s_buf;
        }

        Integer pitchClass() Const { Return m_pc; }

        Integer accidental() Const { Return m_acc; }

        Integer octave() Const { Return m_oct; }

        Real hertz() Const {
                Real R = s_HzReference;
                Real k = pitchClass() + accidental() - 9.0;
                Real o = octave() - 4.0;
                Return( R * Pow(2.0, o + k / Real(s_nDegrees) ) );
        }

        Static Void HzReference( Real ref ) { s_HzReference = ref; }

        Static Real HzReference( ) { Return( s_HzReference); }

        Static Void SetLowestKey( Integer ref ) { s_lowestDegree = ref; }

        Static Void SetHighestKey( Integer ref ) { s_highestDegree = ref; }

        Static Void SetDegrees( Integer ref ) { s_nDegrees = ref; }

        Integer isPitchClass(char c) Const {
                switch (c) {
                case 'C': case 'c': Return 0; Break;
                case 'D': case 'd': Return 2; Break;
                case 'E': case 'e': Return 4; Break;
                case 'F': case 'f': Return 5; Break;
                case 'G': case 'g': Return 7; Break;
                case 'A': case 'a': Return 9; Break;
                case 'B': case 'b': Return 11; Break;
                default: Return -1;
                }
        }

        Integer isAccidental(char c) Const {
                switch (c) {
                case '#':           Return  1;  Break;  // sharp
                case 'S': case 's': Return  1;  Break;  // sharp
                case 'N': case 'n': Return  0;  Break;  // natural
                case 'B': case 'b':     Return -1;      Break;  // flat
                case 'F': case 'f':     Return -1;      Break;  // flat
                case 'X': case 'x':     Return  2;      Break;  // double-sharp
                case 'V': case 'v':     Return -2;      Break;  // double-flat
                default: Return -3;             Break; // may be an octave spec. with no accidental
                }
        }

private:
        Integer m_pc;                                   
        Integer m_acc;                                  
        Integer m_oct;                                  
        Static Real s_HzReference;                              
        Static Integer s_lowestDegree;                  
        Static Integer s_highestDegree;         
        Static Integer s_nDegrees;                              
        Static String s_pcNames;                
        Static char s_buf[16];                  
};



inline Integer Accidental( Pitch p )
{
        Return p.accidental();
}

inline Integer PitchClass( Integer i ) 
{
        Return( Mod( (i - 3), 12 ) ); 
}

inline Integer PitchClass( Pitch p ) 
{
        Return( p.pitchClass() ); 
}

inline Integer Octave( Integer i )
{
        Return( (i - 3) / 12 + 1 ); 
}

inline Integer Octave( Pitch p )
{
        Return( p.octave() ); 
}

inline Real PitchToHertz( Pitch p )
{
        Return( p.hertz() );
}

inline Real KeyToHertz( Integer i ) 
{
        Real R = Pitch::HzReference();
        Integer k = PitchClass( i );
        Integer o = Octave( i );
        Return( R * pow(2, ( (o - 4) + k / 12) ) );
}

inline Void SetDegrees( Integer ref )
{
        Pitch::SetDegrees(ref); 
}

inline Pitch Mod(Pitch p, Integer len)
{
        Return( p % len );
}

#endif // PITCH_H

---