Triplet.hpp

/*
 * 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/>.
 */


/*
 * File created by:
 *     A. N. Yzelman, Dept. of Mathematics, Utrecht University, 2007.
 */


#include<cstdlib>
#include<string>
#include<vector>
#include<fstream>
#include<iostream>

//#define _DEBUG

#include "ULIdef.hpp"

#ifndef _H_TRIPLET
#define _H_TRIPLET

template< typename T >
class Triplet {

   protected:
        
        ULI row;
        
        ULI column;

   public:

#ifdef TRIPLET_META

        TRIPLET_META_TYPE meta;
#endif

        ULI i() const { return row; }

        ULI j() const { return column; }

        void rowOffset( ULI offset ) { row -= offset; }

        void setPosition( const unsigned long int i, const unsigned long int j ) {
                row = i;
                column = j;
        }

        void setRowPosition( const unsigned long int i ) {
                setPosition( i, column );
        }

        void setColumnPosition( const unsigned long int j ) {
                setPosition( row, j );
        }

        T value;

        Triplet( ULI ii, ULI ij, T val ): row( ii ), column( ij ), value( val ) {}

        Triplet(): row( 0 ), column( 0 ), value( 0 ) {}

        Triplet( const Triplet< T > &toCopy ): row( toCopy.i() ), column( toCopy.j() ), value( toCopy.value ) {
#ifdef TRIPLET_META
                meta = toCopy.meta;
#endif
        }

        static std::vector< Triplet< T > > load( const std::string fn, ULI &m, ULI &n ) {
                std::fstream file( fn.c_str(), std::ios::in | std::ios::binary );
                ULI i; ULI j; double v;
                std::vector< Triplet< T > > ret;
                if( !file.is_open() ) {
                        std::cerr << "Error while opening file" << std::endl;
                        exit( 1 );
                }
                file.read( (char*) &i, sizeof( ULI ) );
                file.read( (char*) &j, sizeof( ULI ) );
                m = i;
                n = j;
#ifdef _DEBUG
                std::cout << "m: " << m << ", n: " << n << std::endl;
#endif
                while( true ) {
                        file.read( (char*) &i, sizeof( ULI ) );
                        if( !file ) break;
                        file.read( (char*) &j, sizeof( ULI ) );
                        file.read( (char*) &v, sizeof( T ) );
#ifdef _DEBUG
                        std::cout << "Pushed back: ( " << i << " , " << j << " , " << v << " )" << std::endl;
#endif
                        ret.push_back( Triplet< T >( i, j, v ) );
                }
                file.close();
                return ret;
        }

        static std::vector< Triplet< T > > loadCRS( const std::string fn, ULI &m, ULI &n ) {
                std::fstream file( fn.c_str(), std::ios::in );

                if ( !file.is_open() ) {
                        std::cerr << "Error while opening file" << std::endl;
                        exit( 1 );
                }

                ULI nonzeroes;
                file >> m;
                file >> n;
                file >> nonzeroes;
                
                std::vector< ULI > row_start( m+1 );
                for( size_t i = 0; i < m+1; ++i )
                        file >> row_start[ i ];

                std::vector< ULI > cols( nonzeroes );
                for( size_t j = 0; j < nonzeroes; ++j )
                        file >> cols[ j ];

                T   curval;
                ULI currow = 0;
                std::vector< Triplet< T > > ret;

                for( size_t k = 0; k < nonzeroes; ++k ) {
                        while( k == row_start[ currow + 1 ] ) {
                                currow++;
                                if( currow > m + 1 ) {
                                        std::cerr << "Error in CRS file" << std::endl;
                                        exit( 1 );
                                }
                        }
                        file >> curval;
                        ret.push_back( Triplet< T >( currow, cols[ k ], curval ) );
                }

                file.close();

                return ret;             
        }

        static void save( std::string fn, Triplet< T >* toWrite, const ULI m, const ULI n, const ULI s ) {
                std::fstream myFile ( fn.c_str(), std::ios::out | std::ios::binary);
                myFile.write( (char*) &m, sizeof( ULI ) );
                myFile.write( (char*) &n, sizeof( ULI ) );
                for( unsigned long int i = 0; i<s; i++ ) {
                        const ULI wi = toWrite[ i ].i();
                        const ULI wj = toWrite[ i ].j();
                        const double wv = toWrite[ i ].value;
#ifdef _DEBUG
                        std::cout << "Wrote: ( " << wi << " , " << wj << " , " << wv << " ) " << std::endl;
#endif
                        myFile.write( (char*) &( wi ), sizeof( ULI ) );
                        myFile.write( (char*) &( wj ), sizeof( ULI ) );
                        myFile.write( (char*) &( wv ), sizeof( T ) );
                }
                myFile.close();
        }

        void transpose() { const ULI t = row; row = column; column = t; }

        static void save( std::string fn, std::vector< Triplet< T > > &toWrite, const ULI m, const ULI n ) {
                save( fn, &( toWrite[ 0 ] ), m, n, toWrite.size() );
        }

};

#endif