Maths.h

Go to the documentation of this file.

// (c) IMT - Information Management Technology AG, CH-9470 Buchs, www.imt.ch.
//
// ActiveParts (AP) and the corresponding Data Flow Framework (DFF) is invented and designed by Jakob Daescher.
// ANY USE OF THIS CODE CONSTITUTES ACCEPTANCE OF THE TERMS OF THE COPYRIGHT NOTICE.
// ===================================================================================================
// COPYRIGHT NOTICE
// ===================================================================================================
// Copyright (C) 2005-2075, IMT Information Management Technology AG, 9470 Buchs, Switzerland
// All rights reserved.
// This code is proprietary software of IMT Information Management Technology AG (hereinafter: "IMT").
// Proprietary software is computer software licensed under exclusive legal right of IMT.
//
// The licensee is given the irrevocable, perpetual, worldwide, non-exclusive right and license to use,
// execute and reproduce the software in binary form within the licensed products.
//
// Redistribution and use in source forms, without modification, are permitted provided that the following conditions are met:
// (1) Copying of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
// (2) Copying of source code is only allowed for regulatory documentation and archiving purposes
// (3) 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.
//
// IMT provide no reassurances that the source code provided does not infringe
// any patent, copyright, or any other intellectual property rights of third parties.
// IMT disclaim any liability to any recipient for claims brought against
// recipient by any third party for infringement of that parties intellectual property rights.
//
// THIS SOFTWARE IS PROVIDED BY IMT 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 IMT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
// OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCURE-MENT 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 IMT_BASE_CORE_MATH_MATHS_H
#define IMT_BASE_CORE_MATH_MATHS_H
 
#include <Imt.Base.Core.Math/Function/abs.h>
#include <Imt.Base.Core.Math/Function/arcos.h>
#include <Imt.Base.Core.Math/Function/arcosh.h>
#include <Imt.Base.Core.Math/Function/arsin.h>
#include <Imt.Base.Core.Math/Function/arsinh.h>
#include <Imt.Base.Core.Math/Function/artan.h>
#include <Imt.Base.Core.Math/Function/artan2.h>
#include <Imt.Base.Core.Math/Function/artanh.h>
#include <Imt.Base.Core.Math/Function/compare.h>
#include <Imt.Base.Core.Math/Function/copysign.h>
#include <Imt.Base.Core.Math/Function/cos.h>
#include <Imt.Base.Core.Math/Function/cosh.h>
#include <Imt.Base.Core.Math/Function/erf.h>
#include <Imt.Base.Core.Math/Function/erfc.h>
#include <Imt.Base.Core.Math/Function/exp.h>
#include <Imt.Base.Core.Math/Function/expm1.h>
#include <Imt.Base.Core.Math/Function/fdim.h>
#include <Imt.Base.Core.Math/Function/floor.h>
#include <Imt.Base.Core.Math/Function/fmod.h>
#include <Imt.Base.Core.Math/Function/frexp.h>
#include <Imt.Base.Core.Math/Function/hypot.h>
#include <Imt.Base.Core.Math/Function/ilogb.h>
#include <Imt.Base.Core.Math/Function/isinf.h>
#include <Imt.Base.Core.Math/Function/isnan.h>
#include <Imt.Base.Core.Math/Function/ldexp.h>
#include <Imt.Base.Core.Math/Function/log.h>
#include <Imt.Base.Core.Math/Function/log1p.h>
#include <Imt.Base.Core.Math/Function/log2.h>
#include <Imt.Base.Core.Math/Function/logb.h>
#include <Imt.Base.Core.Math/Function/modf.h>
#include <Imt.Base.Core.Math/Function/nan.h>
#include <Imt.Base.Core.Math/Function/nextafter.h>
#include <Imt.Base.Core.Math/Function/pow.h>
#include <Imt.Base.Core.Math/Function/remainder.h>
#include <Imt.Base.Core.Math/Function/remquo.h>
#include <Imt.Base.Core.Math/Function/rint.h>
#include <Imt.Base.Core.Math/Function/scalbln.h>
#include <Imt.Base.Core.Math/Function/scalbn.h>
#include <Imt.Base.Core.Math/Function/sin.h>
#include <Imt.Base.Core.Math/Function/sinh.h>
#include <Imt.Base.Core.Math/Function/sqrt.h>
#include <Imt.Base.Core.Math/Function/tan.h>
#include <Imt.Base.Core.Math/Function/tanh.h>
#include <Imt.Base.Core.Math/Function/trunc.h>
#include <Imt.Base.Core.Platform/Platform.h>
#include <Imt.Base.Core.Platform/StaticClass.h>
 
namespace imt {
namespace base {
namespace core {
namespace math {
 
class Maths final : private ::imt::base::core::platform::StaticClass {
 
public:
 
    template<typename Type>
    static inline bool areEqualNumbers(Type const left, Type const right) {
        return left == right;
    }
 
    template<typename Type>
    static inline bool areEqualFloats(Type const left, Type const right) {
        return function::areEqualNumbers(left, right);
    }
 
    template<typename Type>
    static inline bool areEqualArrayFloats(Type const* left, Type const* right, size_t size) {
        return function::areEqualNumbers(left, right, size);
    }
 
    template<typename Type>
    static inline Type sqrt(Type const sqVal) {
        return function::sqrt(sqVal);
    }
 
    template<typename Type>
    static inline Type nsqrt(Type const sqVal, Type n) {
        return function::pow(sqVal, 1.0 / n);
    }
 
    template<typename Type>
    static inline Type nsqrt(Type const sqVal, int32_t n) {
        return function::pow(sqVal, 1 / n);
    }
 
    template<typename Type>
    static inline Type exp(Type const value) {
        return function::exp(value);
    }
 
    template<typename Type>
    static inline Type ln(Type const arg) {
        return function::log(arg);
    }
 
    template<typename Type>
    static inline Type log10(Type const arg) {
        return function::log10(arg);
    }
 
    template<typename Type>
    static inline Type pow(Type const base, int32_t const exp) {
        return function::pow(base, exp);
    }
 
    static inline float64_t pow10(int32_t const exp) {
        constexpr float64_t decimalBase {10.0};
        return function::pow(decimalBase, exp);
    }
 
    template<typename Type>
    static inline Type fabs(Type const value) {
        return function::fabs(value);
    }
 
    template<typename Type>
    static inline Type abs(Type const value) {
        return function::abs(value);
    }
 
    template<typename Type>
    static inline Type sin(Type const value) {
        return function::sin(value);
    }
 
    template<typename Type>
    static inline Type cos(Type const value) {
        return function::cos(value);
    }
 
    template<typename Type>
    static inline Type tan(Type const value) {
        return function::tan(value);
    }
 
    template<typename Type>
    static inline Type arcos(Type const value) {
        return function::arcos(value);
    }
 
    template<typename Type>
    static inline Type arsin(Type const value) {
        return function::arsin(value);
    }
 
    template<typename Type>
    static inline Type artan(Type const value) {
        return function::artan(value);
    }
 
    template<typename Type>
    static inline Type artan2(Type const y, Type const x) {
        return function::artan2(y, x);
    }
 
    template<typename Type>
    static inline Type cosh(Type const value) {
        return function::cosh(value);
    }
 
    template<typename Type>
    static inline Type sinh(Type const value) {
        return function::sinh(value);
    }
 
    template<typename Type>
    static inline Type tanh(Type const value) {
        return function::tanh(value);
    }
 
    template<typename Type>
    static inline Type arsinh(Type const value) {
        return function::arsinh(value);
    }
 
    template<typename Type>
    static inline Type arcosh(Type const value) {
        return function::arcosh(value);
    }
 
    template<typename Type>
    static inline Type artanh(Type const value) {
        return function::artanh(value);
    }
 
    template<typename Type>
    static inline Type copysign(Type const& x, Type const& y) {
        return function::copysign(x, y);
    }
 
    template<typename Type>
    static inline Type erf(Type const& x) {
        return function::erf(x);
    }
 
    template<typename Type>
    static inline Type erfc(Type const& x) {
        return function::erfc(x);
    }
 
    template<typename Type>
    static inline Type expm1(Type const& x) {
        return function::expm1(x);
    }
 
    template<typename Type>
    static inline Type fdim(Type const& x, Type const& y) {
        return function::fdim(x, y);
    }
 
    template<typename Type>
    static inline Type floor(Type const& x) {
        return function::floor(x);
    }
 
    template<typename Type>
    static inline Type fmod(Type const& numer, Type const& denom) {
        return function::fmod(numer, denom);
    }
 
    template<typename Type>
    static inline Type frexp(Type const& x, int32_t* exp) {
        return function::frexp(x, exp);
    }
 
    template<typename Type>
    static inline Type hypot(Type const& x, Type const& y) {
        return function::hypot(x, y);
    }
 
    template<typename Type>
    static inline int32_t ilogb(Type const& x) {
        return function::ilogb(x);
    }
 
    template<typename Type>
    static inline bool isinf(Type const& x) {
        return function::isinf(x);
    }
 
    template<typename Type>
    static inline bool isnan(Type const& x) {
        return function::isnan(x);
    }
 
    // AXIVION NEXT Routine AutosarC++19_03-A27.0.4: use of C-style string required to to defined interface of the nan function.
    // AXIVION NEXT Routine AutosarC++19_03-A3.9.1: char is not for an integer but for a C-style string
    static inline double nan(char const* tagp) {
        return function::nan(tagp);
    }
 
    // AXIVION NEXT Routine AutosarC++19_03-A27.0.4: use of C-style string required to to defined interface of the nanf function.
    // AXIVION NEXT Routine AutosarC++19_03-A3.9.1: char is not for an integer but for a C-style string
    static inline float nanf(char const* tagp) {
        return function::nanf(tagp);
    }
 
    template<typename Type>
    static inline bool ldexp(Type const& x, int32_t exp) {
        return function::ldexp(x, exp);
    }
 
    template<typename Type>
    static inline Type log1p(Type const& x) {
        return function::log1p(x);
    }
 
    template<typename Type>
    static inline Type log2(Type const& x) {
        return function::log2(x);
    }
 
    template<typename Type>
    static inline Type logb(Type const& x) {
        return function::logb(x);
    }
 
    template<typename Type>
    static inline Type modf(Type const& x, Type* intpart) {
        return function::modf(x, intpart);
    }
 
    // AXIVION NEXT Routine AutosarC++19_03-A8.4.7: tagp is an array and not a uint8 parameter
    template<typename Type>
    static inline Type modf(Type const& x, int8_t const* tagp) {
        return function::modf(x, tagp);
    }
 
    template<typename Type>
    static inline Type nextafter(Type const& x, Type const& y) {
        return function::nextafter(x, y);
    }
 
    template<typename Type>
    static inline Type remainder(Type const& numer, Type const& denom) {
        return function::remainder(numer, denom);
    }
 
    template<typename Type>
    static inline Type remquo(Type const& numer, Type const& denom, int32_t* quot) {
        return function::remquo(numer, denom, quot);
    }
 
    template<typename Type>
    static inline Type rint(Type const& x) {
        return function::rint(x);
    }
 
    // AXIVION NEXT Routine AutosarC++19_03-A3.9.1: long int can not be replaced with a fixed size int (long int is different on a 32-bit or 64-bit system) and API is also defined by libc/STL
    template<typename Type>
    static inline Type scalbln(Type const& x, long int n) {
        return function::scalbln(x, n);
    }
 
    template<typename Type>
    static inline Type scalbn(Type const& x, int32_t n) {
        return function::scalbn(x, n);
    }
 
    template<typename Type>
    static inline Type trunc(Type const& x) {
        return function::trunc(x);
    }
};
 
} // namespace math
} // namespace core
} // namespace base
} // namespace imt
 
#endif // IMT_BASE_CORE_MATH_MATHS_H