factory.hpp

Go to the documentation of this file.

/*****************************************************************************
    
    factory.hpp -- default factory template class.

    This file is a part of the Arageli library.

    Copyright (C) Nikolai Yu. Zolotykh, 1999--2006
    Copyright (C) Sergey S. Lyalin, 2005
    University of Nizhni Novgorod, Russia

*****************************************************************************/

#ifndef _ARAGELI_factory_hpp_
#define _ARAGELI_factory_hpp_

#include "config.hpp"

#include <complex>

#include "basefuncs.hpp"
#include "std_import.hpp"


namespace Arageli
{



template <typename T> struct factory
{
    static const bool is_specialized = true;

    static const T& unit ()
    {
        static const T unit_s = T(1);
        return unit_s;
    }
    
    static const T& unit (const T& x)
    { return unit(); }

    static const T& opposite_unit ()
    {
        static const T opposite_unit_s = T(-1);
        return opposite_unit_s;
    }
    
    static const T& opposite_unit (const T& x)
    { return opposite_unit(); }

    static const T& null ()
    {
        static const T null_s = T(0);
        return null_s;
    }
    
    static const T& null (const T& x)
    { return null(); }

};



template <typename T>
inline const T& unit ()
{ return factory<T>::unit(); }

template <typename T>
inline T unit (const T& x)  // WARNING.  Making a copy.
{ return factory<T>::unit(x); }

template <typename T>
inline bool is_unit (const T& x)
{ return x == unit<T>(); }

template <typename T>
inline const T& opposite_unit ()
{ return factory<T>::opposite_unit(); }

template <typename T>
inline T opposite_unit (const T&x)  // WARNING.  Making a copy.
{ return factory<T>::opposite_unit(x); }

template <typename T>
inline bool is_opposite_unit (const T& x)
{ return x == opposite_unit<T>(); }

template <typename T>
inline const T& null ()
{ return factory<T>::null(); }

template <typename T>
inline T null (const T&)    // WARNING.  Making a copy.
{ return factory<T>::null(); }

template <typename T>
inline bool is_null (const T& x)
{ return x == null<T>(); }

template <typename T>
inline T opposite (const T& x)
{ return -x; }

template <typename T>
inline T& opposite (const T& x, T* y)
{ return *y = -x; }

template <typename T>
inline T& opposite (T* x)
{ return *x = -*x; }

template <typename T>
inline T inverse (const T& x)
{ return 1 / x; }

template <typename T>
inline T& inverse (const T& x, T* y)
{ return *y = 1 / x; }

template <typename T>
inline T& inverse (T* x)
{ return *x = 1 / *x; }

//template <typename T>
//inline T bitwise_not (const T& x)
//{ return ~x; }
//
//template <typename T>
//inline T& bitwise_not (const T& x, T* y)
//{ return *y = ~x; }
//
//template <typename T>
//inline T& bitwise_not (T* x)
//{ return *x = ~*x; }
//
//template <typename T>
//inline T logical_not (const T& x)
//{ return !x; }
//
//template <typename T>
//inline bool blogical_not (const T& x)
//{ return !x; }
//
//template <typename T>
//inline T& logical_not (const T& x, T* y)
//{ return *y = !x; }
//
//template <typename T>
//inline T& logical_not (T* x)
//{ return *x = !*x; }



template <typename T2>
struct factory<std::complex<T2> >
{
private:

    typedef std::complex<T2> T;
    typedef factory<T2> TT2;

public:

    static const bool is_specialized = true;

    static const T& unit ()
    {
        static const T unit_s(TT2::unit());
        return unit_s;
    }
    
    static T unit (const T& x)
    { return T(TT2::unit(x.real())); }

    static const T& opposite_unit ()
    {
        static const T opposite_unit_s(TT2::opposite_unit());
        return opposite_unit_s;
    }
    
    static T opposite_unit (const T& x)
    { return T(TT2::opposite_unit(x.real())); }

    static const T& null ()
    {
        static const T null_s;
        return null_s;
    }
    
    static const T& null (const T& x)
    { return T(TT2::null(x.real())); }

};

}


//#ifdef ARAGELI_INCLUDE_CPP_WITH_EXPORT_TEMPLATE
//  #define ARAGELI_INCLUDE_CPP_WITH_EXPORT_TEMPLATE_FACTORY
//  #include "factory.cpp"
//  #undef  ARAGELI_INCLUDE_CPP_WITH_EXPORT_TEMPLATE_FACTORY
//#endif


#endif  //  #ifndef _ARAGELI_factory_hpp_

---