Tempus  Version of the Day
Time Integration
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Tempus_UnitTest_NumericalUtils.cpp
Go to the documentation of this file.
1 // @HEADER
2 // ****************************************************************************
3 // Tempus: Copyright (2017) Sandia Corporation
4 //
5 // Distributed under BSD 3-clause license (See accompanying file Copyright.txt)
6 // ****************************************************************************
7 // @HEADER
8 
9 #include "Tempus_UnitTest_Utils.hpp"
10 
11 #include "Tempus_NumericalUtils.hpp"
12 
13 namespace Tempus_Unit_Test {
14 
15 using Tempus::approxEqual;
16 using Tempus::approxEqualAbsTol;
17 using Tempus::approxEqualScale;
18 
19 static double PI = M_PI;
20 static double eps = 1.0e-14;
21 
22 // ************************************************************
23 // ************************************************************
24 TEUCHOS_UNIT_TEST(NumericalUtils, approxEqual)
25 {
26  double zero = 0.0;
27  double one = 1.0;
28 
29  std::vector<double> scales;
30  scales.push_back(1.0);
31  scales.push_back(100.0);
32  scales.push_back(0.01);
33  scales.push_back(1.0e-28);
34  scales.push_back(1.0e+28);
35 
36  std::vector<double> numbers;
37  numbers.push_back(one);
38  numbers.push_back(PI);
39 
40  for (auto& s : scales) {
41  out << " *****************************" << std::endl;
42  out << " s, eps = " << s << ", " << eps << std::endl;
43 
44  TEST_COMPARE(approxEqual(zero * s, (zero - 10.0 * eps) * s), ==, false);
45  TEST_COMPARE(approxEqual(zero * s, (zero - eps) * s), ==, false);
46  TEST_COMPARE(approxEqual(zero * s, (zero)*s), ==, true);
47  TEST_COMPARE(approxEqual(zero * s, (zero + eps) * s), ==, false);
48  TEST_COMPARE(approxEqual(zero * s, (zero + 10.0 * eps) * s), ==, false);
49 
50  // Swap
51  TEST_COMPARE(approxEqual((zero - 10.0 * eps) * s, zero * s), ==, false);
52  TEST_COMPARE(approxEqual((zero - eps) * s, zero * s), ==, false);
53  TEST_COMPARE(approxEqual((zero)*s, zero * s), ==, true);
54  TEST_COMPARE(approxEqual((zero + eps) * s, zero * s), ==, false);
55  TEST_COMPARE(approxEqual((zero + 10.0 * eps) * s, zero * s), ==, false);
56 
57  for (auto& n : numbers) {
58  out << " n = " << n << std::endl;
59 
60  TEST_COMPARE(approxEqual(n * s, (n - 10.0 * eps) * s), ==, false);
61  TEST_COMPARE(approxEqual(n * s, (n - eps) * s), ==, true);
62  TEST_COMPARE(approxEqual(n * s, (n)*s), ==, true);
63  TEST_COMPARE(approxEqual(n * s, (n + eps) * s), ==, true);
64  TEST_COMPARE(approxEqual(n * s, (n + 10.0 * eps) * s), ==, false);
65 
66  // Swap
67  TEST_COMPARE(approxEqual((n - 10.0 * eps) * s, n * s), ==, false);
68  TEST_COMPARE(approxEqual((n - eps) * s, n * s), ==, true);
69  TEST_COMPARE(approxEqual((n)*s, n * s), ==, true);
70  TEST_COMPARE(approxEqual((n + eps) * s, n * s), ==, true);
71  TEST_COMPARE(approxEqual((n + 10.0 * eps) * s, n * s), ==, false);
72  }
73  out << " *****************************" << std::endl;
74  }
75 }
76 
77 // ************************************************************
78 // ************************************************************
79 TEUCHOS_UNIT_TEST(NumericalUtils, approxEqualAbsTol)
80 {
81  double numTol = Tempus::numericalTol<double>();
82  double zero = 0.0;
83  double one = 1.0;
84 
85  std::vector<double> scales;
86  scales.push_back(1.0);
87  scales.push_back(100.0);
88  scales.push_back(0.01);
89  scales.push_back(1.0e-28);
90  scales.push_back(1.0e+28);
91 
92  std::vector<double> numbers;
93  numbers.push_back(zero);
94  numbers.push_back(one);
95  numbers.push_back(PI);
96 
97  for (auto& s : scales) {
98  for (auto& n : numbers) {
99  out << " *****************************" << std::endl;
100  out << " n, s, eps = " << n << ", " << s << ", " << eps << std::endl;
101 
102  TEST_COMPARE(approxEqualAbsTol(n * s, (n - 10.0 * eps) * s, numTol * s),
103  ==, false);
104  TEST_COMPARE(approxEqualAbsTol(n * s, (n - eps) * s, numTol * s), ==,
105  true);
106  TEST_COMPARE(approxEqualAbsTol(n * s, (n)*s, numTol * s), ==, true);
107  TEST_COMPARE(approxEqualAbsTol(n * s, (n + eps) * s, numTol * s), ==,
108  true);
109  TEST_COMPARE(approxEqualAbsTol(n * s, (n + 10.0 * eps) * s, numTol * s),
110  ==, false);
111 
112  // Swap
113  TEST_COMPARE(approxEqualAbsTol((n - 10.0 * eps) * s, n * s, numTol * s),
114  ==, false);
115  TEST_COMPARE(approxEqualAbsTol((n - eps) * s, n * s, numTol * s), ==,
116  true);
117  TEST_COMPARE(approxEqualAbsTol((n)*s, n * s, numTol * s), ==, true);
118  TEST_COMPARE(approxEqualAbsTol((n + eps) * s, n * s, numTol * s), ==,
119  true);
120  TEST_COMPARE(approxEqualAbsTol((n + 10.0 * eps) * s, n * s, numTol * s),
121  ==, false);
122 
123  out << " *****************************" << std::endl;
124  }
125  }
126 }
127 
128 // ************************************************************
129 // ************************************************************
130 TEUCHOS_UNIT_TEST(NumericalUtils, approxEqualScale)
131 {
132  double zero = 0.0;
133  double one = 1.0;
134 
135  std::vector<double> scales;
136  scales.push_back(1.0);
137  scales.push_back(100.0);
138  scales.push_back(0.01);
139  scales.push_back(1.0e-28);
140  scales.push_back(1.0e+28);
141 
142  std::vector<double> numbers;
143  numbers.push_back(zero);
144  numbers.push_back(one);
145  numbers.push_back(PI);
146 
147  for (auto& s : scales) {
148  for (auto& n : numbers) {
149  out << " *****************************" << std::endl;
150  out << " n, s, eps = " << n << ", " << s << ", " << eps << std::endl;
151 
152  TEST_COMPARE(approxEqualScale(n * s, (n - 10.0 * eps) * s, s), ==, false);
153  TEST_COMPARE(approxEqualScale(n * s, (n - eps) * s, s), ==, true);
154  TEST_COMPARE(approxEqualScale(n * s, (n)*s, s), ==, true);
155  TEST_COMPARE(approxEqualScale(n * s, (n + eps) * s, s), ==, true);
156  TEST_COMPARE(approxEqualScale(n * s, (n + 10.0 * eps) * s, s), ==, false);
157 
158  // Swap
159  TEST_COMPARE(approxEqualScale((n - 10.0 * eps) * s, n * s, s), ==, false);
160  TEST_COMPARE(approxEqualScale((n - eps) * s, n * s, s), ==, true);
161  TEST_COMPARE(approxEqualScale((n)*s, n * s, s), ==, true);
162  TEST_COMPARE(approxEqualScale((n + eps) * s, n * s, s), ==, true);
163  TEST_COMPARE(approxEqualScale((n + 10.0 * eps) * s, n * s, s), ==, false);
164 
165  out << " *****************************" << std::endl;
166  }
167  }
168 }
169 
170 } // namespace Tempus_Unit_Test
Tempus_NumericalUtils.hpp
TEST_COMPARE
#define TEST_COMPARE(v1, comp, v2)
Tempus_Unit_Test::PI
static double PI
Definition: Tempus_UnitTest_NumericalUtils.cpp:19
Tempus::approxEqual
bool approxEqual(Scalar a, Scalar b, Scalar relTol=numericalTol< Scalar >())
Test if values are approximately equal within the relative tolerance.
Definition: Tempus_NumericalUtils.hpp:46
Tempus_Unit_Test::eps
static double eps
Definition: Tempus_UnitTest_NumericalUtils.cpp:20
Tempus_UnitTest_Utils.hpp
Tempus_Unit_Test::TEUCHOS_UNIT_TEST
TEUCHOS_UNIT_TEST(BackwardEuler, Default_Construction)
Definition: Tempus_UnitTest_BackwardEuler.cpp:32
Tempus::approxEqualAbsTol
bool approxEqualAbsTol(Scalar a, Scalar b, Scalar absTol)
Test if values are approximately equal within the absolute tolerance.
Definition: Tempus_NumericalUtils.hpp:39
Tempus::approxEqualScale
bool approxEqualScale(Scalar a, Scalar b, Scalar scale, Scalar relTol=numericalTol< Scalar >())
Definition: Tempus_NumericalUtils.hpp:57
Generated on Fri Apr 19 2024 09:25:32 for Tempus by   doxygen 1.8.5