mn_fast_type.hpp

Go to the documentation of this file.

 
#ifndef MINLIB_FAST_TYPE_H_
#define MINLIB_FAST_TYPE_H_
 
#include "mn_config.hpp"
 
#include "mn_algorithm.hpp"
#include "mn_def.hpp"
#include "mn_uint128.hpp"
 
 
#include <stdint.h>
 
namespace mn {
    class basic_fbit {
    public:
        union {
            unsigned char bit : 1;
        };
        basic_fbit() : bit(0) { }
        basic_fbit(bool b) { bit = b ? 1 : 0; }
        basic_fbit(const basic_fbit& b) { bit = b.bit; }
 
        basic_fbit& operator = (const basic_fbit& other) {
            bit = other.bit;
        }
        bool operator == (const basic_fbit& other) {
            return bit == other.bit;
        }
        bool operator != (const basic_fbit& other) {
            return bit != other.bit;
        }
 
        operator bool() { return bit == 1; }
        void flip() { bit = (bit ==1) ? 0 : 1; }
    };
 
    #include <stddef.h>
 
    template <size_t Bits, typename TBaseType>
    class fast_type {
    public:
        using self_type = fast_type<Bits, TBaseType>;
        using value_type = TBaseType;
        using bit_type = fbit;
 
        union {
            value_type Value;
            bit_type bits[Bits];
        };
        explicit fast_type(value_type v) : Value(v) {}
        fast_type(const fast_type& c) : Value(c.Value) { }
 
        unsigned int count() {
            unsigned int i;
            for(int j = 0; j < Bits; j++)
                i += bits[i].bit;
            return i;
        }
        unsigned int zeros() {
            return Bits - count();
        }
        unsigned int set(size_t pos, bool p) {
            bits[pos].bit = p ? 1 : 0;
        }
        size_t size() { return Bits; }
 
        value_type& operator [] (const size_t p) {
            return bits[p];
        }
        self_type& operator = (value_type& v) {
            Value = v; return *this;
        }
 
        self_type& operator = (self_type& other) {
            Value = other.Value; return *this;
        }
        bool operator == (self_type& other) {
            return Value == other.Value;
        }
        bool operator != (self_type& other) {
            return Value != other.Value;
        }
        bool operator <= (self_type& other) {
            return Value <= other.Value;
        }
        bool operator >= (self_type& other) {
            return Value >= other.Value;
        }
        bool operator < (self_type& other) {
            return Value < other.Value;
        }
        bool operator > (self_type& other) {
            return Value > other.Value;
        }
 
        self_type& operator += (self_type& other) {
            Value += other.Value; return *this;
        }
        self_type& operator -= (self_type& other) {
            Value -= other.Value; return *this;
        }
        self_type& operator *= (self_type& other) {
            Value *= other.Value; return *this;
        }
        self_type& operator &= (self_type& other) {
            Value &= other.Value; return *this;
        }
        self_type& operator |= (self_type& other) {
            Value |= other.Value; return *this;
        }
        self_type& operator ^= (self_type& other) {
            Value ^= other.Value; return *this;
        }
        self_type& operator <<= (self_type& other) {
            Value <<= other.Value; return *this;
        }
        self_type& operator >>= (self_type& other) {
            Value >>= other.Value; return *this;
        }
        self_type& operator /= (self_type& other) {
            Value /= other.Value; return *this;
        }
        self_type& operator += (value_type& v) {
            Value += v; return *this;
        }
        self_type& operator -= (value_type& v) {
            Value -= v; return *this;
        }
        self_type& operator *= (value_type& v) {
            Value *= v; return *this;
        }
        self_type& operator /= (value_type& v) {
            Value /= v; return *this;
        }
        self_type& operator <<= (value_type& v) {
            Value <<= v; return *this;
        }
        self_type& operator >>= (value_type& v) {
            Value >>= v; return *this;
        }
        self_type& operator - ( const self_type& rhs) {
            return self_type(*this) -= rhs;
        }
        self_type& operator + ( const self_type& rhs) {
            return self_type(*this) += rhs;
        }
        self_type& operator * ( const self_type& rhs) {
            return self_type(*this) *= rhs;
        }
        self_type& operator / ( const self_type& rhs) {
            return self_type(*this) /= rhs;
        }
        self_type& operator << ( const self_type& rhs) {
            return self_type(*this) <<= rhs;
        }
        self_type& operator >> ( const self_type& rhs) {
            return self_type(*this) >>= rhs;
        }
        self_type& operator | ( const self_type& rhs) {
            self_type result = self_type(*this);
            result.Value |= rhs.Value;
            return result;
        }
        self_type& operator ^ ( const self_type& rhs) {
            self_type result = self_type(*this);
            result.Value ^= rhs.Value;
            return result;
        }
        self_type& operator & ( const self_type& rhs) {
            self_type result = self_type(*this);
            result.Value &= rhs.Value;
            return result;
        }
        self_type& operator ~ () {
            self_type result = self_type(*this);
            result.Value = ~result.Value;
            return result;
        }
 
        self_type& operator ++ () {
            Value++; return *this;
        }
        self_type& operator -- () {
            Value--; return *this;
        }
        self_type& operator ~ () {
            Value = ~Value; return *this;
        }
    };
 
 
 
 
 
    using fsize_t           = fast_type<value2size<size_t>::size,           size_t>;
    using ffloat_t          = fast_type<value2size<float>::size,            float>;
    using fdouble_t         = fast_type<value2size<double>::size,           double>;
 
    using fint8_t           = fast_type<value2size<int8_t>::size,           int8_t>;
    using fint16_t          = fast_type<value2size<int16_t>::size,          int16_t>;
    using fint32_t          = fast_type<value2size<int32_t>::size,          int32_t>;
    using fint64_t          = fast_type<value2size<int64_t>::size,          int64_t>;
 
    using fuint8_t          = fast_type<value2size<uint8_t>::size,          uint8_t>;
    using fuint16_t         = fast_type<value2size<uint16_t>::size,         uint16_t>;
    using fuint32_t         = fast_type<value2size<uint32_t>::size,         uint32_t>;
    using fuint64_t         = fast_type<value2size<uint64_t>::size,         uint64_t>;
    using fuint128_t        = fast_type<value2size<uint128_t>::size,        uint128_t>;
 
    using fint_least8_t     = fast_type<value2size<int_least8_t>::size,     int_least8_t>;
    using fint_least16_t    = fast_type<value2size<int_least16_t>::size,    int_least16_t>;
    using fint_least32_t    = fast_type<value2size<int_least32_t>::size,    int_least32_t>;
    using fint_least64_t    = fast_type<value2size<int_least64_t>::size,    int_least64_t>;
 
    using fuint_least8_t    = fast_type<value2size<uint_least8_t>::size,    uint_least8_t>;
    using fuint_least16_t   = fast_type<value2size<uint_least16_t>::size,   uint_least16_t>;
    using fuint_least32_t   = fast_type<value2size<uint_least32_t>::size,   uint_least32_t>;
    using fuint_least64_t   = fast_type<value2size<uint_least64_t>::size,   uint_least64_t>;
    using fuint_least128_t  = fast_type<value2size<uint_least128_t>::size,  uint_least128_t>;
 
}
 
#endif