/Users/garethloy/Musimathics/Musimat1.2/include/Rhythm.h

Go to the documentation of this file.

/* $Revision: 1.5 $ $Date: 2006/09/08 18:56:52 $ $Author: dgl $ $Name:  $ $Id: Rhythm.h,v 1.5 2006/09/08 18:56:52 dgl Exp $ */
#ifndef RHYTHM_H
#define RHYTHM_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

#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif

#include "Musimat.h"
#include <iostream>

class Rhythm
{
        friend ostream& operator<<(ostream&, Rhythm&);
        friend istream& operator>>( istream& is, Rhythm& p );

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

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


public:

        Rhythm() : m_num(0), m_den(0) { }

        Rhythm(Integer i) : m_num(i), m_den(i) { }

        Rhythm(Real x) : m_num(0), m_den(0) { RealToRational( x, m_num, m_den ); }

        Rhythm(Integer num, Integer den) : m_num(num), m_den(den) { 
                If (m_den == 0)
                        m_den = 1;
        }

        Rhythm(Real x, Integer& num, Integer& den) : m_num(0), m_den(0) { 
                RealToRational( x, num, den ); 
                m_num = num;
                m_den = den;
        }

        Rhythm(Rhythm x, Integer& num, Integer& den) : m_num(0), m_den(0) { 
                RealToRational( x.quotient(), num, den ); 
                m_num = num;
                m_den = den;
        }

        Bool operator==(Const Rhythm& x) Const {
                Return m_num == x.m_num  And m_den == x.m_den;
        }

        Bool operator!=(Const Rhythm& x) Const {
                Return m_num != x.m_num || m_den != x.m_den;
        }
        
        Bool operator>=(Const Rhythm& x) Const {
                Return quotient() >= x.quotient();
        }

        Bool operator>(Const Rhythm& x) Const {
                Return quotient() > x.quotient();
        }

        Bool operator<(Const Rhythm& x) Const {
                Return quotient() < x.quotient();
        }

        Bool operator<=(Const Rhythm& x) Const {
                Return quotient() <= x.quotient();
        }

        Rhythm& operator+=(Const Real x) {
                Return( *this = Rhythm(quotient() + x) );
        }

        Rhythm& operator+=(Rhythm x) {
                Return( *this = Rhythm(quotient() + x.quotient()) );
        }

        Rhythm& operator-=(Const Real x) {
                Return( *this = quotient() - x );
        }

        Rhythm& operator-=(Rhythm x) {
                Return( *this = quotient() - x.quotient() );
        }

        Rhythm& operator*=(Const Real x) {
                Return( *this = quotient() * x );
        }

        Rhythm& operator*=(Rhythm x) {
                Return( *this = quotient() * x.quotient() );
        }

        Rhythm& operator/=(Const Real x) {
                Return( *this = quotient() / x );
        }

        Rhythm& operator/=(Rhythm x) {
                Return( *this = quotient() / x.quotient() );
        }

        Rhythm operator+(Rhythm& x) {
                Return( Rhythm(quotient() + x.quotient()) );
        }

        Rhythm operator-(Rhythm& x) {
                Return( Rhythm(quotient() - x.quotient()) );
        }

        Rhythm operator*(Rhythm& x) {
                Return( Rhythm(quotient() * x.quotient()) );
        }

        Rhythm operator/(Rhythm& x) {
                Return( Rhythm(quotient() / x.quotient()) );
        }

        Rhythm operator+(Const Real x) {
                Return( Rhythm(quotient() + x) );
        }

        Rhythm operator-(Const Real x) {
                Return( Rhythm(quotient() - x) );
        }

        Rhythm operator*(Const Real x) {
                Return( Rhythm(quotient() * x) );
        }

        Rhythm operator/(Const Real x) {
                Return( Rhythm(quotient() / x ) );
        }

        String print(String s = 0) Const {
                If (s)
                        cout << s;
#ifdef _MSC_VER
// Disable Microsoft Visual Studio warning about sprintf()
// until is universal agreement about how to handle its insecurities
#pragma warning(push)
#pragma warning(disable: 4996)
                sprintf(s_buf, "{%d,%d}", m_num, m_den);
#pragma warning(pop)
#else
                sprintf(s_buf, "{%d,%d}", m_num, m_den);
#endif
                Return s_buf;
        }
        
        Static Real tempo(Void) { 
                Return s_tempo; 
        }

        Static Real tempo(Real t) {
                Real s = s_tempo;
                s_tempo = t;
                Return s;
        }

        Real mm( Rhythm beats, Real perMinute ) Const { 
                Return( 1.0 / (4.0 * beats.quotient()) * 60.0 / perMinute ); 
        }

        Real duration( ) { 
                Return ( quotient() * s_fourQuarters );
        }

        Real absDuration( ) Const { 
                Return ( Real(m_num) / Real(m_den) );
        }

private:
        
        Real quotient() Const { Return( s_tempo * m_num / m_den ); }
        Static Real mmInit( Rhythm beats, Real perMinute ) { 
                Real x = ( 1.0 / (4.0 * (Real(beats.m_num) / Real(beats.m_den))) * 60.0 / perMinute );
                Return x;
        }

private:
        Integer m_num;
        Integer m_den;
        Static Real s_tempo;
        Static Real s_fourQuarters;
        Static char s_buf[128];
};

Real metronome( Rhythm B, Real T );

Real Duration( Real x ); 

Real Duration( Rhythm x ); 

Real AbsDuration( Real x ); 

Real AbsDuration( Rhythm x ); 

Void SetTempoScale( Real ts );


extern Rhythm 
        Whole,          
        Half,           
        Quarter,        
        Eighth,         
        Sixteenth       
; 

#endif // RHYTHM_H