SawVector.cpp

/***************************************************************************
*   Copyright (C) 2005 by Nestor Aguirre                                  *
*   nfaguirrec@unal.edu.co                                                *
*                                                                         *
*   This program 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 2 of the License, or     *
*   (at your option) any later version.                                   *
*                                                                         *
*   This program 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 this program; if not, write to the                         *
*   Free Software Foundation, Inc.,                                       *
*   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
***************************************************************************/
#include "SawVector.h"

SawVector::SawVector( uint size, double a )
: SawObject()
{
        this->size = size ;
        vector = gsl_vector_alloc( size ) ;
        gsl_vector_set_all( vector, a ) ;
}

SawVector::SawVector( double* array, uint size )
                : SawObject()
{
        this->size = size ;
        vector = gsl_vector_alloc( size ) ;

        for ( uint i = 0; i < size; i++ ) {
                gsl_vector_set( vector, i, array[ i ] ) ;
        }
}

SawVector::SawVector( const SawVector& vector )
                : SawObject()
{
        this->size = vector.getSize() ;
        this->vector = gsl_vector_alloc( size ) ;
        gsl_vector_memcpy( this->vector, vector.getGSLVector() ) ;
}

void SawVector::operator = ( const SawVector& vector )
{
        this->size = vector.getSize() ;
        this->vector = gsl_vector_alloc( size ) ;
        gsl_vector_memcpy( this->vector, vector.getGSLVector() ) ;
}

SawVector::~SawVector()
{
        gsl_vector_free( vector ) ;
}

void SawVector::swapElements( uint i, uint j )
{
        gsl_vector_swap_elements( vector, i, j ) ;
}

void SawVector::reverse()
{
        gsl_vector_reverse( vector ) ;
}

gsl_vector* SawVector::getGSLVector() const
{
        return vector ;
}

void SawVector::setGSLVector( gsl_vector* vector )
{
        this->vector = vector ;
}

uint SawVector::getSize() const
{
        return size ;
}

double SawVector::get( uint i ) const
{
        return gsl_vector_get( vector, i ) ;
}

void SawVector::set( uint i, double value )
{
        gsl_vector_set( vector, i, value ) ;
}

bool SawVector::operator == ( SawVector vector )
{
        for ( uint i = 0; i < this->size; i++ ) {
                if ( gsl_fcmp( get( i ), vector.get( i ), thresholdDoubleComparation ) != 0 )
                                return false ;
        }

        return true ;
}

bool SawVector::operator != ( SawVector vector )
{
        for ( uint i = 0; i < this->size; i++ ) {
                if ( gsl_fcmp( get( i ), vector.get( i ), thresholdDoubleComparation ) == 0 )
                                return false ;
        }

        return true ;
}

double SawVector::getMax( uint* i ) const
{
        if ( i ) {
                *i = gsl_vector_max_index( vector ) ;
        }
        return gsl_vector_max( vector ) ;
}

double SawVector::getMin( uint* i ) const
{
        if ( i ) {
                *i = gsl_vector_min_index( vector ) ;
        }
        return gsl_vector_min( vector ) ;
}

bool SawVector::isNull() const
{
        if ( gsl_vector_isnull( vector ) == 1 )
                return true ;
        else
                return false ;
}

SawVector SawVector::operator + ( SawVector vector )
{
        gsl_vector * tmp = gsl_vector_alloc( size ) ;
        gsl_vector_memcpy( tmp, this->vector ) ;
        gsl_vector_add( tmp, vector.getGSLVector() ) ;

        SawVector output( size ) ;
        output.setGSLVector( tmp ) ;

        return output ;
}

SawVector SawVector::operator - ( SawVector vector )
{
        gsl_vector * tmp = gsl_vector_alloc( size ) ;
        gsl_vector_memcpy( tmp, this->vector ) ;
        gsl_vector_sub( tmp, vector.getGSLVector() ) ;

        SawVector output( size ) ;
        output.setGSLVector( tmp ) ;

        return output ;
}

double SawVector::operator * ( SawVector vector )
{
        double output ;
        gsl_blas_ddot( this->vector, vector.getGSLVector(), &output ) ;

        return output ;
}

double SawVector::getEuclideanNorm()
{
        return gsl_blas_dnrm2( this->vector ) ;
}

SawVector operator * ( SawVector vector, double a )
{
        gsl_vector * tmp = gsl_vector_alloc( vector.getSize() ) ;
        gsl_vector_memcpy( tmp, vector.getGSLVector() ) ;
        gsl_vector_scale( tmp, a ) ;

        SawVector output( vector.getSize() ) ;
        output.setGSLVector( tmp ) ;

        return output ;
}

SawVector operator * ( double a, SawVector vector )
{
        return vector * a ;
}

SawVector operator + ( SawVector vector, double a )
{
        gsl_vector * tmp = gsl_vector_alloc( vector.getSize() ) ;
        gsl_vector_memcpy( tmp, vector.getGSLVector() ) ;
        gsl_vector_add_constant( tmp, a ) ;

        SawVector output( vector.getSize() ) ;
        output.setGSLVector( tmp ) ;

        return output ;
}

SawVector operator + ( double a, SawVector vector )
{
        return vector + a ;
}

ostream& operator << ( ostream& os, const SawVector& vector )
{
        switch ( vector.getFormatNumberOutputStream() ) {
                        case SawObject::FIXED:
                        os.setf( ios::fixed , ios::floatfield ) ;
                        break ;

                        case SawObject::SCIENTIFIC:
                        os.setf( ios::scientific, ios::floatfield ) ;
                        break ;
        }

        os.precision( vector.precisionOutputStream ) ;

        os << setw( vector.widthOutputStream - vector.precisionOutputStream ) << "[" ;

        for ( uint i = 0; i < vector.size; i++ ) {
                //              if( i< (vector.size-1) )
                //                      os << setw( vector.outputStreamWidth ) << gsl_vector_get( vector.vector, i ) << ", " ;
                //              else
                switch ( vector.getFormatNumberOutputStream() ) {
                                case SawObject::FIXED:
                                os << setw( vector.widthOutputStream ) << gsl_vector_get( vector.vector, i ) ;
                                break ;

                                case SawObject::SCIENTIFIC:
                                os << setw( vector.widthOutputStream + 3 ) << gsl_vector_get( vector.vector, i ) ;
                                break ;
                }
        }

        os << setw( vector.widthOutputStream - vector.precisionOutputStream - 1 ) << "]" ;

        return os ;
}

istream& operator >> ( istream& is, const SawVector& vector )
{
        double tmp ;
        for ( uint i = 0; i < vector.size; i++ ) {
                is >> tmp ;
                gsl_vector_set( vector.vector, i, tmp ) ;
        }
        return is ;
}

---