ivl/details/core/types/evolution.hpp

/* This file is part of the ivl C++ library <http://image.ntua.gr/ivl>.
   A C++ template library extending syntax towards mathematical notation.

   Copyright (C) 2012 Yannis Avrithis <iavr@image.ntua.gr>
   Copyright (C) 2012 Kimon Kontosis <kimonas@image.ntua.gr>

   ivl is free software; you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License 
   version 3 as published by the Free Software Foundation.

   Alternatively, you can redistribute it and/or modify it under the terms 
   of the GNU General Public License version 2 as published by the Free 
   Software Foundation.

   ivl 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 
   and a copy of the GNU Lesser General Public License along 
   with ivl. If not, see <http://www.gnu.org/licenses/>. */

#ifndef IVL_CORE_DETAILS_TYPES_EVOLUTION
#define IVL_CORE_DETAILS_TYPES_EVOLUTION

namespace ivl {
namespace types {


/* These structs allow the compile-time translation from one
 * template type to another. Or otherwise said, they perform
** type promotion for template types */

//--------------------------------------------------------------

// -------------------------- TODO : style -------------

//--------------------------------------------------------------


template <class KEY, class FROM = bool> struct to_type
{
        typedef KEY type;
};

template <class KEY>
struct to_type<KEY, term>
{
        typedef term type;
};

template <class KEY, template<typename> class D, class T>
struct to_type<KEY, D<T> >
{
        typedef D<KEY> type;
};

// spec param class
// todo: make a is_ivl_array check to further specialize
template <class KEY, template<typename, typename> class D, class T, class DS>
struct to_type<KEY, D<T, DS> >
{
        typedef D<KEY, typename DS::template change_derived_param<
                typename to_type<KEY, typename DS::derived_param>::type>::type> type;
};

// note: to_type should only be used for creating new types, which will have 'term' as DERINFO
// any other intermediate types would be illegal, since directly casting one class from one type
// to another type of elements is an unsupported practice.
// A reinterpret cast should take care to not only cast the D<T, ..> to D<KEY, ..> but also
// D<T, A, DERINFO> type; to D<T, A, typename to_type<KEY, DERINFO>::type > type;

//--------------------------------------------------------------


template <class X> struct to_bool : public to_type<bool, X> {};

template <class T> struct promote : public
        t_if<is_ivl_array<T>,
                to_type<typename promote<typename subtype<T>::type>::type, T>,
                to_type<T> >::type { };

template<> struct promote<term> { typedef bool type; };

#include "platform_specific/promote_int_impl.hpp"

template <class Z> struct promote<std::complex<Z> > :
        public to_type<typename std::complex<typename promote<Z>::type> > { };

template <class T> struct to_real : public
        t_if<is_ivl_array<T>,
                to_type<typename to_real<typename subtype<T>::type>::type, T>,
                to_type<T> >::type { };

template<> struct to_real<term> { typedef bool type; };

template<class T>
struct to_real<std::complex<T> > : public to_type<T> { };

template <class T> struct to_complex : public
        t_if<is_ivl_array<T>,
                to_type<typename to_complex<typename subtype<T>::type>::type, T>,
                to_type<std::complex<T> > >::type { };

template<> struct to_complex<term> { typedef bool type; };

template<class T>
struct to_complex<std::complex<T> > : public to_type<std::complex<T> > { };

template <class T> struct to_floating : public
        t_if<is_ivl_array<T>,
                to_type<typename to_floating<typename subtype<T>::type>::type, T>,
                to_type<double> >::type { };

template<> struct to_floating<term> { typedef bool type; };

template<>
struct to_floating<float> : public to_type<float> { };

template <class Z> struct to_floating<std::complex<Z> > :
        public to_type<std::complex<typename to_floating<Z>::type> > { };

template <class T> struct to_real_floating : public
        t_if<is_ivl_array<T>,
                to_type<typename to_real_floating<typename
                        subtype<T>::type>::type, T>,
                to_type<double> >::type { };

template<> struct to_real_floating<term> { typedef bool type; };

template<>
struct to_real_floating<float> : public to_type<float> { };

template <class Z> struct to_real_floating<std::complex<Z> > :
        public to_real_floating<Z> { };

template <class T> struct to_signed : public
        t_if<is_ivl_array<T>,
                to_type<typename to_signed<typename
                        subtype<T>::type>::type, T>,
                to_type<int> >::type { };

template<> struct to_signed<term> { typedef bool type; };

template <>
struct to_signed<float> : public to_type<float> { };

template <>
struct to_signed<double> : public to_type<double> { };

template <class Z> struct to_signed<std::complex<Z> > :
        public to_type<std::complex<typename to_signed<Z>::type> > { };

template <class T> struct to_unsigned : public
        t_if<is_ivl_array<T>,
                to_type<typename to_unsigned<typename
                        subtype<T>::type>::type, T>,
                to_type<unsigned> >::type { };

template<> struct to_unsigned<term> { typedef bool type; };

template <>
struct to_unsigned<float> : public to_type<float> { };

template <>
struct to_unsigned<double> : public to_type<double> { };

template <class Z> struct to_unsigned<std::complex<Z> > :
        public to_type<std::complex<typename to_unsigned<Z>::type> > { };

#include "platform_specific/signed_impl.hpp"

} /* namespace types */
} /* namespace ivl */

#endif // IVL_CORE_DETAILS_TYPES_EVOLUTION