00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013 #pragma once
00014
00015 #ifndef __DYADIC__
00016 #define __DYADIC__
00017
00018
00019 #include <cmath>
00020 #include <limits.h>
00021
00023
00026 class dyadic
00027 {
00028 public:
00029
00030 dyadic(void)
00031 : k(0)
00032 , n(0)
00033 {
00034 }
00035
00036 dyadic(const int k1, const int n1)
00037 : k(k1)
00038 , n(n1)
00039 {
00040 }
00041
00042 ~dyadic(void)
00043 {
00044 }
00045
00047 int k;
00049 int n;
00050
00052 operator double() const
00053 {
00054 return ldexp((double)k,-n);
00055 }
00056
00060 explicit dyadic(const double Arg, const unsigned int RelativeTolerance = 1024)
00061 {
00062 if (Arg==0)
00063 {
00064 n=INT_MAX;
00065 k=0;
00066 }
00067 else
00068 {
00069 int index = RelativeTolerance;
00070 double temp = frexp(Arg,&n);
00071 n = - n;
00072 k = (int) floor(ldexp(temp,index));
00073 n+=index;
00074 }
00075 }
00076
00078 dyadic & move_forward(const unsigned int Arg)
00079 {
00080 k+=Arg;
00081 return *this;
00082 }
00083
00085 dyadic & operator ++ ()
00086 {
00087 ++k;
00088 return *this;
00089 }
00090
00092 dyadic operator ++ (int )
00093 {
00094 dyadic temp = *this;
00095 ++*this;
00096 return temp;
00097 }
00098
00100 dyadic & operator -- ()
00101 {
00102 --k;
00103 return *this;
00104 }
00105
00107 dyadic operator -- (int )
00108 {
00109 dyadic temp = *this;
00110 --*this;
00111 return temp;
00112 }
00113
00115 dyadic operator + (const dyadic & Arg) const
00116 {
00117 dyadic Ans;
00118 return (n <= Arg.n)? dyadic(k + (Arg.k << (Arg.n-n)),n) : dyadic(Arg.k + (k << (n-Arg.n),Arg.n));
00119 }
00120 dyadic & operator += (const dyadic & Arg)
00121 {
00122 return *this=(*this + Arg);
00123 }
00124 dyadic operator - (const dyadic & Arg) const
00125 {
00126 dyadic Ans;
00127 return (n <= Arg.n)? dyadic(k - (Arg.k << (Arg.n-n)),n) : dyadic(((k << (n-Arg.n))- Arg.k,Arg.n));
00128 }
00129 dyadic & operator -= (const dyadic & Arg)
00130 {
00131 return *this=(*this - Arg);
00132 }
00133 bool operator < (const dyadic & Arg) const
00134 {
00135 return (n <= Arg.n)? (k < (Arg.k << (Arg.n-n))) : (k << (n-Arg.n))< Arg.k;
00136 }
00137 bool operator > (const dyadic & Arg) const
00138 {
00139 return (n <= Arg.n)? (k > (Arg.k << (Arg.n-n))) : (k << (n-Arg.n))> Arg.k;
00140 }
00141
00142 };
00143
00144 #endif // __DYADIC__