matrix.h

Go to the documentation of this file.

/* 
 * Copyright (C) 2015 Antoine Joux, Vanessa Vitse and Titouan Coladon
 * 
 * This file is part of openf4.
 * 
 * openf4 is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * openf4 is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with openf4.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef OPENF4_MATRIX_H
#define OPENF4_MATRIX_H

#include "global.h"
#include <iostream>
#include <cassert>
#include <ctime>
#include <chrono>
#include <string>
#include <fstream>
#include <sstream>

#ifdef USE_OPENMP
#include <omp.h>
#endif // USE_OPENMP

#ifdef HAVE_FFLAS_FFPACK
#include <givaro/modular-balanced.h>
#include <fflas-ffpack/ffpack/ffpack.h>
#include <fflas-ffpack/fflas/fflas.h>
#endif // HAVE_FFLAS_FFPACK

#include "element-prime.h"
#include "element-gf2.h"
#include "element-gf2-extension.h"

#ifdef HAVE_GIVARO
#include "element-givaro.h"
#endif // HAVE_GIVARO

#ifdef HAVE_SSE2
#include <emmintrin.h>
#endif // HAVE_SSE2

#ifdef HAVE_SSE4_1
#include <smmintrin.h>
#endif // HAVE_SSE4_1

#ifdef HAVE_SSE4_2
#include <nmmintrin.h>
#endif // HAVE_SSE4_2

namespace F4
{
    template <typename Element>
    class Matrix
    {
        public:
            
            /* Constructor */
            
            Matrix();
            
            Matrix(int height, int width);
            
            Matrix(std::string const & filename);
            
            Matrix(Matrix const & matrix);
            
            Matrix(Matrix && matrix);
            
            
            /* Destructor */
            
            ~Matrix();
            
            
            /* Get / Set */
            
            Element & operator() (int row, int col);
            
            Element operator() (int row, int col) const;
            
            Element getElement(int row, int col) const;
            
            void setElement (int row, int col, Element const & element);
            
            Element * getRow (int row);
            
            int getHeight() const;
            
            int getWidth() const;
            
            void setNbPiv(int nbPiv);
            
            int getNbPiv() const;
            
            void setTau(int * tau);
            
            int * getTau();
            
            void setSigma(int * sigma);
            
            int * getSigma();
            
            void setStartTail(int * startTail);
            
            int * getStartTail();
            
            void setEndCol(int * encCol);
            
            int * getEndCol();
            
            void setInfo(int nbPiv, int *tau, int *sigma, int * startTail, int * endCol);
            
            
            /* Miscellaneous */
            
            void printMatrix (std::ostream & stream) const;
            
            void printMatrix (std::string const & filename) const;
            
            void printMatrixTxt (std::string const & filename) const;
            
            void printMatrixSage(std::string const & filename) const;
            
            bool isZero(int row, int col) const;
            
            void normalizeRow(Element * row, int start, int end);
            
            void normalizeRowPrime(Element * row, int start, int end);
            
            void normalizeRowGF2Extension(Element * row, int start, int end);
            
            void multRow(Element * row, Element const & element, int start, int end);
            
            void multRowPrime(Element * row, Element const & element, int start, int end);
            
            void multRowGF2Extension(Element * row, Element const & element, int start, int end);
            
            void addMultRow(Element * row1, Element * row2, Element element, int start, int end);
            
            void addMultRowPrime(Element * row1, Element * row2, Element element, int start, int end);
            
            void addMultRowGF2Extension(Element * row1, Element * row2, Element element, int start, int end);
            
            void doubleAddMultRowGF2Extension(Element * dest1, Element * dest2, Element mult1, Element mult2, Element * vec, int start, int end);
            
            void tripleAddMultRowGF2Extension(Element * dest1, Element * dest2, Element * dest3, Element mult1, Element mult2, Element mult3, Element * vec, int start, int end);
            
            void quadAddMultRowGF2Extension(Element * dest1, Element * dest2, Element * dest3, Element * dest4, Element mult1, Element mult2, Element mult3, Element mult4, Element * vec, int start, int end);
            
            void octAddMultRowGF2Extension(Element * dest1, Element * dest2, Element * dest3, Element * dest4, Element * dest5, Element * dest6, Element * dest7, Element * dest8, Element mult1, Element mult2, Element mult3, Element mult4, Element mult5, Element mult6, Element mult7, Element mult8, Element * vec, int start, int end);
            
            void groupAddMultRowGF2Extension(int ll, int dec, int startL2, int endL2, int start, int end);
            
            void swapRow(int numRow1, int numRow2);
            
            void swapCol(int numCol1, int numCol2, int start, int end);

            int echelonizeRight (chrono::duration<int,milli> & tmp_ech_db, chrono::duration<int,milli> & tmp_ech_dh);
            
            int echelonize ();
            
            int echelonizePrime ();
            
            int echelonizeGF2Extension ();
            
            
            /* Internal operator */
            
            Matrix & operator=(Matrix const & matrix);
            
            Matrix & operator=(Matrix && matrix);
            
        private:
            Element ** _matrix; 
            int _height; 
            int _width; 
            int _nbPiv; 
            int * _tau; 
            int * _sigma; 
            int * _startTail; 
            int * _endCol; 
    };
    
    
    /* Internal operator */
    
    template <typename Element>
    std::ostream & operator<<(std::ostream & stream, Matrix<Element> const & matrix);
}

#include "../src/matrix.inl"
#endif // OPENF4_MATRIX_H