functions_bit.h

#ifndef FUNCTIONS_BIT_H
#define FUNCTIONS_BIT_H
 
//types of the code
#include "types.h"
#include "functions_type.h"
 
//math header isnan
#include <math.h>
 
 
//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 functions_bit {
 
    //bit manipulation
    //================
    
    //a[p]=1
    template<typename T> requires functions_type::isIntegerType<T>
    inline static T& bitSet(T& a,const tUCInt& p) {
        a |= (1ULL<<p);
        return a;
    }
    
    //a[p]=0
    template<typename T> requires functions_type::isIntegerType<T>
    inline static T& bitClear(T& a,const tUCInt& p) {
        a &= ~(1ULL<<p);
        return a;
    }
    //a[p]=!a[p]
    template<typename T> requires functions_type::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 functions_type::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 functions_type::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 functions_type::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 functions_type::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 functions_type::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 functions_type::isIntegerType<T>
    inline static tBoolean  bitMaskCheckAny(const T& x, const T& mask) {
        return ((x) & (mask));
    }
 
}
    
#endif