Traits.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2004 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// epsic/src/util/Traits.h
 
/*
 * For a useful discussion on traits, please see 
 *
 * "Traits: a new and useful template technique" by Nathan C. Meyers
 * C++ Report, June 1995 http://www.cantrip.org/traits.html
 *
 * These traits were implemented in order that data types such as Jones
 * matrices and Quaternions can be passed to algorithms designed to work
 * with scalar values like float and double.
 *
 * Willem van Straten - 26 October 2004
 *
 */
 
#ifndef __Traits_h
#define __Traits_h
 
#include <complex>

template< class E > struct ElementTraits
{
  typedef E real;

  template< class T >
  static inline E from_complex (const std::complex<T>& value)
  { return value.real(); }

  static inline double to_real (const E& element)
  { return element; }

  static inline E conjugate (const E& element)
  { return element; }
};

template< class E > struct ElementTraits< std::complex<E> >
{
  typedef E real;

  template< class T >
  static inline std::complex<E> from_complex (const std::complex<T>& value)
  { return value; }

  static inline double to_real (const std::complex<E>& element)
  { return element.real(); }

  template< class T >
  static inline std::complex<E> conjugate (const std::complex<T>& value)
  { return std::conj(value); }
};

template< class T, class E = ElementTraits<T> > struct DatumTraits
{
  E element_traits;

  typedef T element_type;
 
  static inline unsigned ndim () { return 1; }
  static inline T& element (T& t, unsigned idim) { return t; }
  static inline const T& element (const T& t, unsigned idim) { return t; }
};

template< class T > 
struct DatumTraits< std::complex<T> >
{
  ElementTraits<T> element_traits;
  typedef T element_type;
 
  static inline unsigned ndim () { return 2; }
  static inline T& element (std::complex<T>& t, unsigned idim)
  { return reinterpret_cast<T*>(&t)[idim]; }
 
  static inline const T& element (const std::complex<T>& t, unsigned idim)
  { return reinterpret_cast<const T*>(&t)[idim]; }
};
 

template<typename T>
std::complex<T> ci (const std::complex<T>& c)
{
  return std::complex<T> (-c.imag(), c.real());
}

template<typename T>
std::complex<T> ci (const T& real)
{
  return std::complex<T> (0.0, real);
}

template<typename T>
T myconj (const T& x) { return ElementTraits<T>::conjugate(x); }

template<typename T>
typename ElementTraits<T>::real
myreal (const T& x) { return ElementTraits<T>::to_real(x); }
 
#endif