std_cplx.h

Go to the documentation of this file.

 
// Written: KG  97/11/30
// Changed: KG  97/11/30
// $Id: std_cplx.h,v 1.5.2.29 2019/05/28 11:13:02 garloff Exp $
 
#ifndef TBCI_STD_CPLX_H
#define TBCI_STD_CPLX_H  
 
#include "tbci/basics.h"
#ifndef HAVE_NO_NEW_HEADERS_BUG
# include <complex>
#else
# include <complex.h>
#endif
 
//#define cplx complex
#ifndef CPLX
# define CPLX(t) CPLX__ complex<t>
# define CPLXR(t,a,r) CPLX__ complex<t> a (r)
# define CPLXRI(t,a,r,i) CPLX__ complex<t> a (r,i)
# define CPLXC(t,a,c) CPLX__ complex<t> a (c)
# define CPLXVRI(t,r,i) (CPLX__ complex<t>(r,i))
#endif
 
//typedef typename T complex<T>::cplx_base;
//typedef complex<T> complex<T>::cplx_t;
 
NAMESPACE_TBCI
// compat
#ifndef TEMPLATED_FABSSQR       // We do need it as the fabssqr() in basics.h is templated!
INST(template <typename T> class CPLX__ complex friend double fabssqr (const CPLX__ complex<T>&);)
template <typename T>
inline double fabssqr (const CPLX__ complex<T>& a)
{ return (a.real()*a.real() + a.imag()*a.imag()); }
#endif
NAMESPACE_END
 
#ifndef HAVE_STDCPLX_FABS
NAMESPACE_CSTD
INST(template <typename T> class CPLX__ complex friend double fabs (const CPLX__ complex<T>&);)
template <typename T>
inline double fabs (const CPLX__ complex<T>& a)
//{ return abs(a); }
{ return GLBL__ MATH__ sqrt (TBCI__ fabssqr (a)); }
NAMESPACE_CSTD_END
#endif
 
#if 0
template <typename T>
inline bool operator == (const CPLX__ complex<T>&a, const T d)
{ return (a.imag() == 0 && a.real() == d); }
#endif
 
#if 0 
NAMESPACE_CPLX
 
INST(template <typename T> class CPLX__ complex friend T real (const CPLX__ complex<T>&);)
template <typename T>
inline T real (const CPLX__ complex<T>& z)
{ return CPLX__ real(z); }
 
INST(template <typename T> class CPLX__ complex friend T imag (const CPLX__ complex<T>&);)
template <typename T>
inline T imag (const CPLX__ complex<T>& z)
{ return CPLX__ imag(z); }
 
INST(template <typename T> class CPLX__ complex friend CPLX__ complex<T> conj (const CPLX__ complex<T>&);)
template <typename T>
inline CPLX__ complex<T> conj (const CPLX__ complex<T>& z)
{ return CPLX__ complex<T> (z.real(), -z.imag()); }
 
NAMESPACE_CPLX_END
#endif
 
#if !defined(NO_NS) && !defined(HAVE_IGNORE_STD_NS_BUG) && defined(HAVE_LIBC_GLOBAL_NS_BUG) && (!defined(HAVE_CPP_GLOBAL_NS_BUG) || !defined(HAVE_CPLX_GLOBAL_NS_BUG))
# define NEED_CPLX_TO_CSTD 1
#endif  
 
#ifdef NEED_CPLX_TO_CSTD
//#if !defined(NO_NS) && defined(HAVE_LIBC_GLOBAL_NS_BUG) && (!defined(HAVE_CPP_GLOBAL_NS_BUG) || !defined(HAVE_CPLX_GLOBAL_NS_BUG))
NAMESPACE_CSTD
template <typename T>
inline CPLX__ complex<T> sqrt (const CPLX__ complex<T>& z)
{ return CPLX__ sqrt (z); }
// exp seems to be needed in :: by DEC CXX. Does it break on MSVC?
//#if defined(HAVE_CPP_GLOBAL_NS_BUG)
#ifndef _MSC_VER
template <typename T>
inline CPLX__ complex<T> exp (const CPLX__ complex<T>& z)
{ return CPLX__ exp (z); }
#endif
NAMESPACE_CSTD_END
//#endif
#endif
 
NAMESPACE_CPLX
// Mathematically thought, the following is nonsense ...
INST(template <typename T> class CPLX__ complex friend bool operator >  (const CPLX__ complex<T>&, const CPLX__ complex<T>&);)
template <typename T>
inline bool operator >  (const CPLX__ complex<T>& a, const CPLX__ complex<T>& b)
{ return (MATH__ fabs(a) > MATH__ fabs(b)); }
 
INST(template <typename T> class CPLX__ complex friend bool operator >= (const CPLX__ complex<T>&, const CPLX__ complex<T>&);)
template <typename T>
inline bool operator >= (const CPLX__ complex<T>& a, const CPLX__ complex<T>& b)
{ return (MATH__ fabs(a) >= MATH__ fabs(b)); }
 
INST(template <typename T> class CPLX__ complex friend bool operator <  (const CPLX__ complex<T>&, const CPLX__ complex<T>&);)
template <typename T>
inline bool operator <  (const CPLX__ complex<T>& a, const CPLX__ complex<T>& b)
{ return (MATH__ fabs(a) < MATH__ fabs(b)); }
 
INST(template <typename T> class CPLX__ complex friend bool operator <= (const CPLX__ complex<T>&, const CPLX__ complex<T>&);)
template <typename T>
inline bool operator <= (const CPLX__ complex<T>& a, const CPLX__ complex<T>& b)
{ return (MATH__ fabs(a) <= MATH__ fabs(b)); }
 
 
/* From and for PLASIMO ... */
/* We dont't need all those CPLX__ namespace specifications, as we are
 * inside NAMESPACE_STD */
#ifdef HAVE_MISS_STDCPLX_FANCY_FN_BUG
INST(template <typename T> class CPLX__ complex friend CPLX__ complex<T> acos (const CPLX__ complex<T>&);)
template <typename T>
inline CPLX__ complex<T> acos (const CPLX__ complex<T> &x)
{ 
        return CPLX__ complex<T>(0,-1)*log(x+sqrt(x*x-CPLX__ complex<T>(1,0))); 
}
 
INST(template <typename T> class CPLX__ complex friend CPLX__ complex<T> asin (const CPLX__ complex<T> &);)
template <typename T>
inline CPLX__ complex<T> asin (const CPLX__ complex<T> &x)
{
        return CPLX__ complex<T>(0,-1)*log(CPLX__ complex<T>(0,1)*x+sqrt(CPLX__ complex<T>(1,0)-x*x));
}
 
INST(template <typename T> class CPLX__ complex friend CPLX__ complex<T> atan (const CPLX__ complex<T> &);)
template <typename T>
inline CPLX__ complex<T> atan (const CPLX__ complex<T> &x)
{
        return acos( 1.0/sqrt(x*x+CPLX__ complex<T>(1,0)) );
}
 
INST(template <typename T> class CPLX__ complex friend CPLX__ complex<T> atanh (const CPLX__ complex<T> &);)
template <typename T>
inline CPLX__ complex<T> atanh (const CPLX__ complex<T> &x)
{ 
  CPLX__ complex<T> arg = (1.0 + x) / (1.0 - x);
  return 0.5 * MATH__ log(arg);
}
 
#endif /* MISS_STDCPLX_FANCY_FN */
#ifdef MISS_STDCPLX_TAN_BUG
INST(template <typename T> class CPLX__ complex friend CPLX__ complex<T> tan(const CPLX__ complex<T> &);)
template <typename T>
inline CPLX__ complex<T> tan(const CPLX__ complex<T> &x)
{
        return sin(x)/cos(x);
}
 
INST(template <typename T> class CPLX__ complex friend CPLX__ complex<T> tanh(const CPLX__ complex<T> &);)
template <typename T>
inline CPLX__ complex<T> tanh(const CPLX__ complex<T> &x)
{
        return sinh(x)/cosh(x);
}
#endif
#ifdef HAVE_MISS_STDCPLX_LOG10_BUG
INST(template <typename T> class CPLX__ complex friend CPLX__ complex<T> log10(const CPLX__ complex<T> &);)
template <typename T>
inline CPLX__ complex<T> log10(const CPLX__ complex<T> &x)
{ 
        const static double InvLn10(1.0/GLBL__ MATH__ log(10));
        return log(x)*InvLn10;
}
#endif  /* MISS_STDCPLX_LOG10 */
 
NAMESPACE_CPLX_END
 
NAMESPACE_TBCI
#ifdef NEED_IMAG_UNIT
const CPLXRI(double,Imag_unit,0.0,1.0);
#endif
NAMESPACE_END
 
#ifdef HAVE_MISS_CPLX_IO_BUG
//INST(template <typename T> class CPLX__ complex friend STD__ ostream operator << (STD__ ostream&, const CPLX__ complex<T>&);)
template <typename T>
STD__ ostream& operator << (STD__ ostream& os, const CPLX__ complex<T>& v)
{
        return os << "(" << v.real() << "," << v.imag() << ")";
}
 
//INST(template <typename T> class CPLX__ complex friend STD__ istream operator >> (STD__ istream&, CPLX__ complex<T>&);)
template <typename T>
STD__ istream& operator >> (STD__ istream& is, CPLX__ complex<T>& v)
{
        char bra; T re, im = 0;
        is >> bra;
        is >> re;
        if (bra != '(') {
                v = CPLX__ complex<T> (re, im);
                return is;
        }
        is >> bra;
        if (bra != ',') {
                if (bra != ')')
                        STD__ cerr << "Error parsing complex!" << STD__ endl;
                v = CPLX__ complex<T> (re, im);
                return is;
        }
        is >> im;
        is >> bra;
        if (bra != ')')
                STD__ cerr << "Error parsing complex!" << STD__ endl;
        v = CPLX__ complex<T> (re, im);
        return is;
}
#endif
 
NAMESPACE_TBCI
#ifdef MALLOC_CACHE
SPECIALIZE_MEMALLOC2(CPLX__ complex<double>,stdcomplex_double)
typedef CPLX__ complex<double>* stdcomplexdoubleptr;
SPECIALIZE_MEMALLOC(stdcomplexdoubleptr)
SPECIALIZE_MEMALLOC2(CPLX__ complex<float>,stdcomplex_float)
typedef CPLX__ complex<float>* stdcomplexfloatptr;
SPECIALIZE_MEMALLOC(stdcomplexfloatptr)
#endif
 
/* If used in loops, a single copy is still cheaper than pointer
 * indirection */
SPEC_TBCI_TRAITS_LOOP_COPY(CPLX__ complex<float>);
SPEC_TBCI_TRAITS_LOOP_COPY(CPLX__ complex<double>);
SPEC_TBCI_TRAITS_ALWAYS_COPY(CPLX__ complex<float>*);
SPEC_TBCI_TRAITS_ALWAYS_COPY(CPLX__ complex<double>*);
 
NAMESPACE_END
 
#endif  /* TBCI_STD_CPLX_H */