lib/maracasVisuLib/src/kernel/include/vector.cxx

   1 /*# ---------------------------------------------------------------------
   2 #
   3 # Copyright (c) CREATIS (Centre de Recherche en Acquisition et Traitement de l'Image
   4 #                        pour la Sant�)
   5 # Authors : Eduardo Davila, Frederic Cervenansky, Claire Mouton
   6 # Previous Authors : Laurent Guigues, Jean-Pierre Roux
   7 # CreaTools website : www.creatis.insa-lyon.fr/site/fr/creatools_accueil
   8 #
   9 #  This software is governed by the CeCILL-B license under French law and
  10 #  abiding by the rules of distribution of free software. You can  use,
  11 #  modify and/ or redistribute the software under the terms of the CeCILL-B
  12 #  license as circulated by CEA, CNRS and INRIA at the following URL
  13 #  http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
  14 #  or in the file LICENSE.txt.
  15 #
  16 #  As a counterpart to the access to the source code and  rights to copy,
  17 #  modify and redistribute granted by the license, users are provided only
  18 #  with a limited warranty  and the software's author,  the holder of the
  19 #  economic rights,  and the successive licensors  have only  limited
  20 #  liability.
  21 #
  22 #  The fact that you are presently reading this means that you have had
  23 #  knowledge of the CeCILL-B license and that you accept its terms.
  24 # ------------------------------------------------------------------------ */
  25
  26 /*=========================================================================
  27
  28   Program:   wxMaracas
  29   Module:    $RCSfile: vector.cxx,v $
  30   Language:  C++
  31   Date:      $Date: 2012/11/15 14:15:31 $
  32   Version:   $Revision: 1.2 $
  33
  34   Copyright: (c) 2002, 2003
  35   License:
  36
  37      This software is distributed WITHOUT ANY WARRANTY; without even
  38      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  39      PURPOSE.  See the above copyright notice for more information.
  40
  41 =========================================================================*/
  42
  43 #include "gslobj.hxx"
  44 #include <string>
  45 #include <gsl/gsl_blas.h>
  46
  47 // ---------------------------------------------------------------------
  48 std::ostream& operator<<( std::ostream& os, const gslobj_vector& v )
  49 {
  50     for( int i = 0; i < v.size( ); i++ ) os << " " << v( i );
  51     return( os );
  52 }
  53
  54 // ---------------------------------------------------------------------
  55 gslobj_vector::gslobj_vector( size_t s )
  56     : _copy( true )
  57 {
  58     _gsl = gsl_vector_alloc( s );
  59 }
  60
  61 // ---------------------------------------------------------------------
  62 gslobj_vector::gslobj_vector( const gslobj_vector& v )
  63     : _copy( true )
  64 {
  65     _gsl = gsl_vector_alloc( v._gsl->size );
  66     gsl_vector_memcpy( _gsl, v._gsl );
  67 }
  68
  69 // ---------------------------------------------------------------------
  70 gslobj_vector::gslobj_vector( double* v, size_t s )
  71     : _copy( false )
  72 {
  73     _view = gsl_vector_view_array( v, s );
  74     _gsl = &( _view.vector );
  75 }
  76
  77 // ---------------------------------------------------------------------
  78 gslobj_vector::gslobj_vector( gsl_vector* v )
  79     : _copy( false )
  80 {
  81     _gsl = v;
  82 }
  83
  84 // ---------------------------------------------------------------------
  85 /*==PS========================================
  86 void gslobj_vector::resize( size_t s )
  87 {
  88     if( _copy ) {
  89
  90         if( s != size( ) )
  91             gsl_vector_free( _gsl );
  92         _gsl = gsl_vector_alloc( s );
  93
  94     } // fi
  95 }
  96 ==PS========================================*/
  97 // ---------------------------------------------------------------------
  98 gslobj_vector& gslobj_vector::operator=( const gslobj_vector& o )
  99 {
 100     gsl_vector_memcpy( _gsl, o._gsl );
 101     return( *this );
 102 }
 103
 104 // ---------------------------------------------------------------------
 105 gslobj_vector& gslobj_vector::operator=( double o )
 106 {
 107     gsl_vector_set_all( _gsl, o );
 108     return( *this );
 109 }
 110
 111 // ---------------------------------------------------------------------
 112 gslobj_vector& gslobj_vector::operator=( double* o )
 113 {
 114     memcpy( _gsl->data, o, _gsl->size * sizeof( double ) );
 115     return( *this );
 116 }
 117
 118 // ---------------------------------------------------------------------
 119 gslobj_vector& gslobj_vector::operator=( gsl_vector* o )
 120 {
 121     gsl_vector_memcpy( _gsl, o );
 122     return( *this );
 123 }
 124
 125 // ---------------------------------------------------------------------
 126 bool gslobj_vector::operator==( const gslobj_vector& o ) const
 127 {
 128     bool ret = true;
 129
 130     if( _gsl->size != o._gsl->size )
 131         return( false );
 132
 133     for( int i = 0; i < _gsl->size && ret; i++ )
 134         ret = ret && ( _gsl->data[ i ] != o._gsl->data[ i ] );
 135     return( ret );
 136 }
 137
 138 // ---------------------------------------------------------------------
 139 gslobj_vector gslobj_vector::operator+( const gslobj_vector& o )
 140 {
 141     gslobj_vector r( *this );
 142     gsl_vector_add( r._gsl, o._gsl );
 143     return( r );
 144 }
 145
 146 // ---------------------------------------------------------------------
 147 gslobj_vector gslobj_vector::operator+( double o )
 148 {
 149     gslobj_vector r( *this );
 150     gsl_vector_add_constant( r._gsl, o );
 151     return( r );
 152 }
 153
 154 // ---------------------------------------------------------------------
 155 gslobj_vector gslobj_vector::operator+( double* o )
 156 {
 157     gslobj_vector r( *this );
 158     gsl_vector_view vw = gsl_vector_view_array( o, _gsl->size );
 159     gsl_vector_add( r._gsl, &( vw.vector ) );
 160     return( r );
 161 }
 162
 163 // ---------------------------------------------------------------------
 164 gslobj_vector gslobj_vector::operator+( gsl_vector* o )
 165 {
 166     gslobj_vector r( *this );
 167     gsl_vector_add( r._gsl, o );
 168     return( r );
 169 }
 170
 171 // ---------------------------------------------------------------------
 172 gslobj_vector& gslobj_vector::operator+=( const gslobj_vector& o )
 173 {
 174     gsl_vector_add( _gsl, o._gsl );
 175     return( *this );
 176 }
 177
 178 // ---------------------------------------------------------------------
 179 gslobj_vector& gslobj_vector::operator+=( double o )
 180 {
 181     gsl_vector_add_constant( _gsl, o );
 182     return( *this );
 183 }
 184
 185 // ---------------------------------------------------------------------
 186 gslobj_vector& gslobj_vector::operator+=( double* o )
 187 {
 188     gsl_vector_view vw = gsl_vector_view_array( o, _gsl->size );
 189     gsl_vector_add( _gsl, &( vw.vector ) );
 190     return( *this );
 191 }
 192
 193 // ---------------------------------------------------------------------
 194 gslobj_vector& gslobj_vector::operator+=( gsl_vector* o )
 195 {
 196     gsl_vector_add( _gsl, o );
 197     return( *this );
 198 }
 199
 200 // ---------------------------------------------------------------------
 201 gslobj_vector gslobj_vector::operator-( const gslobj_vector& o )
 202 {
 203     gslobj_vector r( *this );
 204     gsl_vector_sub( r._gsl, o._gsl );
 205     return( r );
 206 }
 207
 208 // ---------------------------------------------------------------------
 209 gslobj_vector gslobj_vector::operator-( double o )
 210 {
 211     gslobj_vector r( *this );
 212     gsl_vector_add_constant( r._gsl, -o );
 213     return( r );
 214 }
 215
 216 // ---------------------------------------------------------------------
 217 gslobj_vector gslobj_vector::operator-( double* o )
 218 {
 219     gslobj_vector r( *this );
 220     gsl_vector_view vw = gsl_vector_view_array( o, _gsl->size );
 221     gsl_vector_sub( r._gsl, &( vw.vector ) );
 222     return( r );
 223 }
 224
 225 // ---------------------------------------------------------------------
 226 gslobj_vector gslobj_vector::operator-( gsl_vector* o )
 227 {
 228     gslobj_vector r( *this );
 229     gsl_vector_sub( r._gsl, o );
 230     return( r );
 231 }
 232
 233 // ---------------------------------------------------------------------
 234 gslobj_vector& gslobj_vector::operator-=( const gslobj_vector& o )
 235 {
 236     gsl_vector_sub( _gsl, o._gsl );
 237     return( *this );
 238 }
 239
 240 // ---------------------------------------------------------------------
 241 gslobj_vector& gslobj_vector::operator-=( double o )
 242 {
 243     gsl_vector_add_constant( _gsl, -o );
 244     return( *this );
 245 }
 246
 247 // ---------------------------------------------------------------------
 248 gslobj_vector& gslobj_vector::operator-=( double* o )
 249 {
 250     gsl_vector_view vw = gsl_vector_view_array( o, _gsl->size );
 251     gsl_vector_sub( _gsl, &( vw.vector ) );
 252     return( *this );
 253 }
 254
 255 // ---------------------------------------------------------------------
 256 gslobj_vector& gslobj_vector::operator-=( gsl_vector* o )
 257 {
 258     gsl_vector_sub( _gsl, o );
 259     return( *this );
 260 }
 261
 262 // ---------------------------------------------------------------------
 263 gslobj_vector gslobj_vector::operator*( double o )
 264 {
 265     gslobj_vector r( *this );
 266     gsl_vector_scale( r._gsl, o );
 267     return( r );
 268 }
 269
 270 // ---------------------------------------------------------------------
 271 gslobj_vector& gslobj_vector::operator*=( double o )
 272 {
 273     gsl_vector_scale( _gsl, o );
 274     return( *this );
 275 }
 276
 277 // ---------------------------------------------------------------------
 278 double gslobj_vector::dot( const gslobj_vector& o )
 279 {
 280     double r;
 281     gsl_blas_ddot( _gsl, o._gsl, &r );
 282     return( r );
 283 }
 284
 285 // ---------------------------------------------------------------------
 286 double gslobj_vector::dot( double* o )
 287 {
 288     double r;
 289     gsl_vector_view vw = gsl_vector_view_array( o, _gsl->size );
 290     gsl_blas_ddot( _gsl, &( vw.vector ), &r );
 291     return( r );
 292 }
 293
 294 // ---------------------------------------------------------------------
 295 double gslobj_vector::dot( gsl_vector* o )
 296 {
 297     double r;
 298     gsl_blas_ddot( _gsl, o, &r );
 299     return( r );
 300 }
 301
 302 // ---------------------------------------------------------------------
 303 gslobj_vector gslobj_vector::cross( const gslobj_vector& o )
 304 {
 305     return( cross( o._gsl->data ) );
 306 }
 307
 308 // ---------------------------------------------------------------------
 309 gslobj_vector gslobj_vector::cross( double* o )
 310 {
 311     gslobj_vector r( *this );
 312     double S, s;
 313
 314     // 1st element
 315     S = _gsl->data[ 1 ] * o[ 2 ];
 316     s = _gsl->data[ 2 ] * o[ 1 ];
 317     r._gsl->data[ 0 ] = S - s;
 318
 319     // 2nd element
 320     S = _gsl->data[ 2 ] * o[ 0 ];
 321     s = _gsl->data[ 0 ] * o[ 2 ];
 322     r._gsl->data[ 1 ] = S - s;
 323
 324     // 3rd element
 325     S = _gsl->data[ 0 ] * o[ 1 ];
 326     s = _gsl->data[ 1 ] * o[ 0 ];
 327     r._gsl->data[ 2 ] = S - s;
 328     return( r );
 329 }
 330
 331 // ---------------------------------------------------------------------
 332 gslobj_vector gslobj_vector::cross( gsl_vector* o )
 333 {
 334     return( cross( o->data ) );
 335 }
 336
 337 // ---------------------------------------------------------------------
 338 int gslobj_vector::scross( const gslobj_vector& o )
 339 {
 340     *this = cross( o );
 341     return( 1 );
 342 }
 343
 344 // ---------------------------------------------------------------------
 345 int gslobj_vector::scross( double* o )
 346 {
 347     *this = cross( o );
 348     return( 1 );
 349 }
 350
 351 // ---------------------------------------------------------------------
 352 int gslobj_vector::scross( gsl_vector* o )
 353 {
 354     *this = cross( o );
 355     return( 1 );
 356 }
 357
 358 // ---------------------------------------------------------------------
 359 gslobj_vector gslobj_vector::operator/( double o )
 360 {
 361     gslobj_vector r( *this );
 362     gsl_vector_scale( r._gsl, 1.0 / o );
 363     return( r );
 364 }
 365
 366 // ---------------------------------------------------------------------
 367 gslobj_vector& gslobj_vector::operator/=( double o )
 368 {
 369     gsl_vector_scale( _gsl, 1.0 / o );
 370     return( *this );
 371 }
 372
 373 // ---------------------------------------------------------------------
 374 /*==PS========================================
 375 double gslobj_vector::norm1( )
 376 {
 377     return( gsl_blas_dasum( _gsl ) );
 378 }
 379 ==PS========================================*/
 380 // ---------------------------------------------------------------------
 381 double gslobj_vector::norm2( )
 382 {
 383     return( gsl_blas_dnrm2( _gsl ) );
 384 }
 385
 386 // ---------------------------------------------------------------------
 387 gslobj_vector gslobj_vector::normalize( )
 388 {
 389     gslobj_vector r( *this );
 390     gsl_vector_scale( r._gsl, 1.0 / gsl_blas_dnrm2( _gsl ) );
 391     return( r );
 392 }
 393
 394 // ---------------------------------------------------------------------
 395 int gslobj_vector::snormalize( )
 396 {
 397     return( gsl_vector_scale( _gsl, 1.0 / gsl_blas_dnrm2( _gsl ) ) );
 398 }
 399
 400 // eof - gslobj_vector.cxx