complex_long_double.hpp

Go to the documentation of this file.

/*
 * $Id: complex_long_double.hpp 77 2012-01-15 15:32:13Z 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_LONG_DOUBLE_HPP
#define CCGSL_COMPLEX_LONG_DOUBLE_HPP
 
#include<cmath>
#include<cstring>
#include<complex>
#include<gsl/gsl_complex.h>
#include<gsl/gsl_complex_math.h>
 
namespace gsl {
  class complex_long_double : public gsl_complex_long_double {
    friend class complex_long_double_ptr;
    friend class complex_long_double_ref;
    friend class vector_complex_long_double;
    friend class matrix_complex_long_double;
 public:
    // Default constructible: so that it can  be stored in a container
    complex_long_double(){}
    explicit complex_long_double( long double* dat ){
      memcpy( this->dat, dat, 2 * sizeof( long double ) );
    }
    complex_long_double( long double const real, long double const imag ){
      GSL_SET_REAL( this, real );
      GSL_SET_IMAG( this, imag );
    }
    complex_long_double( std::complex<long double> 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_long_double( gsl_complex_long_double const& z ){
      GSL_SET_REAL( this, GSL_REAL( z ) );
      GSL_SET_IMAG( this, GSL_IMAG( z ) );
    }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
    explicit operator std::complex<long double>() const {
      return std::complex<long double>( GSL_REAL( *this ), GSL_IMAG( *this ) );
    }
#else
      operator std::complex<long double>() const {
      std::complex<long double> z = std::complex<long double>( GSL_REAL( *this ), GSL_IMAG( *this ) );
      return z;
    }
#endif      
    gsl_complex_long_double& get(){ return dynamic_cast<gsl_complex_long_double&>( *this ); }
    gsl_complex_long_double const& get() const { return dynamic_cast<gsl_complex_long_double const&>( *this ); }
    static complex_long_double rect( long double x, long double y ){ complex_long_double z; GSL_SET_COMPLEX( &z, x, y ); return z; }
    static complex_long_double polar( long double r, long double theta ){ complex_long_double z;
      GSL_SET_COMPLEX( &z, r * std::cos( theta ), r * std::sin( theta ) ); return z; }
    void set_complex_long_double( long double x, long double y ){ GSL_SET_COMPLEX( this, x, y );}
    long double real() const { return GSL_REAL( *this ); }
    long double imag() const { return GSL_IMAG( *this ); }
    void set_real( long double x ){ GSL_SET_REAL( this, x ); }
    void set_imag( long double y ){ GSL_SET_IMAG( this, y ); }
    bool operator==( complex_long_double const& z ) const { return dat[0] == z.dat[0] and dat[1] == z.dat[1]; }
    bool operator!=( complex_long_double const& z ) const { return dat[0] != z.dat[0] or dat[1] != z.dat[1]; }
    bool operator<( complex_long_double const& z ) const {
      return dat[0] < z.dat[0] or (dat[0] == z.dat[0] and dat[1] < z.dat[1]); }
    bool operator>( complex_long_double const& z ) const {
      return dat[0] > z.dat[0] or (dat[0] == z.dat[0] and dat[1] > z.dat[1]); }
    bool operator<=( complex_long_double const& z ) const { return *this < z or *this == z; }
    bool operator>=( complex_long_double const& z ) const { return *this > z or *this == z; }
  };
    
  class complex_long_double_ref {
  protected:
    long double* dat;
  public:
    complex_long_double_ref( long double* dat ) : dat( dat ){}
    operator gsl_complex_long_double() const {
      gsl_complex_long_double z; memcpy( z.dat, dat, 2 * sizeof( long double ) ); return z; }
    operator complex_long_double() const {
      complex_long_double z; memcpy( z.dat, dat, 2 * sizeof( long double ) ); return z; }
    // Default constructible
    complex_long_double_ref() : dat( 0 ){}
    complex_long_double_ref( complex_long_double& z ) : dat( z.dat ){}
    // copy constructor: default is OK
    // assignment operator: default is OK
    // also need to copy from complex_long_double
    complex_long_double_ref& operator=( complex_long_double const& z ){
      memcpy( dat, z.dat, 2 * sizeof( long double ) ); return *this; }
    // destructor: default is OK
    void set_complex_long_double( long double x, long double y ){ GSL_SET_COMPLEX( this, x, y );}
    long double real() const { return GSL_REAL( *this ); }
    long double imag() const { return GSL_IMAG( *this ); }
    void set_real( long double x ){ GSL_SET_REAL( this, x ); }
    void set_imag( long double y ){ GSL_SET_IMAG( this, y ); }
  };
 
    class complex_long_double_ptr : private complex_long_double_ref {
  public:
    complex_long_double_ptr( long double* dat ) : complex_long_double_ref( dat ){}
    complex_long_double_ref operator*(){ return *this; }
    complex_long_double_ref* operator->(){ return this; }
    complex_long_double_ref const operator*() const { return *this; }
    complex_long_double_ref const* operator->() const { return this; }
  };
 
  template<typename Ch,typename Tr>
  std::basic_ostream<Ch,Tr>& operator<<( std::basic_ostream<Ch,Tr>& stream, complex_long_double const& z ){
    long double 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_long_double_ref const& z ){
    long double i = z.imag();
    if( i >= 0 ) stream << z.real() << "+" << i << "i";
    else stream << z.real() << "-" << -i << "i";
    return stream;
  }
 
  namespace cpx_long_double {
    inline complex_long_double rect( long double x, long double y ){ return complex_long_double::rect( x, y ); }
    inline complex_long_double polar( long double r, long double theta ){ return complex_long_double::polar( r, theta ); }  }
 
}
 
#endif