math.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */

/*
 * This file is part of LibreOffice published API.
 */

#ifndef INCLUDED_RTL_MATH_HXX
#define INCLUDED_RTL_MATH_HXX

#include "rtl/math.h"
#include "rtl/strbuf.hxx"
#include "rtl/string.hxx"
#include "rtl/ustring.hxx"
#include "rtl/ustrbuf.hxx"
#include "sal/mathconf.h"
#include "sal/types.h"

#include <cstddef>
#include <math.h>

namespace rtl {

namespace math {

inline rtl::OString doubleToString(double fValue, rtl_math_StringFormat eFormat,
                                   sal_Int32 nDecPlaces,
                                   char cDecSeparator,
                                   sal_Int32 const * pGroups,
                                   char cGroupSeparator,
                                   bool bEraseTrailingDecZeros = false)
{
    rtl::OString aResult;
    rtl_math_doubleToString(&aResult.pData, NULL, 0, fValue, eFormat, nDecPlaces,
                            cDecSeparator, pGroups, cGroupSeparator,
                            bEraseTrailingDecZeros);
    return aResult;
}

inline rtl::OString doubleToString(double fValue, rtl_math_StringFormat eFormat,
                                   sal_Int32 nDecPlaces,
                                   char cDecSeparator,
                                   bool bEraseTrailingDecZeros = false)
{
    rtl::OString aResult;
    rtl_math_doubleToString(&aResult.pData, NULL, 0, fValue, eFormat, nDecPlaces,
                            cDecSeparator, NULL, 0, bEraseTrailingDecZeros);
    return aResult;
}

inline void doubleToStringBuffer(
    rtl::OStringBuffer& rBuffer, double fValue, rtl_math_StringFormat eFormat,
    sal_Int32 nDecPlaces, char cDecSeparator, sal_Int32 const * pGroups,
    char cGroupSeparator, bool bEraseTrailingDecZeros = false)
{
    rtl_String ** pData;
    sal_Int32 * pCapacity;
    rBuffer.accessInternals(&pData, &pCapacity);
    rtl_math_doubleToString(
        pData, pCapacity, rBuffer.getLength(), fValue, eFormat, nDecPlaces,
        cDecSeparator, pGroups, cGroupSeparator, bEraseTrailingDecZeros);
}

inline void doubleToStringBuffer(
    rtl::OStringBuffer& rBuffer, double fValue, rtl_math_StringFormat eFormat,
    sal_Int32 nDecPlaces, char cDecSeparator,
    bool bEraseTrailingDecZeros = false)
{
    rtl_String ** pData;
    sal_Int32 * pCapacity;
    rBuffer.accessInternals(&pData, &pCapacity);
    rtl_math_doubleToString(
        pData, pCapacity, rBuffer.getLength(), fValue, eFormat, nDecPlaces,
        cDecSeparator, NULL, 0, bEraseTrailingDecZeros);
}

inline rtl::OUString doubleToUString(double fValue,
                                     rtl_math_StringFormat eFormat,
                                     sal_Int32 nDecPlaces,
                                     sal_Unicode cDecSeparator,
                                     sal_Int32 const * pGroups,
                                     sal_Unicode cGroupSeparator,
                                     bool bEraseTrailingDecZeros = false)
{
    rtl::OUString aResult;
    rtl_math_doubleToUString(&aResult.pData, NULL, 0, fValue, eFormat, nDecPlaces,
                             cDecSeparator, pGroups, cGroupSeparator,
                             bEraseTrailingDecZeros);
    return aResult;
}

inline rtl::OUString doubleToUString(double fValue,
                                     rtl_math_StringFormat eFormat,
                                     sal_Int32 nDecPlaces,
                                     sal_Unicode cDecSeparator,
                                     bool bEraseTrailingDecZeros = false)
{
    rtl::OUString aResult;
    rtl_math_doubleToUString(&aResult.pData, NULL, 0, fValue, eFormat, nDecPlaces,
                             cDecSeparator, NULL, 0, bEraseTrailingDecZeros);
    return aResult;
}

inline void doubleToUStringBuffer( rtl::OUStringBuffer& rBuffer, double fValue,
                                   rtl_math_StringFormat eFormat,
                                   sal_Int32 nDecPlaces,
                                   sal_Unicode cDecSeparator,
                                   sal_Int32 const * pGroups,
                                   sal_Unicode cGroupSeparator,
                                   bool bEraseTrailingDecZeros = false)
{
    rtl_uString ** pData;
    sal_Int32 * pCapacity;
    rBuffer.accessInternals( &pData, &pCapacity );
    rtl_math_doubleToUString( pData, pCapacity, rBuffer.getLength(), fValue,
                              eFormat, nDecPlaces, cDecSeparator, pGroups,
                              cGroupSeparator, bEraseTrailingDecZeros);
}

inline void doubleToUStringBuffer( rtl::OUStringBuffer& rBuffer, double fValue,
                                   rtl_math_StringFormat eFormat,
                                   sal_Int32 nDecPlaces,
                                   sal_Unicode cDecSeparator,
                                   bool bEraseTrailingDecZeros = false)
{
    rtl_uString ** pData;
    sal_Int32 * pCapacity;
    rBuffer.accessInternals( &pData, &pCapacity );
    rtl_math_doubleToUString( pData, pCapacity, rBuffer.getLength(), fValue,
                              eFormat, nDecPlaces, cDecSeparator, NULL, 0,
                              bEraseTrailingDecZeros);
}

#ifdef LIBO_INTERNAL_ONLY
inline double stringToDouble(std::string_view aString,
                             char cDecSeparator, char cGroupSeparator,
                             rtl_math_ConversionStatus * pStatus = NULL,
                             sal_Int32 * pParsedEnd = NULL)
{
    char const * pBegin = aString.data();
    char const * pEnd;
    double fResult = rtl_math_stringToDouble(pBegin,
                                             pBegin + aString.size(),
                                             cDecSeparator, cGroupSeparator,
                                             pStatus, &pEnd);
    if (pParsedEnd != NULL)
        *pParsedEnd = static_cast<sal_Int32>(pEnd - pBegin);
    return fResult;
}
#else
inline double stringToDouble(rtl::OString const & rString,
                             char cDecSeparator, char cGroupSeparator,
                             rtl_math_ConversionStatus * pStatus = NULL,
                             sal_Int32 * pParsedEnd = NULL)
{
    char const * pBegin = rString.getStr();
    char const * pEnd;
    double fResult = rtl_math_stringToDouble(pBegin,
                                             pBegin + rString.getLength(),
                                             cDecSeparator, cGroupSeparator,
                                             pStatus, &pEnd);
    if (pParsedEnd != NULL)
        *pParsedEnd = static_cast<sal_Int32>(pEnd - pBegin);
    return fResult;
}
#endif


#ifdef LIBO_INTERNAL_ONLY
inline double stringToDouble(std::u16string_view aString,
                             sal_Unicode cDecSeparator,
                             sal_Unicode cGroupSeparator,
                             rtl_math_ConversionStatus * pStatus = NULL,
                             sal_Int32 * pParsedEnd = NULL)
{
    sal_Unicode const * pBegin = aString.data();
    sal_Unicode const * pEnd;
    double fResult = rtl_math_uStringToDouble(pBegin,
                                              pBegin + aString.size(),
                                              cDecSeparator, cGroupSeparator,
                                              pStatus, &pEnd);
    if (pParsedEnd != NULL)
        *pParsedEnd = static_cast<sal_Int32>(pEnd - pBegin);
    return fResult;
}
#else
inline double stringToDouble(rtl::OUString const & rString,
                             sal_Unicode cDecSeparator,
                             sal_Unicode cGroupSeparator,
                             rtl_math_ConversionStatus * pStatus = NULL,
                             sal_Int32 * pParsedEnd = NULL)
{
    sal_Unicode const * pBegin = rString.getStr();
    sal_Unicode const * pEnd;
    double fResult = rtl_math_uStringToDouble(pBegin,
                                              pBegin + rString.getLength(),
                                              cDecSeparator, cGroupSeparator,
                                              pStatus, &pEnd);
    if (pParsedEnd != NULL)
        *pParsedEnd = static_cast<sal_Int32>(pEnd - pBegin);
    return fResult;
}
#endif

inline double round(
    double fValue, int nDecPlaces = 0,
    rtl_math_RoundingMode eMode = rtl_math_RoundingMode_Corrected)
{
    return rtl_math_round(fValue, nDecPlaces, eMode);
}

inline double pow10Exp(double fValue, int nExp)
{
    return rtl_math_pow10Exp(fValue, nExp);
}

inline double approxValue(double fValue)
{
    return rtl_math_approxValue(fValue);
}

inline double expm1(double fValue)
{
    return rtl_math_expm1(fValue);
}

inline double log1p(double fValue)
{
    return rtl_math_log1p(fValue);
}

inline double atanh(double fValue)
{
    return rtl_math_atanh(fValue);
}

inline double erf(double fValue)
{
    return rtl_math_erf(fValue);
}

inline double erfc(double fValue)
{
    return rtl_math_erfc(fValue);
}

inline double asinh(double fValue)
{
    return rtl_math_asinh(fValue);
}

inline double acosh(double fValue)
{
    return rtl_math_acosh(fValue);
}

inline bool approxEqual(double a, double b)
{
    return rtl_math_approxEqual( a, b );
}

inline bool approxEqual(double a, double b, sal_Int16 nPrec)
{
    if ( a == b )
        return true;
    double x = a - b;
    return (x < 0.0 ? -x : x)
        < ((a < 0.0 ? -a : a) * (1.0 / (pow(2.0, nPrec))));
}

inline double approxAdd(double a, double b)
{
    if ( ((a < 0.0 && b > 0.0) || (b < 0.0 && a > 0.0))
         && approxEqual( a, -b ) )
        return 0.0;
    return a + b;
}

inline double approxSub(double a, double b)
{
    if ( ((a < 0.0 && b < 0.0) || (a > 0.0 && b > 0.0)) && approxEqual( a, b ) )
        return 0.0;
    return a - b;
}

inline double approxFloor(double a)
{
    return floor( approxValue( a ));
}

inline double approxCeil(double a)
{
    return ceil( approxValue( a ));
}

inline bool isFinite(double d)
{
    return SAL_MATH_FINITE(d);
}

inline bool isInf(double d)
{
    // exponent==0x7ff fraction==0
    return !SAL_MATH_FINITE(d) &&
        (reinterpret_cast< sal_math_Double * >(&d)->inf_parts.fraction_hi == 0)
        && (reinterpret_cast< sal_math_Double * >(&d)->inf_parts.fraction_lo
            == 0);
}

inline bool isNan(double d)
{
    // exponent==0x7ff fraction!=0
    return !SAL_MATH_FINITE(d) && (
        (reinterpret_cast< sal_math_Double * >(&d)->inf_parts.fraction_hi != 0)
        || (reinterpret_cast< sal_math_Double * >(&d)->inf_parts.fraction_lo
            != 0) );
}

inline bool isSignBitSet(double d)
{
    return reinterpret_cast< sal_math_Double * >(&d)->inf_parts.sign != 0;
}

inline void setInf(double * pd, bool bNegative)
{
    union
    {
        double sd;
        sal_math_Double md;
    };
    md.w32_parts.msw = bNegative ? 0xFFF00000 : 0x7FF00000;
    md.w32_parts.lsw = 0;
    *pd = sd;
}

inline void setNan(double * pd)
{
    union
    {
        double sd;
        sal_math_Double md;
    };
    md.w32_parts.msw = 0x7FFFFFFF;
    md.w32_parts.lsw = 0xFFFFFFFF;
    *pd = sd;
}

inline bool isValidArcArg(double d)
{
    return fabs(d)
        <= (static_cast< double >(static_cast< unsigned long >(0x80000000))
            * static_cast< double >(static_cast< unsigned long >(0x80000000))
            * 4);
}

inline double sin(double d)
{
    if ( isValidArcArg( d ) )
        return ::sin( d );
    setNan( &d );
    return d;
}

inline double cos(double d)
{
    if ( isValidArcArg( d ) )
        return ::cos( d );
    setNan( &d );
    return d;
}

inline double tan(double d)
{
    if ( isValidArcArg( d ) )
        return ::tan( d );
    setNan( &d );
    return d;
}

}

}

#endif // INCLUDED_RTL_MATH_HXX

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */