include/rtl/math.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 /*
  21  * This file is part of LibreOffice published API.
  22  */
  23
  24 #ifndef INCLUDED_RTL_MATH_HXX
  25 #define INCLUDED_RTL_MATH_HXX
  26
  27 #include "rtl/math.h"
  28 #include "rtl/strbuf.hxx"
  29 #include "rtl/string.hxx"
  30 #include "rtl/ustring.hxx"
  31 #include "rtl/ustrbuf.hxx"
  32 #include "sal/mathconf.h"
  33 #include "sal/types.h"
  34
  35 #include <cstddef>
  36 #include <math.h>
  37
  38 namespace rtl {
  39
  40 namespace math {
  41
  42 /** A wrapper around rtl_math_doubleToString.
  43  */
  44 inline rtl::OString doubleToString(double fValue, rtl_math_StringFormat eFormat,
  45                                    sal_Int32 nDecPlaces,
  46                                    char cDecSeparator,
  47                                    sal_Int32 const * pGroups,
  48                                    char cGroupSeparator,
  49                                    bool bEraseTrailingDecZeros = false)
  50 {
  51     rtl::OString aResult;
  52     rtl_math_doubleToString(&aResult.pData, NULL, 0, fValue, eFormat, nDecPlaces,
  53                             cDecSeparator, pGroups, cGroupSeparator,
  54                             bEraseTrailingDecZeros);
  55     return aResult;
  56 }
  57
  58 /** A wrapper around rtl_math_doubleToString, with no grouping.
  59  */
  60 inline rtl::OString doubleToString(double fValue, rtl_math_StringFormat eFormat,
  61                                    sal_Int32 nDecPlaces,
  62                                    char cDecSeparator,
  63                                    bool bEraseTrailingDecZeros = false)
  64 {
  65     rtl::OString aResult;
  66     rtl_math_doubleToString(&aResult.pData, NULL, 0, fValue, eFormat, nDecPlaces,
  67                             cDecSeparator, NULL, 0, bEraseTrailingDecZeros);
  68     return aResult;
  69 }
  70
  71 /** A wrapper around rtl_math_doubleToString that appends to an
  72     rtl::OStringBuffer.
  73
  74     @since LibreOffice 5.4
  75 */
  76 inline void doubleToStringBuffer(
  77     rtl::OStringBuffer& rBuffer, double fValue, rtl_math_StringFormat eFormat,
  78     sal_Int32 nDecPlaces, char cDecSeparator, sal_Int32 const * pGroups,
  79     char cGroupSeparator, bool bEraseTrailingDecZeros = false)
  80 {
  81     rtl_String ** pData;
  82     sal_Int32 * pCapacity;
  83     rBuffer.accessInternals(&pData, &pCapacity);
  84     rtl_math_doubleToString(
  85         pData, pCapacity, rBuffer.getLength(), fValue, eFormat, nDecPlaces,
  86         cDecSeparator, pGroups, cGroupSeparator, bEraseTrailingDecZeros);
  87 }
  88
  89 /** A wrapper around rtl_math_doubleToString that appends to an
  90     rtl::OStringBuffer, with no grouping.
  91
  92     @since LibreOffice 5.4
  93 */
  94 inline void doubleToStringBuffer(
  95     rtl::OStringBuffer& rBuffer, double fValue, rtl_math_StringFormat eFormat,
  96     sal_Int32 nDecPlaces, char cDecSeparator,
  97     bool bEraseTrailingDecZeros = false)
  98 {
  99     rtl_String ** pData;
 100     sal_Int32 * pCapacity;
 101     rBuffer.accessInternals(&pData, &pCapacity);
 102     rtl_math_doubleToString(
 103         pData, pCapacity, rBuffer.getLength(), fValue, eFormat, nDecPlaces,
 104         cDecSeparator, NULL, 0, bEraseTrailingDecZeros);
 105 }
 106
 107 /** A wrapper around rtl_math_doubleToUString.
 108  */
 109 inline rtl::OUString doubleToUString(double fValue,
 110                                      rtl_math_StringFormat eFormat,
 111                                      sal_Int32 nDecPlaces,
 112                                      sal_Unicode cDecSeparator,
 113                                      sal_Int32 const * pGroups,
 114                                      sal_Unicode cGroupSeparator,
 115                                      bool bEraseTrailingDecZeros = false)
 116 {
 117     rtl::OUString aResult;
 118     rtl_math_doubleToUString(&aResult.pData, NULL, 0, fValue, eFormat, nDecPlaces,
 119                              cDecSeparator, pGroups, cGroupSeparator,
 120                              bEraseTrailingDecZeros);
 121     return aResult;
 122 }
 123
 124 /** A wrapper around rtl_math_doubleToUString, with no grouping.
 125  */
 126 inline rtl::OUString doubleToUString(double fValue,
 127                                      rtl_math_StringFormat eFormat,
 128                                      sal_Int32 nDecPlaces,
 129                                      sal_Unicode cDecSeparator,
 130                                      bool bEraseTrailingDecZeros = false)
 131 {
 132     rtl::OUString aResult;
 133     rtl_math_doubleToUString(&aResult.pData, NULL, 0, fValue, eFormat, nDecPlaces,
 134                              cDecSeparator, NULL, 0, bEraseTrailingDecZeros);
 135     return aResult;
 136 }
 137
 138 /** A wrapper around rtl_math_doubleToUString that appends to an
 139     rtl::OUStringBuffer.
 140  */
 141 inline void doubleToUStringBuffer( rtl::OUStringBuffer& rBuffer, double fValue,
 142                                    rtl_math_StringFormat eFormat,
 143                                    sal_Int32 nDecPlaces,
 144                                    sal_Unicode cDecSeparator,
 145                                    sal_Int32 const * pGroups,
 146                                    sal_Unicode cGroupSeparator,
 147                                    bool bEraseTrailingDecZeros = false)
 148 {
 149     rtl_uString ** pData;
 150     sal_Int32 * pCapacity;
 151     rBuffer.accessInternals( &pData, &pCapacity );
 152     rtl_math_doubleToUString( pData, pCapacity, rBuffer.getLength(), fValue,
 153                               eFormat, nDecPlaces, cDecSeparator, pGroups,
 154                               cGroupSeparator, bEraseTrailingDecZeros);
 155 }
 156
 157 /** A wrapper around rtl_math_doubleToUString that appends to an
 158     rtl::OUStringBuffer, with no grouping.
 159  */
 160 inline void doubleToUStringBuffer( rtl::OUStringBuffer& rBuffer, double fValue,
 161                                    rtl_math_StringFormat eFormat,
 162                                    sal_Int32 nDecPlaces,
 163                                    sal_Unicode cDecSeparator,
 164                                    bool bEraseTrailingDecZeros = false)
 165 {
 166     rtl_uString ** pData;
 167     sal_Int32 * pCapacity;
 168     rBuffer.accessInternals( &pData, &pCapacity );
 169     rtl_math_doubleToUString( pData, pCapacity, rBuffer.getLength(), fValue,
 170                               eFormat, nDecPlaces, cDecSeparator, NULL, 0,
 171                               bEraseTrailingDecZeros);
 172 }
 173
 174 /** A wrapper around rtl_math_stringToDouble.
 175  */
 176 #ifdef LIBO_INTERNAL_ONLY
 177 inline double stringToDouble(std::string_view aString,
 178                              char cDecSeparator, char cGroupSeparator,
 179                              rtl_math_ConversionStatus * pStatus = NULL,
 180                              sal_Int32 * pParsedEnd = NULL)
 181 {
 182     char const * pBegin = aString.data();
 183     char const * pEnd;
 184     double fResult = rtl_math_stringToDouble(pBegin,
 185                                              pBegin + aString.size(),
 186                                              cDecSeparator, cGroupSeparator,
 187                                              pStatus, &pEnd);
 188     if (pParsedEnd != NULL)
 189         *pParsedEnd = static_cast<sal_Int32>(pEnd - pBegin);
 190     return fResult;
 191 }
 192 #else
 193 inline double stringToDouble(rtl::OString const & rString,
 194                              char cDecSeparator, char cGroupSeparator,
 195                              rtl_math_ConversionStatus * pStatus = NULL,
 196                              sal_Int32 * pParsedEnd = NULL)
 197 {
 198     char const * pBegin = rString.getStr();
 199     char const * pEnd;
 200     double fResult = rtl_math_stringToDouble(pBegin,
 201                                              pBegin + rString.getLength(),
 202                                              cDecSeparator, cGroupSeparator,
 203                                              pStatus, &pEnd);
 204     if (pParsedEnd != NULL)
 205         *pParsedEnd = static_cast<sal_Int32>(pEnd - pBegin);
 206     return fResult;
 207 }
 208 #endif
 209
 210
 211 /** A wrapper around rtl_math_uStringToDouble.
 212  */
 213 #ifdef LIBO_INTERNAL_ONLY
 214 inline double stringToDouble(std::u16string_view aString,
 215                              sal_Unicode cDecSeparator,
 216                              sal_Unicode cGroupSeparator,
 217                              rtl_math_ConversionStatus * pStatus = NULL,
 218                              sal_Int32 * pParsedEnd = NULL)
 219 {
 220     sal_Unicode const * pBegin = aString.data();
 221     sal_Unicode const * pEnd;
 222     double fResult = rtl_math_uStringToDouble(pBegin,
 223                                               pBegin + aString.size(),
 224                                               cDecSeparator, cGroupSeparator,
 225                                               pStatus, &pEnd);
 226     if (pParsedEnd != NULL)
 227         *pParsedEnd = static_cast<sal_Int32>(pEnd - pBegin);
 228     return fResult;
 229 }
 230 #else
 231 inline double stringToDouble(rtl::OUString const & rString,
 232                              sal_Unicode cDecSeparator,
 233                              sal_Unicode cGroupSeparator,
 234                              rtl_math_ConversionStatus * pStatus = NULL,
 235                              sal_Int32 * pParsedEnd = NULL)
 236 {
 237     sal_Unicode const * pBegin = rString.getStr();
 238     sal_Unicode const * pEnd;
 239     double fResult = rtl_math_uStringToDouble(pBegin,
 240                                               pBegin + rString.getLength(),
 241                                               cDecSeparator, cGroupSeparator,
 242                                               pStatus, &pEnd);
 243     if (pParsedEnd != NULL)
 244         *pParsedEnd = static_cast<sal_Int32>(pEnd - pBegin);
 245     return fResult;
 246 }
 247 #endif
 248
 249 /** A wrapper around rtl_math_round.
 250  */
 251 inline double round(
 252     double fValue, int nDecPlaces = 0,
 253     rtl_math_RoundingMode eMode = rtl_math_RoundingMode_Corrected)
 254 {
 255     return rtl_math_round(fValue, nDecPlaces, eMode);
 256 }
 257
 258 /** A wrapper around rtl_math_pow10Exp.
 259  */
 260 inline double pow10Exp(double fValue, int nExp)
 261 {
 262     return rtl_math_pow10Exp(fValue, nExp);
 263 }
 264
 265 /** A wrapper around rtl_math_approxValue.
 266  */
 267 inline double approxValue(double fValue)
 268 {
 269     return rtl_math_approxValue(fValue);
 270 }
 271
 272 /** A wrapper around rtl_math_expm1.
 273  */
 274 inline double expm1(double fValue)
 275 {
 276     return rtl_math_expm1(fValue);
 277 }
 278
 279 /** A wrapper around rtl_math_log1p.
 280  */
 281 inline double log1p(double fValue)
 282 {
 283     return rtl_math_log1p(fValue);
 284 }
 285
 286 /** A wrapper around rtl_math_atanh.
 287  */
 288 inline double atanh(double fValue)
 289 {
 290     return rtl_math_atanh(fValue);
 291 }
 292
 293 /** A wrapper around rtl_math_erf.
 294  */
 295 inline double erf(double fValue)
 296 {
 297     return rtl_math_erf(fValue);
 298 }
 299
 300 /** A wrapper around rtl_math_erfc.
 301  */
 302 inline double erfc(double fValue)
 303 {
 304     return rtl_math_erfc(fValue);
 305 }
 306
 307 /** A wrapper around rtl_math_asinh.
 308  */
 309 inline double asinh(double fValue)
 310 {
 311     return rtl_math_asinh(fValue);
 312 }
 313
 314 /** A wrapper around rtl_math_acosh.
 315  */
 316 inline double acosh(double fValue)
 317 {
 318     return rtl_math_acosh(fValue);
 319 }
 320
 321 /** A wrapper around rtl_math_approxEqual.
 322  */
 323 inline bool approxEqual(double a, double b)
 324 {
 325     return rtl_math_approxEqual( a, b );
 326 }
 327
 328 /** Test equality of two values with an accuracy defined by nPrec
 329
 330     @attention
 331     approxEqual( value!=0.0, 0.0 ) _never_ yields true.
 332  */
 333 inline bool approxEqual(double a, double b, sal_Int16 nPrec)
 334 {
 335     if ( a == b )
 336         return true;
 337     double x = a - b;
 338     return (x < 0.0 ? -x : x)
 339         < ((a < 0.0 ? -a : a) * (1.0 / (pow(2.0, nPrec))));
 340 }
 341
 342 /** Add two values.
 343
 344     If signs differ and the absolute values are equal according to approxEqual()
 345     the method returns 0.0 instead of calculating the sum.
 346
 347     If you wanted to sum up multiple values it would be convenient not to call
 348     approxAdd() for each value but instead remember the first value not equal to
 349     0.0, add all other values using normal + operator, and with the result and
 350     the remembered value call approxAdd().
 351  */
 352 inline double approxAdd(double a, double b)
 353 {
 354     if ( ((a < 0.0 && b > 0.0) || (b < 0.0 && a > 0.0))
 355          && approxEqual( a, -b ) )
 356         return 0.0;
 357     return a + b;
 358 }
 359
 360 /** Subtract two values (a-b).
 361
 362     If signs are identical and the values are equal according to approxEqual()
 363     the method returns 0.0 instead of calculating the subtraction.
 364  */
 365 inline double approxSub(double a, double b)
 366 {
 367     if ( ((a < 0.0 && b < 0.0) || (a > 0.0 && b > 0.0)) && approxEqual( a, b ) )
 368         return 0.0;
 369     return a - b;
 370 }
 371
 372 /** floor() method taking approxValue() into account.
 373
 374     Use for expected integer values being calculated by double functions.
 375  */
 376 inline double approxFloor(double a)
 377 {
 378     return floor( approxValue( a ));
 379 }
 380
 381 /** ceil() method taking approxValue() into account.
 382
 383     Use for expected integer values being calculated by double functions.
 384  */
 385 inline double approxCeil(double a)
 386 {
 387     return ceil( approxValue( a ));
 388 }
 389
 390 /** Tests whether a value is neither INF nor NAN.
 391  */
 392 inline bool isFinite(double d)
 393 {
 394     return SAL_MATH_FINITE(d);
 395 }
 396
 397 /** If a value represents +INF or -INF.
 398
 399     The sign bit may be queried with isSignBitSet().
 400
 401     If isFinite(d)==false and isInf(d)==false then NAN.
 402  */
 403 inline bool isInf(double d)
 404 {
 405     // exponent==0x7ff fraction==0
 406     return !SAL_MATH_FINITE(d) &&
 407         (reinterpret_cast< sal_math_Double * >(&d)->inf_parts.fraction_hi == 0)
 408         && (reinterpret_cast< sal_math_Double * >(&d)->inf_parts.fraction_lo
 409             == 0);
 410 }
 411
 412 /** Test on any QNAN or SNAN.
 413  */
 414 inline bool isNan(double d)
 415 {
 416     // exponent==0x7ff fraction!=0
 417     return !SAL_MATH_FINITE(d) && (
 418         (reinterpret_cast< sal_math_Double * >(&d)->inf_parts.fraction_hi != 0)
 419         || (reinterpret_cast< sal_math_Double * >(&d)->inf_parts.fraction_lo
 420             != 0) );
 421 }
 422
 423 /** If the sign bit is set.
 424  */
 425 inline bool isSignBitSet(double d)
 426 {
 427     return reinterpret_cast< sal_math_Double * >(&d)->inf_parts.sign != 0;
 428 }
 429
 430 /** Set to +INF if bNegative==false or -INF if bNegative==true.
 431  */
 432 inline void setInf(double * pd, bool bNegative)
 433 {
 434     union
 435     {
 436         double sd;
 437         sal_math_Double md;
 438     };
 439     md.w32_parts.msw = bNegative ? 0xFFF00000 : 0x7FF00000;
 440     md.w32_parts.lsw = 0;
 441     *pd = sd;
 442 }
 443
 444 /** Set a QNAN.
 445  */
 446 inline void setNan(double * pd)
 447 {
 448     union
 449     {
 450         double sd;
 451         sal_math_Double md;
 452     };
 453     md.w32_parts.msw = 0x7FFFFFFF;
 454     md.w32_parts.lsw = 0xFFFFFFFF;
 455     *pd = sd;
 456 }
 457
 458 /** If a value is a valid argument for sin(), cos(), tan().
 459
 460     IEEE 754 specifies that absolute values up to 2^64 (=1.844e19) for the
 461     radian must be supported by trigonometric functions.  Unfortunately, at
 462     least on x86 architectures, the FPU doesn't generate an error pattern for
 463     values >2^64 but produces erroneous results instead and sets only the
 464     "invalid operation" (IM) flag in the status word :-(  Thus the application
 465     has to handle it itself.
 466  */
 467 inline bool isValidArcArg(double d)
 468 {
 469     return fabs(d)
 470         <= (static_cast< double >(static_cast< unsigned long >(0x80000000))
 471             * static_cast< double >(static_cast< unsigned long >(0x80000000))
 472             * 4);
 473 }
 474
 475 /** Safe sin(), returns NAN if not valid.
 476  */
 477 inline double sin(double d)
 478 {
 479     if ( isValidArcArg( d ) )
 480         return ::sin( d );
 481     setNan( &d );
 482     return d;
 483 }
 484
 485 /** Safe cos(), returns NAN if not valid.
 486  */
 487 inline double cos(double d)
 488 {
 489     if ( isValidArcArg( d ) )
 490         return ::cos( d );
 491     setNan( &d );
 492     return d;
 493 }
 494
 495 /** Safe tan(), returns NAN if not valid.
 496  */
 497 inline double tan(double d)
 498 {
 499     if ( isValidArcArg( d ) )
 500         return ::tan( d );
 501     setNan( &d );
 502     return d;
 503 }
 504
 505 }
 506
 507 }
 508
 509 #endif // INCLUDED_RTL_MATH_HXX
 510
 511 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */