Matrix.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2007-2014, A. N. Yzelman,   Utrecht University 2007-2011;
 *                                                    KU Leuven 2011-2014.
 *                          R. H. Bisseling, Utrecht University 2007-2014.
 * 
 * This file is part of the Sparse Library.
 * 
 * This library was developed under supervision of Prof. dr. Rob H. Bisseling at
 * Utrecht University, from 2007 until 2011. From 2011-2014, development continued 
 * at KU Leuven, where Prof. dr. Dirk Roose contributed significantly to the ideas 
 * behind the newer parts of the library code.
 * 
 *     The Sparse Library 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.
 * 
 *     The Sparse Library 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 the Sparse Library. If not, see <http://www.gnu.org/licenses/>.
 */


#ifndef _H_M
#define _H_M

#include <time.h>

template< typename T >
class Matrix {
        private:
        
        protected:

        public:

                Matrix() {}

                virtual ~Matrix() {}

                virtual unsigned long int m() = 0;

                virtual unsigned long int n() = 0;

                virtual unsigned long int nzs() {
                        return m() * n();
                }

                virtual T* mv( const T* x ) = 0;

                virtual void zax( const T*__restrict__ x, T*__restrict__ z ) = 0;

                virtual void zax( const T*__restrict__ x, T*__restrict__ z, const size_t k, const clockid_t clock_id = 0, double *elapsed_time = NULL ) {
                        struct timespec start, stop; 
                        if( elapsed_time != NULL ) {
                                clock_gettime( clock_id, &start);
                        }
                        for( size_t i = 0; i < k; ++i ) {
                                zax( x, z );
                        }
                        if( elapsed_time != NULL ) {
                                clock_gettime( clock_id, &stop);
                                double time = (stop.tv_sec-start.tv_sec)*1000;
                                time += (stop.tv_nsec-start.tv_nsec)/1000000.0;
                                *elapsed_time += time;
                        }
                }

                template< size_t k >
                void ZaX( const T*__restrict__ const *__restrict__ const X, T *__restrict__ const *__restrict__ const Z ) {
                        //loop k times
                        for( size_t i = 0; i < k; ++i ) {
                                //call regular z=Ax function
                                zax( X[i], Z[i] );
                        }
                        //done
                }

                virtual void zxa( const T*__restrict__ x, T*__restrict__ z ) = 0;

                template< size_t k >
                void ZXa( const T *__restrict__ const *__restrict__ const X, T *__restrict__ const *__restrict__ const Z ) {
                        //loop k times
                        for( size_t i = 0; i < k; ++i ) {
                                //call regular z=xA function
                                zxa( X[i], Z[i] );
                        }
                        //done
                }

                virtual void zxa( const T*__restrict__ x, T*__restrict__ z, const unsigned long int repeat, const clockid_t clock_id = 0, double *elapsed_time = NULL ) {
                        struct timespec start, stop; 
                        if( elapsed_time != NULL ) clock_gettime( clock_id, &start);
                        for( unsigned long int i=0; i<repeat; i++ )
                                zxa( x, z );
                        if( elapsed_time != NULL ) {
                                clock_gettime( clock_id, &stop);
                                double time = (stop.tv_sec-start.tv_sec)*1000;
                                time += (stop.tv_nsec-start.tv_nsec)/1000000.0;
                                *elapsed_time += time;
                        }
                }

                virtual size_t bytesUsed() = 0;
};

#endif //_H_M