functions_numeric.h

#ifndef FUNCTIONS_NUMERIC_H
#define FUNCTIONS_NUMERIC_H
 
//types of the code
#include "types.h"
#include "functions_type.h"
 
//math header isnan
#include <math.h>
 
namespace functions_numeric {
 
    
    
    //equal operators
    //================
    template<typename T>
    inline tBoolean areEquals(const T& e1, const T& e2 )
    { return (e1==e2) ; }
    
    template<>
    inline tBoolean areEquals(const tReal&  e1,const tReal& e2 ) {
        return abs(e1-e2)<std::numeric_limits<tReal>::epsilon();
    }
    template<>
    inline tBoolean areEquals(const tComplex& e1,const tComplex &e2 ) {
        return abs(e1-e2)<std::numeric_limits<tReal>::epsilon();
    }
    
    template<>
    inline tBoolean areEquals(const tString& e1,const tString & e2 ) {
        return (e1.compare(e2)==0);
    }
 
   
    //arithmetic type methods
    //=======================
   
    template<typename T>
    requires functions_type::isRealType<T>
    inline tBoolean isNAN(const T& s) {
        return std::isnan(s);
    }
    
    inline tBoolean isInteger(const tString& s) {
        char* p;
        strtol(s.c_str(), &p, 10);
        if (*p) {
            // conversion failed because the input wasn't a number
            return false;
        }
        else {
            // use converted
            return true;
        }
    }
    inline  tBoolean isNumeric(const tString& s) {
        char* p;
        strtod(s.c_str(), &p);
        if (*p) {
            // conversion failed because the input wasn't a number
            return false;
        }
        else {
            // use converted
            return true;
        }
    }
    inline tBoolean isString(const tString& s) {
        return ( (!isInteger(s)) && (!isNumeric(s)));
    }
    
  
 
  
    //arithmetic type
    //===============
    
    //arithmetic bounds
    //=================
 
    /* \brief get min epsilon
     * @return the minimum positive significant value
     */
    template<class T>
    requires functions_type::isArithmeticType<T>
    inline static T getEpsilon() {
        return std::numeric_limits<T>::epsilon(); 
    }
    /* \brief get infinity value
     * @return the infinity value
     */
    template<class T>
    requires functions_type::isArithmeticType<T>
    inline static T getInfinity() {
        return std::numeric_limits<T>::infinity(); 
    }
    /* \brief get min epsilon
     * @return the minimum positive significant value
     */
    template<class T>
    requires functions_type::isArithmeticType<T>
    inline static T getEpsilonValue() {
        return std::numeric_limits<T>::epsilon(); 
    }
    /* \brief get infinity value
     * @return the infinity value
     */
    template<class T>
    requires functions_type::isArithmeticType<T>
    inline static T getInfinityValue() {
        return std::numeric_limits<T>::infinity(); 
    }
    /* \brief get max value
     * @return the maximum positive  value
     */
    template<class T>
    requires functions_type::isIntegerType<T>
    inline static T getMax() {
        return std::numeric_limits<T>::max(); 
    }
    /* \brief get min value
     * @return the minimum positive  value
     */
    template<class T>
    requires functions_type::isIntegerType<T>
    inline static T getMin() {
        return std::numeric_limits<T>::min(); 
    }
    /* \brief get max value
     * @return the maximum positive  value
     */
    template<class T>
    requires functions_type::isIntegerType<T>
    inline static T getMaxValue() {
        return std::numeric_limits<T>::max(); 
    }
    /* \brief get min value
     * @return the minimum positive  value
     */
    template<class T>
    requires functions_type::isIntegerType<T>
    inline static T getMinValue() {
        return std::numeric_limits<T>::min(); 
    }
 
    
    //arithmetic scalar methods
    //=========================
 
    
    template<typename T>
    requires functions_type::isArithmeticType<T>
    inline const T& min(const T& a,const T&b) {
        return (a<b)?a:b;
    }
    template<typename T>
    requires functions_type::isArithmeticType<T> 
    inline const T& max(const T& a,const T&b) {
        return (a>b)?a:b;
    }
    
    template<typename Q,tUCInt N,tUCInt i> requires (i==N)
    inline Q levelPow(const Q& x) {
        return x;
    }
    template<typename Q,tUCInt N,tUCInt i> requires (i<N)
    inline Q levelPow(const Q&  x) {
        return x*levelPow<Q,N,i+1>(x);
    }
    
    template<typename Q,tUCInt N>
    inline Q pow(const Q&  x) {
        return levelPow<Q,N,1>(x);
    }
 
 
       
    template<typename T,std::enable_if_t<std::is_integral_v<T>> * = nullptr>
    inline tString toString(const T& v,const tUCInt& d) {
        tString ret=std::to_string(v);
        for (tUCInt k=ret.length();k<d;k++) {
            ret="0"+ret;
        }
        return ret;
    }
    template<typename T,std::enable_if_t<std::is_arithmetic_v<T>> * = nullptr>
    inline tString toString(const T& v) {
        std::stringstream sv;
        sv<<v;
        return sv.str();
    }
 
      
    inline tString booleanToString(const tBoolean& v) {
        return (v)?"true":"false";
    }
     
    template<typename T>
    inline void parse(const tString& s,T& v) {
        std::stringstream ss;
        ss<<s;
        ss>>v;
    }
    template<>
    inline  void parse(const tString& s,tBoolean& v) {       
        v=false;
        switch (s[0]) {
        case '1':
        case 't':
        case 'T':
            v=true;
        }
    }
 
 
 
    //quick search
    //============
 
 
    template<typename Q> requires functions_type::isArithmeticType<Q>
    tIndex  quickSearch(const Q& v,
                        const tIndex& n,
                        const Q* values,
                        tBoolean& isFound) {
        
        //return index
        tIndex k;
        
        //range of search in array
        tIndex k0=0;
        tIndex k1=n;
        
        //current value
        Q currentValue;
        
        
        //range is empty
        if (k0==k1) {
            
            isFound=false;
            return k0;
        }
        
        //last included index
        k1--;
        
        //min value
        k=k0;
        currentValue=values[k];
        
        if (v<currentValue) {
            //no values : return  the index of the array greater than v
            isFound=false;
            return k;
        }
        if (v==currentValue) {
            isFound=true;
            return k;
        }
        
        //max value
        k=k1;
        currentValue=values[k];
        
        if (v>currentValue) {
            //no values : return  the index of the array less than v
            isFound=false;
            return k;
        }
        if (v==currentValue) {
            isFound=true;
            return k;
        }
        
        
        
        //quick sort search
        do {
            k=(k0+k1)/2;
            currentValue=values[k];
            if (v==currentValue) {
                isFound=true;
                return k;
            }
            if (v<currentValue) k1=k;
            else k0=k;
        } while (k1-k0>1);
        
        //k1-k0=1
        //ib>=mRows[k0]
        //ib<mRows[k1]
        if (values[k0]==v)  {
            isFound=true;
            return k0;
        }
        
        if (values[k1]==v)  {
            isFound=true;
            return k1;
        }
        //no values : return  the index of the array greater than v
        isFound=false;
        return k1;
    }//end method uickSearch
    
}
 
#endif