complex_float.hpp

Go to the documentation of this file.

/*
 * $Id: complex_float.hpp 97 2012-01-21 16:49:17Z jdl3 $
 * Copyright (C) 2010, 2011, 2012, 2024 John D Lamb
 *
 * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
#ifndef CCGSL_COMPLEX_FLOAT_HPP
#define CCGSL_COMPLEX_FLOAT_HPP
 
#include<cmath>
#include<cstring>
#include<complex>
#include<gsl/gsl_complex.h>
#include<gsl/gsl_complex_math.h>
 
namespace gsl {
  class complex_float : public gsl_complex_float {
    friend class complex_float_ptr;
    friend class complex_float_ref;
    friend class vector_complex_float;
    friend class matrix_complex_float;
 public:
    // Default constructible: so that it can  be stored in a container
    complex_float(){}
    explicit complex_float( float* dat ){
      memcpy( this->dat, dat, 2 * sizeof( float ) );
    }
    complex_float( float const real, float const imag ){
      GSL_SET_REAL( this, real );
      GSL_SET_IMAG( this, imag );
    }
    complex_float( std::complex<float> const& z ){
      GSL_SET_REAL( this, std::real( z ) );
      GSL_SET_IMAG( this, std::imag( z ) );
    }
    // copy constructor: default is OK
    // assignment operator: default is OK
    // destructor: default is OK
    complex_float( gsl_complex_float const& z ){
      GSL_SET_REAL( this, GSL_REAL( z ) );
      GSL_SET_IMAG( this, GSL_IMAG( z ) );
    }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
    explicit operator std::complex<float>() const {
      return std::complex<float>( GSL_REAL( *this ), GSL_IMAG( *this ) );
    }
#else
      operator std::complex<float>() const {
      std::complex<float> z = std::complex<float>( GSL_REAL( *this ), GSL_IMAG( *this ) );
      return z;
    }
#endif      
    gsl_complex_float& get(){ return dynamic_cast<gsl_complex_float&>( *this ); }
    gsl_complex_float const& get() const { return dynamic_cast<gsl_complex_float const&>( *this ); }
    static complex_float rect( float x, float y ){ complex_float z; GSL_SET_COMPLEX( &z, x, y ); return z; }
    static complex_float polar( float r, float theta ){ complex_float z;
      GSL_SET_COMPLEX( &z, r * std::cos( theta ), r * std::sin( theta ) ); return z; }
    void set_complex_float( float x, float y ){ GSL_SET_COMPLEX( this, x, y );}
    float real() const { return GSL_REAL( *this ); }
    float imag() const { return GSL_IMAG( *this ); }
    void set_real( float x ){ GSL_SET_REAL( this, x ); }
    void set_imag( float y ){ GSL_SET_IMAG( this, y ); }
    bool operator==( complex_float const& z ) const { return dat[0] == z.dat[0] and dat[1] == z.dat[1]; }
    bool operator!=( complex_float const& z ) const { return dat[0] != z.dat[0] or dat[1] != z.dat[1]; }
    bool operator<( complex_float const& z ) const {
      return dat[0] < z.dat[0] or (dat[0] == z.dat[0] and dat[1] < z.dat[1]); }
    bool operator>( complex_float const& z ) const {
      return dat[0] > z.dat[0] or (dat[0] == z.dat[0] and dat[1] > z.dat[1]); }
    bool operator<=( complex_float const& z ) const { return *this < z or *this == z; }
    bool operator>=( complex_float const& z ) const { return *this > z or *this == z; }
  };
    
  class complex_float_ref {
  protected:
    float* dat;
  public:
    complex_float_ref( float* dat ) : dat( dat ){}
    operator gsl_complex_float() const {
      gsl_complex_float z; memcpy( z.dat, dat, 2 * sizeof( float ) ); return z; }
    operator complex_float() const {
      complex_float z; memcpy( z.dat, dat, 2 * sizeof( float ) ); return z; }
    // Default constructible
    complex_float_ref() : dat( 0 ){}
    complex_float_ref( complex_float& z ) : dat( z.dat ){}
    // copy constructor: default is OK
    // assignment operator: default is OK
    // also need to copy from complex_float
    complex_float_ref& operator=( complex_float const& z ){
      memcpy( dat, z.dat, 2 * sizeof( float ) ); return *this; }
    // destructor: default is OK
    void set_complex_float( float x, float y ){ GSL_SET_COMPLEX( this, x, y );}
    float real() const { return GSL_REAL( *this ); }
    float imag() const { return GSL_IMAG( *this ); }
    void set_real( float x ){ GSL_SET_REAL( this, x ); }
    void set_imag( float y ){ GSL_SET_IMAG( this, y ); }
  };
 
    class complex_float_ptr : private complex_float_ref {
  public:
    complex_float_ptr( float* dat ) : complex_float_ref( dat ){}
    complex_float_ref operator*(){ return *this; }
    complex_float_ref* operator->(){ return this; }
    complex_float_ref const operator*() const { return *this; }
    complex_float_ref const* operator->() const { return this; }
  };
 
  template<typename Ch,typename Tr>
  std::basic_ostream<Ch,Tr>& operator<<( std::basic_ostream<Ch,Tr>& stream, complex_float const& z ){
    float i = z.imag();
    if( i >= 0 ) stream << z.real() << "+" << i << "i";
    else stream << z.real() << "-" << -i << "i";
    return stream;
  }
 
  template<typename Ch,typename Tr>
  std::basic_ostream<Ch,Tr>& operator<<( std::basic_ostream<Ch,Tr>& stream,
                     complex_float_ref const& z ){
    float i = z.imag();
    if( i >= 0 ) stream << z.real() << "+" << i << "i";
    else stream << z.real() << "-" << -i << "i";
    return stream;
  }
 
  namespace cpx_float {
    inline complex_float rect( float x, float y ){ return complex_float::rect( x, y ); }
    inline complex_float polar( float r, float theta ){ return complex_float::polar( r, theta ); }
  }
 
  typedef gsl_complex_packed_float complex_packed_float;
  typedef gsl_const_complex_packed_float complex_const_packed_float;
  typedef gsl_complex_packed_float_ptr complex_packed_float_ptr;
  typedef gsl_const_complex_packed_float_ptr complex_const_packed_float_ptr;
  typedef gsl_complex_packed_array_float complex_packed_array_float;
  typedef gsl_const_complex_packed_array_float complex_const_packed_array_float;
 
}
 
#endif