FixMath.h

Go to the documentation of this file.

/*
 * FixMath.h
 *
 * Copyright 2023, Thomas Combriat and the Mozzi team
 *
 *
 * FixMath is licensed under a GNU Lesser General Public Licence
 *
 */
 
 
#ifndef FIXMATH2_H_
#define FIXMATH2_H_
 
#if FOR_DOXYGEN_ONLY
#define FIXMATH_UNSAFE
#endif
 
 
#include<Arduino.h>
#include "IntegerType.h"
 
 
 
namespace FixMathPrivate {
  template<typename T> constexpr T shiftR(T x, int8_t bits) {return (bits > 0 ? (x >> (bits)) : bits < 0 ? (x << (-bits)) : x);} // shift right with positive values, left with negative; NOTE: extra condition for bits==0 allows more static tests to work
  constexpr int8_t sBitsToBytes(int8_t N) { return (((N)>>3)+1);}  // conversion between Bits and Bytes for signed
  constexpr int8_t uBitsToBytes(int8_t N) { return (((N-1)>>3)+1);}
  template<typename T>  constexpr T FM_max(T N1, T N2) { return (N1) > (N2) ? (N1) : (N2);}
  template<typename T>  constexpr T FM_min(T N1, T N2) { return (N1) > (N2) ? (N2) : (N1);}
  constexpr uint64_t sFullRange(int8_t N) { return uint64_t(1)<<N;} // FM_maximum absolute value that can be hold in a signed of size N
  constexpr uint64_t uFullRange(int8_t N) { return ((uint64_t(1)<<(N-1))-1) + (uint64_t(1)<<(N-1));}
  constexpr uint64_t rangeAdd(byte NF, byte _NF, uint64_t RANGE, uint64_t _RANGE) { return ((NF > _NF) ? (RANGE + (_RANGE<<(NF-_NF))) : (_RANGE + (RANGE<<(_NF-NF))));}  // returns the RANGE following an addition
  constexpr uint64_t rangeShift(int8_t N, int8_t SH, uint64_t RANGE) { return ((SH < N) ? (RANGE) : (shiftR(RANGE,(N-SH))));}  // make sure that NI or NF does not turn negative when safe shifts are used.
 
  // Helper struct for NIcount(), below. Needed, because C++ does not allow partial specialization of functions
  template<uint64_t value, int8_t bits> struct BitCounter {
    static constexpr int8_t bitsNeeded() { return (value >= (uint64_t(1) << bits) ? bits+1 : (BitCounter<value, bits-1>::bitsNeeded())); }
  };
  template<uint64_t value> struct BitCounter<value, 0> {
    static constexpr int8_t bitsNeeded() { return (value < 1 ? 0 : 1); }
  };
  // Count number of bits needed to represent the constant value (up to 64 bits). Value is specified as template parameter to constrict usage to compile-time evaluation.
  template<uint64_t value> constexpr int8_t NIcount() { return BitCounter<value, 63>::bitsNeeded(); };
}
 
// Forward declaration
template<int8_t NI, int8_t NF, uint64_t RANGE=FixMathPrivate::sFullRange(NI+NF)>
class SFix;
 
// Forward declaration
template<int8_t NI, int8_t NF, uint64_t RANGE=FixMathPrivate::uFullRange(NI+NF)>
class UFix;
 
namespace FixMathPrivate {
  // Alias declaration for a UFix type with the suitable NI count given RANGE and NF
  template<int8_t NF, uint64_t RANGE> using UFixByRange_t=UFix<NIcount<RANGE>()-NF, NF, RANGE>;
  // Alias declaration for an SFix type with the suitable NI count given RANGE and NF
  template<int8_t NF, uint64_t RANGE> using SFixByRange_t=SFix<NIcount<RANGE-1>()-NF, NF, RANGE>;
}
 
template<int8_t NI, int8_t NF, uint64_t RANGE> // NI and NF being the number of bits for the integral and the fractionnal parts respectively.
class UFix
{
  static_assert(NI+NF<=64, "The total width of a UFix cannot exceed 64bits");
  typedef typename IntegerType<FixMathPrivate::uBitsToBytes(NI+NF)>::unsigned_type internal_type ; // smallest size that fits our internal integer
  typedef typename IntegerType<FixMathPrivate::uBitsToBytes(NI+NF+1)>::unsigned_type next_greater_type ; // smallest size that fits 1<<NF for sure (NI could be equal to 0). It can be the same than internal_type in some cases.
  
public:
  constexpr UFix() {}
 
  constexpr UFix(float fl) : internal_value(/*static_cast<internal_type>*/(fl * (next_greater_type(1) << NF))) {}
 
  constexpr UFix(double fl) : internal_value(static_cast<internal_type> (fl * (next_greater_type(1) << NF))) {}
  
  /* Constructor from integer type (as_frac = false) or from fractionnal value (as_frac=true) can be used to emulate the behavior of for instance Q8n0_to_Q8n8 */
 
  template<typename T>
  constexpr UFix(T value,bool as_raw=false) : internal_value(as_raw ? value : (internal_type(value) << NF)) {}
 
 
  template<typename T>
  static constexpr UFix<NI,NF> fromRaw(T raw){return UFix<NI,NF>(raw,true);}
 
 
 
 
 
  template<int8_t _NI, int8_t _NF, uint64_t _RANGE>
  constexpr UFix(const UFix<_NI,_NF, _RANGE>& uf) : internal_value(FixMathPrivate::shiftR((typename IntegerType<FixMathPrivate::uBitsToBytes(FixMathPrivate::FM_max(NI+NF,_NI+_NF))>::unsigned_type) uf.asRaw(),(_NF-NF))) {}
 
 
 
  template<int8_t _NI, int8_t _NF, uint64_t _RANGE>
  constexpr UFix(const SFix<_NI,_NF, _RANGE>& uf) : internal_value(FixMathPrivate::shiftR((typename IntegerType<FixMathPrivate::uBitsToBytes(FixMathPrivate::FM_max(NI+NF,_NI+_NF))>::unsigned_type) uf.asRaw(),(_NF-NF))) {}
 
 
 
   template<int8_t _NI, int8_t _NF, uint64_t _RANGE>
   constexpr FixMathPrivate::UFixByRange_t<FixMathPrivate::FM_max(NF,_NF), FixMathPrivate::rangeAdd(NF,_NF,RANGE,_RANGE)> operator+ (const UFix<_NI,_NF,_RANGE>& op) const // NOTE: C++-11 does not (yet) allow auto return value
  {
    // Number of NI in return type amy be FM_max(NI, _NI), or FM_max(NI, _NI)+1. Most easily determined from the resulting RANGE
    typedef FixMathPrivate::UFixByRange_t<FixMathPrivate::FM_max(NF,_NF), FixMathPrivate::rangeAdd(NF,_NF,RANGE,_RANGE)> worktype;
 
    return worktype(worktype(*this).asRaw() + worktype(op).asRaw(), true);
  }
 
  template<int8_t _NI, int8_t _NF, uint64_t _RANGE>
  constexpr FixMathPrivate::SFixByRange_t<FixMathPrivate::FM_max(NF,_NF), FixMathPrivate::rangeAdd(NF,_NF,RANGE,_RANGE)> operator+ (const SFix<_NI,_NF,_RANGE>& op) const
  {
    typedef FixMathPrivate::SFixByRange_t<FixMathPrivate::FM_max(NF,_NF), FixMathPrivate::rangeAdd(NF,_NF,RANGE,_RANGE)> worktype;
 
    return worktype(worktype(*this).asRaw() + worktype(op).asRaw(), true);
  }
  
#ifdef FIXMATH_UNSAFE
  template<typename T>
  constexpr UFix<NI,NF> operator+ (const T op) const
  {
    return UFix<NI,NF>(internal_value+((internal_type)op<<NF),true);
  }
#endif
 
 
  template<int8_t _NI, int8_t _NF, uint64_t _RANGE> // We do not have the +1 after FixMathPrivate::FM_max(NI, _NI) because the substraction between two UFix should fit in the biggest of the two.
  constexpr FixMathPrivate::SFixByRange_t<FixMathPrivate::FM_max(NF,_NF), FixMathPrivate::FM_max(FixMathPrivate::shiftR(RANGE,FixMathPrivate::FM_max(NF,_NF)-NF), FixMathPrivate::shiftR(_RANGE,FixMathPrivate::FM_max(NF,_NF)-_NF))> operator- (const UFix<_NI,_NF, _RANGE>& op) const
  {
    using namespace FixMathPrivate;
    typedef SFixByRange_t<FM_max(NF,_NF), FM_max(shiftR(RANGE,FM_max(NF,_NF)-NF), shiftR(_RANGE,FM_max(NF,_NF)-_NF))> worktype;
 
    return worktype(worktype(*this).asRaw() - worktype(op).asRaw(), true);
  }
 
  template<int8_t _NI, int8_t _NF, uint64_t _RANGE>
  constexpr FixMathPrivate::SFixByRange_t<FixMathPrivate::FM_max(NF,_NF), FixMathPrivate::rangeAdd(NF,_NF,RANGE,_RANGE)> operator- (const SFix<_NI,_NF, _RANGE>& op2) const
  {
    return -op2+(*this);
  }
 
#ifdef FIXMATH_UNSAFE
  template<typename T>
  constexpr UFix<NI,NF> operator- (const T op) const
  {
    return UFix<NI,NF>(internal_value-((internal_type)op<<NF),true);
  }
#endif
 
  constexpr SFix<NI,NF,RANGE> operator-() const
  {
    return SFix<NI,NF,RANGE>( -(typename IntegerType<FixMathPrivate::sBitsToBytes(NI+NF)>::signed_type)(internal_value),true);
  }
 
  
  template<int8_t _NI, int8_t _NF, uint64_t _RANGE>
  constexpr FixMathPrivate::UFixByRange_t<NF+_NF, RANGE*_RANGE> operator* (const UFix<_NI,_NF,_RANGE>& op) const
  {
    typedef FixMathPrivate::UFixByRange_t<NF+_NF, RANGE*_RANGE> worktype;
    return worktype((typename worktype::internal_type) (internal_value)*op.asRaw(), true);
  }
 
  template<int8_t _NI, int8_t _NF, uint64_t _RANGE>
  constexpr FixMathPrivate::SFixByRange_t<NF+_NF, RANGE*_RANGE> operator* (const SFix<_NI,_NF,_RANGE>& op) const
  {
    typedef FixMathPrivate::SFixByRange_t<NF+_NF, RANGE*_RANGE> worktype;
    return worktype((typename worktype::internal_type) (internal_value)*op.asRaw(), true);
  }
 
#ifdef FIXMATH_UNSAFE
  template<typename T>
  constexpr UFix<NI,NF> operator* (const T op) const
  {
    return UFix<NI,NF>(internal_value*op,true);
  }
#endif
 
 
  constexpr UFix<NF,NI> invFast() const
  {
    static_assert(NI+NF<=64, "The fast inverse cannot be computed for when NI+NF>63. Reduce the number of bits.");
    return UFix<NF,NI>((onesbitmask()/internal_value),true);
  }
 
 
  template<int8_t _NF>
  constexpr UFix<NF,_NF> inv() const
  {
    return UFix<_NF,NF>(internal_value,true).invFast();  
  }
 
 
  
  constexpr UFix<NF,FixMathPrivate::FM_min(NI*2+NF,64-NF)> invFull() const // The FixMathPrivate::FM_min is just to remove compiler error when a big FixMath is instanciated but no accurate inverse is actually computed (this would be catch by the static_assert)
  {
    static_assert(2*NI+2*NF<=64, "The accurate inverse cannot be computed for when 2*NI+2*NF>63. Reduce the number of bits.");
    return inv<NI*2+NF>();
  }
 
  template<int8_t _NF=FixMathPrivate::FM_min(NI*2+NF-1,64-NF)>
  constexpr UFix<NF,_NF> invAccurate() const
  {
    static_assert(NF+_NF+1<=64, "The accurate inverse cannot be computed because the asked precision is too great. Reduce the number of bits.");
    return UFix<NF,_NF>(UFix<NF,_NF+1>::msbone()/internal_value,true);
    }
 
  /*  template<int8_t _NF=FixMathPrivate::FM_min(NI*2+NF,64-NF)>
  constexpr UFix<NF,_NF-1> invAccurateb() const
  {
    static_assert(NF+_NF<=64, "The accurate inverse cannot be computed because the asked precision is too great. Reduce the number of bits.");
    return UFix<NF,_NF-1>(UFix<NF,_NF>::msbone()/internal_value,true);
    }*/
 
 
  /* template<int8_t _NF=FixMathPrivate::FM_min(NI*2+NF,64-NF)>
  constexpr UFix<NF,_NF> invAccurate() const
  {
    static_assert(NF+_NF<=64, "The accurate inverse cannot be computed because the asked precision is too great. Reduce the number of bits.");
    return UFix<NF,_NF>(UFix<NF,_NF-1>(UFix<NF,_NF>::msbone()/internal_value,true)); // the last cast is to have the same return type.
    }*/
  
  
 
 
 
  constexpr UFix<NI,NF> operator>> (const int8_t op) const
  {
    return UFix<NI,NF>(internal_value>>op,true);
  }
 
 
#ifdef FIXMATH_UNSAFE
  constexpr UFix<NI,NF> operator<< (const int8_t op) const
  {
    return UFix<NI,NF>(internal_value<<op,true);
  }
#endif
  
  template<int8_t op>
  constexpr UFix<FixMathPrivate::FM_max(NI-op,0),NF+op, FixMathPrivate::rangeShift(NI,op,RANGE)> sR() const
  {
    return UFix<FixMathPrivate::FM_max(NI-op,0),NF+op,FixMathPrivate::rangeShift(NI,op,RANGE)>(internal_value,true);
  }
 
  template<int8_t op>
  constexpr UFix<NI+op,FixMathPrivate::FM_max(NF-op,0),FixMathPrivate::rangeShift(NF,op,RANGE)> sL() const
  {
    return UFix<NI+op,FixMathPrivate::FM_max(NF-op,0)>(internal_value,true);
  }
 
  
  /** Comparison with another UFix.
      @param op A UFix
      @return true if this is bigger than op, false otherwise
  */
  template<int8_t _NI, int8_t _NF>
  constexpr bool operator> (const UFix<_NI,_NF>& op) const
  {
    using namespace FixMathPrivate;
    typedef UFix<FM_max(NI, _NI),FM_max(NF, _NF)> comptype;  // type suitable for comparison
    return (comptype(*this).asRaw()>comptype(op).asRaw());
  }
 
  template<int8_t _NI, int8_t _NF>
  constexpr bool operator< (const UFix<_NI,_NF>& op) const
  {
    return op > *this;
  }
 
 
  template<int8_t _NI, int8_t _NF>
  constexpr bool operator== (const UFix<_NI,_NF>& op) const
  {
    using namespace FixMathPrivate;
    typedef UFix<FM_max(NI, _NI),FM_max(NF, _NF)> comptype;  // type suitable for comparison
    return (comptype(*this).asRaw()==comptype(op).asRaw());
  }
 
  template<int8_t _NI, int8_t _NF>
  constexpr bool operator!= (const UFix<_NI,_NF>& op) const
  {
    typedef UFix<FixMathPrivate::FM_max(NI, _NI),FixMathPrivate::FM_max(NF, _NF)> comptype;  // type suitable for comparison
    return (comptype(*this).asRaw()!=comptype(op).asRaw());
  }
  
  constexpr SFix<NI,NF,RANGE> asSFix() const
  {
    return SFix<NI,NF,RANGE>(internal_value,true);
  }
 
  constexpr float asFloat() const { return (static_cast<float>(internal_value)) / (next_greater_type(1)<<NF); }
 
  constexpr typename IntegerType<FixMathPrivate::uBitsToBytes(NI)>::unsigned_type asInt() const
  {
    return UFix<NI,0>(*this).asRaw();
  }
  
  constexpr internal_type asRaw() const { return internal_value; }
  
  static constexpr int8_t getNI() {return NI;}
 
  static constexpr int8_t getNF() {return NF;}
 
  static constexpr int8_t getRANGE() {return RANGE;}
 
  template<int8_t BITS> static constexpr void assertSize() { static_assert(NI+NF <= BITS, "Data type is larger than expected!"); }
private:
  template<int8_t, int8_t, uint64_t> friend class UFix;  // for access to internal_type
  template<int8_t, int8_t, uint64_t> friend class SFix;
 
  internal_type internal_value;
  //static constexpr internal_type onesbitmask() { return (internal_type) ((1ULL<< (NI+NF)) - 1); }
  static constexpr internal_type onesbitmask() { return (internal_type) ((1ULL<< (NI+NF-1)) + ((1ULL<< (NI+NF-1)) - 1)); }
  static constexpr internal_type msbone() { return (internal_type) (1ULL<< (NI+NF-1)); }
};
 
 
#ifdef FIXMATH_UNSAFE
// Multiplication
template <int8_t NI, int8_t NF>
constexpr UFix<NI, NF> operator*(uint8_t op, const UFix<NI, NF>& uf) {return uf*op;}
 
template <int8_t NI, int8_t NF>
constexpr UFix<NI, NF> operator*(uint16_t op, const UFix<NI, NF>& uf) {return uf*op;}
 
template <int8_t NI, int8_t NF>
constexpr UFix<NI, NF> operator*(uint32_t op, const UFix<NI, NF>& uf) {return uf*op;}
 
template <int8_t NI, int8_t NF>
constexpr UFix<NI, NF> operator*(uint64_t op, const UFix<NI, NF>& uf) {return uf*op;}
 
template <int8_t NI, int8_t NF>
constexpr UFix<NI, NF> operator*(int8_t op, const UFix<NI, NF>& uf) {return uf*op;}
 
template <int8_t NI, int8_t NF>
constexpr UFix<NI, NF> operator*(int16_t op, const UFix<NI, NF>& uf) {return uf*op;}
 
template <int8_t NI, int8_t NF>
constexpr UFix<NI, NF> operator*(int32_t op, const UFix<NI, NF>& uf) {return uf*op;}
 
template <int8_t NI, int8_t NF>
constexpr UFix<NI, NF> operator*(int64_t op, const UFix<NI, NF>& uf) {return uf*op;}
 
template <int8_t NI, int8_t NF>
constexpr UFix<NI, NF> operator*(float op, const UFix<NI, NF>& uf) {return uf*op;}
 
template <int8_t NI, int8_t NF>
constexpr UFix<NI, NF> operator*(double op, const UFix<NI, NF>& uf) {return uf*op;}
 
// Addition
template <int8_t NI, int8_t NF>
constexpr UFix<NI, NF> operator+(uint8_t op, const UFix<NI, NF>& uf) {return uf+op;}
 
template <int8_t NI, int8_t NF>
constexpr UFix<NI, NF> operator+(uint16_t op, const UFix<NI, NF>& uf) {return uf+op;}
 
template <int8_t NI, int8_t NF>
constexpr UFix<NI, NF> operator+(uint32_t op, const UFix<NI, NF>& uf) {return uf+op;}
 
template <int8_t NI, int8_t NF>
constexpr UFix<NI, NF> operator+(uint64_t op, const UFix<NI, NF>& uf) {return uf+op;}
 
template <int8_t NI, int8_t NF>
constexpr UFix<NI, NF> operator+(int8_t op, const UFix<NI, NF>& uf) {return uf+op;}
 
template <int8_t NI, int8_t NF>
constexpr UFix<NI, NF> operator+(int16_t op, const UFix<NI, NF>& uf) {return uf+op;}
 
template <int8_t NI, int8_t NF>
constexpr UFix<NI, NF> operator+(int32_t op, const UFix<NI, NF>& uf) {return uf+op;}
 
template <int8_t NI, int8_t NF>
constexpr UFix<NI, NF> operator+(int64_t op, const UFix<NI, NF>& uf) {return uf+op;}
 
template <int8_t NI, int8_t NF>
constexpr UFix<NI, NF> operator+(float op, const UFix<NI, NF>& uf) {return uf+op;}
 
template <int8_t NI, int8_t NF>
constexpr UFix<NI, NF> operator+(double op, const UFix<NI, NF>& uf) {return uf+op;}
 
// Substraction
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator-(uint8_t op, const UFix<NI, NF>& uf) {return -uf+op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator-(uint16_t op, const UFix<NI, NF>& uf) {return -uf+op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator-(uint32_t op, const UFix<NI, NF>& uf) {return -uf+op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator-(uint64_t op, const UFix<NI, NF>& uf) {return -uf+op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator-(int8_t op, const UFix<NI, NF>& uf) {return -uf+op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator-(int16_t op, const UFix<NI, NF>& uf) {return -uf+op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator-(int32_t op, const UFix<NI, NF>& uf) {return -uf+op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator-(int64_t op, const UFix<NI, NF>& uf) {return -uf+op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator-(float op, const UFix<NI, NF>& uf) {return -uf+op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator-(double op, const UFix<NI, NF>& uf) {return -uf+op;}
#endif
 
 
template<typename T>
constexpr inline UFix<0, sizeof(T)*8> toUFraction(T val) {
  return UFix<0, sizeof(T)*8>::fromRaw(val); 
}
 
template<typename T>
constexpr inline UFix<sizeof(T)*8,0> toUInt(T val) {
  return UFix<sizeof(T)*8,0>::fromRaw(val); 
}
 
// TODO: auto sixteen = UFixAuto<16>(); could be made to return UFix<1, -4>!
template<uint64_t value>
constexpr FixMathPrivate::UFixByRange_t<0, value> UFixAuto() {
  return FixMathPrivate::UFixByRange_t<0, value>::fromRaw(value);
}
 
 
 
template<int8_t NI, int8_t NF, uint64_t RANGE> // NI and NF being the number of bits for the integral and the fractionnal parts respectively.
class SFix
{
  static_assert(NI+NF<64, "The total width of a SFix cannot exceed 63bits");
  typedef typename IntegerType<FixMathPrivate::sBitsToBytes(NI+NF)>::signed_type internal_type ; // smallest size that fits our internal integer
  typedef typename IntegerType<FixMathPrivate::sBitsToBytes(NI+NF+1)>::signed_type next_greater_type ; // smallest size that fits 1<<NF for sure (NI could be equal to 0). It can be the same than internal_type in some cases.
  
public:
  constexpr SFix() {}
  
  constexpr SFix(float fl) : internal_value(/*static_cast<internal_type>*/(fl * (next_greater_type(1) << NF))) {}
 
  constexpr SFix(double fl) : internal_value(static_cast<internal_type> (fl * (next_greater_type(1) << NF))) {}
 
 
  template<typename T>
  constexpr SFix(T value,bool as_raw=false) : internal_value(as_raw ? value : (internal_type(value) << NF)) {};
 
  template<typename T>
  static constexpr SFix<NI,NF> fromRaw(T raw){return SFix<NI,NF>(raw,true);}
 
 
  template<int8_t _NI, int8_t _NF, uint64_t _RANGE>
  constexpr SFix(const SFix<_NI,_NF, _RANGE>& sf) : internal_value(FixMathPrivate::shiftR((typename IntegerType<FixMathPrivate::sBitsToBytes(FixMathPrivate::FM_max(NI+NF,_NI+_NF))>::signed_type) sf.asRaw(),(_NF-NF))) {}
 
  template<int8_t _NI, int8_t _NF, uint64_t _RANGE>
  constexpr SFix(const UFix<_NI,_NF, _RANGE>& uf) : internal_value(FixMathPrivate::shiftR((typename IntegerType<FixMathPrivate::uBitsToBytes(FixMathPrivate::FM_max(NI+NF,_NI+_NF))>::unsigned_type) uf.asRaw(),(_NF-NF))) {};
 
 
  template<int8_t _NI, int8_t _NF, uint64_t _RANGE>
  constexpr FixMathPrivate::SFixByRange_t<FixMathPrivate::FM_max(NF,_NF),FixMathPrivate::rangeAdd(NF,_NF,RANGE,_RANGE)> operator+ (const SFix<_NI,_NF,_RANGE>& op) const
  {
    typedef FixMathPrivate::SFixByRange_t<FixMathPrivate::FM_max(NF,_NF),FixMathPrivate::rangeAdd(NF,_NF,RANGE,_RANGE)> worktype;
    return worktype(worktype(*this).asRaw() + worktype(op).asRaw(), true);
  }
 
  template<int8_t _NI, int8_t _NF, uint64_t _RANGE>
  constexpr FixMathPrivate::SFixByRange_t<FixMathPrivate::FM_max(NF,_NF),FixMathPrivate::rangeAdd(NF,_NF,RANGE,_RANGE)> operator+ (const UFix<_NI,_NF,_RANGE>& op2) const
  {
    return op2+(*this);
  }
 
#ifdef FIXMATH_UNSAFE
  template<typename T>
  constexpr SFix<NI,NF> operator+ (const T op) const
  {
    return SFix<NI,NF>(internal_value+(op<<NF),true);
  }
#endif
 
 
  template<int8_t _NI, int8_t _NF, uint64_t _RANGE>
  constexpr FixMathPrivate::SFixByRange_t<FixMathPrivate::FM_max(NF,_NF),FixMathPrivate::rangeAdd(NF,_NF,RANGE,_RANGE)> operator- (const SFix<_NI,_NF, _RANGE>& op) const
  {
    typedef FixMathPrivate::SFixByRange_t<FixMathPrivate::FM_max(NF,_NF),FixMathPrivate::rangeAdd(NF,_NF,RANGE,_RANGE)> worktype;
    return worktype(worktype(*this).asRaw() - worktype(op).asRaw(), true);
  }
 
  template<int8_t _NI, int8_t _NF, uint64_t _RANGE>
  constexpr FixMathPrivate::SFixByRange_t<FixMathPrivate::FM_max(NF,_NF),FixMathPrivate::rangeAdd(NF,_NF,RANGE,_RANGE)> operator- (const UFix<_NI,_NF, _RANGE>& op) const
  {
    typedef FixMathPrivate::SFixByRange_t<FixMathPrivate::FM_max(NF,_NF),FixMathPrivate::rangeAdd(NF,_NF,RANGE,_RANGE)> worktype;
    return worktype(worktype(*this).asRaw() - worktype(op).asRaw(), true);
  }
 
#ifdef FIXMATH_UNSAFE
  template<typename T>
  constexpr SFix<NI,NF> operator- (const T op) const
  {
    return SFix<NI,NF>(internal_value-(op<<NF),true);
    }
#endif
 
  /*  constexpr SFix<NI,NF,RANGE> operator-() const
  {
    return SFix<NI,NF,RANGE>(-internal_value,true);
    }*/
  constexpr FixMathPrivate::SFixByRange_t<NF,RANGE+1> operator-() const
  {
typedef FixMathPrivate::SFixByRange_t<NF, RANGE+1> returntype;
 return returntype(-internal_value,true);
  }
  
  
  template<int8_t _NI, int8_t _NF, uint64_t _RANGE>
  constexpr FixMathPrivate::SFixByRange_t<NF+_NF, RANGE*_RANGE> operator* (const SFix<_NI,_NF,_RANGE>& op) const
  {
    typedef FixMathPrivate::SFixByRange_t<NF+_NF, RANGE*_RANGE> worktype;
    return worktype((typename worktype::internal_type)(internal_value)*op.asRaw(), true);
  }
 
  template<int8_t _NI, int8_t _NF, uint64_t _RANGE>
  constexpr FixMathPrivate::SFixByRange_t<NF+_NF, RANGE*_RANGE> operator* (const UFix<_NI,_NF,_RANGE>& op2) const
  {
    return op2*(*this);
  }
 
#ifdef FIXMATH_UNSAFE
  template<typename T>
  constexpr SFix<NI,NF> operator* (const T op) const
  {
    return SFix<NI,NF>(internal_value*op,true);
  }
#endif
 
 
 
  constexpr SFix<NF,NI> invFast() const
  {
    static_assert(NI+NF<=63, "The fast inverse cannot be computed for when NI+NF>63. Reduce the number of bits.");
    return SFix<NF,NI>((onesbitmask()/internal_value),true);
  }
 
  template<int8_t _NF>
  constexpr SFix<NF,_NF> inv() const
  {
    return SFix<_NF,NF>(internal_value,true).invFast();  
  }
 
  constexpr SFix<NF,FixMathPrivate::FM_min(NI*2+NF,63-NF)> invFull() const
  {
    return inv<NI*2+NF>();
  }
 
 
  template<int8_t _NF=FixMathPrivate::FM_min(NI*2+NF-1,63-NF)>
  constexpr SFix<NF,_NF> invAccurate() const
  {
    static_assert(NF+_NF+1<=63, "The accurate inverse cannot be computed because the asked precision is too great. Reduce the number of bits.");
    return SFix<NF,_NF>(SFix<NF,_NF+1>::msbone()/internal_value,true);
    }
 
 
 
  constexpr SFix<NI,NF> operator>> (const int8_t op) const
  {
    return SFix<NI,NF>(internal_value>>op,true);
  }
 
#ifdef FIXMATH_UNSAFE
  constexpr SFix<NI,NF> operator<< (const int8_t op) const
  {
    return SFix<NI,NF>(internal_value<<op,true);
  }
#endif
 
  template<int8_t op>
  constexpr SFix<FixMathPrivate::FM_max(NI-op,0), NF+op, FixMathPrivate::rangeShift(NI,op,RANGE)> sR()
  {
    return SFix<FixMathPrivate::FM_max(NI-op,0),NF+op,FixMathPrivate::rangeShift(NI,op,RANGE)>(internal_value,true);
  }
 
  template<int8_t op>
  constexpr SFix<NI+op,FixMathPrivate::FM_max(NF-op,0),FixMathPrivate::rangeShift(NF,op,RANGE)> sL()
  {
    return SFix<NI+op,FixMathPrivate::FM_max(NF-op,0)>(internal_value,true);
  }
 
 
 
  template<int8_t _NI, int8_t _NF>
  constexpr bool operator> (const SFix<_NI,_NF>& op) const
  {
    using namespace FixMathPrivate;
    typedef SFix<FM_max(NI, _NI), FM_max(NF, _NF)> comptype; // common type suitable for comparison
    return comptype(*this).asRaw()>comptype(op).asRaw();
  }
 
  template<int8_t _NI, int8_t _NF>
  constexpr bool operator< (const SFix<_NI,_NF>& op) const
  {
    return op > *this;
  }
 
 
  template<int8_t _NI, int8_t _NF>
  constexpr bool operator== (const SFix<_NI,_NF>& op) const
  {
    using namespace FixMathPrivate;
    typedef SFix<FM_max(NI, _NI), FM_max(NF, _NF)> comptype; // common type suitable for comparison
    return comptype(*this).asRaw()==comptype(op).asRaw();
  }
 
  template<int8_t _NI, int8_t _NF>
  constexpr bool operator!= (const SFix<_NI,_NF>& op) const
  {
    typedef SFix<FixMathPrivate::FM_max(NI, _NI), FixMathPrivate::FM_max(NF, _NF)> comptype; // common type suitable for comparison
    return comptype(*this).asRaw()!=comptype(op).asRaw();
  }
 
 
  constexpr UFix<NI,NF,RANGE> asUFix() const
  {
    return UFix<NI,NF,RANGE>(internal_value,true);
  }
  
 
  constexpr float asFloat() const {return (static_cast<float>(internal_value)) / (next_greater_type(1)<<NF); }
 
  constexpr typename IntegerType<FixMathPrivate::sBitsToBytes(NI+1)>::signed_type asInt() const // the +1 is to ensure that no overflow occurs at the lower end of the container (ie when getting the integer part of SFix<7,N>(-128.4), which is a valid SFix<7,N>) because the floor is done towards negative values.
  {
    SFix<NI+1,0> integer_part(*this);
    return integer_part.asRaw();
  }
  
  constexpr internal_type asRaw() const {return internal_value; }
 
  static constexpr int8_t getNI() {return NI;}
 
  static constexpr int8_t getNF() {return NF;}
 
  static constexpr int8_t getRANGE() {return RANGE;}
  
 
  template<int8_t BITS> static constexpr void assertSize() { static_assert(NI+NF+1 <= BITS, "Data type is larger than expected!"); }
private:
  template<int8_t, int8_t, uint64_t> friend class UFix;  // for access to internal_type
  template<int8_t, int8_t, uint64_t> friend class SFix;
 
  internal_type internal_value;
  //static constexpr internal_type onesbitmask() { return (internal_type) ((1ULL<< (NI+NF)) - 1); }
  static constexpr internal_type onesbitmask() { return (internal_type) ((1ULL<< (NI+NF-1)) + ((1ULL<< (NI+NF-1)) - 1)); }
  static constexpr internal_type msbone() { return (internal_type) (1ULL<< (NI+NF-1)); }
};
 
 
#ifdef FIXMATH_UNSAFE
 
// Multiplication
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator*(uint8_t op, const SFix<NI, NF>& uf) {return uf*op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator*(uint16_t op, const SFix<NI, NF>& uf) {return uf*op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator*(uint32_t op, const SFix<NI, NF>& uf) {return uf*op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator*(uint64_t op, const SFix<NI, NF>& uf) {return uf*op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator*(int8_t op, const SFix<NI, NF>& uf) {return uf*op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator*(int16_t op, const SFix<NI, NF>& uf) {return uf*op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator*(int32_t op, const SFix<NI, NF>& uf) {return uf*op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator*(int64_t op, const SFix<NI, NF>& uf) {return uf*op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator*(float op, const SFix<NI, NF>& uf) {return uf*op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator*(double op, const SFix<NI, NF>& uf) {return uf*op;}
 
// Addition
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator+(uint8_t op, const SFix<NI, NF>& uf) {return uf+op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator+(uint16_t op, const SFix<NI, NF>& uf) {return uf+op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator+(uint32_t op, const SFix<NI, NF>& uf) {return uf+op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator+(uint64_t op, const SFix<NI, NF>& uf) {return uf+op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator+(int8_t op, const SFix<NI, NF>& uf) {return uf+op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator+(int16_t op, const SFix<NI, NF>& uf) {return uf+op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator+(int32_t op, const SFix<NI, NF>& uf) {return uf+op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator+(int64_t op, const SFix<NI, NF>& uf) {return uf+op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator+(float op, const SFix<NI, NF>& uf) {return uf+op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator+(double op, const SFix<NI, NF>& uf) {return uf+op;}
 
// Substraction
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator-(uint8_t op, const SFix<NI, NF>& uf) {return (-uf)+op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator-(uint16_t op, const SFix<NI, NF>& uf) {return (-uf)+op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator-(uint32_t op, const SFix<NI, NF>& uf) {return (-uf)+op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator-(uint64_t op, const SFix<NI, NF>& uf) {return (-uf)+op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator-(int8_t op, const SFix<NI, NF>& uf) {return (-uf)+op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator-(int16_t op, const SFix<NI, NF>& uf) {return (-uf)+op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator-(int32_t op, const SFix<NI, NF>& uf) {return (-uf)+op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator-(int64_t op, const SFix<NI, NF>& uf) {return (-uf)+op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator-(float op, const SFix<NI, NF>& uf) {return (-uf)+op;}
 
template <int8_t NI, int8_t NF>
constexpr SFix<NI, NF> operator-(double op, const SFix<NI, NF>& uf) {return (-uf)+op;}
 
#endif
 
 
 
 
 
// Comparison between SFix and UFix
 
template<int8_t NI, int8_t NF, int8_t _NI, int8_t _NF>
constexpr bool operator> (const SFix<NI,NF>& op1, const UFix<_NI,_NF>& op2 )
{
  typedef SFix<FixMathPrivate::FM_max(NI, _NI), FixMathPrivate::FM_max(NF, _NF)> worktype;
  return worktype(op1).asRaw() > worktype(op2).asRaw();
}
 
template<int8_t NI, int8_t NF, int8_t _NI, int8_t _NF>
constexpr bool operator> (const UFix<NI,NF>& op1, const SFix<_NI,_NF>& op2 )
{
  typedef SFix<FixMathPrivate::FM_max(NI, _NI), FixMathPrivate::FM_max(NF, _NF)> worktype;
  return worktype(op1).asRaw() > worktype(op2).asRaw();
}
 
template<int8_t NI, int8_t NF, int8_t _NI, int8_t _NF>
constexpr bool operator< (const UFix<NI,NF>& op1, const SFix<_NI,_NF>& op2 )
{
  return op2 > op1;
}
 
 
template<int8_t NI, int8_t NF, int8_t _NI, int8_t _NF>
constexpr bool operator< (const SFix<NI,NF>& op1, const UFix<_NI,_NF>& op2 )
{
  return op2 > op1;
}
 
 
template<int8_t NI, int8_t NF, int8_t _NI, int8_t _NF>
constexpr bool operator== (const SFix<NI,NF>& op1, const UFix<_NI,_NF>& op2)
{
  typedef SFix<FixMathPrivate::FM_max(NI, _NI), FixMathPrivate::FM_max(NF, _NF)> worktype;
  return (worktype(op1).asRaw() == worktype(op2).asRaw());
}
 
 
template<int8_t NI, int8_t NF, int8_t _NI, int8_t _NF>
constexpr bool operator== (const UFix<NI,NF>& op1, const SFix<_NI,_NF>& op2 )
{
  return op2 == op1;
}
 
template<int8_t NI, int8_t NF, int8_t _NI, int8_t _NF>
constexpr bool operator!= (const SFix<NI,NF>& op1, const UFix<_NI,_NF>& op2 )
{
  return !(op1 == op2);
}
 
 
template<int8_t NI, int8_t NF, int8_t _NI, int8_t _NF>
constexpr bool operator!= (const UFix<NI,NF>& op1, const SFix<_NI,_NF>& op2 )
{
  typedef SFix<FixMathPrivate::FM_max(NI, _NI), FixMathPrivate::FM_max(NF, _NF)> comptype;
  return (comptype(op1).asRaw() != comptype(op2).asRaw());;
}
 
 
 
template<typename T>
constexpr SFix<0, sizeof(T)*8-1> toSFraction(T val) {
  return SFix<0, sizeof(T)*8-1>::fromRaw(val); 
}
 
template<typename T>
constexpr SFix<sizeof(T)*8-1,0> toSInt(T val) {
  return SFix<sizeof(T)*8-1,0>::fromRaw(val); 
}
 
template<int64_t value>
constexpr const FixMathPrivate::SFixByRange_t<0, value < 0 ? -value : value+1> SFixAuto() {
  return FixMathPrivate::SFixByRange_t<0, value < 0 ? -value : value+1>::fromRaw(value);
}
 
#include "FixMath_Autotests.h"
 
 
#endif