Main Page   Class Hierarchy   Compound List   File List   Compound Members   File Members  

/magnus/back_end/Map/include/MapEnum.h

Go to the documentation of this file.
00001 /*
00002  *   $Id: MapEnum.h,v 1.1.1.1 1995/11/20 17:54:37 rogern Exp $
00003  */
00004 
00005 // Copyright (C) 1995 The New York Group Theory Cooperative
00006 // See magnus/doc/COPYRIGHT for the full notice.
00007 //
00008 // Contents: Definition of class MapEnum, for enumerating Maps,
00009 //           and helper class IntTuples
00010 //
00011 // Principal Author: Roger Needham
00012 //
00013 // Status: In development
00014 //
00015 // Further Implementation Steps:
00016 //
00017 // * Need to deal with 1-generator domains.
00018 //
00019 // Revision History:
00020 //
00021 
00022 
00023 #ifndef _MAP_ENUM_H_
00024 #define _MAP_ENUM_H_
00025 
00026 
00027 #include "Map.h"
00028 
00029 
00030 //------------------------------------------------------------------------//
00031 //----------------------------- IntTuples --------------------------------//
00032 //---------------------------- helper class ------------------------------//
00033 
00034 
00035 class IntTuples
00036 {
00037   // Objects in this class enumerate all tuples of non-negative integers.
00038   // Pass the length of tuple desired, and the starting radius in the
00039   // taxicab metric.
00040 
00041 public:
00042 
00043   /////////////////////////////////////////////////////////////////////////
00044   //                                                                     //
00045   // Constructors:                                                       //
00046   //                                                                     //
00047   /////////////////////////////////////////////////////////////////////////
00048 
00049   IntTuples(const int tupleLength, const int startRadius = 1);
00050   // tupleLength >= 1, startRadius >= 1
00051 
00052   ~IntTuples( ) { delete [] tuple; }
00053 
00054   /////////////////////////////////////////////////////////////////////////
00055   //                                                                     //
00056   // Accessors:                                                          //
00057   //                                                                     //
00058   /////////////////////////////////////////////////////////////////////////
00059 
00060   const int* nextTuple( );
00061   // You know how long the tuple is.
00062   // This retains custody of the int*.
00063 
00064 
00065 private:
00066 
00067   /////////////////////////////////////////////////////////////////////////
00068   //                                                                     //
00069   // Data Members:                                                       //
00070   //                                                                     //
00071   /////////////////////////////////////////////////////////////////////////
00072 
00073   int r;
00074   // Current radius, i.e., for n == 2:
00075   //
00076   // . . .           . . .           * . .
00077   // . . . r == 0,   * . . r == 1,   . * . r == 2, etc.
00078   // * . .           . * .           . . *
00079   //
00080   // Notice that the entries in a tuple add up to r.
00081 
00082   int* tuple;
00083   // The tuple we return.
00084 
00085   int* end;
00086   // Points to last entry of tuple
00087 
00088   int* sp;
00089   // The `stack' pointer.
00090 };
00091 
00092 
00093 
00094 //------------------------------------------------------------------------//
00095 //------------------------------ MapEnum ---------------------------------//
00096 //------------------------------------------------------------------------//
00097 
00098 class MapEnum
00099 {
00100 public:
00101 
00102   /////////////////////////////////////////////////////////////////////////
00103   //                                                                     //
00104   // Constructors:                                                       //
00105   //                                                                     //
00106   /////////////////////////////////////////////////////////////////////////
00107 
00108   MapEnum(const FGGroup& domain, const FGGroup& range, int radius = 1);
00109 
00110   /////////////////////////////////////////////////////////////////////////
00111   //                                                                     //
00112   // Accessors:                                                          //
00113   //                                                                     //
00114   /////////////////////////////////////////////////////////////////////////
00115 
00116   Map nextMap(int jump = 1);
00117 
00118 
00119 private:
00120 
00121   /////////////////////////////////////////////////////////////////////////
00122   //                                                                     //
00123   // Private Members:                                                    //
00124   //                                                                     //
00125   /////////////////////////////////////////////////////////////////////////
00126 
00127   Word kthWord(int k, int n);
00128   // Returns the kth freely reduced word on n semigroup generators.
00129 
00130   /////////////////////////////////////////////////////////////////////////
00131   //                                                                     //
00132   // Data Members:                                                       //
00133   //                                                                     //
00134   /////////////////////////////////////////////////////////////////////////
00135 
00136   int domainRank;
00137   int rangeRank;
00138 
00139   const FGGroup& theDomain;
00140   const FGGroup& theRange;
00141 
00142   IntTuples theTuples;
00143 };
00144 
00145 #endif

Generated at Tue Jun 19 09:49:37 2001 for Magnus Classes by doxygen1.2.6 written by Dimitri van Heesch, © 1997-2001