OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libstdc++-v3/] [testsuite/] [tr1/] [5_numerical_facilities/] [special_functions/] [06_comp_ellint_3/] [check_value.cc] - Blame information for rev 742

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 742 jeremybenn 
// 2007-02-04  Edward Smith-Rowland <3dw4rd@verizon.net>
2 
//
3 
// Copyright (C) 2007, 2009 Free Software Foundation, Inc.
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
8 
// Free Software Foundation; either version 3, or (at your option)
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
17 
// with this library; see the file COPYING3.  If not see
18 
// <http://www.gnu.org/licenses/>.
19 
 
20 
//  comp_ellint_3
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 k=-0.90000000000000002.
43 
testcase_comp_ellint_3<double> data001[] = {
44 
  { 2.2805491384227703, -0.90000000000000002, 0.0000000000000000 },
45 
  { 2.1537868513875287, -0.90000000000000002, 0.10000000000000001 },
46 
  { 2.0443194576468890, -0.90000000000000002, 0.20000000000000001 },
47 
  { 1.9486280260314426, -0.90000000000000002, 0.29999999999999999 },
48 
  { 1.8641114227238349, -0.90000000000000002, 0.40000000000000002 },
49 
  { 1.7888013241937861, -0.90000000000000002, 0.50000000000000000 },
50 
  { 1.7211781128919523, -0.90000000000000002, 0.59999999999999998 },
51 
  { 1.6600480747670938, -0.90000000000000002, 0.69999999999999996 },
52 
  { 1.6044591960982204, -0.90000000000000002, 0.80000000000000004 },
53 
  { 1.5536420236310946, -0.90000000000000002, 0.90000000000000002 },
54 
};
55 
 
56 
// Test function for k=-0.90000000000000002.
57 
template <typename Tp>
58 
void test001()
59 
{
60 
  const Tp eps = std::numeric_limits<Tp>::epsilon();
61 
  Tp max_abs_diff = -Tp(1);
62 
  Tp max_abs_frac = -Tp(1);
63 
  unsigned int num_datum = sizeof(data001)
64 
                         / sizeof(testcase_comp_ellint_3<double>);
65 
  for (unsigned int i = 0; i < num_datum; ++i)
66 
    {
67 
      const Tp f = std::tr1::comp_ellint_3(Tp(data001[i].k), Tp(data001[i].nu));
68 
      const Tp f0 = data001[i].f0;
69 
      const Tp diff = f - f0;
70 
      if (std::abs(diff) > max_abs_diff)
71 
        max_abs_diff = std::abs(diff);
72 
      if (std::abs(f0) > Tp(10) * eps
73 
       && std::abs(f) > Tp(10) * eps)
74 
        {
75 
          const Tp frac = diff / f0;
76 
          if (std::abs(frac) > max_abs_frac)
77 
            max_abs_frac = std::abs(frac);
78 
        }
79 
    }
80 
  VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
81 
}
82 
 
83 
// Test data for k=-0.80000000000000004.
84 
testcase_comp_ellint_3<double> data002[] = {
85 
  { 1.9953027776647296, -0.80000000000000004, 0.0000000000000000 },
86 
  { 1.8910755418379521, -0.80000000000000004, 0.10000000000000001 },
87 
  { 1.8007226661734588, -0.80000000000000004, 0.20000000000000001 },
88 
  { 1.7214611048717301, -0.80000000000000004, 0.29999999999999999 },
89 
  { 1.6512267838651289, -0.80000000000000004, 0.40000000000000002 },
90 
  { 1.5884528947755532, -0.80000000000000004, 0.50000000000000000 },
91 
  { 1.5319262547427865, -0.80000000000000004, 0.59999999999999998 },
92 
  { 1.4806912324625332, -0.80000000000000004, 0.69999999999999996 },
93 
  { 1.4339837018309474, -0.80000000000000004, 0.80000000000000004 },
94 
  { 1.3911845406776222, -0.80000000000000004, 0.90000000000000002 },
95 
};
96 
 
97 
// Test function for k=-0.80000000000000004.
98 
template <typename Tp>
99 
void test002()
100 
{
101 
  const Tp eps = std::numeric_limits<Tp>::epsilon();
102 
  Tp max_abs_diff = -Tp(1);
103 
  Tp max_abs_frac = -Tp(1);
104 
  unsigned int num_datum = sizeof(data002)
105 
                         / sizeof(testcase_comp_ellint_3<double>);
106 
  for (unsigned int i = 0; i < num_datum; ++i)
107 
    {
108 
      const Tp f = std::tr1::comp_ellint_3(Tp(data002[i].k), Tp(data002[i].nu));
109 
      const Tp f0 = data002[i].f0;
110 
      const Tp diff = f - f0;
111 
      if (std::abs(diff) > max_abs_diff)
112 
        max_abs_diff = std::abs(diff);
113 
      if (std::abs(f0) > Tp(10) * eps
114 
       && std::abs(f) > Tp(10) * eps)
115 
        {
116 
          const Tp frac = diff / f0;
117 
          if (std::abs(frac) > max_abs_frac)
118 
            max_abs_frac = std::abs(frac);
119 
        }
120 
    }
121 
  VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
122 
}
123 
 
124 
// Test data for k=-0.69999999999999996.
125 
testcase_comp_ellint_3<double> data003[] = {
126 
  { 1.8456939983747236, -0.69999999999999996, 0.0000000000000000 },
127 
  { 1.7528050171757608, -0.69999999999999996, 0.10000000000000001 },
128 
  { 1.6721098780092147, -0.69999999999999996, 0.20000000000000001 },
129 
  { 1.6011813647733213, -0.69999999999999996, 0.29999999999999999 },
130 
  { 1.5382162002954762, -0.69999999999999996, 0.40000000000000002 },
131 
  { 1.4818433192178544, -0.69999999999999996, 0.50000000000000000 },
132 
  { 1.4309994736080540, -0.69999999999999996, 0.59999999999999998 },
133 
  { 1.3848459188329196, -0.69999999999999996, 0.69999999999999996 },
134 
  { 1.3427110650397533, -0.69999999999999996, 0.80000000000000004 },
135 
  { 1.3040500499695911, -0.69999999999999996, 0.90000000000000002 },
136 
};
137 
 
138 
// Test function for k=-0.69999999999999996.
139 
template <typename Tp>
140 
void test003()
141 
{
142 
  const Tp eps = std::numeric_limits<Tp>::epsilon();
143 
  Tp max_abs_diff = -Tp(1);
144 
  Tp max_abs_frac = -Tp(1);
145 
  unsigned int num_datum = sizeof(data003)
146 
                         / sizeof(testcase_comp_ellint_3<double>);
147 
  for (unsigned int i = 0; i < num_datum; ++i)
148 
    {
149 
      const Tp f = std::tr1::comp_ellint_3(Tp(data003[i].k), Tp(data003[i].nu));
150 
      const Tp f0 = data003[i].f0;
151 
      const Tp diff = f - f0;
152 
      if (std::abs(diff) > max_abs_diff)
153 
        max_abs_diff = std::abs(diff);
154 
      if (std::abs(f0) > Tp(10) * eps
155 
       && std::abs(f) > Tp(10) * eps)
156 
        {
157 
          const Tp frac = diff / f0;
158 
          if (std::abs(frac) > max_abs_frac)
159 
            max_abs_frac = std::abs(frac);
160 
        }
161 
    }
162 
  VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
163 
}
164 
 
165 
// Test data for k=-0.59999999999999998.
166 
testcase_comp_ellint_3<double> data004[] = {
167 
  { 1.7507538029157526, -0.59999999999999998, 0.0000000000000000 },
168 
  { 1.6648615773343014, -0.59999999999999998, 0.10000000000000001 },
169 
  { 1.5901418016279374, -0.59999999999999998, 0.20000000000000001 },
170 
  { 1.5243814243493585, -0.59999999999999998, 0.29999999999999999 },
171 
  { 1.4659345278069984, -0.59999999999999998, 0.40000000000000002 },
172 
  { 1.4135484285693078, -0.59999999999999998, 0.50000000000000000 },
173 
  { 1.3662507535812816, -0.59999999999999998, 0.59999999999999998 },
174 
  { 1.3232737468822811, -0.59999999999999998, 0.69999999999999996 },
175 
  { 1.2840021261752192, -0.59999999999999998, 0.80000000000000004 },
176 
  { 1.2479362973851875, -0.59999999999999998, 0.90000000000000002 },
177 
};
178 
 
179 
// Test function for k=-0.59999999999999998.
180 
template <typename Tp>
181 
void test004()
182 
{
183 
  const Tp eps = std::numeric_limits<Tp>::epsilon();
184 
  Tp max_abs_diff = -Tp(1);
185 
  Tp max_abs_frac = -Tp(1);
186 
  unsigned int num_datum = sizeof(data004)
187 
                         / sizeof(testcase_comp_ellint_3<double>);
188 
  for (unsigned int i = 0; i < num_datum; ++i)
189 
    {
190 
      const Tp f = std::tr1::comp_ellint_3(Tp(data004[i].k), Tp(data004[i].nu));
191 
      const Tp f0 = data004[i].f0;
192 
      const Tp diff = f - f0;
193 
      if (std::abs(diff) > max_abs_diff)
194 
        max_abs_diff = std::abs(diff);
195 
      if (std::abs(f0) > Tp(10) * eps
196 
       && std::abs(f) > Tp(10) * eps)
197 
        {
198 
          const Tp frac = diff / f0;
199 
          if (std::abs(frac) > max_abs_frac)
200 
            max_abs_frac = std::abs(frac);
201 
        }
202 
    }
203 
  VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
204 
}
205 
 
206 
// Test data for k=-0.50000000000000000.
207 
testcase_comp_ellint_3<double> data005[] = {
208 
  { 1.6857503548125963, -0.50000000000000000, 0.0000000000000000 },
209 
  { 1.6045524936084892, -0.50000000000000000, 0.10000000000000001 },
210 
  { 1.5338490483665983, -0.50000000000000000, 0.20000000000000001 },
211 
  { 1.4715681939859637, -0.50000000000000000, 0.29999999999999999 },
212 
  { 1.4161679518465340, -0.50000000000000000, 0.40000000000000002 },
213 
  { 1.3664739530045971, -0.50000000000000000, 0.50000000000000000 },
214 
  { 1.3215740290190876, -0.50000000000000000, 0.59999999999999998 },
215 
  { 1.2807475181182502, -0.50000000000000000, 0.69999999999999996 },
216 
  { 1.2434165408189539, -0.50000000000000000, 0.80000000000000004 },
217 
  { 1.2091116095504744, -0.50000000000000000, 0.90000000000000002 },
218 
};
219 
 
220 
// Test function for k=-0.50000000000000000.
221 
template <typename Tp>
222 
void test005()
223 
{
224 
  const Tp eps = std::numeric_limits<Tp>::epsilon();
225 
  Tp max_abs_diff = -Tp(1);
226 
  Tp max_abs_frac = -Tp(1);
227 
  unsigned int num_datum = sizeof(data005)
228 
                         / sizeof(testcase_comp_ellint_3<double>);
229 
  for (unsigned int i = 0; i < num_datum; ++i)
230 
    {
231 
      const Tp f = std::tr1::comp_ellint_3(Tp(data005[i].k), Tp(data005[i].nu));
232 
      const Tp f0 = data005[i].f0;
233 
      const Tp diff = f - f0;
234 
      if (std::abs(diff) > max_abs_diff)
235 
        max_abs_diff = std::abs(diff);
236 
      if (std::abs(f0) > Tp(10) * eps
237 
       && std::abs(f) > Tp(10) * eps)
238 
        {
239 
          const Tp frac = diff / f0;
240 
          if (std::abs(frac) > max_abs_frac)
241 
            max_abs_frac = std::abs(frac);
242 
        }
243 
    }
244 
  VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
245 
}
246 
 
247 
// Test data for k=-0.40000000000000002.
248 
testcase_comp_ellint_3<double> data006[] = {
249 
  { 1.6399998658645112, -0.40000000000000002, 0.0000000000000000 },
250 
  { 1.5620566886683604, -0.40000000000000002, 0.10000000000000001 },
251 
  { 1.4941414344266770, -0.40000000000000002, 0.20000000000000001 },
252 
  { 1.4342789859950078, -0.40000000000000002, 0.29999999999999999 },
253 
  { 1.3809986210732901, -0.40000000000000002, 0.40000000000000002 },
254 
  { 1.3331797176377398, -0.40000000000000002, 0.50000000000000000 },
255 
  { 1.2899514672527024, -0.40000000000000002, 0.59999999999999998 },
256 
  { 1.2506255923253344, -0.40000000000000002, 0.69999999999999996 },
257 
  { 1.2146499565727209, -0.40000000000000002, 0.80000000000000004 },
258 
  { 1.1815758115929846, -0.40000000000000002, 0.90000000000000002 },
259 
};
260 
 
261 
// Test function for k=-0.40000000000000002.
262 
template <typename Tp>
263 
void test006()
264 
{
265 
  const Tp eps = std::numeric_limits<Tp>::epsilon();
266 
  Tp max_abs_diff = -Tp(1);
267 
  Tp max_abs_frac = -Tp(1);
268 
  unsigned int num_datum = sizeof(data006)
269 
                         / sizeof(testcase_comp_ellint_3<double>);
270 
  for (unsigned int i = 0; i < num_datum; ++i)
271 
    {
272 
      const Tp f = std::tr1::comp_ellint_3(Tp(data006[i].k), Tp(data006[i].nu));
273 
      const Tp f0 = data006[i].f0;
274 
      const Tp diff = f - f0;
275 
      if (std::abs(diff) > max_abs_diff)
276 
        max_abs_diff = std::abs(diff);
277 
      if (std::abs(f0) > Tp(10) * eps
278 
       && std::abs(f) > Tp(10) * eps)
279 
        {
280 
          const Tp frac = diff / f0;
281 
          if (std::abs(frac) > max_abs_frac)
282 
            max_abs_frac = std::abs(frac);
283 
        }
284 
    }
285 
  VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
286 
}
287 
 
288 
// Test data for k=-0.30000000000000004.
289 
testcase_comp_ellint_3<double> data007[] = {
290 
  { 1.6080486199305126, -0.30000000000000004, 0.0000000000000000 },
291 
  { 1.5323534693557526, -0.30000000000000004, 0.10000000000000001 },
292 
  { 1.4663658145259875, -0.30000000000000004, 0.20000000000000001 },
293 
  { 1.4081767433479089, -0.30000000000000004, 0.29999999999999999 },
294 
  { 1.3563643538969761, -0.30000000000000004, 0.40000000000000002 },
295 
  { 1.3098448759814960, -0.30000000000000004, 0.50000000000000000 },
296 
  { 1.2677758800420666, -0.30000000000000004, 0.59999999999999998 },
297 
  { 1.2294913236274980, -0.30000000000000004, 0.69999999999999996 },
298 
  { 1.1944567571590046, -0.30000000000000004, 0.80000000000000004 },
299 
  { 1.1622376896064912, -0.30000000000000004, 0.90000000000000002 },
300 
};
301 
 
302 
// Test function for k=-0.30000000000000004.
303 
template <typename Tp>
304 
void test007()
305 
{
306 
  const Tp eps = std::numeric_limits<Tp>::epsilon();
307 
  Tp max_abs_diff = -Tp(1);
308 
  Tp max_abs_frac = -Tp(1);
309 
  unsigned int num_datum = sizeof(data007)
310 
                         / sizeof(testcase_comp_ellint_3<double>);
311 
  for (unsigned int i = 0; i < num_datum; ++i)
312 
    {
313 
      const Tp f = std::tr1::comp_ellint_3(Tp(data007[i].k), Tp(data007[i].nu));
314 
      const Tp f0 = data007[i].f0;
315 
      const Tp diff = f - f0;
316 
      if (std::abs(diff) > max_abs_diff)
317 
        max_abs_diff = std::abs(diff);
318 
      if (std::abs(f0) > Tp(10) * eps
319 
       && std::abs(f) > Tp(10) * eps)
320 
        {
321 
          const Tp frac = diff / f0;
322 
          if (std::abs(frac) > max_abs_frac)
323 
            max_abs_frac = std::abs(frac);
324 
        }
325 
    }
326 
  VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
327 
}
328 
 
329 
// Test data for k=-0.19999999999999996.
330 
testcase_comp_ellint_3<double> data008[] = {
331 
  { 1.5868678474541664, -0.19999999999999996, 0.0000000000000000 },
332 
  { 1.5126513474261092, -0.19999999999999996, 0.10000000000000001 },
333 
  { 1.4479323932249568, -0.19999999999999996, 0.20000000000000001 },
334 
  { 1.3908453514752481, -0.19999999999999996, 0.29999999999999999 },
335 
  { 1.3400002519661010, -0.19999999999999996, 0.40000000000000002 },
336 
  { 1.2943374404397376, -0.19999999999999996, 0.50000000000000000 },
337 
  { 1.2530330675914561, -0.19999999999999996, 0.59999999999999998 },
338 
  { 1.2154356555075867, -0.19999999999999996, 0.69999999999999996 },
339 
  { 1.1810223448909913, -0.19999999999999996, 0.80000000000000004 },
340 
  { 1.1493679916141863, -0.19999999999999996, 0.90000000000000002 },
341 
};
342 
 
343 
// Test function for k=-0.19999999999999996.
344 
template <typename Tp>
345 
void test008()
346 
{
347 
  const Tp eps = std::numeric_limits<Tp>::epsilon();
348 
  Tp max_abs_diff = -Tp(1);
349 
  Tp max_abs_frac = -Tp(1);
350 
  unsigned int num_datum = sizeof(data008)
351 
                         / sizeof(testcase_comp_ellint_3<double>);
352 
  for (unsigned int i = 0; i < num_datum; ++i)
353 
    {
354 
      const Tp f = std::tr1::comp_ellint_3(Tp(data008[i].k), Tp(data008[i].nu));
355 
      const Tp f0 = data008[i].f0;
356 
      const Tp diff = f - f0;
357 
      if (std::abs(diff) > max_abs_diff)
358 
        max_abs_diff = std::abs(diff);
359 
      if (std::abs(f0) > Tp(10) * eps
360 
       && std::abs(f) > Tp(10) * eps)
361 
        {
362 
          const Tp frac = diff / f0;
363 
          if (std::abs(frac) > max_abs_frac)
364 
            max_abs_frac = std::abs(frac);
365 
        }
366 
    }
367 
  VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
368 
}
369 
 
370 
// Test data for k=-0.099999999999999978.
371 
testcase_comp_ellint_3<double> data009[] = {
372 
  { 1.5747455615173562, -0.099999999999999978, 0.0000000000000000 },
373 
  { 1.5013711111199950, -0.099999999999999978, 0.10000000000000001 },
374 
  { 1.4373749386463430, -0.099999999999999978, 0.20000000000000001 },
375 
  { 1.3809159606704959, -0.099999999999999978, 0.29999999999999999 },
376 
  { 1.3306223265207477, -0.099999999999999978, 0.40000000000000002 },
377 
  { 1.2854480708580160, -0.099999999999999978, 0.50000000000000000 },
378 
  { 1.2445798942989255, -0.099999999999999978, 0.59999999999999998 },
379 
  { 1.2073745911083187, -0.099999999999999978, 0.69999999999999996 },
380 
  { 1.1733158866987732, -0.099999999999999978, 0.80000000000000004 },
381 
  { 1.1419839485283374, -0.099999999999999978, 0.90000000000000002 },
382 
};
383 
 
384 
// Test function for k=-0.099999999999999978.
385 
template <typename Tp>
386 
void test009()
387 
{
388 
  const Tp eps = std::numeric_limits<Tp>::epsilon();
389 
  Tp max_abs_diff = -Tp(1);
390 
  Tp max_abs_frac = -Tp(1);
391 
  unsigned int num_datum = sizeof(data009)
392 
                         / sizeof(testcase_comp_ellint_3<double>);
393 
  for (unsigned int i = 0; i < num_datum; ++i)
394 
    {
395 
      const Tp f = std::tr1::comp_ellint_3(Tp(data009[i].k), Tp(data009[i].nu));
396 
      const Tp f0 = data009[i].f0;
397 
      const Tp diff = f - f0;
398 
      if (std::abs(diff) > max_abs_diff)
399 
        max_abs_diff = std::abs(diff);
400 
      if (std::abs(f0) > Tp(10) * eps
401 
       && std::abs(f) > Tp(10) * eps)
402 
        {
403 
          const Tp frac = diff / f0;
404 
          if (std::abs(frac) > max_abs_frac)
405 
            max_abs_frac = std::abs(frac);
406 
        }
407 
    }
408 
  VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
409 
}
410 
 
411 
// Test data for k=0.0000000000000000.
412 
testcase_comp_ellint_3<double> data010[] = {
413 
  { 1.5707963267948966, 0.0000000000000000, 0.0000000000000000 },
414 
  { 1.4976955329233277, 0.0000000000000000, 0.10000000000000001 },
415 
  { 1.4339343023863691, 0.0000000000000000, 0.20000000000000001 },
416 
  { 1.3776795151134889, 0.0000000000000000, 0.29999999999999999 },
417 
  { 1.3275651989026322, 0.0000000000000000, 0.40000000000000002 },
418 
  { 1.2825498301618641, 0.0000000000000000, 0.50000000000000000 },
419 
  { 1.2418235332245127, 0.0000000000000000, 0.59999999999999998 },
420 
  { 1.2047457872617382, 0.0000000000000000, 0.69999999999999996 },
421 
  { 1.1708024551734544, 0.0000000000000000, 0.80000000000000004 },
422 
  { 1.1395754288497419, 0.0000000000000000, 0.90000000000000002 },
423 
};
424 
 
425 
// Test function for k=0.0000000000000000.
426 
template <typename Tp>
427 
void test010()
428 
{
429 
  const Tp eps = std::numeric_limits<Tp>::epsilon();
430 
  Tp max_abs_diff = -Tp(1);
431 
  Tp max_abs_frac = -Tp(1);
432 
  unsigned int num_datum = sizeof(data010)
433 
                         / sizeof(testcase_comp_ellint_3<double>);
434 
  for (unsigned int i = 0; i < num_datum; ++i)
435 
    {
436 
      const Tp f = std::tr1::comp_ellint_3(Tp(data010[i].k), Tp(data010[i].nu));
437 
      const Tp f0 = data010[i].f0;
438 
      const Tp diff = f - f0;
439 
      if (std::abs(diff) > max_abs_diff)
440 
        max_abs_diff = std::abs(diff);
441 
      if (std::abs(f0) > Tp(10) * eps
442 
       && std::abs(f) > Tp(10) * eps)
443 
        {
444 
          const Tp frac = diff / f0;
445 
          if (std::abs(frac) > max_abs_frac)
446 
            max_abs_frac = std::abs(frac);
447 
        }
448 
    }
449 
  VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
450 
}
451 
 
452 
// Test data for k=0.10000000000000009.
453 
testcase_comp_ellint_3<double> data011[] = {
454 
  { 1.5747455615173562, 0.10000000000000009, 0.0000000000000000 },
455 
  { 1.5013711111199950, 0.10000000000000009, 0.10000000000000001 },
456 
  { 1.4373749386463430, 0.10000000000000009, 0.20000000000000001 },
457 
  { 1.3809159606704959, 0.10000000000000009, 0.29999999999999999 },
458 
  { 1.3306223265207477, 0.10000000000000009, 0.40000000000000002 },
459 
  { 1.2854480708580160, 0.10000000000000009, 0.50000000000000000 },
460 
  { 1.2445798942989255, 0.10000000000000009, 0.59999999999999998 },
461 
  { 1.2073745911083187, 0.10000000000000009, 0.69999999999999996 },
462 
  { 1.1733158866987732, 0.10000000000000009, 0.80000000000000004 },
463 
  { 1.1419839485283374, 0.10000000000000009, 0.90000000000000002 },
464 
};
465 
 
466 
// Test function for k=0.10000000000000009.
467 
template <typename Tp>
468 
void test011()
469 
{
470 
  const Tp eps = std::numeric_limits<Tp>::epsilon();
471 
  Tp max_abs_diff = -Tp(1);
472 
  Tp max_abs_frac = -Tp(1);
473 
  unsigned int num_datum = sizeof(data011)
474 
                         / sizeof(testcase_comp_ellint_3<double>);
475 
  for (unsigned int i = 0; i < num_datum; ++i)
476 
    {
477 
      const Tp f = std::tr1::comp_ellint_3(Tp(data011[i].k), Tp(data011[i].nu));
478 
      const Tp f0 = data011[i].f0;
479 
      const Tp diff = f - f0;
480 
      if (std::abs(diff) > max_abs_diff)
481 
        max_abs_diff = std::abs(diff);
482 
      if (std::abs(f0) > Tp(10) * eps
483 
       && std::abs(f) > Tp(10) * eps)
484 
        {
485 
          const Tp frac = diff / f0;
486 
          if (std::abs(frac) > max_abs_frac)
487 
            max_abs_frac = std::abs(frac);
488 
        }
489 
    }
490 
  VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
491 
}
492 
 
493 
// Test data for k=0.19999999999999996.
494 
testcase_comp_ellint_3<double> data012[] = {
495 
  { 1.5868678474541664, 0.19999999999999996, 0.0000000000000000 },
496 
  { 1.5126513474261092, 0.19999999999999996, 0.10000000000000001 },
497 
  { 1.4479323932249568, 0.19999999999999996, 0.20000000000000001 },
498 
  { 1.3908453514752481, 0.19999999999999996, 0.29999999999999999 },
499 
  { 1.3400002519661010, 0.19999999999999996, 0.40000000000000002 },
500 
  { 1.2943374404397376, 0.19999999999999996, 0.50000000000000000 },
501 
  { 1.2530330675914561, 0.19999999999999996, 0.59999999999999998 },
502 
  { 1.2154356555075867, 0.19999999999999996, 0.69999999999999996 },
503 
  { 1.1810223448909913, 0.19999999999999996, 0.80000000000000004 },
504 
  { 1.1493679916141863, 0.19999999999999996, 0.90000000000000002 },
505 
};
506 
 
507 
// Test function for k=0.19999999999999996.
508 
template <typename Tp>
509 
void test012()
510 
{
511 
  const Tp eps = std::numeric_limits<Tp>::epsilon();
512 
  Tp max_abs_diff = -Tp(1);
513 
  Tp max_abs_frac = -Tp(1);
514 
  unsigned int num_datum = sizeof(data012)
515 
                         / sizeof(testcase_comp_ellint_3<double>);
516 
  for (unsigned int i = 0; i < num_datum; ++i)
517 
    {
518 
      const Tp f = std::tr1::comp_ellint_3(Tp(data012[i].k), Tp(data012[i].nu));
519 
      const Tp f0 = data012[i].f0;
520 
      const Tp diff = f - f0;
521 
      if (std::abs(diff) > max_abs_diff)
522 
        max_abs_diff = std::abs(diff);
523 
      if (std::abs(f0) > Tp(10) * eps
524 
       && std::abs(f) > Tp(10) * eps)
525 
        {
526 
          const Tp frac = diff / f0;
527 
          if (std::abs(frac) > max_abs_frac)
528 
            max_abs_frac = std::abs(frac);
529 
        }
530 
    }
531 
  VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
532 
}
533 
 
534 
// Test data for k=0.30000000000000004.
535 
testcase_comp_ellint_3<double> data013[] = {
536 
  { 1.6080486199305126, 0.30000000000000004, 0.0000000000000000 },
537 
  { 1.5323534693557526, 0.30000000000000004, 0.10000000000000001 },
538 
  { 1.4663658145259875, 0.30000000000000004, 0.20000000000000001 },
539 
  { 1.4081767433479089, 0.30000000000000004, 0.29999999999999999 },
540 
  { 1.3563643538969761, 0.30000000000000004, 0.40000000000000002 },
541 
  { 1.3098448759814960, 0.30000000000000004, 0.50000000000000000 },
542 
  { 1.2677758800420666, 0.30000000000000004, 0.59999999999999998 },
543 
  { 1.2294913236274980, 0.30000000000000004, 0.69999999999999996 },
544 
  { 1.1944567571590046, 0.30000000000000004, 0.80000000000000004 },
545 
  { 1.1622376896064912, 0.30000000000000004, 0.90000000000000002 },
546 
};
547 
 
548 
// Test function for k=0.30000000000000004.
549 
template <typename Tp>
550 
void test013()
551 
{
552 
  const Tp eps = std::numeric_limits<Tp>::epsilon();
553 
  Tp max_abs_diff = -Tp(1);
554 
  Tp max_abs_frac = -Tp(1);
555 
  unsigned int num_datum = sizeof(data013)
556 
                         / sizeof(testcase_comp_ellint_3<double>);
557 
  for (unsigned int i = 0; i < num_datum; ++i)
558 
    {
559 
      const Tp f = std::tr1::comp_ellint_3(Tp(data013[i].k), Tp(data013[i].nu));
560 
      const Tp f0 = data013[i].f0;
561 
      const Tp diff = f - f0;
562 
      if (std::abs(diff) > max_abs_diff)
563 
        max_abs_diff = std::abs(diff);
564 
      if (std::abs(f0) > Tp(10) * eps
565 
       && std::abs(f) > Tp(10) * eps)
566 
        {
567 
          const Tp frac = diff / f0;
568 
          if (std::abs(frac) > max_abs_frac)
569 
            max_abs_frac = std::abs(frac);
570 
        }
571 
    }
572 
  VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
573 
}
574 
 
575 
// Test data for k=0.39999999999999991.
576 
testcase_comp_ellint_3<double> data014[] = {
577 
  { 1.6399998658645112, 0.39999999999999991, 0.0000000000000000 },
578 
  { 1.5620566886683604, 0.39999999999999991, 0.10000000000000001 },
579 
  { 1.4941414344266770, 0.39999999999999991, 0.20000000000000001 },
580 
  { 1.4342789859950078, 0.39999999999999991, 0.29999999999999999 },
581 
  { 1.3809986210732901, 0.39999999999999991, 0.40000000000000002 },
582 
  { 1.3331797176377398, 0.39999999999999991, 0.50000000000000000 },
583 
  { 1.2899514672527024, 0.39999999999999991, 0.59999999999999998 },
584 
  { 1.2506255923253344, 0.39999999999999991, 0.69999999999999996 },
585 
  { 1.2146499565727209, 0.39999999999999991, 0.80000000000000004 },
586 
  { 1.1815758115929846, 0.39999999999999991, 0.90000000000000002 },
587 
};
588 
 
589 
// Test function for k=0.39999999999999991.
590 
template <typename Tp>
591 
void test014()
592 
{
593 
  const Tp eps = std::numeric_limits<Tp>::epsilon();
594 
  Tp max_abs_diff = -Tp(1);
595 
  Tp max_abs_frac = -Tp(1);
596 
  unsigned int num_datum = sizeof(data014)
597 
                         / sizeof(testcase_comp_ellint_3<double>);
598 
  for (unsigned int i = 0; i < num_datum; ++i)
599 
    {
600 
      const Tp f = std::tr1::comp_ellint_3(Tp(data014[i].k), Tp(data014[i].nu));
601 
      const Tp f0 = data014[i].f0;
602 
      const Tp diff = f - f0;
603 
      if (std::abs(diff) > max_abs_diff)
604 
        max_abs_diff = std::abs(diff);
605 
      if (std::abs(f0) > Tp(10) * eps
606 
       && std::abs(f) > Tp(10) * eps)
607 
        {
608 
          const Tp frac = diff / f0;
609 
          if (std::abs(frac) > max_abs_frac)
610 
            max_abs_frac = std::abs(frac);
611 
        }
612 
    }
613 
  VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
614 
}
615 
 
616 
// Test data for k=0.50000000000000000.
617 
testcase_comp_ellint_3<double> data015[] = {
618 
  { 1.6857503548125963, 0.50000000000000000, 0.0000000000000000 },
619 
  { 1.6045524936084892, 0.50000000000000000, 0.10000000000000001 },
620 
  { 1.5338490483665983, 0.50000000000000000, 0.20000000000000001 },
621 
  { 1.4715681939859637, 0.50000000000000000, 0.29999999999999999 },
622 
  { 1.4161679518465340, 0.50000000000000000, 0.40000000000000002 },
623 
  { 1.3664739530045971, 0.50000000000000000, 0.50000000000000000 },
624 
  { 1.3215740290190876, 0.50000000000000000, 0.59999999999999998 },
625 
  { 1.2807475181182502, 0.50000000000000000, 0.69999999999999996 },
626 
  { 1.2434165408189539, 0.50000000000000000, 0.80000000000000004 },
627 
  { 1.2091116095504744, 0.50000000000000000, 0.90000000000000002 },
628 
};
629 
 
630 
// Test function for k=0.50000000000000000.
631 
template <typename Tp>
632 
void test015()
633 
{
634 
  const Tp eps = std::numeric_limits<Tp>::epsilon();
635 
  Tp max_abs_diff = -Tp(1);
636 
  Tp max_abs_frac = -Tp(1);
637 
  unsigned int num_datum = sizeof(data015)
638 
                         / sizeof(testcase_comp_ellint_3<double>);
639 
  for (unsigned int i = 0; i < num_datum; ++i)
640 
    {
641 
      const Tp f = std::tr1::comp_ellint_3(Tp(data015[i].k), Tp(data015[i].nu));
642 
      const Tp f0 = data015[i].f0;
643 
      const Tp diff = f - f0;
644 
      if (std::abs(diff) > max_abs_diff)
645 
        max_abs_diff = std::abs(diff);
646 
      if (std::abs(f0) > Tp(10) * eps
647 
       && std::abs(f) > Tp(10) * eps)
648 
        {
649 
          const Tp frac = diff / f0;
650 
          if (std::abs(frac) > max_abs_frac)
651 
            max_abs_frac = std::abs(frac);
652 
        }
653 
    }
654 
  VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
655 
}
656 
 
657 
// Test data for k=0.60000000000000009.
658 
testcase_comp_ellint_3<double> data016[] = {
659 
  { 1.7507538029157526, 0.60000000000000009, 0.0000000000000000 },
660 
  { 1.6648615773343014, 0.60000000000000009, 0.10000000000000001 },
661 
  { 1.5901418016279374, 0.60000000000000009, 0.20000000000000001 },
662 
  { 1.5243814243493585, 0.60000000000000009, 0.29999999999999999 },
663 
  { 1.4659345278069984, 0.60000000000000009, 0.40000000000000002 },
664 
  { 1.4135484285693078, 0.60000000000000009, 0.50000000000000000 },
665 
  { 1.3662507535812816, 0.60000000000000009, 0.59999999999999998 },
666 
  { 1.3232737468822811, 0.60000000000000009, 0.69999999999999996 },
667 
  { 1.2840021261752192, 0.60000000000000009, 0.80000000000000004 },
668 
  { 1.2479362973851875, 0.60000000000000009, 0.90000000000000002 },
669 
};
670 
 
671 
// Test function for k=0.60000000000000009.
672 
template <typename Tp>
673 
void test016()
674 
{
675 
  const Tp eps = std::numeric_limits<Tp>::epsilon();
676 
  Tp max_abs_diff = -Tp(1);
677 
  Tp max_abs_frac = -Tp(1);
678 
  unsigned int num_datum = sizeof(data016)
679 
                         / sizeof(testcase_comp_ellint_3<double>);
680 
  for (unsigned int i = 0; i < num_datum; ++i)
681 
    {
682 
      const Tp f = std::tr1::comp_ellint_3(Tp(data016[i].k), Tp(data016[i].nu));
683 
      const Tp f0 = data016[i].f0;
684 
      const Tp diff = f - f0;
685 
      if (std::abs(diff) > max_abs_diff)
686 
        max_abs_diff = std::abs(diff);
687 
      if (std::abs(f0) > Tp(10) * eps
688 
       && std::abs(f) > Tp(10) * eps)
689 
        {
690 
          const Tp frac = diff / f0;
691 
          if (std::abs(frac) > max_abs_frac)
692 
            max_abs_frac = std::abs(frac);
693 
        }
694 
    }
695 
  VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
696 
}
697 
 
698 
// Test data for k=0.69999999999999996.
699 
testcase_comp_ellint_3<double> data017[] = {
700 
  { 1.8456939983747236, 0.69999999999999996, 0.0000000000000000 },
701 
  { 1.7528050171757608, 0.69999999999999996, 0.10000000000000001 },
702 
  { 1.6721098780092147, 0.69999999999999996, 0.20000000000000001 },
703 
  { 1.6011813647733213, 0.69999999999999996, 0.29999999999999999 },
704 
  { 1.5382162002954762, 0.69999999999999996, 0.40000000000000002 },
705 
  { 1.4818433192178544, 0.69999999999999996, 0.50000000000000000 },
706 
  { 1.4309994736080540, 0.69999999999999996, 0.59999999999999998 },
707 
  { 1.3848459188329196, 0.69999999999999996, 0.69999999999999996 },
708 
  { 1.3427110650397533, 0.69999999999999996, 0.80000000000000004 },
709 
  { 1.3040500499695911, 0.69999999999999996, 0.90000000000000002 },
710 
};
711 
 
712 
// Test function for k=0.69999999999999996.
713 
template <typename Tp>
714 
void test017()
715 
{
716 
  const Tp eps = std::numeric_limits<Tp>::epsilon();
717 
  Tp max_abs_diff = -Tp(1);
718 
  Tp max_abs_frac = -Tp(1);
719 
  unsigned int num_datum = sizeof(data017)
720 
                         / sizeof(testcase_comp_ellint_3<double>);
721 
  for (unsigned int i = 0; i < num_datum; ++i)
722 
    {
723 
      const Tp f = std::tr1::comp_ellint_3(Tp(data017[i].k), Tp(data017[i].nu));
724 
      const Tp f0 = data017[i].f0;
725 
      const Tp diff = f - f0;
726 
      if (std::abs(diff) > max_abs_diff)
727 
        max_abs_diff = std::abs(diff);
728 
      if (std::abs(f0) > Tp(10) * eps
729 
       && std::abs(f) > Tp(10) * eps)
730 
        {
731 
          const Tp frac = diff / f0;
732 
          if (std::abs(frac) > max_abs_frac)
733 
            max_abs_frac = std::abs(frac);
734 
        }
735 
    }
736 
  VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
737 
}
738 
 
739 
// Test data for k=0.80000000000000004.
740 
testcase_comp_ellint_3<double> data018[] = {
741 
  { 1.9953027776647296, 0.80000000000000004, 0.0000000000000000 },
742 
  { 1.8910755418379521, 0.80000000000000004, 0.10000000000000001 },
743 
  { 1.8007226661734588, 0.80000000000000004, 0.20000000000000001 },
744 
  { 1.7214611048717301, 0.80000000000000004, 0.29999999999999999 },
745 
  { 1.6512267838651289, 0.80000000000000004, 0.40000000000000002 },
746 
  { 1.5884528947755532, 0.80000000000000004, 0.50000000000000000 },
747 
  { 1.5319262547427865, 0.80000000000000004, 0.59999999999999998 },
748 
  { 1.4806912324625332, 0.80000000000000004, 0.69999999999999996 },
749 
  { 1.4339837018309474, 0.80000000000000004, 0.80000000000000004 },
750 
  { 1.3911845406776222, 0.80000000000000004, 0.90000000000000002 },
751 
};
752 
 
753 
// Test function for k=0.80000000000000004.
754 
template <typename Tp>
755 
void test018()
756 
{
757 
  const Tp eps = std::numeric_limits<Tp>::epsilon();
758 
  Tp max_abs_diff = -Tp(1);
759 
  Tp max_abs_frac = -Tp(1);
760 
  unsigned int num_datum = sizeof(data018)
761 
                         / sizeof(testcase_comp_ellint_3<double>);
762 
  for (unsigned int i = 0; i < num_datum; ++i)
763 
    {
764 
      const Tp f = std::tr1::comp_ellint_3(Tp(data018[i].k), Tp(data018[i].nu));
765 
      const Tp f0 = data018[i].f0;
766 
      const Tp diff = f - f0;
767 
      if (std::abs(diff) > max_abs_diff)
768 
        max_abs_diff = std::abs(diff);
769 
      if (std::abs(f0) > Tp(10) * eps
770 
       && std::abs(f) > Tp(10) * eps)
771 
        {
772 
          const Tp frac = diff / f0;
773 
          if (std::abs(frac) > max_abs_frac)
774 
            max_abs_frac = std::abs(frac);
775 
        }
776 
    }
777 
  VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
778 
}
779 
 
780 
// Test data for k=0.89999999999999991.
781 
testcase_comp_ellint_3<double> data019[] = {
782 
  { 2.2805491384227699, 0.89999999999999991, 0.0000000000000000 },
783 
  { 2.1537868513875282, 0.89999999999999991, 0.10000000000000001 },
784 
  { 2.0443194576468890, 0.89999999999999991, 0.20000000000000001 },
785 
  { 1.9486280260314424, 0.89999999999999991, 0.29999999999999999 },
786 
  { 1.8641114227238347, 0.89999999999999991, 0.40000000000000002 },
787 
  { 1.7888013241937859, 0.89999999999999991, 0.50000000000000000 },
788 
  { 1.7211781128919521, 0.89999999999999991, 0.59999999999999998 },
789 
  { 1.6600480747670936, 0.89999999999999991, 0.69999999999999996 },
790 
  { 1.6044591960982200, 0.89999999999999991, 0.80000000000000004 },
791 
  { 1.5536420236310944, 0.89999999999999991, 0.90000000000000002 },
792 
};
793 
 
794 
// Test function for k=0.89999999999999991.
795 
template <typename Tp>
796 
void test019()
797 
{
798 
  const Tp eps = std::numeric_limits<Tp>::epsilon();
799 
  Tp max_abs_diff = -Tp(1);
800 
  Tp max_abs_frac = -Tp(1);
801 
  unsigned int num_datum = sizeof(data019)
802 
                         / sizeof(testcase_comp_ellint_3<double>);
803 
  for (unsigned int i = 0; i < num_datum; ++i)
804 
    {
805 
      const Tp f = std::tr1::comp_ellint_3(Tp(data019[i].k), Tp(data019[i].nu));
806 
      const Tp f0 = data019[i].f0;
807 
      const Tp diff = f - f0;
808 
      if (std::abs(diff) > max_abs_diff)
809 
        max_abs_diff = std::abs(diff);
810 
      if (std::abs(f0) > Tp(10) * eps
811 
       && std::abs(f) > Tp(10) * eps)
812 
        {
813 
          const Tp frac = diff / f0;
814 
          if (std::abs(frac) > max_abs_frac)
815 
            max_abs_frac = std::abs(frac);
816 
        }
817 
    }
818 
  VERIFY(max_abs_frac < Tp(2.5000000000000020e-13));
819 
}
820 
 
821 
int main(int, char**)
822 
{
823 
  test001<double>();
824 
  test002<double>();
825 
  test003<double>();
826 
  test004<double>();
827 
  test005<double>();
828 
  test006<double>();
829 
  test007<double>();
830 
  test008<double>();
831 
  test009<double>();
832 
  test010<double>();
833 
  test011<double>();
834 
  test012<double>();
835 
  test013<double>();
836 
  test014<double>();
837 
  test015<double>();
838 
  test016<double>();
839 
  test017<double>();
840 
  test018<double>();
841 
  test019<double>();
842 
  return 0;
843 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.