Changeset 18 for include/fflas-ffpack/fflas.h

Timestamp:

04/28/07 20:58:32 (2 years ago)

Author:

pernet

Message:

Introduction of the field Modular<float> and the corresponding specializations using the float BLAS.

Files:

• include/fflas-ffpack/fflas.h (modified) (10 diffs)

include/fflas-ffpack/fflas.h

@@ -38 +38 @@
 
 #define DOUBLE_MANTISSA 53
+#define FLOAT_MANTISSA 24
         
 class FFLAS {
@@ -47 +48 @@
         enum FFLAS_SIDE      { FflasLeft=141, FflasRight = 142 };
         
+        typedef UnparametricField<float> FloatDomain;
+
         typedef UnparametricField<double> DoubleDomain;
+
+
+        
         
 //---------------------------------------------------------------------
@@ -224 +230 @@
          */
         template<class Field>
-        static typename Field::Element* fgemm (const Field& F,
-                                               const enum FFLAS_TRANSPOSE ta,
-                                               const enum FFLAS_TRANSPOSE tb,
-                                               const size_t m,
-                                               const size_t n,
-                                               const size_t k,
-                                               const typename Field::Element alpha,
-                                               const typename Field::Element* A, 
-                                               const size_t lda,
-                                               const typename Field::Element* B,
-                                               const size_t ldb, 
-                                               const typename Field::Element beta,
-                                               typename Field::Element* C, 
-                                               const size_t ldc){
+        static typename Field::Element*
+        fgemm (const Field& F,
+               const enum FFLAS_TRANSPOSE ta,
+               const enum FFLAS_TRANSPOSE tb,
+               const size_t m,
+               const size_t n,
+               const size_t k,
+               const typename Field::Element alpha,
+               const typename Field::Element* A, 
+               const size_t lda,
+               const typename Field::Element* B,
+               const size_t ldb, 
+               const typename Field::Element beta,
+               typename Field::Element* C, 
+               const size_t ldc){
                 size_t ws =0;
                 if ( (ta==FflasNoTrans)  && (tb==FflasNoTrans)) {
@@ -305 +312 @@
                         }
                 }
+        //---------------------------------------------------------------------
+        // Finite Field matrix => float matrix
+        //---------------------------------------------------------------------
+        template<class Field>
+        static void MatF2MatFl (const Field& F,
+                                FloatDomain::Element* S, const size_t lds,
+                                const typename Field::Element* E,
+                                const size_t lde,const size_t m, const size_t n){
+                
+                const typename Field::Element* Ei = E;
+                FloatDomain::Element *Si=S;
+                size_t j; 
+                for (; Ei < E+lde*m; Ei+=lde, Si += lds)
+                        for ( j=0; j<n; ++j){
+                                F.convert(*(Si+j),*(Ei+j));
+                        }
+                }
         
         //---------------------------------------------------------------------
@@ -324 +348 @@
                                 F.convert(*(Si+j),*(Ei+j));
         }
+
+        //---------------------------------------------------------------------
+        // Finite Field matrix => float matrix
+        // Special design for upper-triangular matrices
+        //---------------------------------------------------------------------
+        template<class Field>
+        static void MatF2MatFl_Triangular (const Field& F,
+                                           typename FloatDomain::Element* S, const size_t lds,
+                                           const typename Field::Element* const E,
+                                           const size_t lde,
+                                           const size_t m, const size_t n){
+                
+                const typename Field::Element* Ei = E;
+                typename FloatDomain::Element* Si = S;
+                size_t i=0, j;
+                for ( ; i<m;++i, Ei+=lde, Si+=lds)
+                        for ( j=i; j<n;++j)
+                                F.convert(*(Si+j),*(Ei+j));
+        }
         
         //---------------------------------------------------------------------
@@ -336 +379 @@
                 typename Field::Element* Si = S;
                 const DoubleDomain::Element* Ei =E;
+                size_t j;
+                for ( ; Si < S+m*lds; Si += lds, Ei+= lde){
+                        for ( j=0; j<n;++j)
+                                F.init( *(Si+j), *(Ei+j) );
+                }
+        }
+
+        //---------------------------------------------------------------------
+        // float matrix => Finite Field matrix
+        //---------------------------------------------------------------------
+        template<class Field>
+        static void MatFl2MatF (const Field& F,
+                                typename Field::Element* S, const size_t lds,
+                                const typename FloatDomain::Element* E, const size_t lde,
+                                const size_t m, const size_t n){
+                
+                typename Field::Element* Si = S;
+                const FloatDomain::Element* Ei =E;
                 size_t j;
                 for ( ; Si < S+m*lds; Si += lds, Ei+= lde){
@@ -358 +419 @@
                                     const typename Field::Element& beta);
 
+        template <class Field>
+        static size_t DotProdBoundCompute (const Field& F, const size_t w,
+                                           const typename Field::Element& beta);
+        
+        template <class Element>
+        class callDotProdBoundCompute;
+
         /** @brief Bound for the delayed modulus triangular system solving
          *
@@ -369 +437 @@
         template <class Field>
         static size_t TRSMBound (const Field& F);
-        
+
+        template <class Element>
+        class callTRSMBound;
 
         template <class Field>
@@ -430 +500 @@
                               typename Field::Element * C, const size_t ldc,
                               const size_t kmax, const size_t w);
-        template<bool AreEq>
+
+
+        template<class Element>
         class callWinoMain;
 
-        template<bool AreEq>
+        template<class Element>
         class callClassicMatmul;
 
-        template<bool AreEq>
+        template<class Element>
         class callFsquare;
 
-        template<bool AreEq>
+        template<class Element>
         class callMatVectProd;
                 
@@ -464 +536 @@
                                          typename Field::Element * B, const size_t ldb, 
                                          const size_t nmax);
-        template<bool AreEq>
+        template<class Element>
         class callFtrsmLeftLowNoTrans;
         
-        template<bool AreEq>
+        template<class Element>
         class callFtrsmRightUpNoTrans;
         
-        template<bool AreEq>
+        template<class Element>
         class callFtrmmLeftUpNoTrans;
         
-        template<bool AreEq>
+        template<class Element>
         class callFtrmmLeftUpTrans;
 
-        template<bool AreEq>
+        template<class Element>
         class callFtrmmLeftLowNoTrans;          
 
-        template<bool AreEq>
+        template<class Element>
         class callFtrmmLeftLowTrans;            
 
-        template<bool AreEq>
+        template<class Element>
         class callFtrmmRightUpNoTrans;          
 
-        template<bool AreEq>
+        template<class Element>
         class callFtrmmRightUpTrans;            
 
-        template<bool AreEq>
+        template<class Element>
         class callFtrmmRightLowNoTrans;         
 
-        template<bool AreEq>
+        template<class Element>
         class callFtrmmRightLowTrans;