OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-03 17:56:21 +03:00
Code Packages Releases Activity

Coding - Precision.hxx file optimization

Browse Source 
Precision.hxx optimized to have compiler-time
  constants for the most common floating-point values.
Reorganized code to avoid static jumping for parametric.
This commit is contained in:
dpasukhi 2024-09-11 15:13:10 +00:00
parent 72b244bc98
commit a52ee17c73
1 changed files with 18 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
src/Precision/Precision.hxx
View File

@ -118,7 +118,7 @@ public:
//! you can use :
//! If ( Abs( D1.D2 ) < Precision::Angular() ) ...
//! (although the function IsNormal does exist).
static Standard_Real Angular() { return 1.e-12; }
static constexpr Standard_Real Angular() { return 1.e-12; }
//! Returns the recommended precision value when
//! checking coincidence of two points in real space.
@ -160,11 +160,11 @@ public:
//! distance (1 / 10 millimeter). This distance
//! becomes easily measurable, but only within a restricted
//! space which contains some small objects of the complete scene.
static Standard_Real Confusion() { return 1.e-7; }
static constexpr Standard_Real Confusion() { return 1.e-7; }
//! Returns square of Confusion.
//! Created for speed and convenience.
static Standard_Real SquareConfusion() { return Confusion() * Confusion(); }
static constexpr Standard_Real SquareConfusion() { return Confusion() * Confusion(); }
//! Returns the precision value in real space, frequently
//! used by intersection algorithms to decide that a solution is reached.
@ -188,7 +188,7 @@ public:
//! The tolerance of intersection is equal to :
//! Precision::Confusion() / 100.
//! (that is, 1.e-9).
static Standard_Real Intersection() { return Confusion() * 0.01; }
static constexpr Standard_Real Intersection() { return Confusion() * 0.01; }
//! Returns the precision value in real space, frequently used
//! by approximation algorithms.
@ -203,14 +203,14 @@ public:
//! (that is, 1.e-6).
//! You may use a smaller tolerance in an approximation
//! algorithm, but this option might be costly.
static Standard_Real Approximation() { return Confusion() * 10.0; }
static constexpr Standard_Real Approximation() { return Confusion() * 10.0; }
//! Convert a real space precision to a parametric
//! space precision. <T> is the mean value of the
//! length of the tangent of the curve or the surface.
//!
//! Value is P / T
static Standard_Real Parametric (const Standard_Real P, const Standard_Real T) { return P / T; }
static inline Standard_Real Parametric (const Standard_Real P, const Standard_Real T) { return P / T; }
//! Returns a precision value in parametric space, which may be used :
//! - to test the coincidence of two points in the real space,
@ -256,11 +256,11 @@ public:
//! 2.Pi without impacting on the resulting point.
//! Therefore, take great care when adjusting a parametric
//! tolerance to your own algorithm.
static Standard_Real PConfusion (const Standard_Real T) { return Parametric (Confusion(), T); }
static inline Standard_Real PConfusion (const Standard_Real T) { return Parametric (Confusion(), T); }
//! Returns square of PConfusion.
//! Created for speed and convenience.
static Standard_Real SquarePConfusion() { return PConfusion() * PConfusion(); }
static constexpr Standard_Real SquarePConfusion() { return PConfusion() * PConfusion(); }
//! Returns a precision value in parametric space, which
//! may be used by intersection algorithms, to decide that
@ -275,7 +275,7 @@ public:
//! segment whose length is equal to 100. (default value), or T.
//! The parametric tolerance of intersection is equal to :
//! - Precision::Intersection() / 100., or Precision::Intersection() / T.
static Standard_Real PIntersection (const Standard_Real T) { return Parametric(Intersection(),T); }
static inline Standard_Real PIntersection (const Standard_Real T) { return Parametric(Intersection(),T); }
//! Returns a precision value in parametric space, which may
//! be used by approximation algorithms. The purpose of this
@ -290,47 +290,47 @@ public:
//! segment whose length is equal to 100. (default value), or T.
//! The parametric tolerance of intersection is equal to :
//! - Precision::Approximation() / 100., or Precision::Approximation() / T.
static Standard_Real PApproximation (const Standard_Real T) { return Parametric(Approximation(),T); }
static inline Standard_Real PApproximation (const Standard_Real T) { return Parametric(Approximation(),T); }
//! Convert a real space precision to a parametric
//! space precision on a default curve.
//!
//! Value is Parametric(P,1.e+2)
static Standard_Real Parametric (const Standard_Real P) { return Parametric (P, 100.0); }
static inline Standard_Real Parametric (const Standard_Real P) { return P * 0.01; }
//! Used to test distances in parametric space on a
//! default curve.
//!
//! This is Precision::Parametric(Precision::Confusion())
static Standard_Real PConfusion() { return Parametric (Confusion()); }
static constexpr Standard_Real PConfusion() { return Confusion() * 0.01; }
//! Used for Intersections in parametric space on a
//! default curve.
//!
//! This is Precision::Parametric(Precision::Intersection())
static Standard_Real PIntersection() { return Parametric (Intersection()); }
static constexpr Standard_Real PIntersection() { return Intersection() * 0.01; }
//! Used for Approximations in parametric space on a
//! default curve.
//!
//! This is Precision::Parametric(Precision::Approximation())
static Standard_Real PApproximation() { return Parametric (Approximation()); }
static constexpr Standard_Real PApproximation() { return Approximation() * 0.01; }
//! Returns True if R may be considered as an infinite
//! number. Currently Abs(R) > 1e100
static Standard_Boolean IsInfinite (const Standard_Real R) { return Abs (R) >= (0.5 * Precision::Infinite()); }
static inline Standard_Boolean IsInfinite (const Standard_Real R) { return Abs (R) >= (0.5 * Precision::Infinite()); }
//! Returns True if R may be considered as a positive
//! infinite number. Currently R > 1e100
static Standard_Boolean IsPositiveInfinite (const Standard_Real R) { return R >= (0.5 * Precision::Infinite()); }
static inline Standard_Boolean IsPositiveInfinite (const Standard_Real R) { return R >= (0.5 * Precision::Infinite()); }
//! Returns True if R may be considered as a negative
//! infinite number. Currently R < -1e100
static Standard_Boolean IsNegativeInfinite (const Standard_Real R) { return R <= -(0.5 * Precision::Infinite()); }
static inline Standard_Boolean IsNegativeInfinite (const Standard_Real R) { return R <= -(0.5 * Precision::Infinite()); }
//! Returns a big number that can be considered as
//! infinite. Use -Infinite() for a negative big number.
static Standard_Real Infinite() { return 2.e+100; }
static constexpr Standard_Real Infinite() { return 2.e+100; }
};