sal/inc/rtl/math.hxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: math.hxx,v $
  10  * $Revision: 1.8 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #if !defined INCLUDED_RTL_MATH_HXX
  32 #define INCLUDED_RTL_MATH_HXX
  33
  34 #include "rtl/math.h"
  35 #include "rtl/string.hxx"
  36 #include "rtl/ustring.hxx"
  37 #include "rtl/ustrbuf.hxx"
  38 #include "sal/mathconf.h"
  39 #include "sal/types.h"
  40
  41 #include <math.h>
  42
  43 namespace rtl {
  44
  45 namespace math {
  46
  47 /** A wrapper around rtl_math_doubleToString.
  48  */
  49 inline rtl::OString doubleToString(double fValue, rtl_math_StringFormat eFormat,
  50                                    sal_Int32 nDecPlaces,
  51                                    sal_Char cDecSeparator,
  52                                    sal_Int32 const * pGroups,
  53                                    sal_Char cGroupSeparator,
  54                                    bool bEraseTrailingDecZeros = false)
  55 {
  56     rtl::OString aResult;
  57     rtl_math_doubleToString(&aResult.pData, 0, 0, fValue, eFormat, nDecPlaces,
  58                             cDecSeparator, pGroups, cGroupSeparator,
  59                             bEraseTrailingDecZeros);
  60     return aResult;
  61 }
  62
  63 /** A wrapper around rtl_math_doubleToString, with no grouping.
  64  */
  65 inline rtl::OString doubleToString(double fValue, rtl_math_StringFormat eFormat,
  66                                    sal_Int32 nDecPlaces,
  67                                    sal_Char cDecSeparator,
  68                                    bool bEraseTrailingDecZeros = false)
  69 {
  70     rtl::OString aResult;
  71     rtl_math_doubleToString(&aResult.pData, 0, 0, fValue, eFormat, nDecPlaces,
  72                             cDecSeparator, 0, 0, bEraseTrailingDecZeros);
  73     return aResult;
  74 }
  75
  76 /** A wrapper around rtl_math_doubleToUString.
  77  */
  78 inline rtl::OUString doubleToUString(double fValue,
  79                                      rtl_math_StringFormat eFormat,
  80                                      sal_Int32 nDecPlaces,
  81                                      sal_Unicode cDecSeparator,
  82                                      sal_Int32 const * pGroups,
  83                                      sal_Unicode cGroupSeparator,
  84                                      bool bEraseTrailingDecZeros = false)
  85 {
  86     rtl::OUString aResult;
  87     rtl_math_doubleToUString(&aResult.pData, 0, 0, fValue, eFormat, nDecPlaces,
  88                              cDecSeparator, pGroups, cGroupSeparator,
  89                              bEraseTrailingDecZeros);
  90     return aResult;
  91 }
  92
  93 /** A wrapper around rtl_math_doubleToUString, with no grouping.
  94  */
  95 inline rtl::OUString doubleToUString(double fValue,
  96                                      rtl_math_StringFormat eFormat,
  97                                      sal_Int32 nDecPlaces,
  98                                      sal_Unicode cDecSeparator,
  99                                      bool bEraseTrailingDecZeros = false)
 100 {
 101     rtl::OUString aResult;
 102     rtl_math_doubleToUString(&aResult.pData, 0, 0, fValue, eFormat, nDecPlaces,
 103                              cDecSeparator, 0, 0, bEraseTrailingDecZeros);
 104     return aResult;
 105 }
 106
 107 /** A wrapper around rtl_math_doubleToUString that appends to an
 108     rtl::OUStringBuffer.
 109  */
 110 inline void doubleToUStringBuffer( rtl::OUStringBuffer& rBuffer, double fValue,
 111                                    rtl_math_StringFormat eFormat,
 112                                    sal_Int32 nDecPlaces,
 113                                    sal_Unicode cDecSeparator,
 114                                    sal_Int32 const * pGroups,
 115                                    sal_Unicode cGroupSeparator,
 116                                    bool bEraseTrailingDecZeros = false)
 117 {
 118     rtl_uString ** pData;
 119     sal_Int32 * pCapacity;
 120     rBuffer.accessInternals( &pData, &pCapacity );
 121     rtl_math_doubleToUString( pData, pCapacity, rBuffer.getLength(), fValue,
 122                               eFormat, nDecPlaces, cDecSeparator, pGroups,
 123                               cGroupSeparator, bEraseTrailingDecZeros);
 124 }
 125
 126 /** A wrapper around rtl_math_doubleToUString that appends to an
 127     rtl::OUStringBuffer, with no grouping.
 128  */
 129 inline void doubleToUStringBuffer( rtl::OUStringBuffer& rBuffer, double fValue,
 130                                    rtl_math_StringFormat eFormat,
 131                                    sal_Int32 nDecPlaces,
 132                                    sal_Unicode cDecSeparator,
 133                                    bool bEraseTrailingDecZeros = false)
 134 {
 135     rtl_uString ** pData;
 136     sal_Int32 * pCapacity;
 137     rBuffer.accessInternals( &pData, &pCapacity );
 138     rtl_math_doubleToUString( pData, pCapacity, rBuffer.getLength(), fValue,
 139                               eFormat, nDecPlaces, cDecSeparator, 0, 0,
 140                               bEraseTrailingDecZeros);
 141 }
 142
 143 /** A wrapper around rtl_math_stringToDouble.
 144  */
 145 inline double stringToDouble(rtl::OString const & rString,
 146                              sal_Char cDecSeparator, sal_Char cGroupSeparator,
 147                              rtl_math_ConversionStatus * pStatus,
 148                              sal_Int32 * pParsedEnd)
 149 {
 150     sal_Char const * pBegin = rString.getStr();
 151     sal_Char const * pEnd;
 152     double fResult = rtl_math_stringToDouble(pBegin,
 153                                              pBegin + rString.getLength(),
 154                                              cDecSeparator, cGroupSeparator,
 155                                              pStatus, &pEnd);
 156     if (pParsedEnd != 0)
 157         *pParsedEnd = (sal_Int32)(pEnd - pBegin);
 158     return fResult;
 159 }
 160
 161 /** A wrapper around rtl_math_uStringToDouble.
 162  */
 163 inline double stringToDouble(rtl::OUString const & rString,
 164                              sal_Unicode cDecSeparator,
 165                              sal_Unicode cGroupSeparator,
 166                              rtl_math_ConversionStatus * pStatus,
 167                              sal_Int32 * pParsedEnd)
 168 {
 169     sal_Unicode const * pBegin = rString.getStr();
 170     sal_Unicode const * pEnd;
 171     double fResult = rtl_math_uStringToDouble(pBegin,
 172                                               pBegin + rString.getLength(),
 173                                               cDecSeparator, cGroupSeparator,
 174                                               pStatus, &pEnd);
 175     if (pParsedEnd != 0)
 176         *pParsedEnd = (sal_Int32)(pEnd - pBegin);
 177     return fResult;
 178 }
 179
 180 /** A wrapper around rtl_math_round.
 181  */
 182 inline double round(
 183     double fValue, int nDecPlaces = 0,
 184     rtl_math_RoundingMode eMode = rtl_math_RoundingMode_Corrected)
 185 {
 186     return rtl_math_round(fValue, nDecPlaces, eMode);
 187 }
 188
 189 /** A wrapper around rtl_math_pow10Exp.
 190  */
 191 inline double pow10Exp(double fValue, int nExp)
 192 {
 193     return rtl_math_pow10Exp(fValue, nExp);
 194 }
 195
 196 /** A wrapper around rtl_math_approxValue.
 197  */
 198 inline double approxValue(double fValue)
 199 {
 200     return rtl_math_approxValue(fValue);
 201 }
 202
 203 /** A wrapper around rtl_math_expm1.
 204  */
 205 inline double expm1(double fValue)
 206 {
 207     return rtl_math_expm1(fValue);
 208 }
 209
 210 /** A wrapper around rtl_math_log1p.
 211  */
 212 inline double log1p(double fValue)
 213 {
 214     return rtl_math_log1p(fValue);
 215 }
 216
 217 /** A wrapper around rtl_math_atanh.
 218  */
 219 inline double atanh(double fValue)
 220 {
 221     return rtl_math_atanh(fValue);
 222 }
 223
 224 /** A wrapper around rtl_math_erf.
 225  */
 226 inline double erf(double fValue)
 227 {
 228     return rtl_math_erf(fValue);
 229 }
 230
 231 /** A wrapper around rtl_math_erfc.
 232  */
 233 inline double erfc(double fValue)
 234 {
 235     return rtl_math_erfc(fValue);
 236 }
 237
 238 /** A wrapper around rtl_math_asinh.
 239  */
 240 inline double asinh(double fValue)
 241 {
 242     return rtl_math_asinh(fValue);
 243 }
 244
 245 /** A wrapper around rtl_math_acosh.
 246  */
 247 inline double acosh(double fValue)
 248 {
 249     return rtl_math_acosh(fValue);
 250 }
 251
 252
 253 /** Test equality of two values with an accuracy of the magnitude of the
 254     given values scaled by 2^-48 (4 bits roundoff stripped).
 255
 256     @ATTENTION
 257     approxEqual( value!=0.0, 0.0 ) _never_ yields true.
 258  */
 259 inline bool approxEqual(double a, double b)
 260 {
 261     if ( a == b )
 262         return true;
 263     double x = a - b;
 264     return (x < 0.0 ? -x : x)
 265         < ((a < 0.0 ? -a : a) * (1.0 / (16777216.0 * 16777216.0)));
 266 }
 267
 268 /** Add two values.
 269
 270     If signs differ and the absolute values are equal according to approxEqual()
 271     the method returns 0.0 instead of calculating the sum.
 272
 273     If you wanted to sum up multiple values it would be convenient not to call
 274     approxAdd() for each value but instead remember the first value not equal to
 275     0.0, add all other values using normal + operator, and with the result and
 276     the remembered value call approxAdd().
 277  */
 278 inline double approxAdd(double a, double b)
 279 {
 280     if ( ((a < 0.0 && b > 0.0) || (b < 0.0 && a > 0.0))
 281          && approxEqual( a, -b ) )
 282         return 0.0;
 283     return a + b;
 284 }
 285
 286 /** Substract two values (a-b).
 287
 288     If signs are identical and the values are equal according to approxEqual()
 289     the method returns 0.0 instead of calculating the substraction.
 290  */
 291 inline double approxSub(double a, double b)
 292 {
 293     if ( ((a < 0.0 && b < 0.0) || (a > 0.0 && b > 0.0)) && approxEqual( a, b ) )
 294         return 0.0;
 295     return a - b;
 296 }
 297
 298 /** floor() method taking approxValue() into account.
 299
 300     Use for expected integer values being calculated by double functions.
 301  */
 302 inline double approxFloor(double a)
 303 {
 304     return floor( approxValue( a ));
 305 }
 306
 307 /** ceil() method taking approxValue() into account.
 308
 309     Use for expected integer values being calculated by double functions.
 310  */
 311 inline double approxCeil(double a)
 312 {
 313     return ceil( approxValue( a ));
 314 }
 315
 316 /** Tests whether a value is neither INF nor NAN.
 317  */
 318 inline bool isFinite(double d)
 319 {
 320     return SAL_MATH_FINITE(d) != 0;
 321 }
 322
 323 /** If a value represents +INF or -INF.
 324
 325     The sign bit may be queried with isSignBitSet().
 326
 327     If isFinite(d)==false and isInf(d)==false then NAN.
 328  */
 329 inline bool isInf(double d)
 330 {
 331     // exponent==0x7ff fraction==0
 332     return (SAL_MATH_FINITE(d) == 0) &&
 333         (reinterpret_cast< sal_math_Double * >(&d)->inf_parts.fraction_hi == 0)
 334         && (reinterpret_cast< sal_math_Double * >(&d)->inf_parts.fraction_lo
 335             == 0);
 336 }
 337
 338 /** Test on any QNAN or SNAN.
 339  */
 340 inline bool isNan(double d)
 341 {
 342     // exponent==0x7ff fraction!=0
 343     return (SAL_MATH_FINITE(d) == 0) && (
 344         (reinterpret_cast< sal_math_Double * >(&d)->inf_parts.fraction_hi != 0)
 345         || (reinterpret_cast< sal_math_Double * >(&d)->inf_parts.fraction_lo
 346             != 0) );
 347 }
 348
 349 /** If the sign bit is set.
 350  */
 351 inline bool isSignBitSet(double d)
 352 {
 353     return reinterpret_cast< sal_math_Double * >(&d)->inf_parts.sign != 0;
 354 }
 355
 356 /** Set to +INF if bNegative==false or -INF if bNegative==true.
 357  */
 358 inline void setInf(double * pd, bool bNegative)
 359 {
 360     reinterpret_cast< sal_math_Double * >(pd)->w32_parts.msw
 361         = bNegative ? 0xFFF00000 : 0x7FF00000;
 362     reinterpret_cast< sal_math_Double * >(pd)->w32_parts.lsw = 0;
 363 }
 364
 365 /** Set a QNAN.
 366  */
 367 inline void setNan(double * pd)
 368 {
 369     reinterpret_cast< sal_math_Double * >(pd)->w32_parts.msw = 0x7FFFFFFF;
 370     reinterpret_cast< sal_math_Double * >(pd)->w32_parts.lsw = 0xFFFFFFFF;
 371 }
 372
 373 /** If a value is a valid argument for sin(), cos(), tan().
 374
 375     IEEE 754 specifies that absolute values up to 2^64 (=1.844e19) for the
 376     radian must be supported by trigonometric functions.  Unfortunately, at
 377     least on x86 architectures, the FPU doesn't generate an error pattern for
 378     values >2^64 but produces erroneous results instead and sets only the
 379     "invalid operation" (IM) flag in the status word :-(  Thus the application
 380     has to handle it itself.
 381  */
 382 inline bool isValidArcArg(double d)
 383 {
 384     return fabs(d)
 385         <= (static_cast< double >(static_cast< unsigned long >(0x80000000))
 386             * static_cast< double >(static_cast< unsigned long >(0x80000000))
 387             * 2);
 388 }
 389
 390 /** Safe sin(), returns NAN if not valid.
 391  */
 392 inline double sin(double d)
 393 {
 394     if ( isValidArcArg( d ) )
 395         return ::sin( d );
 396     setNan( &d );
 397     return d;
 398 }
 399
 400 /** Safe cos(), returns NAN if not valid.
 401  */
 402 inline double cos(double d)
 403 {
 404     if ( isValidArcArg( d ) )
 405         return ::cos( d );
 406     setNan( &d );
 407     return d;
 408 }
 409
 410 /** Safe tan(), returns NAN if not valid.
 411  */
 412 inline double tan(double d)
 413 {
 414     if ( isValidArcArg( d ) )
 415         return ::tan( d );
 416     setNan( &d );
 417     return d;
 418 }
 419
 420 }
 421
 422 }
 423
 424 #endif // INCLUDED_RTL_MATH_HXX