inplace_arithmetics.hpp

//
// (c) Copyright 2012 DESY, Eugen Wintersberger <eugen.wintersberger@desy.de>
//
// This file is part of libpnicore.
//
// libpnicore 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.
//
// libpnicore 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 libpnicore.  If not, see <http://www.gnu.org/licenses/>.
//
// ============================================================================
//
//  Created on: Jul 24, 2012
//      Author: Eugen Wintersberger <eugen.wintersberger@desy.de>
//

#pragma once

#include <limits>
#include <functional>

#include "../../error/exception_utils.hpp"
#include "../../types.hpp"
#include "../../utilities/sfinae_macros.hpp"

namespace pni{
namespace core{

#define CHECK_ARITHMETIC_SINGLE(type)\
    static_assert(std::is_arithmetic<typename type::value_type>::value || \
                  is_complex_type<typename type::value_type>::value,\
            "Arithemtic operations can only be used with arithmetic types!")

#define CHECK_ARITHMETIC_DOUBLE(type1,type2)\
    static_assert(\
            (std::is_arithmetic<typename type1::value_type>::value || \
             is_complex_type<typename type1::value_type>::value) && \
            (std::is_arithmetic<typename type2::value_type>::value || \
             is_complex_type<typename type2::value_type>::value), \
            "Arithemtic operations can only be used with arithmetic types!")

    struct inplace_arithmetics
    {
                 
        //==================inplace addition===================================

        template<
                 typename LTYPE,
                 typename T,
                 typename = enable_if<or_t<
                           is_pod<T>,is_cmplx<T>
                           >>
                > 
        static void add(LTYPE &a,T b)
        {
            CHECK_ARITHMETIC_SINGLE(LTYPE);

            size_t n = a.size();
            for(size_t i = 0;i<n;++i) a[i] += b;
        }

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

        template<
                 typename LTYPE,
                 typename RTYPE,
                 typename = enable_if<not_t<
                            or_t<is_pod<RTYPE>,is_cmplx<RTYPE>>
                            >>
                >
        static void add(LTYPE &a,const RTYPE &b)
        {
            CHECK_ARITHMETIC_DOUBLE(LTYPE,RTYPE);
            size_t n = a.size();
            for(size_t i=0;i<n;++i) a[i] += b[i];
        }

        //==================inplace subtraction===============================

        template<
                 typename LTYPE,
                 typename T,
                 typename = enable_if<or_t< 
                            is_pod<T>,is_cmplx<T> 
                            >>
                >
        static void sub(LTYPE &a,T b)
        {
            CHECK_ARITHMETIC_SINGLE(LTYPE);
            size_t n = a.size();
            for(size_t i=0;i<n;++i) a[i] -= b;
        }

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

        template<
                 typename LTYPE,
                 typename RTYPE,
                 typename = enable_if<not_t<
                            or_t<is_pod<RTYPE>,is_cmplx<RTYPE>>
                            >>
                >
        static void sub(LTYPE &a,const RTYPE &b)
        {
            CHECK_ARITHMETIC_DOUBLE(LTYPE,RTYPE);
            size_t n = a.size();
            for(size_t i=0;i<n;++i) a[i] -= b[i];
        }


        //=====================inplace multiplication======================

        template<
                 typename LTYPE,
                 typename T,
                 typename = enable_if<or_t< 
                            is_pod<T>,is_cmplx<T> 
                            >>
                >
        static void mult(LTYPE &a,T b)
        {
            CHECK_ARITHMETIC_SINGLE(LTYPE);
            size_t n=a.size();
            for(size_t i=0;i<n;++i) a[i] *= b;
        }

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

        template<
                 typename LTYPE,
                 typename RTYPE,
                 typename = enable_if<not_t<
                            or_t<is_pod<RTYPE>,is_cmplx<RTYPE>>
                            >>
                >
        static void mult(LTYPE &a,const RTYPE &b)
        {
            CHECK_ARITHMETIC_DOUBLE(LTYPE,RTYPE);
            size_t n=a.size();
            for(size_t i=0;i<n;++i) a[i] *= b[i];
        }
        
        //=====================inplace division============================

        template<
                 typename LTYPE,
                 typename T,
                 typename = enable_if<or_t< 
                            is_pod<T>,is_cmplx<T> 
                            >>
                >
        static void div(LTYPE &a,T b)
        {
            CHECK_ARITHMETIC_SINGLE(LTYPE);
            size_t n = a.size();
            for(size_t i=0;i<n;++i) a[i] /= b;
        }

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

        template<
                 typename LTYPE,
                 typename RTYPE,
                 typename = enable_if<not_t<
                            or_t<is_pod<RTYPE>,is_cmplx<RTYPE>>
                            >>
                >
        static void div(LTYPE &a,const RTYPE &b)
        {
            CHECK_ARITHMETIC_DOUBLE(LTYPE,RTYPE);
            size_t n = a.size();
            for(size_t i=0;i<n;++i) a[i] /= b[i];
        }
    };

//end namespace
}
}