]>
Commit | Line | Data |
---|---|---|
b34f60ac | 1 | // 2007-02-04 Edward Smith-Rowland <3dw4rd@verizon.net> |
2 | // | |
f1717362 | 3 | // Copyright (C) 2007-2016 Free Software Foundation, Inc. |
b34f60ac | 4 | // |
5 | // This file is part of the GNU ISO C++ Library. This library is free | |
6 | // software; you can redistribute it and/or modify it under the | |
7 | // terms of the GNU General Public License as published by the | |
6bc9506f | 8 | // Free Software Foundation; either version 3, or (at your option) |
b34f60ac | 9 | // any later version. |
10 | // | |
11 | // This library is distributed in the hope that it will be useful, | |
12 | // but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | // GNU General Public License for more details. | |
15 | // | |
16 | // You should have received a copy of the GNU General Public License along | |
6bc9506f | 17 | // with this library; see the file COPYING3. If not see |
18 | // <http://www.gnu.org/licenses/>. | |
b34f60ac | 19 | |
20 | // sph_neumann | |
21 | ||
22 | ||
23 | // Compare against values generated by the GNU Scientific Library. | |
24 | // The GSL can be found on the web: http://www.gnu.org/software/gsl/ | |
25 | ||
26 | #include <tr1/cmath> | |
27 | #if defined(__TEST_DEBUG) | |
28 | #include <iostream> | |
29 | #define VERIFY(A) \ | |
30 | if (!(A)) \ | |
31 | { \ | |
32 | std::cout << "line " << __LINE__ \ | |
33 | << " max_abs_frac = " << max_abs_frac \ | |
34 | << std::endl; \ | |
35 | } | |
36 | #else | |
37 | #include <testsuite_hooks.h> | |
38 | #endif | |
39 | #include "../testcase.h" | |
40 | ||
41 | ||
42 | // Test data for n=0. | |
43 | testcase_sph_neumann<double> data001[] = { | |
44 | { -0.056732437092645263, 0, 5.0000000000000000 }, | |
45 | { 0.083907152907645249, 0, 10.000000000000000 }, | |
46 | { 0.050645860857254754, 0, 15.000000000000000 }, | |
47 | { -0.020404103090669597, 0, 20.000000000000000 }, | |
48 | { -0.039648112474538942, 0, 25.000000000000000 }, | |
49 | { -0.0051417149962528020, 0, 30.000000000000000 }, | |
50 | { 0.025819777288328762, 0, 35.000000000000000 }, | |
51 | { 0.016673451541306544, 0, 40.000000000000000 }, | |
52 | { -0.011673821973727327, 0, 45.000000000000000 }, | |
53 | { -0.019299320569842265, 0, 50.000000000000000 }, | |
54 | { -0.00040230465930828606, 0, 55.000000000000000 }, | |
55 | { 0.015873549673585938, 0, 60.000000000000000 }, | |
56 | { 0.0086531361728949541, 0, 65.000000000000000 }, | |
57 | { -0.0090474171869471404, 0, 70.000000000000000 }, | |
58 | { -0.012290016929663325, 0, 75.000000000000000 }, | |
59 | { 0.0013798405479880946, 0, 80.000000000000000 }, | |
60 | { 0.011580901686988727, 0, 85.000000000000000 }, | |
61 | { 0.0049785957347685574, 0, 90.000000000000000 }, | |
62 | { -0.0076860374841559963, 0, 95.000000000000000 }, | |
63 | { -0.0086231887228768386, 0, 100.00000000000000 }, | |
64 | }; | |
65 | ||
66 | // Test function for n=0. | |
67 | template <typename Tp> | |
68 | void test001() | |
69 | { | |
70 | const Tp eps = std::numeric_limits<Tp>::epsilon(); | |
71 | Tp max_abs_diff = -Tp(1); | |
72 | Tp max_abs_frac = -Tp(1); | |
73 | unsigned int num_datum = sizeof(data001) | |
74 | / sizeof(testcase_sph_neumann<double>); | |
75 | for (unsigned int i = 0; i < num_datum; ++i) | |
76 | { | |
77 | const Tp f = std::tr1::sph_neumann(Tp(data001[i].n), Tp(data001[i].x)); | |
78 | const Tp f0 = data001[i].f0; | |
79 | const Tp diff = f - f0; | |
80 | if (std::abs(diff) > max_abs_diff) | |
81 | max_abs_diff = std::abs(diff); | |
82 | if (std::abs(f0) > Tp(10) * eps | |
83 | && std::abs(f) > Tp(10) * eps) | |
84 | { | |
85 | const Tp frac = diff / f0; | |
86 | if (std::abs(frac) > max_abs_frac) | |
87 | max_abs_frac = std::abs(frac); | |
88 | } | |
89 | } | |
90 | VERIFY(max_abs_frac < Tp(5.0000000000000028e-11)); | |
91 | } | |
92 | ||
93 | // Test data for n=1. | |
94 | testcase_sph_neumann<double> data002[] = { | |
95 | { 0.18043836751409864, 1, 5.0000000000000000 }, | |
96 | { 0.062792826379701516, 1, 10.000000000000000 }, | |
97 | { -0.039976131953324147, 1, 15.000000000000000 }, | |
98 | { -0.046667467690914864, 1, 20.000000000000000 }, | |
99 | { 0.0037081455049293634, 1, 25.000000000000000 }, | |
100 | { 0.032762996969886965, 1, 30.000000000000000 }, | |
101 | { 0.012971498479556564, 1, 35.000000000000000 }, | |
102 | { -0.018210992723451058, 1, 40.000000000000000 }, | |
103 | { -0.019168385477952129, 1, 45.000000000000000 }, | |
104 | { 0.0048615106626817301, 1, 50.000000000000000 }, | |
105 | { 0.018170052158169303, 1, 55.000000000000000 }, | |
106 | { 0.0053447361795967109, 1, 60.000000000000000 }, | |
107 | { -0.012587316051033977, 1, 65.000000000000000 }, | |
108 | { -0.011184829982069090, 1, 70.000000000000000 }, | |
109 | { 0.0050065549130635621, 1, 75.000000000000000 }, | |
110 | { 0.012440856180892041, 1, 80.000000000000000 }, | |
111 | { 0.0022077237839479508, 1, 85.000000000000000 }, | |
112 | { -0.0098779785318421041, 1, 90.000000000000000 }, | |
113 | { -0.0072731342338976518, 1, 95.000000000000000 }, | |
114 | { 0.0049774245238688201, 1, 100.00000000000000 }, | |
115 | }; | |
116 | ||
117 | // Test function for n=1. | |
118 | template <typename Tp> | |
119 | void test002() | |
120 | { | |
121 | const Tp eps = std::numeric_limits<Tp>::epsilon(); | |
122 | Tp max_abs_diff = -Tp(1); | |
123 | Tp max_abs_frac = -Tp(1); | |
124 | unsigned int num_datum = sizeof(data002) | |
125 | / sizeof(testcase_sph_neumann<double>); | |
126 | for (unsigned int i = 0; i < num_datum; ++i) | |
127 | { | |
128 | const Tp f = std::tr1::sph_neumann(Tp(data002[i].n), Tp(data002[i].x)); | |
129 | const Tp f0 = data002[i].f0; | |
130 | const Tp diff = f - f0; | |
131 | if (std::abs(diff) > max_abs_diff) | |
132 | max_abs_diff = std::abs(diff); | |
133 | if (std::abs(f0) > Tp(10) * eps | |
134 | && std::abs(f) > Tp(10) * eps) | |
135 | { | |
136 | const Tp frac = diff / f0; | |
137 | if (std::abs(frac) > max_abs_frac) | |
138 | max_abs_frac = std::abs(frac); | |
139 | } | |
140 | } | |
141 | VERIFY(max_abs_frac < Tp(2.5000000000000014e-11)); | |
142 | } | |
143 | ||
144 | // Test data for n=2. | |
145 | testcase_sph_neumann<double> data003[] = { | |
146 | { 0.16499545760110443, 2, 5.0000000000000000 }, | |
147 | { -0.065069304993734797, 2, 10.000000000000000 }, | |
148 | { -0.058641087247919589, 2, 15.000000000000000 }, | |
149 | { 0.013403982937032370, 2, 20.000000000000000 }, | |
150 | { 0.040093089935130465, 2, 25.000000000000000 }, | |
151 | { 0.0084180146932414986, 2, 30.000000000000000 }, | |
152 | { -0.024707934561509628, 2, 35.000000000000000 }, | |
153 | { -0.018039275995565374, 2, 40.000000000000000 }, | |
154 | { 0.010395929608530519, 2, 45.000000000000000 }, | |
155 | { 0.019591011209603170, 2, 50.000000000000000 }, | |
156 | { 0.0013933984133902479, 2, 55.000000000000000 }, | |
157 | { -0.015606312864606103, 2, 60.000000000000000 }, | |
158 | { -0.0092340892214042153, 2, 65.000000000000000 }, | |
159 | { 0.0085680673305727519, 2, 70.000000000000000 }, | |
160 | { 0.012490279126185866, 2, 75.000000000000000 }, | |
161 | { -0.00091330844120464307, 2, 80.000000000000000 }, | |
162 | { -0.011502982024025860, 2, 85.000000000000000 }, | |
163 | { -0.0053078616858299602, 2, 90.000000000000000 }, | |
164 | { 0.0074563595609802805, 2, 95.000000000000000 }, | |
165 | { 0.0087725114585929034, 2, 100.00000000000000 }, | |
166 | }; | |
167 | ||
168 | // Test function for n=2. | |
169 | template <typename Tp> | |
170 | void test003() | |
171 | { | |
172 | const Tp eps = std::numeric_limits<Tp>::epsilon(); | |
173 | Tp max_abs_diff = -Tp(1); | |
174 | Tp max_abs_frac = -Tp(1); | |
175 | unsigned int num_datum = sizeof(data003) | |
176 | / sizeof(testcase_sph_neumann<double>); | |
177 | for (unsigned int i = 0; i < num_datum; ++i) | |
178 | { | |
179 | const Tp f = std::tr1::sph_neumann(Tp(data003[i].n), Tp(data003[i].x)); | |
180 | const Tp f0 = data003[i].f0; | |
181 | const Tp diff = f - f0; | |
182 | if (std::abs(diff) > max_abs_diff) | |
183 | max_abs_diff = std::abs(diff); | |
184 | if (std::abs(f0) > Tp(10) * eps | |
185 | && std::abs(f) > Tp(10) * eps) | |
186 | { | |
187 | const Tp frac = diff / f0; | |
188 | if (std::abs(frac) > max_abs_frac) | |
189 | max_abs_frac = std::abs(frac); | |
190 | } | |
191 | } | |
192 | VERIFY(max_abs_frac < Tp(5.0000000000000028e-11)); | |
193 | } | |
194 | ||
195 | // Test data for n=5. | |
196 | testcase_sph_neumann<double> data004[] = { | |
197 | { -0.32046504674973919, 5, 5.0000000000000000 }, | |
198 | { 0.093833541678691818, 5, 10.000000000000000 }, | |
199 | { 0.020475698281859061, 5, 15.000000000000000 }, | |
200 | { -0.048172347757372780, 5, 20.000000000000000 }, | |
201 | { -0.018309489232548347, 5, 25.000000000000000 }, | |
202 | { 0.026639390496569996, 5, 30.000000000000000 }, | |
203 | { 0.022006038985576210, 5, 35.000000000000000 }, | |
204 | { -0.011268975348057965, 5, 40.000000000000000 }, | |
205 | { -0.021770388372274862, 5, 45.000000000000000 }, | |
206 | { -0.00069711319645853712, 5, 50.000000000000000 }, | |
207 | { 0.017439589450220897, 5, 55.000000000000000 }, | |
208 | { 0.0088699170919343089, 5, 60.000000000000000 }, | |
209 | { -0.010421334444951861, 5, 65.000000000000000 }, | |
210 | { -0.012746769858008551, 5, 70.000000000000000 }, | |
211 | { 0.0026282888028967737, 5, 75.000000000000000 }, | |
212 | { 0.012477658581324189, 5, 80.000000000000000 }, | |
213 | { 0.0040771816818182642, 5, 85.000000000000000 }, | |
214 | { -0.0089777759570579801, 5, 90.000000000000000 }, | |
215 | { -0.0083184557896676149, 5, 95.000000000000000 }, | |
216 | { 0.0037206784862748965, 5, 100.00000000000000 }, | |
217 | }; | |
218 | ||
219 | // Test function for n=5. | |
220 | template <typename Tp> | |
221 | void test004() | |
222 | { | |
223 | const Tp eps = std::numeric_limits<Tp>::epsilon(); | |
224 | Tp max_abs_diff = -Tp(1); | |
225 | Tp max_abs_frac = -Tp(1); | |
226 | unsigned int num_datum = sizeof(data004) | |
227 | / sizeof(testcase_sph_neumann<double>); | |
228 | for (unsigned int i = 0; i < num_datum; ++i) | |
229 | { | |
230 | const Tp f = std::tr1::sph_neumann(Tp(data004[i].n), Tp(data004[i].x)); | |
231 | const Tp f0 = data004[i].f0; | |
232 | const Tp diff = f - f0; | |
233 | if (std::abs(diff) > max_abs_diff) | |
234 | max_abs_diff = std::abs(diff); | |
235 | if (std::abs(f0) > Tp(10) * eps | |
236 | && std::abs(f) > Tp(10) * eps) | |
237 | { | |
238 | const Tp frac = diff / f0; | |
239 | if (std::abs(frac) > max_abs_frac) | |
240 | max_abs_frac = std::abs(frac); | |
241 | } | |
242 | } | |
243 | VERIFY(max_abs_frac < Tp(5.0000000000000028e-11)); | |
244 | } | |
245 | ||
246 | // Test data for n=10. | |
247 | testcase_sph_neumann<double> data005[] = { | |
248 | { -26.656114405718704, 10, 5.0000000000000000 }, | |
249 | { -0.17245367208805784, 10, 10.000000000000000 }, | |
250 | { 0.078461689849642580, 10, 15.000000000000000 }, | |
251 | { -0.036843410496289961, 10, 20.000000000000000 }, | |
252 | { -0.021158339301097472, 10, 25.000000000000000 }, | |
253 | { 0.031219591064754935, 10, 30.000000000000000 }, | |
254 | { 0.012840593422414804, 10, 35.000000000000000 }, | |
255 | { -0.021803068636888072, 10, 40.000000000000000 }, | |
256 | { -0.014071636804469047, 10, 45.000000000000000 }, | |
257 | { 0.013524687511158756, 10, 50.000000000000000 }, | |
258 | { 0.015684932653180592, 10, 55.000000000000000 }, | |
259 | { -0.0056356895567262122, 10, 60.000000000000000 }, | |
260 | { -0.015364490270315362, 10, 65.000000000000000 }, | |
261 | { -0.0014525575672261291, 10, 70.000000000000000 }, | |
262 | { 0.012648951699549433, 10, 75.000000000000000 }, | |
263 | { 0.0068571608061120358, 10, 80.000000000000000 }, | |
264 | { -0.0080151152941401460, 10, 85.000000000000000 }, | |
265 | { -0.0098139742219019131, 10, 90.000000000000000 }, | |
266 | { 0.0025002854072314951, 10, 95.000000000000000 }, | |
267 | { 0.010025777373636153, 10, 100.00000000000000 }, | |
268 | }; | |
269 | ||
270 | // Test function for n=10. | |
271 | template <typename Tp> | |
272 | void test005() | |
273 | { | |
274 | const Tp eps = std::numeric_limits<Tp>::epsilon(); | |
275 | Tp max_abs_diff = -Tp(1); | |
276 | Tp max_abs_frac = -Tp(1); | |
277 | unsigned int num_datum = sizeof(data005) | |
278 | / sizeof(testcase_sph_neumann<double>); | |
279 | for (unsigned int i = 0; i < num_datum; ++i) | |
280 | { | |
281 | const Tp f = std::tr1::sph_neumann(Tp(data005[i].n), Tp(data005[i].x)); | |
282 | const Tp f0 = data005[i].f0; | |
283 | const Tp diff = f - f0; | |
284 | if (std::abs(diff) > max_abs_diff) | |
285 | max_abs_diff = std::abs(diff); | |
286 | if (std::abs(f0) > Tp(10) * eps | |
287 | && std::abs(f) > Tp(10) * eps) | |
288 | { | |
289 | const Tp frac = diff / f0; | |
290 | if (std::abs(frac) > max_abs_frac) | |
291 | max_abs_frac = std::abs(frac); | |
292 | } | |
293 | } | |
294 | VERIFY(max_abs_frac < Tp(5.0000000000000028e-11)); | |
295 | } | |
296 | ||
297 | // Test data for n=20. | |
298 | testcase_sph_neumann<double> data006[] = { | |
299 | { -926795140.30575454, 20, 5.0000000000000000 }, | |
300 | { -1211.2106053526034, 20, 10.000000000000000 }, | |
301 | { -1.5559965765652188, 20, 15.000000000000000 }, | |
302 | { -0.093401132250914426, 20, 20.000000000000000 }, | |
303 | { 0.044031985675276435, 20, 25.000000000000000 }, | |
304 | { -0.036078033606613907, 20, 30.000000000000000 }, | |
305 | { 0.029828405631319641, 20, 35.000000000000000 }, | |
306 | { -0.0048414810986760785, 20, 40.000000000000000 }, | |
307 | { -0.020504694681516944, 20, 45.000000000000000 }, | |
308 | { 0.013759531302541211, 20, 50.000000000000000 }, | |
309 | { 0.012783038861734196, 20, 55.000000000000000 }, | |
310 | { -0.013117009421906418, 20, 60.000000000000000 }, | |
311 | { -0.010338106075674407, 20, 65.000000000000000 }, | |
312 | { 0.010538610814111246, 20, 70.000000000000000 }, | |
313 | { 0.010200029094273743, 20, 75.000000000000000 }, | |
314 | { -0.0073123450945617122, 20, 80.000000000000000 }, | |
315 | { -0.010581510354950906, 20, 85.000000000000000 }, | |
316 | { 0.0036866374015298714, 20, 90.000000000000000 }, | |
317 | { 0.010498384318338270, 20, 95.000000000000000 }, | |
318 | { 5.6317293788333982e-05, 20, 100.00000000000000 }, | |
319 | }; | |
320 | ||
321 | // Test function for n=20. | |
322 | template <typename Tp> | |
323 | void test006() | |
324 | { | |
325 | const Tp eps = std::numeric_limits<Tp>::epsilon(); | |
326 | Tp max_abs_diff = -Tp(1); | |
327 | Tp max_abs_frac = -Tp(1); | |
328 | unsigned int num_datum = sizeof(data006) | |
329 | / sizeof(testcase_sph_neumann<double>); | |
330 | for (unsigned int i = 0; i < num_datum; ++i) | |
331 | { | |
332 | const Tp f = std::tr1::sph_neumann(Tp(data006[i].n), Tp(data006[i].x)); | |
333 | const Tp f0 = data006[i].f0; | |
334 | const Tp diff = f - f0; | |
335 | if (std::abs(diff) > max_abs_diff) | |
336 | max_abs_diff = std::abs(diff); | |
337 | if (std::abs(f0) > Tp(10) * eps | |
338 | && std::abs(f) > Tp(10) * eps) | |
339 | { | |
340 | const Tp frac = diff / f0; | |
341 | if (std::abs(frac) > max_abs_frac) | |
342 | max_abs_frac = std::abs(frac); | |
343 | } | |
344 | } | |
345 | VERIFY(max_abs_frac < Tp(1.0000000000000007e-09)); | |
346 | } | |
347 | ||
348 | // Test data for n=50. | |
349 | testcase_sph_neumann<double> data007[] = { | |
350 | { -6.9641091882698388e+42, 50, 5.0000000000000000 }, | |
351 | { -4.5282272723512023e+27, 50, 10.000000000000000 }, | |
352 | { -9.0004902645887027e+18, 50, 15.000000000000000 }, | |
353 | { -9542541667002.5098, 50, 20.000000000000000 }, | |
354 | { -363518140.71026677, 50, 25.000000000000000 }, | |
355 | { -152551.57233157745, 50, 30.000000000000000 }, | |
356 | { -386.26599186208625, 50, 35.000000000000000 }, | |
357 | { -4.3290507947291035, 50, 40.000000000000000 }, | |
358 | { -0.19968460851503764, 50, 45.000000000000000 }, | |
359 | { -0.041900001504607758, 50, 50.000000000000000 }, | |
360 | { 0.010696040672421900, 50, 55.000000000000000 }, | |
361 | { 0.0078198768555268507, 50, 60.000000000000000 }, | |
362 | { -0.010088474938191242, 50, 65.000000000000000 }, | |
363 | { 0.0062423671279824801, 50, 70.000000000000000 }, | |
364 | { 0.0011284242794941733, 50, 75.000000000000000 }, | |
365 | { -0.0093934266037485562, 50, 80.000000000000000 }, | |
366 | { 0.013108079602843424, 50, 85.000000000000000 }, | |
367 | { -0.0075396607225722626, 50, 90.000000000000000 }, | |
368 | { -0.0042605703552836558, 50, 95.000000000000000 }, | |
369 | { 0.010747822973682470, 50, 100.00000000000000 }, | |
370 | }; | |
371 | ||
372 | // Test function for n=50. | |
373 | template <typename Tp> | |
374 | void test007() | |
375 | { | |
376 | const Tp eps = std::numeric_limits<Tp>::epsilon(); | |
377 | Tp max_abs_diff = -Tp(1); | |
378 | Tp max_abs_frac = -Tp(1); | |
379 | unsigned int num_datum = sizeof(data007) | |
380 | / sizeof(testcase_sph_neumann<double>); | |
381 | for (unsigned int i = 0; i < num_datum; ++i) | |
382 | { | |
383 | const Tp f = std::tr1::sph_neumann(Tp(data007[i].n), Tp(data007[i].x)); | |
384 | const Tp f0 = data007[i].f0; | |
385 | const Tp diff = f - f0; | |
386 | if (std::abs(diff) > max_abs_diff) | |
387 | max_abs_diff = std::abs(diff); | |
388 | if (std::abs(f0) > Tp(10) * eps | |
389 | && std::abs(f) > Tp(10) * eps) | |
390 | { | |
391 | const Tp frac = diff / f0; | |
392 | if (std::abs(frac) > max_abs_frac) | |
393 | max_abs_frac = std::abs(frac); | |
394 | } | |
395 | } | |
396 | VERIFY(max_abs_frac < Tp(2.5000000000000014e-11)); | |
397 | } | |
398 | ||
399 | // Test data for n=100. | |
400 | testcase_sph_neumann<double> data008[] = { | |
401 | { -1.7997139826259744e+116, 100, 5.0000000000000000 }, | |
402 | { -8.5732263093296254e+85, 100, 10.000000000000000 }, | |
403 | { -1.9270658593711675e+68, 100, 15.000000000000000 }, | |
404 | { -7.2208893582952363e+55, 100, 20.000000000000000 }, | |
405 | { -2.0868752613007946e+46, 100, 25.000000000000000 }, | |
406 | { -4.2496124023612646e+38, 100, 30.000000000000000 }, | |
407 | { -1.7042898348910271e+32, 100, 35.000000000000000 }, | |
408 | { -6.3021565260724554e+26, 100, 40.000000000000000 }, | |
409 | { -1.3199917400494369e+22, 100, 45.000000000000000 }, | |
410 | { -1.1256928913265985e+18, 100, 50.000000000000000 }, | |
411 | { -309801083340341.00, 100, 55.000000000000000 }, | |
412 | { -232585620046.64737, 100, 60.000000000000000 }, | |
413 | { -421135935.93756086, 100, 65.000000000000000 }, | |
414 | { -1680637.4531202619, 100, 70.000000000000000 }, | |
415 | { -13868.302591128842, 100, 75.000000000000000 }, | |
416 | { -227.24385709173322, 100, 80.000000000000000 }, | |
417 | { -7.2807038787139486, 100, 85.000000000000000 }, | |
418 | { -0.46648154448250878, 100, 90.000000000000000 }, | |
419 | { -0.067270772720654542, 100, 95.000000000000000 }, | |
420 | { -0.022983850491562267, 100, 100.00000000000000 }, | |
421 | }; | |
422 | ||
423 | // Test function for n=100. | |
424 | template <typename Tp> | |
425 | void test008() | |
426 | { | |
427 | const Tp eps = std::numeric_limits<Tp>::epsilon(); | |
428 | Tp max_abs_diff = -Tp(1); | |
429 | Tp max_abs_frac = -Tp(1); | |
430 | unsigned int num_datum = sizeof(data008) | |
431 | / sizeof(testcase_sph_neumann<double>); | |
432 | for (unsigned int i = 0; i < num_datum; ++i) | |
433 | { | |
434 | const Tp f = std::tr1::sph_neumann(Tp(data008[i].n), Tp(data008[i].x)); | |
435 | const Tp f0 = data008[i].f0; | |
436 | const Tp diff = f - f0; | |
437 | if (std::abs(diff) > max_abs_diff) | |
438 | max_abs_diff = std::abs(diff); | |
439 | if (std::abs(f0) > Tp(10) * eps | |
440 | && std::abs(f) > Tp(10) * eps) | |
441 | { | |
442 | const Tp frac = diff / f0; | |
443 | if (std::abs(frac) > max_abs_frac) | |
444 | max_abs_frac = std::abs(frac); | |
445 | } | |
446 | } | |
447 | VERIFY(max_abs_frac < Tp(2.5000000000000015e-12)); | |
448 | } | |
449 | ||
450 | int main(int, char**) | |
451 | { | |
452 | test001<double>(); | |
453 | test002<double>(); | |
454 | test003<double>(); | |
455 | test004<double>(); | |
456 | test005<double>(); | |
457 | test006<double>(); | |
458 | test007<double>(); | |
459 | test008<double>(); | |
460 | return 0; | |
461 | } |