---

more/math/mathbits.h

Go to the documentation of this file.

//  more/bits/mathbits.h -- used by math.h and complex.h
//  Copyright (C) 1998--2001  Petter Urkedal (petter.urkedal@matfys.lth.se)

//  This file 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 file 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

//  As a special exception, you may use this file as part of a free
//  software library without restriction.  Specifically, if other files
//  instantiate templates or use macros or inline functions from this
//  file, or you compile this file and link it with other files to
//  produce an executable, this file does not by itself cause the
//  resulting executable to be covered by the GNU General Public
//  License.  This exception does not however invalidate any other
//  reasons why the executable file might be covered by the GNU General
//  Public License.

//  $Id: mathbits.h,v 1.1 2002/05/30 18:01:38 petter_urkedal Exp $



#ifndef MORE_MATHBITS_H
#define MORE_MATHBITS_H

#include <more/meta.h>

namespace more {
namespace math {

  // --- traits ---

  template<typename T>
    struct undefined_type {};

  template<typename T> struct scalar_type_
    { typedef typename T::scalar_type eval; };
  template<typename T> struct scalar_type_<const T>
    { typedef const typename scalar_type_<T>::eval eval; };
  template<> struct scalar_type_<float> { typedef float eval; };
  template<> struct scalar_type_<double> { typedef double eval; };
  template<> struct scalar_type_<long double> { typedef long double eval; };
  template<> struct scalar_type_<int> { typedef int eval; };

  template<typename T> struct norm_type_
    { typedef typename scalar_type_<T>::eval eval; };
  template<typename T> struct norm_type_<const T>
    { typedef const typename norm_type_<T>::eval eval; };

  template<typename T>
    struct element_type_ { typedef typename T::element_type eval; };

  template<typename T>
    struct position_type_ { typedef typename T::position_type eval; };

  template<typename T>
    struct outer_product_type_ {
        typedef typename T::outer_product_type eval;
    };
  template<typename T> struct outer_product_type_<const T>
      { typedef const typename outer_product_type_<T>::eval eval; };
  template<> struct outer_product_type_<float> { typedef float eval; };
  template<> struct outer_product_type_<double> { typedef double eval; };
  template<> struct outer_product_type_<long double>
    { typedef long double eval; };
  template<> struct outer_product_type_<int> { typedef int eval; };

  template<typename T, typename U> struct balanced_type_
      { typedef typename bigger_type_<T, U>::eval eval; };

  template<typename T, typename U> struct times_type_
      { typedef typename balanced_type_<T, U>::eval eval; };

  template<typename T, typename U> struct divides_type_
      { typedef typename balanced_type_<T, U>::eval eval; };

  template<typename T, typename U> struct plus_type_
      { typedef typename balanced_type_<T, U>::eval eval; };

  template<typename T, typename U> struct minus_type_
      { typedef typename balanced_type_<T, U>::eval eval; };


  template<typename T> struct size_
      { static int const eval = T::CTC_size; };


    // --- zero and one ---

    struct zero_tag {
        operator char() const { return 0; }
        operator short() const { return 0; }
        operator int() const { return 0; }
        operator long() const { return 0L; }
        operator unsigned long() const { return 0L; }
        operator float() const { return 0.0F; }
        operator double() const { return 0.0; }
        operator long double() const { return 0.0L; }
        // Complex is taken care of by zero_tag --> T --> complex<T>.
//      operator std::complex<float>() const
//          { return std::complex<float>(zero_tag(), zero_tag()); }
//      operator std::complex<double>() const
//          { return std::complex<double>(zero_tag(), zero_tag()); }
//      operator std::complex<long double>() const
//          { return std::complex<long double>(zero_tag(), zero_tag()); }
    };
    extern zero_tag zero;

    struct one_tag {
        operator char() const { return 1; }
        operator short() const { return 1; }
        operator int() const { return 1; }
        operator long() const { return 1L; }
        operator unsigned long() const { return 1L; }
        operator float() const { return 1.0F; }
        operator double() const { return 1.0; }
        operator long double() const { return 1.0L; }
        // Complex is taken care of by zero_tag --> T --> complex<T>.
//      operator std::complex<float>() const
//          { return std::complex<float>(one_tag(), zero_tag()); }
//      operator std::complex<double>() const
//          { return std::complex<double>(one_tag(), zero_tag()); }
//      operator std::complex<long double>() const
//          { return std::complex<long double>(one_tag(), zero_tag()); }
    };
    extern one_tag one;

    struct minus_one_tag {
        operator char() const { return 1; }
        operator short() const { return 1; }
        operator int() const { return 1; }
        operator long() const { return 1L; }
        operator unsigned long() const { return 1L; }
        operator float() const { return 1.0F; }
        operator double() const { return 1.0; }
        operator long double() const { return 1.0L; }
//      operator std::complex<float>() const
//          { return std::complex<float>(minus_one_tag(), zero_tag()); }
//      operator std::complex<double>() const
//          { return std::complex<double>(minus_one_tag(), zero_tag()); }
//      operator std::complex<long double>() const
//          { return std::complex<long double>(minus_one_tag(), zero_tag()); }
    };

    inline one_tag operator+(one_tag) { return one_tag(); }
    inline minus_one_tag operator+(minus_one_tag) { return minus_one_tag(); }
    inline minus_one_tag operator-(one_tag) { return minus_one_tag(); }
    inline one_tag operator-(minus_one_tag) { return one_tag(); }

    template<typename T>
      inline zero_tag operator*(zero_tag, T) { return zero; }
    template<typename T>
      inline zero_tag operator*(T, zero_tag) { return zero; }
    template<typename T>
      inline zero_tag operator/(zero_tag, T) { return zero; }
    template<typename T>
      inline T operator+(zero_tag, const T& x) { return x; }
    template<typename T>
      inline T operator+(const T& x, zero_tag) { return x; }
    template<typename T>
      inline T operator-(zero_tag, const T& x) { return -x; }
    template<typename T>
      inline T operator-(const T& x, zero_tag) { return x; }
    template<typename T>
      inline T operator*(one_tag, const T& x) { return x; }
    template<typename T>
      inline T operator*(const T& x, one_tag) { return x; }
    template<typename T>
      inline T operator/(const T&x, one_tag) { return x; }
    template<typename T>
      inline T operator*(minus_one_tag, const T& x) { return -x; }
    template<typename T>
      inline T operator*(const T& x, minus_one_tag) { return -x; }
    template<typename T>
      inline T operator/(const T&x, minus_one_tag) { return -x; }

}
  using namespace math;
}
#endif

---