functions.h

Go to the documentation of this file.

#ifndef FUNCTIONS_H
#define FUNCTIONS_H
 
//types of the code
#include "types.h"
 
//standart library
#include <stdlib.h>
 
//for type name
#include <cxxabi.h>
 
//include the Template condition
#include<type_traits>
 
//regex header fro string manipulation
#include <regex>
 
//template type verification header
#include<type_traits>
#include<concepts>
 
//math header isnan
#include <math.h>
 
#ifdef DEBUG
//define the assert method
#include<cassert>
#endif
 
//bitwise operators
//================
// a | b | iand
// 0 | 0 | 0
// 0 | 1 | 0
// 1 | 0 | 0
// 1 | 1 | 1
#define iand(a,b) ( (a) & (b) )
 
// a | b | ior
// 0 | 0 | 0
// 0 | 1 | 1
// 1 | 0 | 1
// 1 | 1 | 1
#define ior(a,b) ( (a)  | (b) )
 
// a | b | inor
// 0 | 0 | 1
// 0 | 1 | 0
// 1 | 0 | 0
// 1 | 1 | 0
#define inor(a,b) ( ~( (a) | (b) ) )
 
// a | b | ixor
// 0 | 0 | 0
// 0 | 1 | 1
// 1 | 0 | 1
// 1 | 1 | 0
#define ixor(a,b) ( (a) ^  (b) ) )
 
// a | inot
// 0 | 1
// 1 | 0 
#define inot(a) ( 256 - (~(a)) )
 
namespace core_functions {
 
    //template type verifications
    //============================
 
    //is complex
    template <typename T>
    struct is_complex : std::false_type {};
    
    template <std::floating_point T>
    struct is_complex<std::complex<T>> : std::true_type {};
    
    template <typename T>
    concept isComplexType =
        ( std::floating_point<T> || is_complex<T>::value);
 
    
    //type verification for  real or integer type
    template<typename T>
    concept isArithmeticType=
        (std::is_arithmetic_v<T> || isComplexType<T> );
    
    //orded type
    template<typename T>
    concept isOrderedType =
        (std::totally_ordered<T>);
 
    //type verification string type
    template<typename T>
    concept isStringType=
        (std::is_constructible<std::string,T>::value);
    
    //type verification for real type
    template<typename T>
    concept isRealType=
        (std::is_floating_point_v<T>);
    
    
    //type verification for integer type
    template<typename T>
    concept isIntegerType=
        (std::is_integral_v<T>);
    
    // type verification for signed integer type
    template<typename T>
    concept isSignedIntegerType=
        (std::is_integral_v<T>) && (std::is_signed_v<T>);
 
    // type verification for unsigned integer type
    template<typename T>
    concept isUnsignedIntegerType=
        (std::is_integral_v<T>) && (!std::is_signed_v<T>);
 
 
    // type verification that the class Derived inherits from the class base
    template<class Base, class Derived>
    concept isBaseOf= std::is_base_of_v<Base, Derived>;
    
    // type verification that the class T is an array of type T
    template<class T>
    concept isArray= std::is_array<T>();
    
    // type verification that the class T is a bounded  array of type T
    template<class T>
    concept isBoundedArray= std::is_bounded_array<T>::value;
    
    // type verification that the class T is a bounded  array of type T
    template<class T>
    concept isUnboundedArray= std::is_unbounded_array<T>::value;
 
    // type verification that the class T is an double array of type T
    template<class T>
    concept isDoubleArray= std::is_pointer_v<T**>;
    
    // type verification that the class T is a pointer
    template<class T>
    concept isPointer= std::is_pointer_v<T>;
 
    // type verification that the class T is a not null pointer
    template<class T>
    concept iNotNullPointer= not std::is_pointer<std::nullptr_t>::value;
 
    // type verification that the class T and Q are same
    template<class T,class Q>
    concept isSameType= std::is_same<T,Q>::value;
 
    
    //type accessors
    //==============
    
    //type id operator
    template <class T>
    inline static tString getTypeName(const T& v)  {
        return typeid(v).name();
    };
    
    template <class T>
    inline static tString getTypeName()  {
        tString tname=typeid(T).name();
        int status;
        char *demangled_name = abi::__cxa_demangle(tname.c_str(), NULL, NULL, &status);
        if(status == 0) {
            tname = demangled_name;
            std::free(demangled_name);
        }   
        return tname;
    };
    template <class T>
    inline tString pointerToString(const T * ptr)  {
        std::stringstream cstr;
        cstr<<ptr;
        return cstr.str();
    };
    //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);
    }
 
 
    //bit manipulation
 
    //a[p]=1
    template<typename T> requires isIntegerType<T>
    inline static T& bitSet(T& a,const tUCInt& p) {
        a |= (1ULL<<p);
        return a;
    }
    
    //a[p]=0
    template<typename T> requires isIntegerType<T>
    inline static T& bitClear(T& a,const tUCInt& p) {
        a &= ~(1ULL<<p);
        return a;
    }
    //a[p]=!a[p]
    template<typename T> requires isIntegerType<T>
    inline static T& bitFlip(T& a,const tUCInt& p) {
        a ^= (1ULL<<p);
        return a;
    }
    
    //b=a[p];a[n-1]...a[2]a[1]a[0]
    template<typename T> requires isIntegerType<T>
    inline static tBoolean bitGet(const T& a,const tUCInt& p) {
        return (!!(a & (1ULL<<p)));
    }
 
 
    //a[p]=1 for all p=1  for all p were mask[p]=1
    template<typename T> requires isIntegerType<T>
    inline static T& bitMaskSet(T& x, const T& mask) {
        x |= (mask);
        return x;
    }
    
    //a[p]=0 for all p=1  for all p where mask[p]=1
    template<typename T> requires isIntegerType<T>
    inline static T& bitMaskClear(T& x, const T& mask) {
        x &= (~(mask));
        return x;
    };
    
    //a[p]=!a[p] for all  for all p where mask[p]=1
    template<typename T> requires isIntegerType<T>
    inline static T& bitMaskFlip(T& x, const T& mask) {
        x ^= mask;
        return x;
    }
    
    //return true is all a[p]=1 for all p where mask[p]=1
    template<typename T> requires isIntegerType<T>
    inline static tBoolean bitMaskCheckAll(const T& x, const T& mask) {
        return (!(~(x) & (mask)));
    }
 
    //return false (0) if  it does not exist any  p such that a[p]=1 for all p where mask[p]=1
    //return true is all a[p]=1 for all p where mask[p]=1
    template<typename T> requires isIntegerType<T>
    inline static tBoolean  bitMaskCheckAny(const T& x, const T& mask) {
        return ((x) & (mask));
    }
 
 
    
    //string manipulations
    //====================
    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) {
        return std::to_string(v);
    }
    
    inline tString booleanToString(const tBoolean& v) {
        return (v)?"true":"false";
    }
    
    inline tString& ltrim(tString& s) {
        s=std::regex_replace(s, std::regex("^\\s+"), std::string(""));
        return s;
    }
    inline tString& rtrim(tString& s) {
        s=std::regex_replace(s, std::regex("\\s+$"), std::string(""));
        return s;
    }
    
    inline tString& trim(tString& s) {
        return ltrim(rtrim(s));
    }
    
    inline void replaceAll(const tString& word,const tString& rWord,tString& str) {
        tIndex pos = str.find(word);
        tIndex lWord=word.length();
        tIndex lrWord=rWord.length();
        // Repeat till end is reached
        while( pos != std::string::npos)
        {
            // Replace this occurrence of Sub String
            str.replace(pos, lWord , rWord);
            // Get the next occurrence from the current position
            pos =str.find(word, pos + lrWord);
        }
    }
    inline void toLower(tString& s) {
        std::transform(s.cbegin(), s.cend(), s.begin(),
                       [](unsigned char c){ return std::tolower(c);});
    }
    inline void toUpper(tString& s) {
        tString r=s;//returned string
        std::transform(s.cbegin(), s.cend(), s.begin(),
                       [](unsigned char c){ return std::toupper(c);});
    }
 
    inline void tokenize(tString& str,
                         const tString& delim,
                         std::vector<tString> words) {
        char *rest=&str[0];
        char *token;
        words.clear();
        while ( (token = strtok_r(rest,delim.c_str(),&rest))) words.push_back(tString(token));
    }
    
   
 
    //Numeric functions
    //======================
 
    template<typename T>
    requires core_functions::isArithmeticType<T>
    inline const T& min(const T& a,const T&b) {
        return (a<b)?a:b;
    }
    template<typename T>
    requires core_functions::isArithmeticType<T>
    inline const T& max(const T& a,const T&b) {
        return (a>b)?a:b;
    }
    
    template<typename T>
    requires core_functions::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)));
    }
    
    /* \brief get min epsilon
     * @return the minimum positive significant value
     */
    template<class T>
    requires core_functions::isArithmeticType<T>
    inline static T getEpsilon() {
        return std::numeric_limits<T>::epsilon(); 
    }
    /* \brief get infinity value
     * @return the infinity value
     */
    template<class T>
    requires core_functions::isArithmeticType<T>
    inline static T getInfinity() {
        return std::numeric_limits<T>::infinity(); 
    }
    /* \brief get max value
     * @return the maximum positive  value
     */
    template<class T>
    requires core_functions::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 core_functions::isIntegerType<T>
    inline static T getMin() {
        return std::numeric_limits<T>::min(); 
    }
    
    
    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) {
        tString ss(s);
        core_functions::toLower(ss);
        if (ss.compare("true")==0) v=true;
        v=false;
    }
 
    template<typename T,size_t D>
    inline tString toString(const std::array<T,D>& a) {
        std::stringstream ss;
        ss<<"{";
        for(const auto & ai : a) {
            ss<<ai<<",";
        }
        ss.seekp(-1, std::ios_base::end);
        ss<<"}";
        return ss.str();
    }
    template<typename T>
    inline tString toString(const std::valarray<T>& a) {
        std::stringstream ss;
        ss<<"{";
        for(const auto & ai : a) {
            ss<<ai<<",";
        }
        ss.seekp(-1, std::ios_base::end);
        ss<<"}";
        return ss.str();
    }
 
    //complex multiplicator
    template<typename Q>
    inline const std::pair<Q,Q>& complexMultiply(const std::pair<Q,Q>& alpha,std::pair<Q,Q>& beta) {
        Q betaImg=beta.second;
        beta.second=alpha.first*betaImg+alpha.second*beta.first;
        beta.first=alpha.first*beta.first-alpha.second*betaImg;
        return beta;
        
    }
    
    //complex add
    template<typename Q>
    inline const std::pair<Q,Q>& complexAdd(const std::pair<Q,Q>& alpha,std::pair<Q,Q>& beta) {
        beta.first+=alpha.first;
        beta.second+=alpha.second;
        return beta;
 
    }
 
}//end core_functions namespace
 
    
    
//class function
    
 
//debug command
//==============
//if the program has been compiled with -DDEBUG, the assert command is executed 
#ifdef DEBUG
 
#define ASSERT(a) {assert(a);}
#define ASSERT_IN(a) {assert(a);}
#define ASSERT_OUT(a) {assert(a);}
#define ASSERT_EXCEPTION(T,P,F,C) { if (!(T)) throw CORE_Exception(P,F,C);}
 
#else
 
#define ASSERT(a) {}
#define ASSERT_IN(a) {}
#define ASSERT_OUT(a) {}
#define ASSERT_EXCEPTION(T,P,F,C)
 
//endif DEBUG
#endif 
 
 
//endif FUNCTION_H
#endif