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

#include "MusimatChapter9.h"

Go to the source code of this file.


 MusimatChapter9Section (C090903)
Void rotate (IntegerList Reference f, Integer n, Integer i=0)
Static Void para1 ()

Function Documentation

MusimatChapter9Section ( C090903   )

Definition at line 2 of file C090903.cpp.

References para1().

        Print("*** 9.9.3 Circular Permutation ***");
         9.9.3 Circular Permutation
         A circular permutation, or rotation, occurs when the element at one end is 
         lopped off and attached to the other end circularly (figure 9.9). There are n 
         circular permutations of n objects. Rotation can be to the left or right by 
         one or more places.
         Here is a method that rotates a list by an arbitrary number of places either 
         to the right or left.
        para1(); // Step into this function to continue.
Static Void para1 (  )

Definition at line 29 of file C090903.cpp.

References rotate().

         This example uses recursion to perform its function. It takes three arguments, 
         a list f, the number n of positions to rotate by, and i, the index for where 
         to begin, usually set to zero. If n is positive, the list is rotated to the 
         right that many places; if n is negative, the list is rotated that many 
         positions to the left. The first step is to constrain n modulo the length 
         of the list so that any amount of rotation can be handled.
         The declaration IntegerList Reference f requires a bit of explanation. We 
         want Rotate() to modify the list that is supplied. But functions are 
         ordinarily supplied only with copies of the value of the actual arguments 
         (see appendix B, B.1.22). The word Reference in the declaration tells 
         Musimat that it should supply Rotate() with the actual variable named when 
         the function is invoked. Thus changes to the list handed to Rotate() will 
         persist after the function is finished.
         We need to make sure the variable pos stays within the range of valid list 
         elements, which naturally suggests the use of Mod(), except that Mod() can 
         return negative values. But list indexes must be strictly positive. So we 
         use a function called PosMod(), which returns only the positive wing of 
         modulo values (see appendix A.6).
         "Musimat" V1 Table 9.3 shows left and right rotation by various amounts for a list 
         iL defined as follows.
        Print("*** Rotate examples ***");
        IntegerList iL = IntegerList(0, 1, 2, 3, 4, 5);
        Print("Starting list:", iL);
        Print("Successive forward rotations by 1:");
        For (Integer i = 0; i < Length(iL); i = i + 1) {
                rotate(iL, 1);
        Print("Backward rotations by 1:");
        For (Integer i = 0; i < Length(iL); i = i + 1) {
                rotate(iL, -1);
Void rotate ( IntegerList Reference  f,
Integer  n,
Integer  i = 0 

Definition at line 19 of file C090903.cpp.

References rotate().

        n = Mod(n, Length(f));                                          //constrain rotation to length of list
        Integer x = f[i];                                                       //store f[i] for use after recursion
        If (i < Length(f)-1)                                                    // reached the end?
                rotate(f, n, i+1);                                              // no, call rotate() recursively
        // continue from here when the recursion unwinds
        Integer pos = PosMod(i+n, Length(f));           // index list modulo its length
        f[pos] = x;                                                                     // assign value of x saved above