polyhedral-gravity 3.0rc3__tar.gz → 3.2rc1__tar.gz

{polyhedral_gravity-3.0rc3/polyhedral_gravity.egg-info → polyhedral_gravity-3.2rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: polyhedral_gravity
-Version: 3.0rc3
+Version: 3.2rc1
 Summary: Package to compute full gravity tensor of a given constant density polyhedron for arbitrary points according to the geodetic convention
 Author: Jonas Schuhmacher
 Author-email: jonas.schuhmacher@tum.de
@@ -79,8 +79,8 @@ which is strongly based on the former implementation in FORTRAN.
 
 > [!NOTE]
 > The [GitHub Pages](https://esa.github.io/polyhedral-gravity-model) of this project
-contain the full extensive documentation of C++ Library and the Python Interface
-as well as background on the gravity model and advanced settings not detailed here!
+contain the full extensive documentation of the C++ Library and Python Interface
+as well as background on the gravity model and advanced settings not detailed here.
 
 ## Input & Output (C++ and Python)
 
@@ -139,7 +139,7 @@ cube_density = 1.0
 computation_point = np.array([0, 0, 0])
 ```
 
-We first, define a constant density Polyhedron from `vertices` and `faces`
+We first define a constant density Polyhedron from `vertices` and `faces`
 
 ```python
 cube_polyhedron = Polyhedron(
@@ -148,9 +148,9 @@ cube_polyhedron = Polyhedron(
 )
 ```
 
-In case you want to hand over the polyhedron via a supported file format,
+In case you want to hand over the polyhedron via a [supported file format](https://esa.github.io/polyhedral-gravity-model/quickstart/supported_input.html),
 just replace the `polyhedral_source` argument with *a list of strings*,
-where each string is the path to a supported file format.
+where each string is the path to a supported file format, e.g. `polyhedral_source=["eros.node","eros.face"]` or `polyhedral_source=["eros.mesh"]`.
 
 Continuing, the simplest way to compute the gravity is to use the `evaluate` function:
 
@@ -168,14 +168,15 @@ evaluations. This is especially useful if you want to compute the gravity
 for multiple computation points, but don't know the "future points" in advance.
 
 ```python
-evaluable = GravityEvaluable(polyhedron=cube_polyhedron)
+evaluable = GravityEvaluable(polyhedron=cube_polyhedron) # stores intermediate computation steps
 potential, acceleration, tensor = evaluable(
   computation_points=computation_point,
   parallel=True,
 )
+# Any future evaluable call after this one will be faster
 ```
 
-Note that the `computation_point` could also be (N, 3)-shaped array.
+Note that the `computation_point` could also be (N, 3)-shaped array to compute multiple points at once.
 In this case, the return value of `evaluate(..)` or an `GravityEvaluable` will
 be a list of triplets comprising potential, acceleration, and tensor.
 
@@ -185,15 +186,15 @@ This property is - by default - checked when constructing the `Polyhedron`! So,
 is impossible if not **explicitly** disabled to create an invalid `Polyhedron`.
 You can disable/ enable this setting via the optional `integrity_check` flag and can even
 automatically repair the ordering via `HEAL`.
-As advanced user/ when you "know the mesh",
-you want to disable this check (via `DISABLE`) due to the additional runtime overhead!
+If you are confident that your mesh is defined correctly (e.g. checked once with the integrity check)
+you can disable this check (via `DISABLE`) to avoid the additional runtime overhead of the check.
 
 ```python
 cube_polyhedron = Polyhedron(
   polyhedral_source=(cube_vertices, cube_faces),
   density=cube_density,
   normal_orientation=NormalOrientation.INWARDS, # OUTWARDS (default) or INWARDS
-  integrity_check=PolyhedronIntegrity.VERIFY,   # AUTOMATIC (default) == VERIFY, DISABLE or HEAL
+  integrity_check=PolyhedronIntegrity.VERIFY,   # VERIFY (default), DISABLE or HEAL
 )
 ```
 
@@ -333,8 +334,7 @@ The following options are available:
 During testing POLYHEDRAL_GRAVITY_PARALLELIZATION=`TBB` has been the most performant.
 It is further not recommend to change the LOGGING_LEVEL to something else than `INFO=2`.
 
-The recommended CMake command would look like this (we only need to change `PARALLELIZATION_DEVICE`, since
-the defaults of the others are already correctly set):
+The recommended CMake settings using the `TBB` backend would look like this:
 
 ```bash
 cmake .. -POLYHEDRAL_GRAVITY_PARALLELIZATION="TBB"
@@ -345,7 +345,7 @@ cmake .. -POLYHEDRAL_GRAVITY_PARALLELIZATION="TBB"
 After the build, the gravity model can be run by executing:
 
 ```bash
-    ./polyhedralGravity <YAML-Configuration-File>
+./polyhedralGravity <YAML-Configuration-File>
 ```
 
 where the YAML-Configuration-File contains the required parameters.

{polyhedral_gravity-3.0rc3 → polyhedral_gravity-3.2rc1}/README.md

@@ -60,8 +60,8 @@ which is strongly based on the former implementation in FORTRAN.
 
 > [!NOTE]
 > The [GitHub Pages](https://esa.github.io/polyhedral-gravity-model) of this project
-contain the full extensive documentation of C++ Library and the Python Interface
-as well as background on the gravity model and advanced settings not detailed here!
+contain the full extensive documentation of the C++ Library and Python Interface
+as well as background on the gravity model and advanced settings not detailed here.
 
 ## Input & Output (C++ and Python)
 
@@ -120,7 +120,7 @@ cube_density = 1.0
 computation_point = np.array([0, 0, 0])
 ```
 
-We first, define a constant density Polyhedron from `vertices` and `faces`
+We first define a constant density Polyhedron from `vertices` and `faces`
 
 ```python
 cube_polyhedron = Polyhedron(
@@ -129,9 +129,9 @@ cube_polyhedron = Polyhedron(
 )
 ```
 
-In case you want to hand over the polyhedron via a supported file format,
+In case you want to hand over the polyhedron via a [supported file format](https://esa.github.io/polyhedral-gravity-model/quickstart/supported_input.html),
 just replace the `polyhedral_source` argument with *a list of strings*,
-where each string is the path to a supported file format.
+where each string is the path to a supported file format, e.g. `polyhedral_source=["eros.node","eros.face"]` or `polyhedral_source=["eros.mesh"]`.
 
 Continuing, the simplest way to compute the gravity is to use the `evaluate` function:
 
@@ -149,14 +149,15 @@ evaluations. This is especially useful if you want to compute the gravity
 for multiple computation points, but don't know the "future points" in advance.
 
 ```python
-evaluable = GravityEvaluable(polyhedron=cube_polyhedron)
+evaluable = GravityEvaluable(polyhedron=cube_polyhedron) # stores intermediate computation steps
 potential, acceleration, tensor = evaluable(
   computation_points=computation_point,
   parallel=True,
 )
+# Any future evaluable call after this one will be faster
 ```
 
-Note that the `computation_point` could also be (N, 3)-shaped array.
+Note that the `computation_point` could also be (N, 3)-shaped array to compute multiple points at once.
 In this case, the return value of `evaluate(..)` or an `GravityEvaluable` will
 be a list of triplets comprising potential, acceleration, and tensor.
 
@@ -166,15 +167,15 @@ This property is - by default - checked when constructing the `Polyhedron`! So,
 is impossible if not **explicitly** disabled to create an invalid `Polyhedron`.
 You can disable/ enable this setting via the optional `integrity_check` flag and can even
 automatically repair the ordering via `HEAL`.
-As advanced user/ when you "know the mesh",
-you want to disable this check (via `DISABLE`) due to the additional runtime overhead!
+If you are confident that your mesh is defined correctly (e.g. checked once with the integrity check)
+you can disable this check (via `DISABLE`) to avoid the additional runtime overhead of the check.
 
 ```python
 cube_polyhedron = Polyhedron(
   polyhedral_source=(cube_vertices, cube_faces),
   density=cube_density,
   normal_orientation=NormalOrientation.INWARDS, # OUTWARDS (default) or INWARDS
-  integrity_check=PolyhedronIntegrity.VERIFY,   # AUTOMATIC (default) == VERIFY, DISABLE or HEAL
+  integrity_check=PolyhedronIntegrity.VERIFY,   # VERIFY (default), DISABLE or HEAL
 )
 ```
 
@@ -314,8 +315,7 @@ The following options are available:
 During testing POLYHEDRAL_GRAVITY_PARALLELIZATION=`TBB` has been the most performant.
 It is further not recommend to change the LOGGING_LEVEL to something else than `INFO=2`.
 
-The recommended CMake command would look like this (we only need to change `PARALLELIZATION_DEVICE`, since
-the defaults of the others are already correctly set):
+The recommended CMake settings using the `TBB` backend would look like this:
 
 ```bash
 cmake .. -POLYHEDRAL_GRAVITY_PARALLELIZATION="TBB"
@@ -326,7 +326,7 @@ cmake .. -POLYHEDRAL_GRAVITY_PARALLELIZATION="TBB"
 After the build, the gravity model can be run by executing:
 
 ```bash
-    ./polyhedralGravity <YAML-Configuration-File>
+./polyhedralGravity <YAML-Configuration-File>
 ```
 
 where the YAML-Configuration-File contains the required parameters.

{polyhedral_gravity-3.0rc3 → polyhedral_gravity-3.2rc1}/cmake/pybind11.cmake

@@ -2,7 +2,7 @@ include(FetchContent)
 
 message(STATUS "Setting up pybind11")
 
-find_package(pybind11 2.10.4 QUIET)
+find_package(pybind11 2.12.0 QUIET)
 
 if (${pybind11_FOUND})
 
@@ -12,11 +12,10 @@ else()
 
     message(STATUS "Using pybind11 from git repository")
 
-    #Fetches the version 2.10.4 from the official github of pybind11
     FetchContent_Declare(pybind11
             GIT_REPOSITORY https://github.com/pybind/pybind11
-            GIT_TAG v2.10.4
-            )
+            GIT_TAG v2.12.0
+    )
 
     FetchContent_MakeAvailable(pybind11)
 

{polyhedral_gravity-3.0rc3 → polyhedral_gravity-3.2rc1}/cmake/spdlog.cmake

@@ -2,7 +2,7 @@ include(FetchContent)
 
 message(STATUS "Setting up spdlog")
 
-find_package(spdlog 1.11.0 QUIET)
+find_package(spdlog 1.14.1 QUIET)
 
 if (${spdlog_FOUND})
 
@@ -12,11 +12,10 @@ else()
 
     message(STATUS "Using spdlog from git repository")
 
-    #Fetches the version 1.11.0 for spdlog
     FetchContent_Declare(spdlog
             GIT_REPOSITORY https://github.com/gabime/spdlog.git
-            GIT_TAG v1.11.0
-            )
+            GIT_TAG v1.14.1
+    )
 
     # Disable stuff we don't need
     option(SPDLOG_BUILD_EXAMPLE "" OFF)

{polyhedral_gravity-3.0rc3 → polyhedral_gravity-3.2rc1}/cmake/tbb.cmake

@@ -2,11 +2,11 @@ include(FetchContent)
 
 message(STATUS "Setting up tbb via CMake")
 
-#Fetches the version v2021.5.0 from the official github of tbb
+#Fetches the version v2021.12.0 from the official github of tbb
 FetchContent_Declare(tbb
         GIT_REPOSITORY https://github.com/oneapi-src/oneTBB.git
-        GIT_TAG v2021.5.0
-        )
+        GIT_TAG v2021.12.0
+)
 
 # Disable tests & and do not treat tbb-compile errors as warnings
 option(TBB_TEST "Enable testing" OFF)

{polyhedral_gravity-3.0rc3 → polyhedral_gravity-3.2rc1}/cmake/yaml.cmake

@@ -2,7 +2,7 @@ include(FetchContent)
 
 message(STATUS "Setting up yaml-cpp")
 
-find_package(yaml-cpp 0.7.0 QUIET)
+find_package(yaml-cpp 0.8.0 QUIET)
 
 if (${yaml-cpp_FOUND})
 
@@ -10,10 +10,10 @@ if (${yaml-cpp_FOUND})
 
 else()
 
-    #Fetches the version 0.7.0 for yaml-cpp
+    #Fetches the version 0.8.0 for yaml-cpp
     FetchContent_Declare(yaml-cpp
             GIT_REPOSITORY https://github.com/jbeder/yaml-cpp.git
-            GIT_TAG yaml-cpp-0.7.0
+            GIT_TAG 0.8.0
             )
 
     # Disable everything we don't need

{polyhedral_gravity-3.0rc3 → polyhedral_gravity-3.2rc1/polyhedral_gravity.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: polyhedral_gravity
-Version: 3.0rc3
+Version: 3.2rc1
 Summary: Package to compute full gravity tensor of a given constant density polyhedron for arbitrary points according to the geodetic convention
 Author: Jonas Schuhmacher
 Author-email: jonas.schuhmacher@tum.de
@@ -79,8 +79,8 @@ which is strongly based on the former implementation in FORTRAN.
 
 > [!NOTE]
 > The [GitHub Pages](https://esa.github.io/polyhedral-gravity-model) of this project
-contain the full extensive documentation of C++ Library and the Python Interface
-as well as background on the gravity model and advanced settings not detailed here!
+contain the full extensive documentation of the C++ Library and Python Interface
+as well as background on the gravity model and advanced settings not detailed here.
 
 ## Input & Output (C++ and Python)
 
@@ -139,7 +139,7 @@ cube_density = 1.0
 computation_point = np.array([0, 0, 0])
 ```
 
-We first, define a constant density Polyhedron from `vertices` and `faces`
+We first define a constant density Polyhedron from `vertices` and `faces`
 
 ```python
 cube_polyhedron = Polyhedron(
@@ -148,9 +148,9 @@ cube_polyhedron = Polyhedron(
 )
 ```
 
-In case you want to hand over the polyhedron via a supported file format,
+In case you want to hand over the polyhedron via a [supported file format](https://esa.github.io/polyhedral-gravity-model/quickstart/supported_input.html),
 just replace the `polyhedral_source` argument with *a list of strings*,
-where each string is the path to a supported file format.
+where each string is the path to a supported file format, e.g. `polyhedral_source=["eros.node","eros.face"]` or `polyhedral_source=["eros.mesh"]`.
 
 Continuing, the simplest way to compute the gravity is to use the `evaluate` function:
 
@@ -168,14 +168,15 @@ evaluations. This is especially useful if you want to compute the gravity
 for multiple computation points, but don't know the "future points" in advance.
 
 ```python
-evaluable = GravityEvaluable(polyhedron=cube_polyhedron)
+evaluable = GravityEvaluable(polyhedron=cube_polyhedron) # stores intermediate computation steps
 potential, acceleration, tensor = evaluable(
   computation_points=computation_point,
   parallel=True,
 )
+# Any future evaluable call after this one will be faster
 ```
 
-Note that the `computation_point` could also be (N, 3)-shaped array.
+Note that the `computation_point` could also be (N, 3)-shaped array to compute multiple points at once.
 In this case, the return value of `evaluate(..)` or an `GravityEvaluable` will
 be a list of triplets comprising potential, acceleration, and tensor.
 
@@ -185,15 +186,15 @@ This property is - by default - checked when constructing the `Polyhedron`! So,
 is impossible if not **explicitly** disabled to create an invalid `Polyhedron`.
 You can disable/ enable this setting via the optional `integrity_check` flag and can even
 automatically repair the ordering via `HEAL`.
-As advanced user/ when you "know the mesh",
-you want to disable this check (via `DISABLE`) due to the additional runtime overhead!
+If you are confident that your mesh is defined correctly (e.g. checked once with the integrity check)
+you can disable this check (via `DISABLE`) to avoid the additional runtime overhead of the check.
 
 ```python
 cube_polyhedron = Polyhedron(
   polyhedral_source=(cube_vertices, cube_faces),
   density=cube_density,
   normal_orientation=NormalOrientation.INWARDS, # OUTWARDS (default) or INWARDS
-  integrity_check=PolyhedronIntegrity.VERIFY,   # AUTOMATIC (default) == VERIFY, DISABLE or HEAL
+  integrity_check=PolyhedronIntegrity.VERIFY,   # VERIFY (default), DISABLE or HEAL
 )
 ```
 
@@ -333,8 +334,7 @@ The following options are available:
 During testing POLYHEDRAL_GRAVITY_PARALLELIZATION=`TBB` has been the most performant.
 It is further not recommend to change the LOGGING_LEVEL to something else than `INFO=2`.
 
-The recommended CMake command would look like this (we only need to change `PARALLELIZATION_DEVICE`, since
-the defaults of the others are already correctly set):
+The recommended CMake settings using the `TBB` backend would look like this:
 
 ```bash
 cmake .. -POLYHEDRAL_GRAVITY_PARALLELIZATION="TBB"
@@ -345,7 +345,7 @@ cmake .. -POLYHEDRAL_GRAVITY_PARALLELIZATION="TBB"
 After the build, the gravity model can be run by executing:
 
 ```bash
-    ./polyhedralGravity <YAML-Configuration-File>
+./polyhedralGravity <YAML-Configuration-File>
 ```
 
 where the YAML-Configuration-File contains the required parameters.

{polyhedral_gravity-3.0rc3 → polyhedral_gravity-3.2rc1}/polyhedral_gravity.egg-info/SOURCES.txt

@@ -41,6 +41,8 @@ src/polyhedralGravity/output/Logging.cpp
 src/polyhedralGravity/output/Logging.h
 src/polyhedralGravity/util/UtilityConstants.h
 src/polyhedralGravity/util/UtilityContainer.h
+src/polyhedralGravity/util/UtilityFloatArithmetic.cpp
+src/polyhedralGravity/util/UtilityFloatArithmetic.h
 src/polyhedralGravity/util/UtilityThrust.h
 src/polyhedralGravityPython/CMakeLists.txt
 src/polyhedralGravityPython/PolyhedralGravityPython.cpp

{polyhedral_gravity-3.0rc3 → polyhedral_gravity-3.2rc1}/setup.py

@@ -175,7 +175,7 @@ picture_in_readme = '''<p align="center">
 # --------------------------------------------------------------------------------
 setup(
     name="polyhedral_gravity",
-    version="3.0rc3",
+    version="3.2rc1",
     author="Jonas Schuhmacher",
     author_email="jonas.schuhmacher@tum.de",
     description="Package to compute full gravity tensor of a given constant density polyhedron for arbitrary points "

{polyhedral_gravity-3.0rc3 → polyhedral_gravity-3.2rc1}/src/polyhedralGravity/model/GravityModelData.h

@@ -6,7 +6,7 @@
 #include <algorithm>
 #include <tuple>
 #include "polyhedralGravity/util/UtilityContainer.h"
-#include "polyhedralGravity/util/UtilityConstants.h"
+#include "polyhedralGravity/util/UtilityFloatArithmetic.h"
 
 namespace polyhedralGravity {
 
@@ -76,20 +76,23 @@ namespace polyhedralGravity {
         double s2;
 
         /**
-         * Checks two Distance structs for equality.
-         * @warning This method compares doubles! So only exact copies will evaluate to true.
+         * Checks two Distance structs for equality with another one by ensuring that the members are
+         * almost equal.
          * @param rhs the other Distance struct
          * @return true if equal
          *
          * @note Just used for testing purpose
          */
         bool operator==(const Distance &rhs) const {
-            return l1 == rhs.l1 && l2 == rhs.l2 && s1 == rhs.s1 && s2 == rhs.s2;
+            return util::almostEqualRelative(l1, rhs.l1) &&
+                   util::almostEqualRelative(l2, rhs.l2) &&
+                   util::almostEqualRelative(s1, rhs.s1) &&
+                   util::almostEqualRelative(s2, rhs.s2);
         }
 
         /**
-         * Checks two Distance structs for inequality.
-         * @warning This method compares doubles! So only exact copies will evaluate to false.
+         * Checks two Distance structs for inequality with another one by ensuring that the members are
+         * not almost equal.
          * @param rhs the other Distance struct
          * @return false if unequal
          *
@@ -130,20 +133,20 @@ namespace polyhedralGravity {
         double an;
 
         /**
-         * Checks two TranscendentalExpressions for equality.
-         * @warning This method compares doubles! So only exact copies will evaluate to true.
+         * Checks two TranscendentalExpressions for equality with another one by ensuring that the members are
+         * almost equal.
          * @param rhs the other TranscendentalExpressions
          * @return true if equal
          *
          * @note Just used for testing purpose
          */
         bool operator==(const TranscendentalExpression &rhs) const {
-            return ln == rhs.ln && an == rhs.an;
+            return util::almostEqualRelative(ln, rhs.ln) && util::almostEqualRelative(an, rhs.an);
         }
 
         /**
-         * Checks two TranscendentalExpressions for inequality.
-         * @warning This method compares doubles! So only exact copies will evaluate to false.
+         * Checks two TranscendentalExpressions for inequality with another one by ensuring that the members are
+         * not almost equal.
          * @param rhs the other TranscendentalExpressions
          * @return false if unequal
          *
@@ -191,20 +194,23 @@ namespace polyhedralGravity {
         double d;
 
         /**
-         * Checking the equality of two this Hessian Plane with another one by comparing their members.
-         * @warning This method compares doubles! So only exact copies will evaluate to true.
+         * Checking the equality of two this Hessian Plane with another one by ensuring that the members are
+         * almost equal.
          * @param rhs other HessianPlane
          * @return true if equal
          *
          * @note Just used for testing purpose
          */
         bool operator==(const HessianPlane &rhs) const {
-            return a == rhs.a && b == rhs.b && c == rhs.c && d == rhs.d;
+            return util::almostEqualRelative(a, rhs.a) &&
+                   util::almostEqualRelative(b, rhs.b) &&
+                   util::almostEqualRelative(c, rhs.c) &&
+                   util::almostEqualRelative(d, rhs.d);
         }
 
         /**
-         * Checking the inequality of two this Hessian Plane with another one by comparing their members.
-         * @warning This method compares doubles! So only exact copies will evaluate to false.
+         * Checking the inequality of two this Hessian Plane with another one by ensuring that the members are
+         * not almost equal.
          * @param rhs other HessianPlane
          * @return true if unequal
          *
@@ -213,6 +219,17 @@ namespace polyhedralGravity {
         bool operator!=(const HessianPlane &rhs) const {
             return !(rhs == *this);
         }
+
+         /**
+         * Pretty output of this struct on the given ostream.
+         * @param os the ostream
+         * @param hessianPlane a HessianPlane
+         * @return os
+         */
+        friend std::ostream &operator<<(std::ostream &os, const HessianPlane &hessianPlane) {
+            os << "a: " << hessianPlane.a << " b: " << hessianPlane.b << " c: " << hessianPlane.c << " d: " << hessianPlane.d;
+            return os;
+        }
     };
 
 }

{polyhedral_gravity-3.0rc3 → polyhedral_gravity-3.2rc1}/src/polyhedralGravity/model/GravityModelDetail.cpp

@@ -28,7 +28,7 @@ namespace polyhedralGravity::GravityModel::detail {
         //Calculate N_i * -G_i1 where * is the dot product and then use the inverted sgn
         //We abstain on the double multiplication with -1 in the line above and beyond since two
         //times multiplying with -1 equals no change
-        return sgn(dot(planeUnitNormal, vertex0), util::EPSILON);
+        return sgn(dot(planeUnitNormal, vertex0), util::EPSILON_ZERO_OFFSET);
     }
 
     HessianPlane computeHessianPlane(const Array3 &p, const Array3 &q, const Array3 &r) {
@@ -95,7 +95,7 @@ namespace polyhedralGravity::GravityModel::detail {
                        segmentNormalOrientations.begin(),
                        [&projectionPointOnPlane](const Array3 &segmentUnitNormal, const Array3 &vertex) {
                            using namespace util;
-                           return sgn((dot(segmentUnitNormal, projectionPointOnPlane - vertex)), util::EPSILON) * -1.0;
+                           return sgn((dot(segmentUnitNormal, projectionPointOnPlane - vertex)), util::EPSILON_ZERO_OFFSET) * -1.0;
                        });
         return segmentNormalOrientations;
     }
@@ -190,8 +190,8 @@ namespace polyhedralGravity::GravityModel::detail {
 
                               //4. Option: |s1 - l1| == 0 && |s2 - l2| == 0 Computation point P is located from the beginning on
                               // the direction of a specific segment (P coincides with P' and P'')
-                              if (std::abs(distance.s1 - distance.l1) < EPSILON &&
-                                  std::abs(distance.s2 - distance.l2) < EPSILON) {
+                              if (std::abs(distance.s1 - distance.l1) < EPSILON_ZERO_OFFSET &&
+                                  std::abs(distance.s2 - distance.l2) < EPSILON_ZERO_OFFSET) {
                                   //4. Option - Case 2: P is located on the segment from its right side
                                   // s1 = -|s1|, s2 = -|s2|, l1 = -|l1|, l2 = -|l2|
                                   if (distance.s2 < distance.s1) {
@@ -200,7 +200,7 @@ namespace polyhedralGravity::GravityModel::detail {
                                       distance.l1 *= -1.0;
                                       distance.l2 *= -1.0;
                                       return distance;
-                                  } else if (std::abs(distance.s2 - distance.s1) < EPSILON) {
+                                  } else if (std::abs(distance.s2 - distance.s1) < EPSILON_ZERO_OFFSET) {
                                       //4. Option - Case 1: P is located inside the segment (s2 == s1)
                                       // s1 = -|s1|, s2 = |s2|, l1 = -|l1|, l2 = |l2|
                                       distance.s1 *= -1.0;
@@ -264,9 +264,9 @@ namespace polyhedralGravity::GravityModel::detail {
                               // If sigma_pq == 0 && either of the distances of P' to the two segment endpoints == 0 OR
                               // the 1D and 3D distances are smaller than some EPSILON
                               // then LN_pq can be set to zero
-                              if ((segmentNormalOrientation == 0.0 && (r1Norm < EPSILON || r2Norm < EPSILON)) ||
-                                  (std::abs(distance.s1 + distance.s2) < EPSILON &&
-                                   std::abs(distance.l1 + distance.l2) < EPSILON)) {
+                              if ((segmentNormalOrientation == 0.0 && (r1Norm < EPSILON_ZERO_OFFSET || r2Norm < EPSILON_ZERO_OFFSET)) ||
+                                  (std::abs(distance.s1 + distance.s2) < EPSILON_ZERO_OFFSET &&
+                                   std::abs(distance.l1 + distance.l2) < EPSILON_ZERO_OFFSET)) {
                                   transcendentalExpressionPerSegment.ln = 0.0;
                               } else {
                                   //Implementation of
@@ -277,7 +277,7 @@ namespace polyhedralGravity::GravityModel::detail {
 
                               //Compute AN_pq according to (15)
                               // If h_p == 0 or h_pq == 0 then AN_pq is zero, too (distances are always positive!)
-                              if (planeDistance < EPSILON || segmentDistance < EPSILON) {
+                              if (planeDistance < EPSILON_ZERO_OFFSET || segmentDistance < EPSILON_ZERO_OFFSET) {
                                   transcendentalExpressionPerSegment.an = 0.0;
                               } else {
                                   //Implementation of:
@@ -331,7 +331,7 @@ namespace polyhedralGravity::GravityModel::detail {
             const unsigned int j = thrust::get<2>(tuple);
 
             //segmentNormalOrientation != 0.0
-            if (std::abs(segmentNormalOrientation) > EPSILON) {
+            if (std::abs(segmentNormalOrientation) > EPSILON_ZERO_OFFSET) {
                 return false;
             }
 
@@ -358,14 +358,14 @@ namespace polyhedralGravity::GravityModel::detail {
             j = thrust::get<1>(tuple);
 
             //segmentNormalOrientation != 0.0
-            if (std::abs(segmentNormalOrientation) > EPSILON) {
+            if (std::abs(segmentNormalOrientation) > EPSILON_ZERO_OFFSET) {
                 return false;
             }
 
             r1Norm = projectionPointVertexNorms[(j + 1) % 3];
             r2Norm = projectionPointVertexNorms[j];
             //r1Norm == 0.0 || r2Norm == 0.0
-            return r1Norm < EPSILON || r2Norm < EPSILON;
+            return r1Norm < EPSILON_ZERO_OFFSET || r2Norm < EPSILON_ZERO_OFFSET;
         })) {
             using namespace util;
             //Two segment vectors G_1 and G_2 of this plane

{polyhedral_gravity-3.0rc3 → polyhedral_gravity-3.2rc1}/src/polyhedralGravity/model/GravityModelDetail.h

@@ -21,6 +21,7 @@
 #include "polyhedralGravity/util/UtilityConstants.h"
 #include "polyhedralGravity/util/UtilityContainer.h"
 #include "polyhedralGravity/util/UtilityThrust.h"
+#include "polyhedralGravity/util/UtilityFloatArithmetic.h"
 #include "polyhedralGravity/output/Logging.h"
 
 namespace polyhedralGravity::GravityModel::detail {

{polyhedral_gravity-3.0rc3 → polyhedral_gravity-3.2rc1}/src/polyhedralGravity/model/Polyhedron.cpp

@@ -137,7 +137,7 @@ namespace polyhedralGravity {
                                    "The mesh check is enabled and analyzes the polyhedron for degnerated faces & "
                                    "that all plane unit normals point in the specified direction. This checks requires "
                                    "a quadratic runtime cost which is most of the time not desirable. "
-                                   "Please explcity set the inetgrity_check to either VERIFY, HEAL or DISABLE."
+                                   "Please explicitly set the integrity_check to either VERIFY, HEAL or DISABLE."
                                    "You can find further details in the documentation!");
             // NO BREAK! AUTOMATIC implies VERIFY, but with a info mesage to explcitly set the option
             case PolyhedronIntegrity::VERIFY:
@@ -153,13 +153,13 @@ namespace polyhedralGravity {
                     if (violatingIndices.empty()) {
                         sstream << "Instead all plane unit normals are pointing "
                                 << actualOrientation
-                                << ". You can either reconstruct the polyhedron with the ortientation set to " << actualOrientation
+                                << ". You can either reconstruct the polyhedron with the orientation set to " << actualOrientation
                                 << ". Alternativly, you can reconstruct with the inetgrity_check set to HEAL";
                     } else {
                         sstream << "The actual majority orientation of the polyhedron's normals is " << actualOrientation
                                 << ". You can either:\n 1) Fix the ordering of the following faces:\n"
                                 << violatingIndices << '\n'
-                                << "2) Or you reconstruct the polyhedron using the inetgrity_check set to HEAL.";
+                                << "2) Or you reconstruct the polyhedron using the integrity_check set to HEAL.";
                     }
                     // In case of HEAL, don't throw but repair
                     if (integrity != PolyhedronIntegrity::HEAL) {
@@ -202,7 +202,7 @@ namespace polyhedralGravity {
         const Array3 rayVector = normal(segmentVector1, segmentVector2);
 
         // The origin of the array has a slight offset in direction of the normal
-        const Array3 rayOrigin = centroid + (rayVector * EPSILON);
+        const Array3 rayOrigin = centroid + (rayVector * EPSILON_ZERO_OFFSET);
 
         // Count every triangular face which is intersected by the ray
         const auto &[begin, end] = this->transformIterator();
@@ -224,7 +224,7 @@ namespace polyhedralGravity {
         const Array3 edge2 = triangle[2] - triangle[0];
         const Array3 h = cross(rayVector, edge2);
         const double a = dot(edge1, h);
-        if (a > -EPSILON && a < EPSILON) {
+        if (a > -EPSILON_ZERO_OFFSET && a < EPSILON_ZERO_OFFSET) {
             return nullptr;
         }
 
@@ -242,7 +242,7 @@ namespace polyhedralGravity {
         }
 
         const double t = f * dot(edge2, q);
-        if (t > EPSILON) {
+        if (t > EPSILON_ZERO_OFFSET) {
             return std::make_unique<Array3>(rayOrigin + rayVector * t);
         } else {
             return nullptr;

{polyhedral_gravity-3.0rc3 → polyhedral_gravity-3.2rc1}/src/polyhedralGravity/model/Polyhedron.h

@@ -22,6 +22,7 @@
 #include "thrust/iterator/transform_iterator.h"
 #include "polyhedralGravity/util/UtilityContainer.h"
 #include "polyhedralGravity/util/UtilityConstants.h"
+#include "polyhedralGravity/util/UtilityFloatArithmetic.h"
 
 namespace polyhedralGravity {
 
@@ -150,7 +151,7 @@ namespace polyhedralGravity {
          *
          * @note ASSERTS PRE-CONDITION that the in the indexing in the faces vector starts with zero!
          * @throws std::invalid_argument if no face contains the node zero indicating mathematical index
-         * @throws std::invalid_argument dpending on the {@param integrity} flag
+         * @throws std::invalid_argument dpending on the {@link integrity} flag
          */
         Polyhedron(
                 const std::vector<Array3> &vertices,
@@ -169,7 +170,7 @@ namespace polyhedralGravity {
          *
          * @note ASSERTS PRE-CONDITION that the in the indexing in the faces vector starts with zero!
          * @throws std::invalid_argument if no face contains the node zero indicating mathematical index
-         * @throws std::invalid_argument dpending on the {@param integrity} flag
+         * @throws std::invalid_argument dpending on the {@link integrity} flag
          */
         Polyhedron(
                 const PolyhedralSource &polyhedralSource,
@@ -187,7 +188,7 @@ namespace polyhedralGravity {
          *
          * @note ASSERTS PRE-CONDITION that the in the indexing in the faces vector starts with zero!
          * @throws std::invalid_argument if no face contains the node zero indicating mathematical index
-         * @throws std::invalid_argument dpending on the {@param integrity} flag
+         * @throws std::invalid_argument dpending on the {@link integrity} flag
          */
         Polyhedron(const PolyhedralFiles &polyhedralFiles, double density,
                    const NormalOrientation &orientation = NormalOrientation::OUTWARDS,
@@ -203,7 +204,7 @@ namespace polyhedralGravity {
          *
          * @note ASSERTS PRE-CONDITION that the in the indexing in the faces vector starts with zero!
          * @throws std::invalid_argument if no face contains the node zero indicating mathematical index
-         * @throws std::invalid_argument dpending on the {@param integrity} flag
+         * @throws std::invalid_argument dpending on the {@link integrity} flag
          */
         Polyhedron(const std::variant<PolyhedralSource, PolyhedralFiles> &polyhedralSource, double density,
                    const NormalOrientation &orientation = NormalOrientation::OUTWARDS,

{polyhedral_gravity-3.0rc3 → polyhedral_gravity-3.2rc1}/src/polyhedralGravity/util/UtilityConstants.h

@@ -2,15 +2,6 @@
 
 namespace polyhedralGravity::util {
 
-    /**
-     * The EPSILON used in the polyhedral gravity model.
-     * @related Used to determine if a floating point number is equal to zero as threshold for rounding errors
-     * @related Used for the sgn() function to determine the sign of a double value. Different compilers
-     * produce different results if no EPSILON is applied for the comparison!
-     */
-    constexpr double EPSILON = 1e-14;
-
-
     /**
      * PI with enough precision
      */

polyhedral_gravity-3.2rc1/src/polyhedralGravity/util/UtilityFloatArithmetic.cpp

@@ -0,0 +1,51 @@
+#include "UtilityFloatArithmetic.h"
+
+
+namespace polyhedralGravity::util {
+
+    template<typename FloatType>
+    bool almostEqualUlps(FloatType lhs, FloatType rhs, int ulpDistance) {
+        static_assert(std::is_same_v<FloatType, float> || std::is_same_v<FloatType, double>,
+                      "Template argument must be FloatType: Either float or double!");
+
+        // In case the floats are equal in their representation, return true
+        if (lhs == rhs) {
+            return true;
+        }
+
+        // In case the signs mismatch, return false
+        if (lhs < static_cast<FloatType>(0.0) && rhs > static_cast<FloatType>(0.0) ||
+            lhs > static_cast<FloatType>(0.0) && rhs < static_cast<FloatType>(0.0)) {
+            return false;
+            }
+
+        if constexpr (std::is_same_v<FloatType, float>) {
+            // In case of float, compute ULP distance by interpreting float as 32-bit integer
+            return reinterpret_cast<std::int32_t&>(rhs) - reinterpret_cast<std::int32_t&>(lhs) <= ulpDistance;
+        }
+        else if constexpr (std::is_same_v<FloatType, double>) {
+            // In case of double, compute ULP distance by interpreting double as 64-bit integer
+            return reinterpret_cast<std::int64_t&>(rhs) - reinterpret_cast<std::int64_t&>(lhs) <= ulpDistance;
+        }
+
+        // Due to the static_assert above, this should not happen
+        return false;
+    }
+
+    // Template Instantations for float and double (required since definition is in .cpp file,
+    //      also makes the static assert not strictly necessary)
+    template bool almostEqualUlps<float>(float lhs, float rhs, int ulpDistance);
+    template bool almostEqualUlps<double>(double lhs, double rhs, int ulpDistance);
+
+
+    template<typename FloatType>
+    bool almostEqualRelative(FloatType lhs, FloatType rhs, double epsilon) {
+        const FloatType diff = std::abs(rhs - lhs);
+        const FloatType largerValue = std::max(std::abs(rhs), std::abs(lhs));
+        return diff <= largerValue * epsilon;
+    }
+
+    template bool almostEqualRelative<float>(float lhs, float rhs, double epsilon);
+    template bool almostEqualRelative<double>(double lhs, double rhs, double epsilon);
+
+}

polyhedral_gravity-3.2rc1/src/polyhedralGravity/util/UtilityFloatArithmetic.h

@@ -0,0 +1,73 @@
+#pragma once
+
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <type_traits>
+
+namespace polyhedralGravity::util {
+
+    /**
+     * The EPSILON used in the polyhedral gravity model to determine a radius around zero/ to use as slight offset.
+     * @related Used to determine if a floating point number is equal to zero as threshold for rounding errors
+     * @related Used for the sgn() function to determine the sign of a double value. Different compilers
+     * produce different results if no EPSILON is applied for the comparison!
+     */
+    constexpr double EPSILON_ZERO_OFFSET = 1e-14;
+
+    /**
+     * This relative EPSILON is utilized ONLY for testing purposes to compare intermediate values to
+     * Tsoulis' reference implementation Fortran.
+     * It is used in the {@link polyhedralGravity::util::almostEqualRelative} function.
+     *
+     * @note While in theory no difference at all is observed when compiling this program on Linux using GCC on x86_64,
+     *  the intermediate values change when the program is compiled in different environments.
+     *  Hence, this solves the flakiness of the tests when on different plattforms
+     */
+    constexpr double EPSILON_ALMOST_EQUAL = 1e-10;
+
+    /**
+     * The maximal allowed ULP distance utilized for FloatingPoint comparisons using the
+     * {@link polyhedralGravity::util::almostEqualUlps} function.
+     *
+     * @see https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
+     */
+    constexpr int MAX_ULP_DISTANCE = 4;
+
+
+    /**
+     * Function for comparing closeness of two floating point numbers using ULP (Units in the Last Place) method.
+     *
+     * @tparam FloatType must be either double or float (ensured by static assertion)
+     * @param lhs The left hand side floating point number to compare.
+     * @param rhs The right hand side floating point number to compare.
+     * @param ulpDistance The maximum acceptable ULP distance between the two floating points
+     *      for which they would be considered near each other. This is optional and by default, it will be {@link MAX_ULP_DISTANCE}.
+     *
+     * @return true if the ULP distance between lhs and rhs is less than or equal to the provided ulpDistance value, otherwise, false.
+     *  Returns true if both numbers are exactly the same. Returns false if the signs do not match.
+     * @example The ULP distance between 3.0 and std::nextafter(3.0, INFINITY) would be 1,
+     *      the ULP distance of 3.0 and std::nextafter(std::nextafter(3.0, INFINITY), INFINITY) would be 2, etc.
+     * @see https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
+     */
+    template<typename FloatType>
+    bool almostEqualUlps(FloatType lhs, FloatType rhs, int ulpDistance = MAX_ULP_DISTANCE);
+
+    /**
+     * Function to check if two floating point numbers are relatively equal to each other within a given error range or tolerance.
+     *
+     * @tparam FloatType must be either double or float (ensured by static assertion)
+     * @param lhs The first floating-point number to be compared.
+     * @param rhs The second floating-point number to be compared.
+     * @param epsilon The tolerance for comparison. Two numbers that are less than epsilon apart are considered equal.
+     *                The default value is {@link EPSILON_ALMOST_EQUAL}.
+     *
+     * @return boolean value - Returns `true` if the absolute difference between `lhs` and `rhs` is less than or equal to
+     *                         the relative error factored by the larger of the magnitude of `lhs` and `rhs`. Otherwise, `false`.
+     * @see https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
+     */
+    template<typename FloatType>
+    bool almostEqualRelative(FloatType lhs, FloatType rhs, double epsilon = EPSILON_ALMOST_EQUAL);
+
+
+}

{polyhedral_gravity-3.0rc3 → polyhedral_gravity-3.2rc1}/src/polyhedralGravityPython/PolyhedralGravityPython.cpp

@@ -152,8 +152,8 @@ PYBIND11_MODULE(polyhedral_gravity, m) {
 
                                         * :code:`AUTOMATIC` (Default): Prints to stdout and throws ValueError if normal_orientation is wrong/ inconsisten
                                         * :code:`VERIFY`: Like :code:`AUTOMATIC`, but does not print to stdout
-                                        * :code:`DISABLE`: Recommened, when you know the mesh to avoid to pay :math:`O(n^2)` runtime. Disables ALL checks
-                                        * :code`HEAL`: Automatically fixes the normal_orientation and vertex ordering to the correct values
+                                        * :code:`DISABLE`: Recommened, when you are familiar with the mesh to avoid :math:`O(n^2)` runtime cost. Disables ALL checks
+                                        * :code:`HEAL`: Automatically fixes the normal_orientation and vertex ordering to the correct values
 
             Raises:
                 ValueError: If the faces array does not contain a reference to vertex 0 indicating an index start at 1
@@ -182,7 +182,7 @@ PYBIND11_MODULE(polyhedral_gravity, m) {
                 This utility is mainly for diagnostics and debugging purposes. If the polyhedron is constrcuted with `integrity_check`
                 set to :code:`AUTOMATIC` or :code:`VERIFY`, the construction fails anyways.
                 If set to :code:`HEAL`, this method should return an empty set (but maybe a different ordering than initially specified)
-                Only if set to code:`DISABLE`, then this method might actually return a set with faulty indices.
+                Only if set to :code:`DISABLE`, then this method might actually return a set with faulty indices.
                 Hence, if you want to know your mesh error. Construct the polyhedron with :code:`integrity_check=DISABLE` and call this method.
             )mydelimiter")
             .def("__getitem__", &Polyhedron::getResolvedFace, R"mydelimiter(