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

Go to the documentation of this file.

/* $Revision: 1.4 $ $Date: 2006/09/12 17:37:40 $ $Author: dgl $ $Name:  $ $Id: _musimat_8h-source.html,v 1.4 2006/09/12 17:37:40 dgl Exp $ */
#ifndef MUSIMAT_H
#define MUSIMAT_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 "Aliases.h"
#include "MathFuns.h"
#include "Complex.h"
#include "List.h"
#include "Matrix.h"
#include "Rational.h"
#include "Rhythm.h"
#include "Pitch.h"

extern Const Real Pi;


typedef List<Integer> IntegerList;

typedef List<Real> RealList;

typedef List<String> StringList;

typedef List<Complex> ComplexList;

typedef List<Pitch> PitchList;

typedef List<Rational> RationalList;

typedef List<Rhythm> RhythmList;


typedef Matrix<Integer> IntegerMatrix;

typedef Matrix<Real> RealMatrix;

typedef Matrix<String> StringMatrix;

typedef Matrix<Complex> ComplexMatrix;

typedef Matrix<Pitch> PitchMatrix;

typedef Matrix<Rational> RationalMatrix;

typedef Matrix<Rhythm> RhythmMatrix;



#include "Random.h"
#include "Dynamics.h"
#include "Pitches.h"
#include "Row.h"


template<class ListType> inline Real Max( ListType L ) { Return( L.max() ); }
inline Complex Max( ComplexList L ) { Return( L.max() ); }
inline Integer Max( IntegerList L ) { Return( L.max() ); }
inline Rhythm Max( RhythmList L ) { Return( L.max() ); }
inline Rational Max( RationalList L ) { Return( L.max() ); }
inline Pitch Max( PitchList L ) { Return( L.max() ); }

template<class ListType> inline Integer MaxPos( ListType L ) { Return( L.maxPos() ); }

template<class Type> inline Real Min( Type L ) { Return( L.min() ); }
inline Complex Min( ComplexList L ) { Return( L.min() ); }
inline Integer Min( IntegerList L ) { Return( L.min() ); }
inline Rhythm Min( RhythmList L ) { Return( L.min() ); }
inline Rational Min( RationalList L ) { Return( L.min() ); }
inline Pitch Min( PitchList L ) { Return( L.min() ); }

template<class Type> inline Integer MinPos( Type L ) { Return( L.minPos() ); }


template<class Type> Void Print(Type i) { cout << i << endl; }

template<class Type> Void Print(String s, Type i) { cout << s << i << endl; }


Integer Length( RhythmList Reference L );

Integer Length( String s );

RationalList RealListToRationalList( RealList R );

inline PitchList IntegerListToPitchList( IntegerList Reference L )
{
        PitchList P;
        For( Integer i = 0; i < Length( L ); i++ )
                P[i] = L[i];
        Return P;
}

inline IntegerList PitchListToIntegerList( PitchList Reference P )
{
        IntegerList L;
        For( Integer i = 0; i < Length( P ); i++ )
                L[i] = P[i];
        Return L;
}

#endif // MUSIMAT_H

---