nlpsolver/src/com/sun/star/comp/Calc/NLPSolver/BaseEvolutionarySolver.java |
8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
New commits:
commit 763149e2f48766427e0962058ad812b07caf1e07
Author: Todor Balabanov <todor.balaba...@gmail.com>
AuthorDate: Sun Apr 28 12:14:40 2024 +0300
Commit: Caolán McNamara <caolan.mcnam...@collabora.com>
CommitDate: Mon Apr 29 15:40:27 2024 +0200
Double values comparison changed to compare method.
Using the Double.compare() method is often preferred over the == comparison
operator for comparing double values due to several reasons:
Handling NaN (Not-a-Number) values: The Double.compare() method correctly
handles NaN values, while the == operator does not. If either of the
operands
is NaN, the == operator will always return false, regardless of the other
operand. In contrast, Double.compare() will correctly evaluate NaN values
according to the IEEE 754 floating-point standard.
Handling positive and negative zero: The == operator treats positive zero
and
negative zero as equal, whereas they are distinct values in IEEE 754
floating-point representation. Double.compare() correctly distinguishes
between positive and negative zero.
Robustness against rounding errors: Floating-point arithmetic can introduce
rounding errors, causing two double values that should be equal to differ
slightly. Directly comparing them with the == operator might yield
unexpected
results due to these small differences. Double.compare() allows you to
define
a tolerance level if necessary, providing more control over how equality is
determined.
Consistent behavior: The behavior of Double.compare() is consistent and
predictable across different platforms and JVM implementations, as it
follows
the IEEE 754 standard. On the other hand, the behavior of the == operator
might vary depending on the platform and compiler optimizations.
Suitability for sorting: Double.compare() returns an integer value that can
be directly used for sorting double values in ascending or descending order.
This makes it convenient for sorting arrays or collections of double values.
Overall, while the == operator might work in some cases, using
Double.compare() provides more robust and predictable behavior, especially
when dealing with floating-point numbers in Java.
Change-Id: I5756936a0d2b4fe11b9113ddd33b6ae691f5103f
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/166796
Tested-by: Jenkins
Reviewed-by: Caolán McNamara <caolan.mcnam...@collabora.com>
Tested-by: Caolán McNamara <caolan.mcnam...@collabora.com>
diff --git
a/nlpsolver/src/com/sun/star/comp/Calc/NLPSolver/BaseEvolutionarySolver.java
b/nlpsolver/src/com/sun/star/comp/Calc/NLPSolver/BaseEvolutionarySolver.java
index 0c402e87c12f..b3ec15a8ca92 100644
--- a/nlpsolver/src/com/sun/star/comp/Calc/NLPSolver/BaseEvolutionarySolver.java
+++ b/nlpsolver/src/com/sun/star/comp/Calc/NLPSolver/BaseEvolutionarySolver.java
@@ -211,7 +211,7 @@ public abstract class BaseEvolutionarySolver extends
BaseNLPSolver {
//0 is a bad starting point, so just pick some other.
//That is certainly not optimal but the user should specify
//bounds or at least a good starting point anyway.
- if (value == 0.0)
+ if (Double.compare(value, 0.0D) == 0)
value = 1000;
double b1;
@@ -366,7 +366,7 @@ public abstract class BaseEvolutionarySolver extends
BaseNLPSolver {
switch (m_extConstraints[i].Operator.getValue()) {
case SolverConstraintOperator.EQUAL_value:
- result = value == targetValue;
+ result = Double.compare(value, targetValue) == 0;
break;
case SolverConstraintOperator.GREATER_EQUAL_value:
result = value >= targetValue;
@@ -375,10 +375,10 @@ public abstract class BaseEvolutionarySolver extends
BaseNLPSolver {
result = value <= targetValue;
break;
case SolverConstraintOperator.INTEGER_value:
- result = Math.rint(value) == value;
+ result = Double.compare(Math.rint(value), value) == 0;
break;
case SolverConstraintOperator.BINARY_value:
- result = (value == 0.0 || value == 1.0);
+ result = (Double.compare(value, 0.0D) == 0 ||
Double.compare(value, 1.0D) == 0);
break;
}
} else {
