C:/Musimathics_local/Musimat/MusimatChapter9/C091102.cpp File Reference

#include "MusimatChapter9.h"

Go to the source code of this file.

Functions
	MusimatChapter9Section (C091102)
IntegerMatrix	setComplex (IntegerList prime)
Static Void	para1 ()
IntegerList	getPC (PitchList p)
Void	generateSetComplex (PitchList P)
Static Void	para2 ()

---

Function Documentation

Void generateSetComplex

(

PitchList

P

)

Definition at line 99 of file C091102.cpp.

References getPC(), setComplex(), and transpose().

                                     {
        IntegerList set = getPC(P);
        Print("Starting set:", set);
        Integer offset = set[0];
        IntegerList tSet = transpose(set, -offset);
        Print("Transposed set:", tSet);
        IntegerMatrix sc = setComplex( tSet );
        Print("Set complex:");
        Print(sc);
}

IntegerList getPC

(

PitchList

p

)

Definition at line 91 of file C091102.cpp.

References x.

                               {
        IntegerList x;
        For (Integer i = 0; i < Length(p); i++)
                x[i] = PitchClass(p[i]) + Accidental( p[i] );
        Return( x );
}

MusimatChapter9Section

(

C091102

)

Definition at line 2 of file C091102.cpp.

References para1(), and para2().

                                {
Print("*** 9.11.2 The Set Complex ***");
/*****************************************************************************

9.11.2 The Set Complex

Using these tools, we can create a matrix containing the prime form, inverse, 
retrograde, and all transpositions of any row, called the set complex. The 
purpose of these transformations is to generate variants that are related to 
the original intervallic structure of the prime row, to be used as material 
in developing compositions.

Matrix is simply a two-dimensional grid, or list of lists, all of the same 
length. The individual elements of Matrix can be accessed by extending the 
index operator […]. The first operand is the matrix, the second is the row 
position, and the third is the column position. (Whether row or column comes 
first is arbitrary. The following order is called row/column order.)   

                0       1
M =     0       A       B
        1       C       D

For example, for this matrix, M[0][0] == A, M[0][1] == B, M[1][0] == C, and 
M[1][1] == D. The following is a method for creating a set complex. It 
basically copies the prime form to the zeroth row, then copies the inverse 
form to the zeroth column, then for each other cell in the matrix sums the 
corresponding row and column value modulo the length of the prime form:
*****************************************************************************/
        para1(); // Step into this function to continue.
        para2(); // Step into this function to continue.
}

Static Void para1

(

)

Definition at line 56 of file C091102.cpp.

                    {
/*****************************************************************************
To demonstrate these tools, table 9.4 shows the set complex the following row: 
        (G, As, B, F, E, Cs, C, A, Gs, D, Ds, Fs) 
o  Prime rows are read left to right, 
o  Retrograde rows, right to left 
o  Inverse rows, top to bottom, 
o  Retrograde inverse rows, bottom to top.
This completes the precomposition phase. Now it’s time to look at methods to 
traverse the rows created with the preceding techniques to generate a 
composition.

Table 9.4 Set Complex
{0, 3, 4, 10, 9, 6, 5, 2, 1, 7, 8, 11}
{9, 0, 1, 7, 6, 3, 2, 11, 10, 4, 5, 8}
{8, 11, 0, 6, 5, 2, 1, 10, 9, 3, 4, 7}
{2, 5, 6, 0, 11, 8, 7, 4, 3, 9, 10, 1}
{3, 6, 7, 1, 0, 9, 8, 5, 4, 10, 11, 2}
{6, 9, 10, 4, 3, 0, 11, 8, 7, 1, 2, 5}
{7, 10, 11, 5, 4, 1, 0, 9, 8, 2, 3, 6}
{10, 1, 2, 8, 7, 4, 3, 0, 11, 5, 6, 9}
{11, 2, 3, 9, 8, 5, 4, 1, 0, 6, 7, 10}
{5, 8, 9, 3, 2, 11, 10, 7, 6, 0, 1, 4}
{4, 7, 8, 2, 1, 10, 9, 6, 5, 11, 0, 3}
{1, 4, 5, 11, 10, 7, 6, 3, 2, 8, 9, 0}

The functions below perform steps in preparation for calling setComplex().
getPC() converts a PitchList to an IntegerList by summing the diatonic
pitch class and accidental of the Pitch.
generateSetComplex() first calls getPC() to convert the Pitch list to
an IntegerList, then transposes the resulting set, then
invokes setComplex() to generate the set complex Matrix.
*****************************************************************************/
}

Static Void para2

(

)

Definition at line 110 of file C091102.cpp.

References generateSetComplex().

                    {
/*****************************************************************************
Here we evaluate the set complex for our test set.
*****************************************************************************/
        PitchList test(G, As, B, F, E, Cs, C, A, Gs, D, Ds, Fs);
        Print("*** Pitch classes for test ***");
        Print(test);
        generateSetComplex(test);

}}

IntegerMatrix setComplex

(

IntegerList

prime

)

Definition at line 34 of file C091102.cpp.

References a, b, and invert().

                                            {
        Print("Prime row:", prime);
        Integer len = Length(prime);
        IntegerMatrix M(len, len);
        IntegerList inverted = invert(prime);
        Print("Inverted row:", inverted);
        For (Integer i = 0; i < len; i = i + 1) {
                 M[0][i] = prime[i];
                 M[i][0] = inverted[i];
        }
        For (Integer i = 1; i < len; i = i + 1) {
                For (Integer j = 1; j < len; j = j + 1) {
                        Integer a = M[i][0];
                        Integer b = M[0][j];
                        // M(i,j) = Mod(M(i,0) + M(0,j), len);
                        M[i][j] = Mod(a + b, len);
                }
        }
        Return(M);
}

---