allow candidate generators w/o order in PAlgebra constructor

Author: Shai Halevi

src/NumbTh.cpp

@@ -314,7 +314,8 @@ static bool gtAbsVal(long a, long b)
 
 // Returns in gens a generating set for Zm* /<p>, and in ords the
 // order of these generators. Return value is the order of p in Zm*.
-long findGenerators(vector<long>& gens, vector<long>& ords, long m, long p)
+long findGenerators(vector<long>& gens, vector<long>& ords, long m, long p,
+                    const vector<long>& candidates)
 {
   gens.clear();
   ords.clear();
@@ -333,20 +334,28 @@ long findGenerators(vector<long>& gens, vector<long>& ords, long m, long p)
   // The order of p is the size of the equivalence class of 1
 #if 0
   long ordP = std::count(classes.begin(), classes.end(), 1);
-       // count(from,to,val) returns # of elements in (from,to) with value=val
+    // count(from,to,val) returns # of elements in (from,to) with value=val
 #else
-   long ordP = 0;
-   for (long i = 0; i < lsize(classes); i++)
-      if (classes[i] == 1) ordP++;
+  long ordP = 0;
+  for (long i = 0; i < lsize(classes); i++)
+    if (classes[i] == 1) ordP++;
 #endif
 
-  // Compute orders in (Z/mZ)^*/<p> while comparing to (Z/mZ)^*
+  // Compute orders in (Z/mZ)^* /<p> while comparing to (Z/mZ)^*
+  long candIdx=0;
   while (true) {
     compOrder(orders,classes,true,m);
     // if the orders of i in Zm* /<p> and Zm* are not the same, then
     // order[i] contains the order in Zm* /<p> with negative sign
 
-    long idx = argmax(orders, &gtAbsVal); // find the element with largest order
+    long idx=0;
+    if (candIdx<lsize(candidates)) { // try next candidate
+      idx = candidates[candIdx++];
+      if (abs(orders[idx])<=1)
+        idx=0;
+    }
+    if (idx==0) // no viable candidates supplied externally
+      idx = argmax(orders, &gtAbsVal);// find the element with largest order
     long largest = orders[idx];
 
     if (abs(largest) == 1) break;   // Trivial group, we are done

src/NumbTh.h

@@ -342,7 +342,8 @@ long phi_N(long N);
 
 //! Returns in gens a generating set for Zm* /<p>, and in ords the
 //! order of these generators. Return value is the order of p in Zm*.
-long findGenerators(vector<long>& gens, vector<long>& ords, long m, long p);
+long findGenerators(vector<long>& gens, vector<long>& ords, long m, long p,
+                    const vector<long>& candidates=vector<long>());
 
 //! Find e-th root of unity modulo the current modulus.
 void FindPrimitiveRoot(zz_p &r, unsigned long e);

src/PAlgebra.cpp

@@ -127,20 +127,24 @@ PAlgebra::PAlgebra(unsigned long mm, unsigned long pp,
   // Compute the generators for (Z/mZ)^* (defined in NumbTh.cpp)
 
   std::vector<long> tmpOrds;
-  if (_gens.size() == 0 || isDryRun()) 
-      this->ordP = findGenerators(this->gens, tmpOrds, mm, pp);
-  else {
-    assert(_gens.size() == _ords.size());
+  if (_gens.size() == _ords.size() && !isDryRun()) {
+    // externally supplied generator,orders
     tmpOrds = _ords;
     this->gens = _gens;
     this->ordP = multOrd(pp, mm);
   }
+  else
+    // treat externally supplied generators (if any) as candidates
+    this->ordP = findGenerators(this->gens, tmpOrds, mm, pp, _gens);
+
+  // Record for each generator gi whether it has the same order in
+  // ZM* as in Zm* /(p,g1,...,g_{i-1})
   resize(native, lsize(tmpOrds));
   for (long j=0; j<lsize(tmpOrds); j++) {
     native[j] = (tmpOrds[j]>0);
     tmpOrds[j] = abs(tmpOrds[j]);
   }
-  cube.initSignature(tmpOrds);
+  cube.initSignature(tmpOrds); // set hypercume with these dimensions
 
   phiM = ordP * getNSlots();