type_operators.hpp

Go to the documentation of this file.

/*
Copyright (c) 2014, Sam Schetterer, Nathan Kutz, University of Washington
Authors: Sam Schetterer
All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/
#ifndef TYPE_OPERATORS_HPP
#define TYPE_OPERATORS_HPP
#include <complex>
#include <utility>
#include "float_traits.hpp"
//I would recommend rolling your own static assert, so there is a more specific error message as well.
//But dim_check will always fail when value is false
template<int bound, int dim>
struct dim_check{
    constexpr static bool value = dim > 0 && dim <= bound;
    static_assert(value, "Dimension is outside of bounds");
};
//Getter structs to allow for generic and effecient retrieval of various parameters
//If only c++ allowed partial specialization of functions...
template<class T, int dim>
struct get{
    static_assert(dim > 0, "Dimension less than one passed to getter");
    static_assert(std::is_floating_point<T>::value, "Non floating-point type used with standard getter");
    static inline T& pull(T& inval){
        return inval;
    }
};
template<class T, int dim>
struct get<T[], dim>{
    static_assert(dim > 0, "Dimension less than one passed to getter");
    static_assert(std::is_floating_point<T>::value, "Non floating-point type used with standard getter");
    template<size_t N>
        static inline T& pull(T(& array)[N]){
            static_assert(dim <= N, "Dimension higher than array dimension used");
            return array[dim-1];
        }
};

template<class T, int dim>
struct get<T*, dim>{
    static_assert(dim > 0, "Dimension less than one passed to getter");
    static_assert(std::is_floating_point<T>::value, "Non floating-point type used with standard getter");
    //adios bounds-checking...
    static inline T& pull(T* inval){
        return inval[dim-1];
    }
};

//These make it possible to extract from the complex values holding non-basic types 
//without violating dimension rules
template<class T, size_t dim, bool is_first>
struct comp_get_helper{
    static inline typename float_traits<T>::type& pull(std::complex<T>& pullfrom){
            T& cur = ((T*)&pullfrom)[0];
            //is in the first value, use the current dim
            return get<T, dim>::pull(cur);
        }
};

template<class T, size_t dim>
struct comp_get_helper<T, dim, false>{
    static inline typename float_traits<T>::type& pull(std::complex<T>& pullfrom){
            T& cur = ((T*)&pullfrom)[1];
            //is in the second value, subtract dim of T to get proper index
            return get<T, dim-float_traits<T>::dim>::pull(cur);
        }
};
/*
 * This gets a value from a complex number. This is a somewhat complex proposition, since
 * the types can be nested (std::complex<example_type> for example).
 *
 * If you were to imagine the relevant floating_point values as an N dimensional array,=
 * The pull function would return the Nth value in that array (1-indexed, since this is dimensions)
 *
 * For example, an std::complex<example_type> would be [{val1, val2}, i*{val1, val2}];
 * get<2> would return val2 from the real part, while get<3> would return val1 from the imaginary part
 */
template<class T, int dim>
struct get<std::complex<T>, dim>{
    static_assert(dim_check<float_traits<std::complex<T>>::dim, dim>::value,
            "Dimension used outside the range of complex values");
    //having this function cleans up the code, and decreases the number of specializations
    static inline typename float_traits<T>::type& pull(std::complex<T>& inval){
        constexpr static bool is_first = dim <= float_traits<T>::dim;
        return comp_get_helper<T, dim, is_first>::pull(inval); 
    }
};

template<class T, int dim>
struct get_cref{
    typedef typename float_traits<T>::type real_type;
    const static inline real_type& pull(const T& inval){
        return get<T, dim>(const_cast<T&>(inval));
    }
};

template<class T, int dim>
struct get_val{
    typedef typename float_traits<T>::type real_type;
    static inline real_type pull(const T& inval){
        return get<T, dim>(const_cast<T&>(inval));
    }
};

template<class T, size_t dim = float_traits<T>::dim>
struct apply{
    private:
        template<class U>
            static auto get(U& inval) -> decltype(get<U, dim>::pull(inval)){
                return ::get<U, dim>::pull(inval);
            }
    public:
        static_assert(dim >= 1, "A dimension less then one has been given to the apply structure");
        //no dimension checking here, that should be done by the getter function
        template<class Lambda>
            static inline void transform(T& inval, Lambda&& func){
                std::forward<Lambda>(func)(get(inval), dim);
                apply<T, dim-1>::transform(inval, std::forward<Lambda>(func));
            }

        template<template<size_t> class Lambda>
            static inline void transform(T& inval){
                Lambda<dim>::apply(inval);
                apply<T, dim-1>::template transform<Lambda>(inval);
            }
        template<class Lambda, class Final>
            static inline void transform(T& inval, Lambda&& func, Final&& finish){
                apply<T, dim>::transform(inval, std::forward<Lambda>(func));
                std::forward<Final>(finish)(inval);
            }

        template<class Lambda, class Trans>
            static inline void map_into(const T& inval, Lambda&& func, Trans& outval){
                static_assert(float_traits<Trans>::dim == float_traits<T>::dim,
                        "The dimension of the Trans type is not equal to the dimension of the T type");
                get(outval) = std::forward<Lambda>(func)(get_cref<T, dim>::pull(inval), dim);
                apply<T, dim-1>::map_into(inval, std::forward<Lambda>(func), outval);
            }
        template<class Lambda, class Trans>
            static inline Trans map(const T& inval, Lambda&& func){
                Trans val;
                map_into(inval, std::forward<Lambda>(func), val);
                return val;
            }
        template<class Lambda, class Trans, class constr, class postop>
            static inline Trans map(const T& inval, Lambda&& func,
                    postop&& finish, constr&& build){
                Trans val = std::forward<constr>(build)();
                map_into(inval, std::forward<Lambda>(func), val);
                std::forward<postop>(finish)(val);
                return val;
            }
};
template<class T>
struct apply<T, 1>{
    private:
    static constexpr size_t dim=1;
    template<class U>
        static auto get(U& inval) -> decltype(get<U, dim>::pull(inval)){
            return ::get<U, 1>::pull(inval);
        }
    public:
    template<class Lambda>
        static inline void transform(T& inval, Lambda&& func){
            std::forward<Lambda>(func)(get(inval), 1);
        }
    template<template<size_t> class Lambda>
        static inline void transform(T& inval){
            Lambda<1>::apply(inval);
        }
    template<class Lambda, class Final>
        static inline void transform(T& inval, Lambda&& func, Final&& finish){
            std::forward<Lambda>(func)(get(inval), 1);
            std::forward<Final>(finish)(inval);
        }
    template<class Lambda, class Trans>
        static inline void map_into(const T& inval, Lambda&& func, Trans& outval){
            get(outval) = std::forward<Lambda>(func)(get(inval), 1);
        }

};
#endif