#include "MusimatChapter9.h"

Functions
	MusimatChapter9Section (C091101)
IntegerList	transpose (IntegerList L, Integer t)
Static Void	para1 ()
IntegerList	invert (IntegerList L)
Static Void	para2 ()
IntegerList	retrograde (IntegerList L)
Static Void	para3 ()

Function Documentation

IntegerList invert ( IntegerList L )

Definition at line 63 of file C091101.cpp.

                                  {
        For(Integer i = 0; i < Length(L); i = i + 1) {
                L[i] = Mod(12 - L[i], 12);
        }
        Return(L);
}

MusimatChapter9Section ( C091101 )

Definition at line 2 of file C091101.cpp.

References para1(), para2(), and para3().

                                {
        Print("*** 9.11.1 Precomposition ***");
        /*****************************************************************************
         
         9.11.1 Precomposition
         
         The process of composing atonal music is typically divided into two parts.
         
         o Precomposing: assembling the musical materials
         
         o Composing: applying the assembled materials in a design
         
         Musimat already has a number of data types and operations, but a few more are needed:
         
         o To represent pitches as symbols with integer values, such as:
         
         Integer C = 0, Cs = Db = 1, D = 2, Ds = Eb = 3 . . ., B = 11;
         
         o To represent motives as lists, such as: 
         
         IntegerList a = {F, F, G, A}; 
         IntegerList b = {F, A, G}; 
         IntegerList c = {F, E};
         IntegerList d = {Bb, A, G, F}; 
         IntegerList e = {E, C, D, E, F, F};
         
         o To combine motives and concatenate lists:
         
         IntegerList y = Join(a, b, a, c, a, d, e);
         
         (y is defined as the list of pitches of the tune "Yankee Doodle.")
         
         The function transpose() below transposes a pitch set.
         *****************************************************************************/
        para1(); // Step into this function to continue.
        para2(); // Step into this function to continue.
        para3(); // Step into this function to continue.
}

Static Void para1 ( )

Definition at line 48 of file C091101.cpp.

References transpose().

                    {
        /*****************************************************************************
         Here is an example of transposing a list:
         *****************************************************************************/
        
        Print("*** Transposing a list ***");
        IntegerList L( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 );
        Print("Original row:", L);
        Print("Row transposed by 6: ", transpose(L, 6) );
        
        /*****************************************************************************
         To invert a pitch set:
         *****************************************************************************/
}

Static Void para2 ( )

Definition at line 70 of file C091101.cpp.

References invert().

                    {
        /*****************************************************************************
         Here is an example of inverting a list:
         *****************************************************************************/
        Print("*** Inverting a list ***");
        IntegerList L( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 );
        Print("Original row:", L);
        Print( "Inverted row:", invert(L) );
        
        /*****************************************************************************
         To take the retrograde of a set:
         *****************************************************************************/
}

Static Void para3 ( )

Definition at line 93 of file C091101.cpp.

                    {
        /*****************************************************************************
         Here is an example of retrograding a list:
         *****************************************************************************/
        Print("*** Retrograding a list ***");
        IntegerList L( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 );
        Print("Original row:", L);
        Print( "Retrograded row:", retrograde(L) );
        
}

IntegerList retrograde ( IntegerList L )

Definition at line 84 of file C091101.cpp.

References n().

                                      {
        Integer n = Length(L);
        IntegerList R = L;                                                              // make a new list as long as L
        For(Integer i = 0; i < n; i = i + 1) {
                R[i] = L[n - i - 1];
        }
        Return(R);
}

IntegerList transpose	(	IntegerList	L,
		Integer	t
	)

Definition at line 41 of file C091101.cpp.

                                                {
        For(Integer i = 0; i < Length(L); i = i + 1) {
                L[i] = PosMod(L[i] + t, 12); // BUG: given as Mod() in "Musimat", s.b. PosMod()
        }
        Return(L);
}

/Users/garethloy/Musimathics/Musimat1.2/MusimatChapter9/C091101.cpp File Reference

Functions

Function Documentation