Tempus Version of the Day
Time Integration
Loading...
Searching...
No Matches
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
10
12
13
14namespace Tempus_Unit_Test {
15
19
20static double PI = M_PI;
21static double eps = 1.0e-14;
22
23
24// ************************************************************
25// ************************************************************
26TEUCHOS_UNIT_TEST(NumericalUtils, approxEqual)
27{
28 double zero = 0.0;
29 double one = 1.0;
30
31 std::vector<double> scales;
32 scales.push_back(1.0);
33 scales.push_back(100.0);
34 scales.push_back(0.01);
35 scales.push_back(1.0e-28);
36 scales.push_back(1.0e+28);
37
38 std::vector<double> numbers;
39 numbers.push_back(one);
40 numbers.push_back(PI);
41
42 for(auto& s : scales) {
43
44 out << " *****************************" << std::endl;
45 out << " s, eps = " << s << ", " << eps << std::endl;
46
47 TEST_COMPARE(approxEqual(zero*s, (zero-10.0*eps)*s), ==, false);
48 TEST_COMPARE(approxEqual(zero*s, (zero- eps)*s), ==, false);
49 TEST_COMPARE(approxEqual(zero*s, (zero )*s), ==, true );
50 TEST_COMPARE(approxEqual(zero*s, (zero+ eps)*s), ==, false);
51 TEST_COMPARE(approxEqual(zero*s, (zero+10.0*eps)*s), ==, false);
52
53 // Swap
54 TEST_COMPARE(approxEqual((zero-10.0*eps)*s, zero*s), ==, false);
55 TEST_COMPARE(approxEqual((zero- eps)*s, zero*s), ==, false);
56 TEST_COMPARE(approxEqual((zero )*s, zero*s), ==, true );
57 TEST_COMPARE(approxEqual((zero+ eps)*s, zero*s), ==, false);
58 TEST_COMPARE(approxEqual((zero+10.0*eps)*s, zero*s), ==, false);
59
60 for(auto& n : numbers) {
61
62 out << " n = " << n << std::endl;
63
64 TEST_COMPARE(approxEqual(n*s, (n-10.0*eps)*s), ==, false);
65 TEST_COMPARE(approxEqual(n*s, (n- eps)*s), ==, true );
66 TEST_COMPARE(approxEqual(n*s, (n )*s), ==, true );
67 TEST_COMPARE(approxEqual(n*s, (n+ eps)*s), ==, true );
68 TEST_COMPARE(approxEqual(n*s, (n+10.0*eps)*s), ==, false);
69
70 // Swap
71 TEST_COMPARE(approxEqual((n-10.0*eps)*s, n*s), ==, false);
72 TEST_COMPARE(approxEqual((n- eps)*s, n*s), ==, true );
73 TEST_COMPARE(approxEqual((n )*s, n*s), ==, true );
74 TEST_COMPARE(approxEqual((n+ eps)*s, n*s), ==, true );
75 TEST_COMPARE(approxEqual((n+10.0*eps)*s, n*s), ==, false);
76
77 }
78 out << " *****************************" << std::endl;
79 }
80
81}
82
83
84// ************************************************************
85// ************************************************************
86TEUCHOS_UNIT_TEST(NumericalUtils, approxEqualAbsTol)
87{
88 double numTol = Tempus::numericalTol<double>();
89 double zero = 0.0;
90 double one = 1.0;
91
92 std::vector<double> scales;
93 scales.push_back(1.0);
94 scales.push_back(100.0);
95 scales.push_back(0.01);
96 scales.push_back(1.0e-28);
97 scales.push_back(1.0e+28);
98
99 std::vector<double> numbers;
100 numbers.push_back(zero);
101 numbers.push_back(one);
102 numbers.push_back(PI);
103
104 for(auto& s : scales) {
105 for(auto& n : numbers) {
106
107 out << " *****************************" << std::endl;
108 out << " n, s, eps = " << n << ", " << s << ", " << eps << std::endl;
109
110 TEST_COMPARE(approxEqualAbsTol(n*s, (n-10.0*eps)*s, numTol*s), ==, false);
111 TEST_COMPARE(approxEqualAbsTol(n*s, (n- eps)*s, numTol*s), ==, true );
112 TEST_COMPARE(approxEqualAbsTol(n*s, (n )*s, numTol*s), ==, true );
113 TEST_COMPARE(approxEqualAbsTol(n*s, (n+ eps)*s, numTol*s), ==, true );
114 TEST_COMPARE(approxEqualAbsTol(n*s, (n+10.0*eps)*s, numTol*s), ==, false);
115
116 // Swap
117 TEST_COMPARE(approxEqualAbsTol((n-10.0*eps)*s, n*s, numTol*s), ==, false);
118 TEST_COMPARE(approxEqualAbsTol((n- eps)*s, n*s, numTol*s), ==, true );
119 TEST_COMPARE(approxEqualAbsTol((n )*s, n*s, numTol*s), ==, true );
120 TEST_COMPARE(approxEqualAbsTol((n+ eps)*s, n*s, numTol*s), ==, true );
121 TEST_COMPARE(approxEqualAbsTol((n+10.0*eps)*s, n*s, numTol*s), ==, false);
122
123 out << " *****************************" << std::endl;
124 }
125 }
126
127}
128
129
130// ************************************************************
131// ************************************************************
132TEUCHOS_UNIT_TEST(NumericalUtils, approxEqualScale)
133{
134 double zero = 0.0;
135 double one = 1.0;
136
137 std::vector<double> scales;
138 scales.push_back(1.0);
139 scales.push_back(100.0);
140 scales.push_back(0.01);
141 scales.push_back(1.0e-28);
142 scales.push_back(1.0e+28);
143
144 std::vector<double> numbers;
145 numbers.push_back(zero);
146 numbers.push_back(one);
147 numbers.push_back(PI);
148
149 for(auto& s : scales) {
150 for(auto& n : numbers) {
151
152 out << " *****************************" << std::endl;
153 out << " n, s, eps = " << n << ", " << s << ", " << eps << std::endl;
154
155 TEST_COMPARE(approxEqualScale(n*s, (n-10.0*eps)*s, s), ==, false);
156 TEST_COMPARE(approxEqualScale(n*s, (n- eps)*s, s), ==, true );
157 TEST_COMPARE(approxEqualScale(n*s, (n )*s, s), ==, true );
158 TEST_COMPARE(approxEqualScale(n*s, (n+ eps)*s, s), ==, true );
159 TEST_COMPARE(approxEqualScale(n*s, (n+10.0*eps)*s, s), ==, false);
160
161 // Swap
162 TEST_COMPARE(approxEqualScale((n-10.0*eps)*s, n*s, s), ==, false);
163 TEST_COMPARE(approxEqualScale((n- eps)*s, n*s, s), ==, true );
164 TEST_COMPARE(approxEqualScale((n )*s, n*s, s), ==, true );
165 TEST_COMPARE(approxEqualScale((n+ eps)*s, n*s, s), ==, true );
166 TEST_COMPARE(approxEqualScale((n+10.0*eps)*s, n*s, s), ==, false);
167
168 out << " *****************************" << std::endl;
169 }
170 }
171
172}
173
174
175} // namespace Tempus_Test
TEUCHOS_UNIT_TEST(BackwardEuler, Default_Construction)
bool approxEqual(Scalar a, Scalar b, Scalar relTol=numericalTol< Scalar >())
Test if values are approximately equal within the relative tolerance.
bool approxEqualScale(Scalar a, Scalar b, Scalar scale, Scalar relTol=numericalTol< Scalar >())
Test if values are approximately equal within the relative tolerance given a scale.
bool approxEqualAbsTol(Scalar a, Scalar b, Scalar absTol)
Test if values are approximately equal within the absolute tolerance.