src/base/FBaseFloat.cpp

   1 //
   2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Apache License, Version 2.0 (the License);
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://www.apache.org/licenses/LICENSE-2.0
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an "AS IS" BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 //
  16
  17 /**
  18  * @file                FBaseFloat.cpp
  19  * @brief               This is the implementation file for Float class.
  20  * @see         Number class
  21  */
  22 #include <cfloat>
  23 #include <math.h>
  24 #include <stdio.h>
  25 #include <wchar.h>
  26 #include <errno.h>
  27 #include <limits.h>
  28 #include <FBaseFloat.h>
  29 #include <FBaseResult.h>
  30 #include <FBaseSysLog.h>
  31 #include "FBase_LocalizedNumParser.h"
  32
  33 namespace Tizen { namespace Base
  34 {
  35
  36 union FloatBitRep
  37 {
  38         explicit
  39         FloatBitRep(float f = 0.0)
  40                 : value(f)
  41         {
  42         };
  43
  44         FloatBitRep(unsigned int i)
  45                 : rep(i)
  46         {
  47         };
  48
  49         float value;
  50         unsigned int rep;
  51 };
  52
  53 Float::Float(float value)
  54         : value(value)
  55         , __pFloatImpl(null)
  56 {
  57 }
  58
  59 Float::Float(const Float& value)
  60         : value(value.value)
  61         , __pFloatImpl(null)
  62 {
  63 }
  64
  65 Float::~Float(void)
  66 {
  67 }
  68
  69 Float&
  70 Float::operator =(const Float& rhs)
  71 {
  72         if (&rhs != this)
  73         {
  74                 value = rhs.value;
  75         }
  76         return *this;
  77 }
  78
  79 int
  80 Float::Compare(float f1, float f2)
  81 {
  82         int ret = 0;
  83
  84         if (f1 > f2)
  85         {
  86                 ret = 1;
  87         }
  88         else if (f1 < f2)
  89         {
  90                 ret = -1;
  91         }
  92         else
  93         {
  94                 ret = 0;
  95         }
  96
  97         return ret;
  98 }
  99
 100 int
 101 Float::CompareTo(const Float& value) const
 102 {
 103         return(Float::Compare(this->value, value.value));
 104 }
 105
 106 bool
 107 Float::Equals(const Object& obj) const
 108 {
 109         const Float* pOther = dynamic_cast< const Float* >(&obj);
 110
 111         if (pOther == null)
 112         {
 113                 return false;
 114         }
 115
 116         if (Float::Compare(this->value, (*pOther).value) == 0)
 117         {
 118                 return true;
 119         }
 120         else
 121         {
 122                 return false;
 123         }
 124 }
 125
 126 int
 127 Float::GetHashCode(void) const
 128 {
 129         float* pTemp = const_cast< float* >(&value);
 130         int* pValue = reinterpret_cast< int* >(pTemp);
 131         return *pValue;
 132 }
 133
 134 int
 135 Float::GetHashCode(float val)
 136 {
 137         int* pValue = reinterpret_cast< int* >(&val);
 138         return *pValue;
 139 }
 140
 141 result
 142 Float::Parse(const String& s, float& ret)
 143 {
 144         double tmpRet = _LocalizedNumParser::ToFloat(s, "");
 145
 146         if (IsNaN(tmpRet))
 147         {
 148                 result r = GetLastResult();
 149                 SysLogException(NID_BASE, r, "[%s] Propagating.", GetErrorMessage(r));
 150                 return r;
 151         }
 152
 153         ret = tmpRet;
 154         return E_SUCCESS;
 155 }
 156
 157 char
 158 Float::ToChar(void) const
 159 {
 160         return static_cast< char >(value);
 161 }
 162
 163 short
 164 Float::ToShort(void) const
 165 {
 166         return static_cast< short >(value);
 167 }
 168
 169 int
 170 Float::ToInt(void) const
 171 {
 172         return static_cast< int >(value);
 173 }
 174
 175 long
 176 Float::ToLong(void) const
 177 {
 178         return static_cast< long >(value);
 179 }
 180
 181 long long
 182 Float::ToLongLong(void) const
 183 {
 184         return static_cast< long long >(value);
 185 }
 186
 187 float
 188 Float::ToFloat(void) const
 189 {
 190         return value;
 191 }
 192
 193 double
 194 Float::ToDouble(void) const
 195 {
 196         return static_cast< double >(value);
 197 }
 198
 199 String
 200 Float::ToString(void) const
 201 {
 202         return Float::ToString(value);
 203 }
 204
 205 String
 206 Float::ToString(int precision) const
 207 {
 208         return Float::ToString(value, precision);
 209 }
 210
 211 String
 212 Float::ToString(float value)
 213 {
 214         return _LocalizedNumParser::ToString(value, "");
 215 }
 216
 217 String
 218 Float::ToString(float value, int precision)
 219 {
 220         return _LocalizedNumParser::ToString(value, "", precision);
 221 }
 222
 223
 224 int
 225 Float::ToBits(float value)
 226 {
 227         FloatBitRep bitRep;
 228         bitRep.value = value;
 229         return bitRep.rep;
 230 }
 231
 232 float
 233 Float::ToFloatFromBits(int value)
 234 {
 235         FloatBitRep bitRep;
 236         bitRep.rep = value;
 237         return bitRep.value;
 238 }
 239
 240 bool
 241 Float::IsFinite(float value)
 242 {
 243         return isfinite(value);
 244 }
 245
 246 bool
 247 Float::IsInfinity(void) const
 248 {
 249         return Float::IsInfinity(value);
 250 }
 251
 252 bool
 253 Float::IsInfinity(float value)
 254 {
 255         return !Float::IsFinite(value);
 256 }
 257
 258 bool
 259 Float::IsNaN(void) const
 260 {
 261         return Float::IsNaN(value);
 262 }
 263
 264 bool
 265 Float::IsNaN(float value)
 266 {
 267         return isnan(value);
 268 }
 269
 270 float
 271 Float::GetMaxValue(void)
 272 {
 273         return FLT_MAX;
 274 }
 275
 276 float
 277 Float::GetMinValue(void)
 278 {
 279         return FLT_MIN;
 280 }
 281
 282 }} // Tizen::Base