---

more/num/optype.h

Go to the documentation of this file.

//  Copyright (C) 1998--2002  Petter Urkedal
//
//  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: optype.h,v 1.2 2002/09/01 12:02:18 petter_urkedal Exp $

//  STATUS.  Only used in unmaintained matrixalgo.h and matrixtypes.h
//  headers.

#ifndef MORE_NUM_OPTYPE_H
#define MORE_NUM_OPTYPE_H

///\if bits

namespace more {
namespace num {

/*  This file defines operator result types for arithmetic types.  In
    most cases it may be sufficient to specialise the balanced_type
    template, as is done for the elementary types.

    These definitions are mostly intended for numerical algorithms.
    The support for integer types is therefore limited to the signed
    types.  The main function of this file is to define the templates,
    which elsewhere is specialized to matrix classes.  This makes it
    possible for algorithms to keep track of different representations 
    and of matrices.
*/



//   I d e n t i t y   O b j e c t s


template <class T> struct additive_identity {};

template<> struct additive_identity<double>
    { operator double() { return 0.0; } };
template<> struct additive_identity<int>
    { operator int() { return 0; } };
template<> struct additive_identity<long int>
    { operator long int() { return 0L; } };

template <class T>
struct multiplicative_identity {};

template<> struct multiplicative_identity<double>
    { operator double() { return 1.0; } };
template<> struct multiplicative_identity<int>
    { operator int() { return 1; } };
template<> struct multiplicative_identity<long int>
    { operator long int() { return 1L; }};



//   O p e r a t o r   R e s u l t   T y p e   T e m p l a t e s


template <class T, class U>
struct balanced_type {};
template <class T, class U>
struct plus_type        { typedef typename balanced_type<T, U>::self self; };
template <class T, class U>
struct minus_type       { typedef typename plus_type<T, U>::self self; };
template <class T, class U>
struct times_type       { typedef typename balanced_type<T, U>::self self; };
template <class T, class U>
struct divides_type     { typedef typename times_type<T, U>::self self; };
template <class T, class U>
struct remainder_type   { typedef typename divides_type<T, U>::self self; };
template <class T>
struct negation_type    { typedef T self; };
template <class T>
struct inverse_type     { typedef void self; }; // invalid by default
// more...



//   S p e c i a l i s a t i o n   f o r   E l e m e n t a r y   T y p e s
//
//              -- Note:  Unsigned types are not supported.


//  char [x] short [x] int [x] long

template<> struct balanced_type<char, char>     { typedef char self; };

template<> struct balanced_type<short, short>   { typedef short self; };
template<> struct balanced_type<char, short>    { typedef short self; };
template<> struct balanced_type<short, char>    { typedef short self; };

template<> struct balanced_type<int, int>       { typedef int self; };
template<> struct balanced_type<short, int>     { typedef int self; };
template<> struct balanced_type<int, short>     { typedef int self; };
template<> struct balanced_type<char, int>      { typedef int self; };
template<> struct balanced_type<int, char>      { typedef int self; };

template<> struct balanced_type<long, long>     { typedef long self; };
template<> struct balanced_type<long, int>      { typedef long self; };
template<> struct balanced_type<int, long>      { typedef long self; };
template<> struct balanced_type<long, short>    { typedef long self; };
template<> struct balanced_type<short, long>    { typedef long self; };
template<> struct balanced_type<long, char>      { typedef long self; };
template<> struct balanced_type<char, long>      { typedef long self; };


//  float [x] double [x] long double

template<> struct balanced_type<float, float>   { typedef float self; };

template<> struct balanced_type<double, double> { typedef double self; };
template<> struct balanced_type<double, float>  { typedef double self; };
template<> struct balanced_type<float, double>  { typedef double self; };

template<> struct balanced_type<long double, long double>
    { typedef long double self; };
template<> struct balanced_type<long double, float>
    { typedef long double self; };
template<> struct balanced_type<float, long double>
    { typedef long double self; };
template<> struct balanced_type<long double, double>
    { typedef long double self; };
template<> struct balanced_type<double, long double>
    { typedef long double self; };


//  short, int, long [x] float, double, long double

template<> struct balanced_type<float, short>   { typedef float self; };
template<> struct balanced_type<short, float>   { typedef float self; };
template<> struct balanced_type<float, int>     { typedef float self; };
template<> struct balanced_type<int, float>     { typedef float self; };
template<> struct balanced_type<float, long>    { typedef float self; };
template<> struct balanced_type<long, float>    { typedef float self; };

template<> struct balanced_type<double, short>  { typedef double self; };
template<> struct balanced_type<short, double>  { typedef double self; };
template<> struct balanced_type<double, int>    { typedef double self; };
template<> struct balanced_type<int, double>    { typedef double self; };
template<> struct balanced_type<double, long>   { typedef double self; };
template<> struct balanced_type<long, double>   { typedef double self; };

template<> struct balanced_type<long double, short>
    { typedef long double self; };
template<> struct balanced_type<short, long double>
    { typedef long double self; };
template<> struct balanced_type<long double, int>
    { typedef long double self; };
template<> struct balanced_type<int, long double>
    { typedef long double self; };
template<> struct balanced_type<long double, long>
    { typedef long double self; };
template<> struct balanced_type<long, long double>
    { typedef long double self; };

}}

///\endif

#endif

---