Changeset 25 for tests

Show
Ignore:
Timestamp:
07/05/07 14:28:33 (2 years ago)
Author:
pernet
Message:

* add a transposed version of the LQUP decomposition routine LUdivine
* fix many bugs in LUdivine
* new schedules for Winograd algorithm for matrix multiplication: 2 cases depending whether beta = 0 or not, taken form [Huss Ledermann & Al. 96]
* new tests for ftrtri, echelon and redechelon

Location:
tests
Files:
5 added
3 modified

Legend:

Unmodified
Added
Removed
  • tests/test-fgemm.C

    r16 r25  
    77//------------------------------------------------------------------------- 
    88 
    9 #define DEBUG 1 
     9#define DEBUG 0 
     10#define NEWWINO 
    1011#define TIME 1 
    1112 
    1213#include <iomanip> 
    1314#include <iostream> 
    14 #include "fflas-ffpack/modular-balanced.h" 
     15using namespace std; 
     16 
     17#include "fflas-ffpack/modular-positive.h" 
    1518#include "timer.h" 
    1619#include "Matio.h" 
     
    1821 
    1922 
    20 using namespace std; 
     23 
    2124 
    2225typedef Modular<double> Field; 
     26//typedef Modular<float> Field; 
     27//typedef Modular<int> Field; 
    2328 
    2429int main(int argc, char** argv){ 
     
    4146                exit(-1); 
    4247        } 
    43         Field F(atoi(argv[1])); 
     48        Field F((long)atoi(argv[1])); 
    4449 
    4550        F.init( alpha, Field::Element(atoi(argv[6]))); 
     
    7378         
    7479        Field::Element * C; 
    75         C = new Field::Element[m*n]; 
    7680 
     81//      write_field (F, cerr<<"A = "<<endl, A, m, k, lda); 
     82//      write_field (F, cerr<<"B = "<<endl, B, k, n, ldb); 
    7783        Timer tim,t; t.clear();tim.clear();  
    7884        for(int i = 0;i<nbit;++i){ 
    7985                if (!F.isZero(beta)){ 
    8086                        C = read_field(F,argv[8],&m,&n); 
    81                 } 
     87                }else 
     88                        C = new Field::Element[m*n]; 
    8289                t.clear(); 
    8390                t.start(); 
     
    8693                t.stop(); 
    8794                tim+=t; 
     95                if (i<nbit-1) 
     96                        delete[] C; 
    8897        } 
    8998 
    9099#if DEBUG 
    91100        bool wrong = false; 
    92         Field::Element * Cd = new Field::Element[m*n]; 
     101        Field::Element zero; 
     102        F.init(zero, 0.0); 
     103        Field::Element * Cd; 
    93104        if (!F.isZero(beta)) 
    94105                Cd = read_field(F,argv[8],&m,&n); 
     106        else{ 
     107                Cd  = new Field::Element[m*n]; 
     108                for (size_t i=0; i<m*n; ++i) 
     109                        F.assign (*(Cd+i), zero); 
     110        } 
    95111        Field::Element aij, bij, beta_alpha; 
    96112        F.div (beta_alpha, beta, alpha); 
     
    127143                cerr<<"PASS"<<endl; 
    128144        } 
     145        delete[] Cd; 
    129146#endif 
    130147 
     148        delete[] C; 
     149        delete[] A; 
     150        delete[] B; 
    131151#if TIME 
    132152        double mflops = (2.0*(m*k-((!F.isZero(beta))?m:0))/1000000.0)*nbit*n/tim.usertime(); 
  • tests/test-invert.C

    r16 r25  
    99#define DEBUG 1 
    1010#define TIME 1 
     11using namespace std; 
    1112 
    1213#include <iomanip> 
     
    1920 
    2021 
    21 using namespace std; 
    2222 
    23 typedef Modular<float> Field; 
     23typedef Modular<double> Field; 
    2424 
    2525int main(int argc, char** argv){ 
     
    4040        F.init(zero,0.0); 
    4141        F.init(one,1.0); 
    42         Field::Element * A,*Ab; 
     42        Field::Element * A; 
    4343        A = read_field(F,argv[2],&n,&n); 
    44         Ab = new Field::Element[n*n]; 
    45         for (int i=0; i<n*n;++i) 
    46                 F.assign(*(Ab+i),*(A+i)); 
    47         Field::Element * X = new Field::Element[n*n]; 
    4844 
    4945        Timer tim,t; t.clear();tim.clear();  
     
    5349                t.clear(); 
    5450                t.start(); 
    55                 FFPACK::Invert2 (F, n, A, n, X, n, nullity); 
     51                FFPACK::Invert (F, n, A, n, nullity); 
    5652                t.stop(); 
    5753                tim+=t; 
    58                 if (i+1<nbit) 
    59                         for (int i=0; i<n*n;++i) 
    60                                 F.assign(*(A+i),*(Ab+i)); 
    6154        } 
    6255 
    6356#if DEBUG 
     57        Field::Element *Ab = read_field(F,argv[2],&n,&n); 
    6458        Field::Element *I = new Field::Element[n*n]; 
    6559        FFLAS::fgemm (F, FFLAS::FflasNoTrans, FFLAS::FflasNoTrans, n, n, n, 
    66                       1.0, Ab, n, X, n, 0.0, I, n);  
     60                      1.0, Ab, n, A, n, 0.0, I, n);  
    6761        bool wrong = false; 
    6862 
     
    7872                else{ 
    7973                        cerr<<"FAIL"<<endl; 
    80                         write_field (F,cerr<<"A="<<endl,A,n,n,n); 
    81                         write_field (F,cerr<<"X="<<endl,X,n,n,n); 
     74                        write_field (F,cerr<<"A="<<endl,Ab,n,n,n); 
     75                        write_field (F,cerr<<"A^-1="<<endl,A,n,n,n); 
    8276                        write_field (F,cerr<<"I="<<endl,I,n,n,n); 
    8377                } 
     
    8579                cerr<<"PASS"<<endl; 
    8680        } 
     81        delete[] I; 
     82        delete[] Ab; 
     83 
    8784#endif 
     85        delete[] A; 
    8886 
    8987#if TIME 
  • tests/test-lqup.C

    r16 r25  
    2121#include "timer.h" 
    2222#include "fflas-ffpack/modular-balanced.h" 
     23#include "fflas-ffpack/modular-positive.h" 
    2324#include "fflas-ffpack/ffpack.h" 
    2425 
     
    3031        int R=0; 
    3132 
    32         if (argc!=5){ 
    33                 cerr<<"usage : test-lqup <p> <A> <c> <i>"<<endl 
    34                     <<"        to do i LQUP factorisation of A with cutoff criterium set to c" 
     33        if (argc!=4){ 
     34                cerr<<"usage : test-lqup <p> <A> <i>"<<endl 
     35                    <<"        to do i LQUP factorisation of A" 
    3536                    <<endl; 
    3637                exit(-1); 
     
    4142        A = read_field(F,argv[2],&m,&n); 
    4243         
    43         size_t *P = new size_t[n]; 
    44         size_t *Q = new size_t[m]; 
    45                  
     44        size_t maxP, maxQ; 
     45                         
    4646        //      size_t cutoff = atoi(argv[3]); 
    47         nbf = atoi(argv[4]); 
     47        nbf = atoi(argv[3]); 
    4848         
    4949        Timer tim,timc; 
    5050        timc.clear(); 
    5151 
    52         enum FFLAS::FFLAS_DIAG diag = FFLAS::FflasNonUnit; 
    53          
     52        enum FFLAS::FFLAS_DIAG diag = FFLAS::FflasUnit; 
     53        enum FFLAS::FFLAS_TRANSPOSE trans = FFLAS::FflasTrans; 
     54        if (trans == FFLAS::FflasTrans){ 
     55                maxP = m; 
     56                maxQ = n; 
     57        } else{ 
     58                maxP = n; 
     59                maxQ = m; 
     60        } 
     61        size_t *P = new size_t[maxP]; 
     62        size_t *Q = new size_t[maxQ]; 
     63                 
     64        //write_field (F,cerr<<"A = "<<endl, A, m,n,n); 
    5465        for ( i=0;i<nbf;i++){ 
    5566                if (i) {                 
     
    6374                tim.clear();       
    6475                tim.start();     
    65                 R = FFPACK::LUdivine (F, diag, m, n, A, n, P, Q, 
    66                                             FFPACK::FfpackLQUP); 
     76                R = FFPACK::LUdivine (F, diag, trans, m, n, A, n, P, Q, 
     77                                      FFPACK::FfpackLQUP); 
    6778                tim.stop(); 
    6879                timc+=tim; 
    6980        } 
    70         //write_field (F,cerr<<"Result = "<<endl, A, m,n,n); 
    71  
    72 //      cerr<<"P = ["; 
    73 //      for (size_t i=0; i<n; ++i) 
    74 //              cerr<<P[i]<<" "; 
    75 //      cerr<<"]"<<endl; 
    76 //      cerr<<"Q = ["; 
    77 //      for (size_t i=0; i<m; ++i) 
    78 //              cerr<<Q[i]<<" "; 
    79 //      cerr<<"]"<<endl; 
     81        write_field (F,cerr<<"Result = "<<endl, A, m,n,n); 
     82 
     83        cerr<<"P = ["; 
     84        for (size_t i=0; i<maxP; ++i) 
     85                cerr<<P[i]<<" "; 
     86        cerr<<"]"<<endl; 
     87        cerr<<"Q = ["; 
     88        for (size_t i=0; i<maxQ; ++i) 
     89                cerr<<Q[i]<<" "; 
     90        cerr<<"]"<<endl; 
    8091#if DEBUG 
    81         Field::Element * L = new Field::Element[m*m]; 
    82         Field::Element * U = new Field::Element[m*n]; 
    8392        Field::Element * X = new Field::Element[m*n]; 
    84          
    85         Field::Element zero,one; 
    86         F.init(zero,0.0); 
    87         F.init(one,1.0); 
    88         for (int i=0; i<R; ++i){ 
    89                 for (int j=0; j<i; ++j) 
    90                         F.assign ( *(U + i*n + j), zero); 
    91                 for (int j=i; j<n; ++j) 
    92                         F.assign (*(U + i*n + j), *(A+ i*n+j)); 
    93         } 
    94         for (int i=R;i<m; ++i) 
    95                 for (int j=0; j<n; ++j) 
    96                         F.assign(*(U+i*n+j), zero); 
    97         for ( int i=0; i<m; ++i ){ 
    98                 int j=0; 
    99                 for (; j< ((i<R)?i:R) ; ++j ) 
    100                         F.assign( *(L + i*m+j), *(A+i*n+j)); 
    101                 for (; j<m; ++j ) 
    102                         F.assign( *(L+i*m+j), zero); 
    103         } 
    104  
    105 //      write_field(F,cerr<<"L = "<<endl,L,m,m,m); 
    106 //      write_field(F,cerr<<"U = "<<endl,U,m,n,n); 
    107         FFPACK::applyP( F, FFLAS::FflasRight, FFLAS::FflasNoTrans, m,0,R, L, m, Q); 
    108         if (diag == FFLAS::FflasNonUnit) 
     93        Field::Element * L, *U; 
     94        if (trans == FFLAS::FflasNoTrans){ 
     95                L = new Field::Element[m*m]; 
     96                U = new Field::Element[m*n]; 
     97                                 
     98                Field::Element zero,one; 
     99                F.init(zero,0.0); 
     100                F.init(one,1.0); 
     101                for (int i=0; i<R; ++i){ 
     102                        for (int j=0; j<i; ++j) 
     103                                F.assign ( *(U + i*n + j), zero); 
     104                        for (int j=i+1; j<n; ++j) 
     105                                F.assign (*(U + i*n + j), *(A+ i*n+j)); 
     106                } 
     107                for (int i=R;i<m; ++i) 
     108                        for (int j=0; j<n; ++j) 
     109                                F.assign(*(U+i*n+j), zero); 
     110                for ( int i=0; i<m; ++i ){ 
     111                        int j=0; 
     112                        for (; j< ((i<R)?i:R) ; ++j ) 
     113                                F.assign( *(L + i*m+j), *(A+i*n+j)); 
     114                        for (; j<m; ++j ) 
     115                                F.assign( *(L+i*m+j), zero); 
     116                } 
     117                 
     118                write_field(F,cerr<<"L = "<<endl,L,m,m,m); 
     119                write_field(F,cerr<<"U = "<<endl,U,m,n,n); 
     120                FFPACK::applyP( F, FFLAS::FflasRight, FFLAS::FflasNoTrans, m,0,R, L, m, Q); 
    109121                for ( int i=0; i<m; ++i ) 
    110                         F.assign (*(L+i*(m+1)),one); 
    111         else{ 
    112                 int i=0; 
    113                 while (Q[i]==size_t(i)){*(L+i*(m+1)) = * (U+i*(n+1)); ++i;} 
    114                 for ( int i=0; i<R; ++i ) 
     122                        F.assign(*(L+i*(m+1)), one); 
     123 
     124                write_field(F,cerr<<"L = "<<endl,L,m,m,m); 
     125                write_field(F,cerr<<"U = "<<endl,U,m,n,n); 
     126                if (diag == FFLAS::FflasNonUnit) 
     127                        for ( int i=0; i<R; ++i ) 
     128                                F.assign (*(U+i*(n+1)), *(A+i*(n+1))); 
     129                         
     130                else{ 
     131                        for ( int i=0; i<R; ++i ){ 
     132                                *(L+Q[i]*(m+1)) = *(A+Q[i]*n+i); 
     133                                F.assign (*(U+i*(n+1)),one); 
     134                        } 
     135                } 
     136                write_field(F,cerr<<"L = "<<endl,L,m,m,m); 
     137                write_field(F,cerr<<"U = "<<endl,U,m,n,n); 
     138 
     139                FFPACK::applyP (F, FFLAS::FflasRight, FFLAS::FflasNoTrans, m,0,R, U, n, P); 
     140                FFPACK::applyP (F, FFLAS::FflasLeft, FFLAS::FflasTrans, n,0,R, U, n, Q); 
     141                FFLAS::fgemm (F, FFLAS::FflasNoTrans, FFLAS::FflasNoTrans, m,n,m, 1.0, L,m, U,n, 0.0, X,n); 
     142                //delete[] A; 
     143        } else { 
     144 
     145                L = new Field::Element[m*n]; 
     146                U = new Field::Element[n*n]; 
     147 
     148                 
     149                Field::Element zero,one; 
     150                F.init(zero,0.0); 
     151                F.init(one,1.0); 
     152                for (int i=0; i<R; ++i){ 
     153                        for (int j=0; j<i; ++j) 
     154                                F.assign ( *(L + i + j*n), zero); 
     155                        for (int j=i+1; j<m; ++j) 
     156                                F.assign (*(L + i + j*n), *(A+ i+j*n)); 
     157                } 
     158                 
     159                for (int i=R;i<n; ++i) 
     160                        for (int j=0; j<m; ++j) 
     161                                F.assign(*(L+i+j*n), zero); 
     162                for ( int i=0; i<n; ++i ){ 
     163                        int j=0; 
     164                        for (;  j< ((i<R)?i:R) ; ++j ) 
     165                                F.assign( *(U + i+j*n), *(A+i+j*n)); 
     166                        for (; j<n; ++j ) 
     167                                F.assign( *(U+i+j*n), zero); 
     168                } 
     169                write_field(F,cerr<<"L = "<<endl,L,m,n,n); 
     170                write_field(F,cerr<<"U = "<<endl,U,n,n,n); 
     171 
     172                FFPACK::applyP( F, FFLAS::FflasLeft, FFLAS::FflasTrans, n,0,R, U, n, Q); 
     173 
     174 
     175                for (int i=0; i<n; ++i) 
    115176                        F.assign (*(U+i*(n+1)),one); 
    116         } 
    117         FFPACK::applyP (F, FFLAS::FflasRight, FFLAS::FflasNoTrans, m,0,R, U, n, P); 
    118         FFPACK::applyP (F, FFLAS::FflasLeft, FFLAS::FflasTrans, n,0,R, U, n, Q); 
    119         FFLAS::fgemm (F, FFLAS::FflasNoTrans, FFLAS::FflasNoTrans, m,n,m, 1.0, L,m, U,n, 0.0, X,n); 
    120         //delete[] A; 
    121  
     177 
     178                if (diag == FFLAS::FflasNonUnit) 
     179                        for ( int i=0; i<R; ++i ) 
     180                                F.assign (*(L+i*(n+1)), *(A+i*(n+1))); 
     181                else{ 
     182                        for ( int i=0; i<R; ++i ){ 
     183                                *(U+Q[i]*(n+1)) = *(A+Q[i]+i*n); 
     184                                F.assign (*(L+i*(n+1)),one); 
     185                        } 
     186                } 
     187                write_field(F,cerr<<"L = "<<endl,L,m,n,n); 
     188                write_field(F,cerr<<"U = "<<endl,U,n,n,n); 
     189 
     190                FFPACK::applyP (F, FFLAS::FflasLeft, FFLAS::FflasTrans, n,0,R, L, n, P); 
     191                FFPACK::applyP (F, FFLAS::FflasRight, FFLAS::FflasNoTrans, m,0,R, L, n, Q); 
     192                FFLAS::fgemm (F, FFLAS::FflasNoTrans, FFLAS::FflasNoTrans, m,n,n, 1.0, L,n, U,n, 0.0, X,n); 
     193        } 
    122194        Field::Element * B =  read_field(F,argv[2],&m,&n); 
    123195        bool fail = false; 
     
    127199                                fail=true; 
    128200         
     201        write_field(F,cerr<<"X = "<<endl,X,m,n,n); 
     202        write_field(F,cerr<<"B = "<<endl,B,m,n,n); 
    129203        delete[] B; 
    130204        if (fail) 
     
    134208        else 
    135209                cerr<<"PASS"<<endl; 
    136                  
    137 //      cout<<m<<" "<<n<<" M"<<endl; 
    138 //      for (size_t i=0; i<m; ++i) 
    139 //              for (size_t j=0; j<n; ++j) 
    140 //                      if (!F.isZero(*(A+i*n+j))) 
    141 //                              cout<<i+1<<" "<<j+1<<" "<<(*(A+i*n+j))<<endl; 
    142 //      cout<<"0 0 0"<<endl; 
    143  
    144210#endif 
    145211        delete[] A;