Number.h

Go to the documentation of this file.

// ========================================================================= //
// This file is part of MyraMath, copyright (c) 2014-2019 by Ryan A Chilton  //
// and distributed by MyraCore, LLC. See LICENSE.txt for license terms.      //
// ========================================================================= //

#ifndef MYRAMATH_UTILITY_NUMBER_H
#define MYRAMATH_UTILITY_NUMBER_H

#include <myramath/utility/detail/LIBPUBLIC.h>

#include <complex>

namespace myra {

typedef float NumberS;
typedef double NumberD;
typedef std::complex<float> NumberC;
typedef std::complex<double> NumberZ;

template<class Number> char typechar();

template<class Number> const char* typestring();

template<class Number> class ReflectPrecision;

template<> class ReflectPrecision<NumberS>
  { public: typedef NumberS type; };
template<> class ReflectPrecision<NumberD>
  { public: typedef NumberD type; };
template<> class ReflectPrecision<NumberC>
  { public: typedef NumberS type; };
template<> class ReflectPrecision<NumberZ>
  { public: typedef NumberD type; };

template<class Precision> class ReflectComplex;

template<> class ReflectComplex<NumberS>
  { public: typedef NumberC type; };
template<> class ReflectComplex<NumberD>
  { public: typedef NumberZ type; };

template<class Container> class ReflectNumber;

LIBPUBLIC NumberD raise_precision(NumberS s);
LIBPUBLIC NumberZ raise_precision(NumberC c);

template<class Number> class RaisePrecision;
template<> class RaisePrecision<NumberS>
  { public: typedef NumberD type; };
template<> class RaisePrecision<NumberC>
  { public: typedef NumberZ type; };

LIBPUBLIC NumberS lower_precision(NumberD d);
LIBPUBLIC NumberC lower_precision(NumberZ z);

template<class Number> class LowerPrecision;
template<> class LowerPrecision<NumberD>
  { public: typedef NumberS type; };
template<> class LowerPrecision<NumberZ>
  { public: typedef NumberC type; };

LIBPUBLIC NumberS scalar_norm2(NumberS x);
LIBPUBLIC NumberD scalar_norm2(NumberD x);
LIBPUBLIC NumberS scalar_norm2(NumberC x);
LIBPUBLIC NumberD scalar_norm2(NumberZ x);

LIBPUBLIC NumberS scalar_norm1(NumberS x);
LIBPUBLIC NumberD scalar_norm1(NumberD x);
LIBPUBLIC NumberS scalar_norm1(NumberC x);
LIBPUBLIC NumberD scalar_norm1(NumberZ x);

LIBPUBLIC NumberS realpart(NumberS s);
LIBPUBLIC NumberD realpart(NumberD d);
LIBPUBLIC NumberS realpart(NumberC c);
LIBPUBLIC NumberD realpart(NumberZ z);

LIBPUBLIC NumberS imagpart(NumberS s);
LIBPUBLIC NumberD imagpart(NumberD d);
LIBPUBLIC NumberS imagpart(NumberC c);
LIBPUBLIC NumberD imagpart(NumberZ z);

LIBPUBLIC NumberS conjugate(NumberS s);
LIBPUBLIC NumberD conjugate(NumberD d);
LIBPUBLIC NumberC conjugate(NumberC c);
LIBPUBLIC NumberZ conjugate(NumberZ z);

LIBPUBLIC NumberS argument(NumberS s);
LIBPUBLIC NumberD argument(NumberD d);
LIBPUBLIC NumberS argument(NumberC c);
LIBPUBLIC NumberD argument(NumberZ z);

template<class NumberA, class NumberB> class ReflectField;

// ReflectField rules for matched Number types.
template<> class ReflectField<NumberS,NumberS> { public: typedef NumberS type; }; // float  @ float  = float
template<> class ReflectField<NumberD,NumberD> { public: typedef NumberD type; }; // double @ double = double
template<> class ReflectField<NumberC,NumberC> { public: typedef NumberC type; }; // complex<float > @ complex<float > = complex<float >
template<> class ReflectField<NumberZ,NumberZ> { public: typedef NumberZ type; }; // complex<double> @ complex<double> = complex<double>

// ReflectField rules for mismatched Number types.
template<> class ReflectField<NumberS,NumberC> { public: typedef NumberC type; }; // float  @ complex<float > = complex<float >
template<> class ReflectField<NumberD,NumberZ> { public: typedef NumberZ type; }; // double @ complex<double> = complex<double>
template<> class ReflectField<NumberC,NumberS> { public: typedef NumberC type; }; // complex<float > @ float  = complex<float >
template<> class ReflectField<NumberZ,NumberD> { public: typedef NumberZ type; }; // complex<double> @ double = complex<double>

// Occasionally, int's can wander into expressions. They are always promoted to match the "other" type.
template<> class ReflectField<NumberS,int> { public: typedef NumberS type; };     // float  @ int  = float
template<> class ReflectField<NumberD,int> { public: typedef NumberD type; };     // double @ int = double
template<> class ReflectField<NumberC,int> { public: typedef NumberC type; };     // complex<float > @ int = complex<float >
template<> class ReflectField<NumberZ,int> { public: typedef NumberZ type; };     // complex<double> @ int = complex<double>
template<> class ReflectField<int,NumberS> { public: typedef NumberS type; };     // int @ float  = float
template<> class ReflectField<int,NumberD> { public: typedef NumberD type; };     // int @ double = double
template<> class ReflectField<int,NumberC> { public: typedef NumberC type; };     // int @ complex<float > = complex<float >
template<> class ReflectField<int,NumberZ> { public: typedef NumberZ type; };     // int @ complex<double> = complex<double>

template<class NumberA, class NumberB> class MatchNumber;
template<> class MatchNumber<NumberS,NumberS> { public: typedef NumberS type; };
template<> class MatchNumber<NumberD,NumberD> { public: typedef NumberD type; };
template<> class MatchNumber<NumberC,NumberC> { public: typedef NumberC type; };
template<> class MatchNumber<NumberZ,NumberZ> { public: typedef NumberZ type; };
template<> class MatchNumber<NumberS,int> { public: typedef NumberS type; };
template<> class MatchNumber<NumberD,int> { public: typedef NumberD type; };
template<> class MatchNumber<NumberC,int> { public: typedef NumberC type; };
template<> class MatchNumber<NumberZ,int> { public: typedef NumberZ type; };
template<> class MatchNumber<int,NumberS> { public: typedef NumberS type; };
template<> class MatchNumber<int,NumberD> { public: typedef NumberD type; };
template<> class MatchNumber<int,NumberC> { public: typedef NumberC type; };
template<> class MatchNumber<int,NumberZ> { public: typedef NumberZ type; };

} // namespace myra

#endif