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

Go to the documentation of this file.

/* $Revision: 1.4 $ $Date: 2006/09/08 18:56:52 $ $Author: dgl $ $Name:  $ $Id: Row.h,v 1.4 2006/09/08 18:56:52 dgl Exp $ */
#ifndef ROW_H
#define ROW_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 "Musimat.h"



template<class Type> Type Reference Rotate( Type Reference f, Integer n )
{
        f.rotate(n);
        Return( f );
}

template<class Type1, class Type2> Type1 Transpose( Type1 L, Type2 t, Type2 lim ) {
        L.transpose(t, lim);
        Return( L );
}


inline PitchList Transpose( PitchList L, Integer t ) {
        For ( Integer i = 0; i < L.length(); i = i + 1 ) {
                L[i].transModuloOctave(t);
        }
        Return( L );
}

template<class Type1, class Type2> Type1 Invert( Type1 L, Type2 lim ) {
        L.invert(lim);
        Return( L );
}

inline PitchList Invert( PitchList L, Integer lim = 12 ) {
        For ( Integer i = 0; i < L.length(); i = i + 1 ) {
                L[i].invert();
        }
        Return( L );
}

template<class Type> Type Reference Retrograde( Type Reference L ) {
        L.retrograde();
        Return( L );
}

template<class MatrixType, class ListType> MatrixType SetComplex( ListType prime ) {
        Integer len = Length( prime );
        MatrixType M( len, len );
        ListType inverted = Invert( prime, 12 );
        Integer i;

        For ( i = 0; i < len; i = i + 1 ) {
                 M[0][i] = prime[i];
                 M[i][0] = inverted[i];
        }

        For ( i = 1; i < len; i = i + 1 ) {
                For ( Integer j = 1; j < len; j = j + 1 ) {
                          M[ i ][ j ] = Mod( M[ i ][ 0 ] + M[ 0 ][ j ], len);
                }
        }

        Return( M );
}

template<class ElementType, class ListType> ElementType cycle( ListType L, Integer Reference pos, Integer inc ) {
        Integer i = PosMod( pos, Length( L ) );
        pos = PosMod( pos + inc, Length( L ) );
        Return( L[ i ] );
}

template<class ElementType, class ListType> ElementType palindrome( ListType L, Integer Reference pos, Integer Reference inc ) {
        Integer curPos = pos;
        ElementType x = cycle<ElementType,ListType>( L, pos, inc );
        If ( curPos + inc != pos ) {
                inc = inc * (-1); // change direction
                pos = curPos;
        }
        Return( x ); 
}

template<class ElementType, class ListType> ElementType permute( ListType L, Integer Reference pos, Integer Reference count, Integer inc ) { 
        Integer curPos = pos;                   // save the current position
        ElementType x = cycle<ElementType,ListType>( L, pos, 1 );       // update pos and get list value
        count = count + 1;                              // increment counter
        If ( count == Length( L ) ) {   // have we output L items from list?
                count = 0;                                      // reset count
                pos = curPos + inc;                     // permute position for next time
        }
        Return( x ); 
}

Integer InterpTendency( Real f, IntegerList L1, Integer Reference pos1, IntegerList L2, Integer Reference pos2, Integer inc );

Pitch LinearInterpolate( Pitch x, Pitch xMin, Pitch xMax, Pitch yMin, Pitch yMax );

template<class ElementType, class ListType> ListType stretch( ListType L, ElementType xMin, ElementType xMax, ElementType yMin, ElementType yMax ) {
        For ( Integer i = 0; i < Length( L ); i = i + 1 ) {
                 L[ i ] = ElementType( linearInterpolate( L[ i ], xMin, xMax, yMin, yMax ) );
        }
        Return( L );
}


template<class ListType> ListType RandomRow( Integer N ) {
        IntegerList L;                          // Keep track of the pitches chosen so far
        ListType M;                             // Used to build up our random 12-tone row 
        Integer i;
        // First, set all list elements to zero, which means "unused"
        For ( i = 0; i < N; i = i + 1 ) {
                 L[ i ] = 0;    
        }
        // Now build up M, marking off elements in L when they are chosen
        For ( i = 0; i < N; i = i ) {
                Integer x = IRandom( 0, N - 1 );
                If ( L[ x ] == 0 ) {    // Hasn't been chosen yet?
                         L[ x ] = 1;    // Mark it "used"
                         M[ i ] = x;    // Save the result
                        i = i + 1;      // Now increment the control variable
                }
        }
        Return( M );
}

template<class ElementType, class ListType> Void swap( ListType Reference L, Integer from, Integer to ) {
        ElementType x = L[ to ];                // save the target value
         L[ to ] = L[ from ];           // swap from -> to
         L[ from ] = x;                 // swap to -> from
}

template<class ElementType, class ListType> ListType shuffle( ListType L ) {
        // SeedRandom( 788429 );        // Uncomment to test alternative shuffle
        ListType M = RandomRow<ListType>( Length( L ) ); // Determine what elements to swap
        Print( "M=", M );
        For ( Integer i = 0; i < Length( L ); i = i + 1 ) {
                Integer j = M[ i ];
                swap<ElementType,ListType>( L, i, j );
        }
        Return( L );
}

template<class ElementType, class ListType> ElementType randTendency( ListType L1, Integer Reference pos1, ListType L2, Integer Reference pos2, Integer inc ) {
        Integer x = cycle<ElementType,ListType>( L1, pos1, inc );
        Integer y = cycle<ElementType,ListType>( L2, pos2, inc );
        If ( x < y )
                Return( IRandom( x, y ) );
        Else
                Return( IRandom( y, x ) );              
}


#endif // ROW_H