Changeset 62 for include/fflas-ffpack/modular-balanced.h

Timestamp:

06/03/08 21:24:57 (7 months ago)

Author:

pernet

Message:

* Change the design of fflas-bounds
* Modular<double> -> ModularBalanced?<double>
* Fix the winograd recursion issue (when some steps are done over the field)
* Fix a bunch of bugs
* Remove the template specialization by the Element (incompatible with the soon coming compressed representations over small fields)
* Create a randiter file, generic wrt the modular field

Files:

• include/fflas-ffpack/modular-balanced.h (modified) (6 diffs)

include/fflas-ffpack/modular-balanced.h

@@ -12 +12 @@
  */
 
+#ifndef __MODULAR_BALANCED_H
+#define __MODULAR_BALANCED_H
+
 #include <math.h>
-
-
-#ifndef __MODULAR_DOUBLE_BALANCED_H
-#define __MODULAR_DOUBLE_BALANCED_H
-
-template <class T>
-class Modular;
+#include "fflas-ffpack/modular-randiter.h"
 
 template <class Element>
-class ModularRandIter
-{
-public:
-        ModularRandIter (const Modular<Element> &F):_F(F){}
-        ModularRandIter (const ModularRandIter<Element> &R) 
-                : _F (R._F) {}
-        Element &random (Element &a) const
-        { return _F.init(a,(double)rand()); }
-private:
-        Modular<Element> _F;
-        
-};
+class ModularBalanced;
 
 template<>
-class Modular <double>{
+class ModularBalanced <double>{
 
 protected:
@@ -47 +33 @@
         typedef double Element;
         typedef unsigned long FieldInt;
-        typedef ModularRandIter<double> RandIter;
+        typedef ModularBalancedRandIter<double> RandIter;
 
         const bool balanced;
 
-        Modular<double> (int p)  : modulus((double)p), inv_modulus(1./(double)p), half_mod( (p-1.)/2), balanced(true) {}
-
-        Modular<double>(const Modular<double>& mf) : modulus(mf.modulus), inv_modulus(mf.inv_modulus), half_mod(mf.half_mod), balanced(true){}
-        
-        const Modular<double> &operator=(const Modular<double> &F) {
+        ModularBalanced<double> (int p)  : modulus((double)p), inv_modulus(1./(double)p), half_mod( (p-1.)/2), balanced(true) {}
+
+        ModularBalanced<double>(const ModularBalanced<double>& mf) : modulus(mf.modulus), inv_modulus(mf.inv_modulus), half_mod(mf.half_mod), balanced(true){}
+        
+        const ModularBalanced<double> &operator=(const ModularBalanced<double> &F) {
                         modulus = F.modulus;
                         inv_modulus = F.inv_modulus;
@@ -242 +228 @@
                 return init( r, tmp );
         }
+
+        static inline double getMaxModulus()
+        { return 67108864.0; } // 2^26
                 
 };
 template<>
-class Modular <float>{
+class ModularBalanced <float>{
 
 protected:
@@ -256 +245 @@
         typedef float Element;
         typedef unsigned long FieldInt;
-        typedef ModularRandIter<float> RandIter;
+        typedef ModularBalancedRandIter<float> RandIter;
 
         const bool balanced;
 
-        Modular<float> (int p)  : modulus((float)p), inv_modulus(1./(float)p), half_mod( (p-1.)/2), balanced(true) {}
-
-        Modular<float>(const Modular<float>& mf) : modulus(mf.modulus), inv_modulus(mf.inv_modulus), half_mod(mf.half_mod), balanced(true){}
-        
-        const Modular<float> &operator=(const Modular<float> &F) {
+        ModularBalanced<float> (int p)  : modulus((float)p), inv_modulus(1./(float)p), half_mod( (p-1.)/2), balanced(true) {}
+
+        ModularBalanced<float>(const ModularBalanced<float>& mf) : modulus(mf.modulus), inv_modulus(mf.inv_modulus), half_mod(mf.half_mod), balanced(true){}
+        
+        const ModularBalanced<float> &operator=(const ModularBalanced<float> &F) {
                         modulus = F.modulus;
                         inv_modulus = F.inv_modulus;
@@ -271 +260 @@
                 }
 
-        
-        
-        
-        
         FieldInt &cardinality (FieldInt &c) const{ 
                 return c = (FieldInt) modulus;
@@ -462 +447 @@
                 return init( r, tmp );
         }
+        static inline float getMaxModulus()
+        { return 2048; } // 2^11
                 
 };