KDIS/KDIS/DataTypes/KFIXED.cpp

   1 /*********************************************************************
   2 Copyright 2013 Karl Jones
   3 All rights reserved.
   4
   5 Redistribution and use in source and binary forms, with or without
   6 modification, are permitted provided that the following conditions are met:
   7
   8 1. Redistributions of source code must retain the above copyright notice, this
   9    list of conditions and the following disclaimer.
  10 2. Redistributions in binary form must reproduce the above copyright notice,
  11    this list of conditions and the following disclaimer in the documentation
  12    and/or other materials provided with the distribution.
  13
  14 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  15 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  16 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  17 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
  18 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  19 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  20 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  21 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  23 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24
  25 For Further Information Please Contact me at
  26 Karljj1@yahoo.com
  27 http://p.sf.net/kdis/UserGuide
  28 *********************************************************************/
  29
  30 #include "./KFIXED.h"
  31
  32 using namespace KDIS;
  33 using namespace DATA_TYPE;
  34
  35 /**
  36  *  [n].[m] digit fixed point binary number:
  37  *
  38  *      records fractions of integer values to precision [m] binary places
  39  *
  40  *  stored value (using integer container) = (int or float rhs) * 2^m
  41  *
  42  *  "2^m" is equivalent to "1 << m" which is can be literal constant.
  43  *
  44  *  Such code is used at many points in this file.
  45  */
  46
  47 //////////////////////////////////////////////////////////////////////////
  48 // protected:
  49 //////////////////////////////////////////////////////////////////////////
  50
  51 template<class Type, KUINT8 BinaryPoint>
  52 Type KFIXED<Type, BinaryPoint>::convert( KFLOAT32 V ) const
  53 {
  54     return V * ( 1 << BinaryPoint );
  55 }
  56
  57 //////////////////////////////////////////////////////////////////////////
  58
  59 template<class Type, KUINT8 BinaryPoint>
  60 Type KFIXED<Type, BinaryPoint>::convert( KFLOAT64 V ) const
  61 {
  62     return V * ( 1 << BinaryPoint );
  63 }
  64
  65 //////////////////////////////////////////////////////////////////////////
  66 // public:
  67 //////////////////////////////////////////////////////////////////////////
  68
  69 template<class Type, KUINT8 BinaryPoint>
  70 KFIXED<Type, BinaryPoint>::KFIXED() :
  71     m_Val( 0 )
  72 {
  73 }
  74
  75 //////////////////////////////////////////////////////////////////////////
  76
  77 template<class Type, KUINT8 BinaryPoint>
  78 KFIXED<Type, BinaryPoint>::KFIXED( KFLOAT32 V ) :
  79     m_Val( convert( V ) )
  80 {
  81 }
  82
  83 //////////////////////////////////////////////////////////////////////////
  84
  85 template<class Type, KUINT8 BinaryPoint>
  86 KFIXED<Type, BinaryPoint>::KFIXED( KFLOAT64 V ) :
  87     m_Val( convert( V ) )
  88 {
  89 }
  90
  91 //////////////////////////////////////////////////////////////////////////
  92
  93 template<class Type, KUINT8 BinaryPoint>
  94 KFIXED<Type, BinaryPoint>::KFIXED( Type V ) :
  95     m_Val( V )
  96 {
  97 }
  98
  99 //////////////////////////////////////////////////////////////////////////
 100
 101 template<class Type, KUINT8 BinaryPoint>
 102 KFIXED<Type, BinaryPoint>::KFIXED( KDataStream & stream )
 103 {
 104     Decode( stream );
 105 }
 106
 107 //////////////////////////////////////////////////////////////////////////
 108
 109 template<class Type, KUINT8 BinaryPoint>
 110 KFIXED<Type, BinaryPoint>::~KFIXED()
 111 {
 112 }
 113
 114 //////////////////////////////////////////////////////////////////////////
 115
 116 template<class Type, KUINT8 BinaryPoint>
 117 void KFIXED<Type, BinaryPoint>::Set( KFLOAT32 V )
 118 {
 119     m_Val = convert( V );
 120 }
 121
 122 //////////////////////////////////////////////////////////////////////////
 123
 124 template<class Type, KUINT8 BinaryPoint>
 125 void KFIXED<Type, BinaryPoint>::Set( KFLOAT64 V )
 126 {
 127     m_Val = convert( V );
 128 }
 129
 130 //////////////////////////////////////////////////////////////////////////
 131
 132 template<class Type, KUINT8 BinaryPoint>
 133 void KFIXED<Type, BinaryPoint>::Set( Type V )
 134 {
 135     m_Val = V ;
 136 }
 137
 138 //////////////////////////////////////////////////////////////////////////
 139
 140 template<class Type, KUINT8 BinaryPoint>
 141 Type KFIXED<Type, BinaryPoint>::Get() const
 142 {
 143     return m_Val;
 144 }
 145
 146 //////////////////////////////////////////////////////////////////////////
 147
 148 template<class Type, KUINT8 BinaryPoint>
 149 KFLOAT32 KFIXED<Type, BinaryPoint>::GetAsFloat32() const
 150 {
 151     return  m_Val * ( 1.0 / ( 1 << BinaryPoint ) );
 152 }
 153
 154 //////////////////////////////////////////////////////////////////////////
 155
 156 template<class Type, KUINT8 BinaryPoint>
 157 KString KFIXED<Type, BinaryPoint>::GetAsString() const
 158 {
 159     KStringStream ss;
 160
 161     ss << GetAsFloat32() << "\n";
 162
 163     return ss.str();
 164 }
 165
 166 //////////////////////////////////////////////////////////////////////////
 167
 168 template<class Type, KUINT8 BinaryPoint>
 169 void KFIXED<Type, BinaryPoint>::Decode( KDataStream & stream )
 170 {
 171     if( stream.GetBufferSize() < sizeof( Type ) )throw KException( __FUNCTION__, NOT_ENOUGH_DATA_IN_BUFFER );
 172
 173     stream >> m_Val;
 174 }
 175
 176 //////////////////////////////////////////////////////////////////////////
 177
 178 template<class Type, KUINT8 BinaryPoint>
 179 KDataStream KFIXED<Type, BinaryPoint>::Encode() const
 180 {
 181     KDataStream stream;
 182
 183     KFIXED<Type, BinaryPoint>::Encode( stream );
 184
 185     return stream;
 186 }
 187
 188 //////////////////////////////////////////////////////////////////////////
 189
 190 template<class Type, KUINT8 BinaryPoint>
 191 void KFIXED<Type, BinaryPoint>::Encode( KDataStream & stream ) const
 192 {
 193     stream << m_Val;
 194 }
 195
 196 //////////////////////////////////////////////////////////////////////////
 197 // operators:
 198 //////////////////////////////////////////////////////////////////////////
 199
 200 // Some macros to reduce the code a little
 201
 202 // DEFINE_OPERATOR ******************************************************************************************
 203 #define DEFINE_OPERATOR( OPERATOR )                                                                         \
 204                                                                                                             \
 205 template<class Type, KUINT8 BinaryPoint>                                                                    \
 206 KFIXED<Type, BinaryPoint> KFIXED<Type, BinaryPoint>::operator OPERATOR ( KFLOAT32 Value )                   \
 207 {                                                                                                           \
 208     return GetAsFloat32() OPERATOR Value;                                                                   \
 209 }                                                                                                           \
 210                                                                                                             \
 211 template<class Type, KUINT8 BinaryPoint>                                                                    \
 212 KFIXED<Type, BinaryPoint> KFIXED<Type, BinaryPoint>::operator OPERATOR ( KFLOAT64 Value )                   \
 213 {                                                                                                           \
 214     return GetAsFloat32() OPERATOR Value;                                                                   \
 215 }                                                                                                           \
 216                                                                                                             \
 217 template<class Type, KUINT8 BinaryPoint>                                                                    \
 218 KFIXED<Type, BinaryPoint> KFIXED<Type, BinaryPoint>::operator OPERATOR ( Type Value )                       \
 219 {                                                                                                           \
 220     return *this OPERATOR KFIXED( Value ).GetAsFloat32();                                                   \
 221 }                                                                                                           \
 222                                                                                                             \
 223 template<class Type, KUINT8 BinaryPoint>                                                                    \
 224 KFIXED<Type, BinaryPoint> KFIXED<Type, BinaryPoint>::operator OPERATOR ( KFIXED<Type, BinaryPoint> Value )  \
 225 {                                                                                                           \
 226     return GetAsFloat32() OPERATOR Value.GetAsFloat32();                                                    \
 227 }
 228
 229 // DEFINE_COMPARISION_OPERATOR ******************************************************************************
 230 #define DEFINE_COMPARISION_OPERATOR( OPERATOR )                                                             \
 231                                                                                                             \
 232 template<class Type, KUINT8 BinaryPoint>                                                                    \
 233 KBOOL KFIXED<Type, BinaryPoint>::operator OPERATOR ( KFLOAT32 Value ) const                                 \
 234 {                                                                                                           \
 235     return m_Val OPERATOR convert( Value );                                                                 \
 236 }                                                                                                           \
 237                                                                                                             \
 238 template<class Type, KUINT8 BinaryPoint>                                                                    \
 239 KBOOL KFIXED<Type, BinaryPoint>::operator OPERATOR ( KFLOAT64 Value ) const                                 \
 240 {                                                                                                           \
 241     return m_Val OPERATOR convert( Value );                                                                 \
 242 }                                                                                                           \
 243                                                                                                             \
 244 template<class Type, KUINT8 BinaryPoint>                                                                    \
 245 KBOOL KFIXED<Type, BinaryPoint>::operator OPERATOR ( Type Value ) const                                     \
 246 {                                                                                                           \
 247     return m_Val OPERATOR m_Val;                                                                            \
 248 }                                                                                                           \
 249                                                                                                             \
 250 template<class Type, KUINT8 BinaryPoint>                                                                    \
 251 KBOOL KFIXED<Type, BinaryPoint>::operator OPERATOR ( KFIXED<Type, BinaryPoint> Value ) const                \
 252 {                                                                                                           \
 253     return m_Val OPERATOR Value.m_Val;                                                                      \
 254 }
 255
 256 //***************************** End Macros ******************************************************************
 257
 258 template<class Type, KUINT8 BinaryPoint>
 259 KFIXED<Type, BinaryPoint> KFIXED<Type, BinaryPoint>::operator = ( KFLOAT32 Value )
 260 {
 261     m_Val = convert( Value );
 262     return *this;
 263 }
 264
 265 //////////////////////////////////////////////////////////////////////////
 266
 267 template<class Type, KUINT8 BinaryPoint>
 268 KFIXED<Type, BinaryPoint> KFIXED<Type, BinaryPoint>::operator = ( KFLOAT64 Value )
 269 {
 270     m_Val = convert( Value );
 271     return *this;
 272 }
 273
 274 //////////////////////////////////////////////////////////////////////////
 275
 276 template<class Type, KUINT8 BinaryPoint>
 277 KFIXED<Type, BinaryPoint> KFIXED<Type, BinaryPoint>::operator = ( Type Value )
 278 {
 279     m_Val = Value;
 280     return *this;
 281 }
 282
 283 //////////////////////////////////////////////////////////////////////////
 284
 285 template<class Type, KUINT8 BinaryPoint>
 286 KFIXED<Type, BinaryPoint> KFIXED<Type, BinaryPoint>::operator = ( KFIXED<Type, BinaryPoint> Value )
 287 {
 288     m_Val = Value.m_Val;
 289     return *this;
 290 }
 291
 292 //////////////////////////////////////////////////////////////////////////
 293
 294 DEFINE_OPERATOR( + )
 295 DEFINE_OPERATOR( - )
 296 DEFINE_OPERATOR( * )
 297 DEFINE_OPERATOR( / )
 298
 299 //////////////////////////////////////////////////////////////////////////
 300
 301 DEFINE_COMPARISION_OPERATOR( == )
 302 DEFINE_COMPARISION_OPERATOR( != )
 303 DEFINE_COMPARISION_OPERATOR( < )
 304 DEFINE_COMPARISION_OPERATOR( <= )
 305 DEFINE_COMPARISION_OPERATOR( > )
 306 DEFINE_COMPARISION_OPERATOR( >= )
 307
 308 //////////////////////////////////////////////////////////////////////////
 309
 310 template<class Type, KUINT8 BinaryPoint>
 311 KFIXED<Type, BinaryPoint>::operator KFLOAT32 () const
 312 {
 313     return GetAsFloat32();
 314 }
 315
 316 //////////////////////////////////////////////////////////////////////////
 317
 318 template<class Type, KUINT8 BinaryPoint>
 319 KFIXED<Type, BinaryPoint>::operator Type () const
 320 {
 321     return m_Val;
 322 }
 323
 324 //////////////////////////////////////////////////////////////////////////
 325
 326 // When using a template class with implementation in a cpp file, linker
 327 // errors will occur if you do not pre-declare the template types in that same file.
 328 // This is good for us in this case as we only need to support a binary point of 3 and 8.
 329 // If you do wish to add support for other binary point positions then simply add them
 330 // below and re-compile.
 331
 332 template class KDIS::DATA_TYPE::KFIXED<KINT16, 3>;
 333 template class KDIS::DATA_TYPE::KFIXED<KINT16, 8>;
 334 template class KDIS::DATA_TYPE::KFIXED<KINT8, 3>;