EIC code displayed by LXR master/​include/​opencascade/​Standard_Real.hxx	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-09-22 08:59:18

 // Copyright (c) 1998-1999 Matra Datavision
 // Copyright (c) 1999-2014 OPEN CASCADE SAS
 //
 // This file is part of Open CASCADE Technology software library.
 //
 // This library is free software; you can redistribute it and/or modify it under
 // the terms of the GNU Lesser General Public License version 2.1 as published
 // by the Free Software Foundation, with special exception defined in the file
 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
 // distribution for complete text of the license and disclaimer of any warranty.
 //
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
 #ifndef _Standard_Real_HeaderFile
 #define _Standard_Real_HeaderFile
 
 #include <algorithm>
 #include <cmath>
 #include <climits>
 #include <float.h>
 
 #ifdef _MSC_VER
   #ifndef _USE_MATH_DEFINES
     #define _USE_MATH_DEFINES
   #endif
   #include <math.h>
 #endif
 
 #include <Standard_TypeDef.hxx>
 
 //! Returns the value of the arc cosine of a @p theValue.
 Standard_DEPRECATED("This function duplicates std::acos and will be removed in future releases. "
                     "Use std::acos instead.")
 inline double ACos(const double theValue)
 {
   return std::acos(theValue);
 }
 
 //! Returns the approximate value of the arc cosine @p theValue.
 //! The max error is about 1 degree near Value=0.
 //! NOTE: Avoid using this function in new code, it presumably slower then std::acos.
 Standard_DEPRECATED("Deprecated, use std::acos instead")
 Standard_EXPORT double ACosApprox(const double theValue);
 
 //! Returns the value of the arc sine of a @p theValue.
 Standard_DEPRECATED("This function duplicates std::asin and will be removed in future releases. "
                     "Use std::asin instead.")
 inline double ASin(const double theValue)
 {
   return std::asin(theValue);
 }
 
 //! Computes the arc tangent of @p theX divided by @p theY using the signs of both
 //! arguments to determine the quadrant of the return value.
 Standard_DEPRECATED("This function duplicates std::atan2 and will be removed in future releases. "
                     "Use std::atan2 instead.")
 inline double ATan2(const double theX, const double theY)
 {
   return std::atan2(theX, theY);
 }
 
 //! Returns the value of the hyperbolic arc tangent of @p theValue.
 Standard_DEPRECATED("This function duplicates std::atanh and will be removed in future releases. "
                     "Use std::atanh instead.")
 inline double ATanh(const double theValue)
 {
   return std::atanh(theValue);
 }
 
 //! Returns the value of the hyperbolic arc cosine of @p theValue.
 Standard_DEPRECATED("This function duplicates std::acosh and will be removed in future releases. "
                     "Use std::acosh instead.")
 inline double ACosh(const double theValue)
 {
   return std::acosh(theValue);
 }
 
 //! Returns the hyperbolic cosine of a double @p theValue.
 Standard_DEPRECATED("This function duplicates std::cosh and will be removed in future releases. "
                     "Use std::cosh instead.")
 inline double Cosh(const double theValue)
 {
   return std::cosh(theValue);
 }
 
 //! Returns the hyperbolic sine of a double @p theValue.
 Standard_DEPRECATED("This function duplicates std::sinh and will be removed in future releases. "
                     "Use std::sinh instead.")
 inline double Sinh(const double theValue)
 {
   return std::sinh(theValue);
 }
 
 //! Computes the natural (base-e) logarithm of number @p theValue.
 Standard_DEPRECATED("This function duplicates std::log and will be removed in future releases. "
                     "Use std::log instead.")
 inline double Log(const double theValue)
 {
   return std::log(theValue);
 }
 
 //! Returns the square root of a double @p theValue.
 Standard_DEPRECATED("This function duplicates std::sqrt and will be removed in future releases. "
                     "Use std::sqrt instead.")
 inline double Sqrt(const double theValue)
 {
   return std::sqrt(theValue);
 }
 
 //! Returns the next representable value of a double @p theValue
 //! in the direction of @p theDirection. Equivalent to std::nextafter.
 Standard_DEPRECATED(
   "This function duplicates std::nextafter and will be removed in future releases. "
   "Use std::nextafter instead.")
 inline double NextAfter(const double theValue, const double theDirection)
 {
   return std::nextafter(theValue, theDirection);
 }
 
 //! Composes a floating point value with the magnitude of @p theMagnitude
 //! and the sign of @p theSign. Equivalent to std::copysign.
 Standard_DEPRECATED(
   "This function duplicates std::copysign and will be removed in future releases. "
   "Use std::copysign instead.")
 inline double Sign(const double theMagnitude, const double theSign)
 {
   return std::copysign(theMagnitude, theSign);
 }
 
 //! Returns the minimum positive double value greater than zero.
 [[nodiscard]] constexpr double RealSmall()
 {
   return DBL_MIN;
 }
 
 //! Returns the absolute value of a double @p Value.
 //! Equivalent to std::abs.
 Standard_DEPRECATED("This function duplicates std::abs and will be removed in future releases. "
                     "Use std::abs instead.")
 inline double Abs(const double theValue)
 {
   return std::abs(theValue);
 }
 
 //! Returns Standard_True if two doubles are equal within the precision
 //! defined by RealSmall().
 [[nodiscard]] inline bool IsEqual(const double theValue1, const double theValue2)
 {
   return std::abs(theValue1 - theValue2) < RealSmall();
 }
 
 //! Returns the number of digits of precision in a double.
 [[nodiscard]] constexpr int RealDigits()
 {
   return DBL_DIG;
 }
 
 //! Returns the minimum positive double such that
 //! 1.0 + RealEpsilon() != 1.0.
 [[nodiscard]] constexpr double RealEpsilon()
 {
   return DBL_EPSILON;
 }
 
 //! Returns the minimum value of a double.
 [[nodiscard]] constexpr double RealFirst()
 {
   return -DBL_MAX;
 }
 
 //! Returns the minimum value of exponent(base 10) of a double.
 [[nodiscard]] constexpr int RealFirst10Exp()
 {
   return DBL_MIN_10_EXP;
 }
 
 //! Returns the maximum value of a double.
 [[nodiscard]] constexpr double RealLast()
 {
   return DBL_MAX;
 }
 
 //! Returns the maximum value of exponent(base 10) of a double.
 [[nodiscard]] constexpr int RealLast10Exp()
 {
   return DBL_MAX_10_EXP;
 }
 
 //! Returns the size in bits of the mantissa part of a double.
 [[nodiscard]] constexpr int RealMantissa()
 {
   return DBL_MANT_DIG;
 }
 
 //! Returns the radix of a double.
 [[nodiscard]] constexpr int RealRadix()
 {
   return FLT_RADIX;
 }
 
 //! Returns the size in bits of a double.
 [[nodiscard]] constexpr int RealSize()
 {
   return CHAR_BIT * sizeof(double);
 }
 
 //! Converts a int @p theValue to a double.
 [[nodiscard]] constexpr double IntToReal(const int theValue)
 {
   return theValue;
 }
 
 //! Returns the value of the arc tangent of a double @p theValue.
 Standard_DEPRECATED("This function duplicates std::atan and will be removed in future releases. "
                     "Use std::atan instead.")
 inline double ATan(const double theValue)
 {
   return std::atan(theValue);
 }
 
 //! Returns the next integer greater than or equal to a double @p theValue.
 Standard_DEPRECATED("This function duplicates std::ceil and will be removed in future releases. "
                     "Use std::ceil instead.")
 inline double Ceiling(const double theValue)
 {
   return std::ceil(theValue);
 }
 
 //! Returns the cosine of a double @p theValue.
 //! Equivalent to std::cos.
 Standard_DEPRECATED("This function duplicates std::cos and will be removed in future releases. "
                     "Use std::cos instead.")
 inline double Cos(const double theValue)
 {
   return std::cos(theValue);
 }
 
 //! The function returns absolute value of difference between @p theValue and other nearest value of
 //! double type. Nearest value is chosen in direction of infinity the same sign as @p theValue.
 //! If @p theValue is 0 then returns minimal positive value of double type.
 [[nodiscard]] inline double Epsilon(const double theValue)
 {
   return theValue >= 0.0 ? (std::nextafter(theValue, RealLast()) - theValue)
                          : (theValue - std::nextafter(theValue, RealFirst()));
 }
 
 //! Returns the exponential of a double @p theValue.
 //! Equivalent to std::exp.
 Standard_DEPRECATED("This function duplicates std::exp and will be removed in future releases. "
                     "Use std::exp instead.")
 inline double Exp(const double theValue)
 {
   return std::exp(theValue);
 }
 
 //! Returns the nearest integer less than or equal to a double @p theValue.
 //! Equivalent to std::floor.
 Standard_DEPRECATED("This function duplicates std::floor and will be removed in future releases. "
                     "Use std::floor instead.")
 inline double Floor(const double theValue)
 {
   return std::floor(theValue);
 }
 
 //! Returns the integer part of a double @p theValue.
 //! Equivalent to std::trunc.
 Standard_DEPRECATED("This function duplicates std::trunc and will be removed in future releases. "
                     "Use std::trunc instead.")
 inline double IntegerPart(const double theValue)
 {
   return std::trunc(theValue);
 }
 
 //! Returns the logarithm to base 10 of a double @p theValue.
 //! Equivalent to std::log10.
 Standard_DEPRECATED("This function duplicates std::log10 and will be removed in future releases. "
                     "Use std::log10 instead.")
 inline double Log10(const double theValue)
 {
   return std::log10(theValue);
 }
 
 //! Returns the maximum value of two doubles.
 //! Equivalent to std::max.
 Standard_DEPRECATED("This function duplicates std::max and will be removed in future releases. "
                     "Use std::max instead.")
 constexpr double Max(const double theValue1, const double theValue2)
 {
   return (std::max)(theValue1, theValue2);
 }
 
 //! Returns the minimum value of two doubles.
 //! Equivalent to std::min.
 Standard_DEPRECATED("This function duplicates std::min and will be removed in future releases. "
                     "Use std::min instead.")
 constexpr double Min(const double theValue1, const double theValue2)
 {
   return (std::min)(theValue1, theValue2);
 }
 
 //! Returns a double @p theValue raised to the power of @p thePower.
 Standard_DEPRECATED("This function duplicates std::pow and will be removed in future releases. "
                     "Use std::pow instead.")
 inline double Pow(const double theValue, const double thePower)
 {
   return std::pow(theValue, thePower);
 }
 
 //! Returns the fractional part of a double @p theValue.
 //! Always non-negative.
 [[nodiscard]] inline double RealPart(const double theValue)
 {
   return std::abs(std::trunc(theValue) - theValue);
 }
 
 //! Converts a double @p theValue to the nearest valid int.
 //! If input value is out of valid range for int, minimal or maximal possible int is returned.
 [[nodiscard]] constexpr int RealToInt(const double theValue)
 {
   // Note that on WNT under MS VC++ 8.0 conversion of double value less
   // than INT_MIN or greater than INT_MAX to integer will cause signal
   // "Floating point multiple trap" (OCC17861)
   return theValue < static_cast<double>(INT_MIN)
            ? static_cast<int>(INT_MIN)
            : (theValue > static_cast<double>(INT_MAX) ? static_cast<int>(INT_MAX)
                                                       : static_cast<int>(theValue));
 }
 
 //! Converts a double @p theValue to the nearest valid float.
 //! If input value is out of valid range for float, minimal or maximal
 //! possible float is returned.
 [[nodiscard]] constexpr float RealToShortReal(const double theValue)
 {
   return theValue < -FLT_MAX  ? -FLT_MAX
          : theValue > FLT_MAX ? FLT_MAX
                               : static_cast<float>(theValue);
 }
 
 //! Returns the nearest integer of a double @p theValue.
 //! Equivalent to std::round.
 Standard_DEPRECATED("This function duplicates std::round and will be removed in future releases. "
                     "Use std::round instead.")
 inline double Round(const double theValue)
 {
   return std::round(theValue);
 }
 
 //! Returns the sine of a double @p theValue.
 //! Equivalent to std::sin.
 Standard_DEPRECATED("This function duplicates std::sin and will be removed in future releases. "
                     "Use std::sin instead.")
 inline double Sin(const double theValue)
 {
   return std::sin(theValue);
 }
 
 //! Returns the hyperbolic arc sine of a double @p theValue.
 //! Equivalent to std::asinh.
 Standard_DEPRECATED("This function duplicates std::asinh and will be removed in future releases. "
                     "Use std::asinh instead.")
 inline double ASinh(const double theValue)
 {
   return std::asinh(theValue);
 }
 
 //! Returns the square of a double @p theValue.
 [[nodiscard]] constexpr double Square(const double theValue)
 {
   return theValue * theValue;
 }
 
 //! Returns the tangent of a double @p theValue.
 //! Equivalent to std::tan.
 Standard_DEPRECATED("This function duplicates std::tan and will be removed in future releases. "
                     "Use std::tan instead.")
 inline double Tan(const double theValue)
 {
   return std::tan(theValue);
 }
 
 //! Returns the hyperbolic tangent of a double @p theValue.
 //! Equivalent to std::tanh.
 Standard_DEPRECATED("This function duplicates std::tanh and will be removed in future releases. "
                     "Use std::tanh instead.")
 inline double Tanh(const double theValue)
 {
   return std::tanh(theValue);
 }
 
 #endif // _Standard_Real_HeaderFile

This page was automatically generated by the 2.3.7 LXR engine. The LXR team