1 /*
2  * Copyright (c) 2021 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "ComplexTest.h"
17 
18 #include <stdio.h>
19 #include <stdlib.h>
20 #include <unistd.h>
21 #include <math.h>
22 #include <limits.h>
23 #include <complex.h>
24 #include "log.h"
25 #include "MathUtils.h"
26 
27 #ifdef __cplusplus
28 extern "C" {
29 #endif
30 
31 
TestCabsnull32 int TestCabs()
33 {
34     const int testCount = 3;
35     double _Complex testZ[testCount];
36     testZ[0] = 1.0 + 3.0 * I;
37     testZ[1] = 0.0 - 3.0 * I;
38     testZ[2] = 6.5555555 - 5.0 * I;
39     double expected[] = {3.16227766016837952279, 3.0, 8.24471393764394};
40 
41     int sum = 0;
42     for (int i = 0; i < testCount; ++i) {
43         double d = cabs(testZ[i]);
44         if (!Equal(d, expected[i])) {
45             LOG("cabs of %lf+%lfi failed, expected:%.20lf, actual:%.20lf\n",
46                 creal(testZ[i]), cimag(testZ[i]), expected[i], d);
47             sum++;
48         }
49     }
50     return sum;
51 }
52 
TestCabsfnull53 int TestCabsf()
54 {
55     const int testCount = 3;
56     float _Complex testZ[testCount];
57     testZ[0] = 4.0 + 3.0 * I;
58     testZ[1] = 0.0 - 3.0 * I;
59     testZ[2] = 6.555 - 5.0 * I;
60     float expected[] = {5.0, 3.0, 8.244272};
61 
62     int sum = 0;
63     for (int i = 0; i < testCount; ++i) {
64         float d = cabsf(testZ[i]);
65         if (!Equalf(d, expected[i])) {
66             LOG("cabsf of %f+%fi failed, expected:%.10f, actual:%.10f",
67                 creal(testZ[i]), cimag(testZ[i]), expected[i], d);
68             sum++;
69         }
70     }
71     return sum;
72 }
73 
TestCabslnull74 int TestCabsl()
75 {
76     const int testCount = 3;
77     long double _Complex testZ[testCount];
78     testZ[0] = 4.0 + 3.0 * I;
79     testZ[1] = 0.0 - 3.0 * I;
80     testZ[2] = 1.23456789123456789 - 2.0 * I;
81     long double expected[] = {5.0, 3.0, 2.35035271354479216};
82 
83     int sum = 0;
84     for (int i = 0; i < testCount; ++i) {
85         long double d = cabsl(testZ[i]);
86         if (!Equall(d, expected[i])) {
87             LOG("cabsl of %Lf+%Lfi failed, expected:%.20Lf, actual:%.20Lf",
88                 creal(testZ[i]), cimag(testZ[i]), expected[i], d);
89             sum++;
90         }
91     }
92     return sum;
93 }
94 
TestCacosnull95 int TestCacos()
96 {
97     const int testCount = 3;
98     double _Complex testZ[testCount];
99     testZ[0] = 3.0 + 4.0 * I;
100     testZ[1] = 0.0 - 3.0 * I;
101     testZ[2] = 1.123456 - 2.0 * I;
102     double _Complex expected[testCount];
103     double _Complex resultval[testCount];
104 
105     expected[0] = 0.93681246115571925603 + (-2.30550903124346850959) * I;
106     expected[1] = 1.57079632679489655800 + 1.81844645923206682525 * I;
107     expected[2] = 1.09661331246844784282 + 1.54935939824075052940 * I;
108 
109     int sum = 0;
110     for (int i = 0; i < testCount; ++i) {
111         resultval[i] = cacos(testZ[i]);
112         if ((!Equal(creal(expected[i]), creal(resultval[i]))) && (!Equall(cimag(expected[i]), cimag(resultval[i])))) {
113             LOG("ctanl of %.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf +%.20Lfi\n",
114                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
115                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
116             sum++;
117         }
118     }
119     return sum;
120 }
121 
TestCacosfnull122 int TestCacosf()
123 {
124     const int testCount = 3;
125     float _Complex testZ[testCount];
126     testZ[0] = 3.0 + 4.0 * I;
127     testZ[1] = 0.0 - 3.0 * I;
128     testZ[2] = 1.123456 - 2.0 * I;
129     float _Complex expected[testCount];
130     float _Complex resultval[testCount];
131 
132     expected[0] = 0.9368131757 + -2.3055081367 * I;
133     expected[1] = 1.5707963705 + 1.8184465170 * I;
134     expected[2] = 1.0966134071 + 1.5493593216 * I;
135 
136     int sum = 0;
137     for (int i = 0; i < testCount; ++i) {
138         resultval[i] = cacosf(testZ[i]);
139         if ((!Equalf(creal(expected[i]), creal(resultval[i]))) && (!Equall(cimag(expected[i]), cimag(resultval[i])))) {
140             LOG("cacosf of %f+%fi failed, \n expected:%.10f+%.10fi,\n actual:%.10f +%.10fi\n",
141                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
142                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
143             sum++;
144         }
145     }
146     return sum;
147 }
148 
TestCacoshnull149 int TestCacosh()
150 {
151     const int testCount = 3;
152     double _Complex testZ[testCount];
153     testZ[0] = 3.0 + 4.0 * I;
154     testZ[1] = 0.0 - 3.0 * I;
155     testZ[2] = 1.123456 - 2.0 * I;
156     double _Complex expected[testCount];
157     double _Complex resultval[testCount];
158 
159     expected[0] = 2.30550903124346850959 + 0.93681246115571925603 * I;
160     expected[1] = 1.81844645923206682525 + -1.57079632679489655800 * I;
161     expected[2] = 1.54935939824075052940 + -1.09661331246844784282 * I;
162 
163     int sum = 0;
164     for (int i = 0; i < testCount; ++i) {
165         resultval[i] = cacosh(testZ[i]);
166         if ((!Equal(creal(expected[i]), creal(resultval[i]))) && (!Equall(cimag(expected[i]), cimag(resultval[i])))) {
167             LOG("cocosh of %.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf +%.20Lfi\n",
168                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
169                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
170             sum++;
171         }
172     }
173     return sum;
174 }
175 
TestCacoshfnull176 int TestCacoshf()
177 {
178     const int testCount = 3;
179     float _Complex testZ[testCount];
180     testZ[0] = 3.0 + 4.0 * I;
181     testZ[1] = 0.0 - 3.0 * I;
182     testZ[2] = 1.123456 - 2.0 * I;
183     float _Complex expected[testCount];
184     float _Complex resultval[testCount];
185     expected[0] = 2.3055081367 + 0.9368131757 * I;
186     expected[1] = 1.8184465170 + -1.5707963705 * I;
187     expected[2] = 1.5493593216 + -1.0966134071 * I;
188 
189     int sum = 0;
190     for (int i = 0; i < testCount; ++i) {
191         resultval[i] = cacoshf(testZ[i]);
192         if ((!Equalf(creal(expected[i]), creal(resultval[i]))) && (!Equall(cimag(expected[i]), cimag(resultval[i])))) {
193             LOG("cacoshf of %f+%fi failed, \n expected:%.10f+%.10fi,\n actual:%.10f +%.10fi\n",
194                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
195                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
196             sum++;
197         }
198     }
199     return sum;
200 }
201 
TestCacoshlnull202 int TestCacoshl()
203 {
204     const int testCount = 3;
205     long double _Complex testZ[testCount];
206     testZ[0] = 3.0 + 4.0 * I;
207     testZ[1] = 0.0 - 3.0 * I;
208     testZ[2] = 1.123456 - 2.0 * I;
209     long double _Complex expected[testCount];
210     long double _Complex resultval[testCount];
211     expected[0] = 2.30550903124346850959 + 0.93681246115571925603 * I;
212     expected[1] = 1.81844645923206682525 + -1.57079632679489655800 * I;
213     expected[2] = 1.54935939824075052940 + -1.09661331246844784282 * I;
214 
215     int sum = 0;
216     for (int i = 0; i < testCount; ++i) {
217         resultval[i] = cacoshl(testZ[i]);
218         if ((!Equall(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
219             LOG("cacoshl of %.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf +%.20Lfi\n",
220                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
221                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
222             sum++;
223         }
224     }
225     return sum;
226 }
227 
TestCacoslnull228 int TestCacosl()
229 {
230     const int testCount = 3;
231     long double _Complex testZ[testCount];
232     testZ[0] = 3.0 + 4.0 * I;
233     testZ[1] = 0.0 - 3.0 * I;
234     testZ[2] = 1.123456 - 2.0 * I;
235     long _Complex expected[testCount];
236     long _Complex resultval[testCount];
237 
238     expected[0] = 0.936812 - 2.305509 * I;
239     expected[1] = 1.570796 + 1.818446 * I;
240     expected[2] = 1.096613 + 1.549359 * I;
241 
242     int sum = 0;
243     for (int i = 0; i < testCount; ++i) {
244         resultval[i] = cacosl(testZ[i]);
245         if ((!Equall(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
246             LOG("cacosl of %.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf+%.20Lfi\n",
247                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
248                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
249             sum++;
250         }
251     }
252     return sum;
253 }
254 
TestCargnull255 int TestCarg()
256 {
257     const int testCount = 3;
258     double _Complex testZ[testCount];
259     testZ[0] = 3.0 + 4.0 * I;
260     testZ[1] = 0.0 - 3.0 * I;
261     testZ[2] = 1.23456789 - 2.0 * I;
262     double expected[] = {0.92729521800161218703, -1.57079632679489655800, -1.01776488671168796607};
263 
264     int sum = 0;
265     for (int i = 0; i < testCount; ++i) {
266         double resultval = carg(testZ[i]);
267         if (!Equal(resultval, expected[i])) {
268             LOG("carg of %Lf+%Lfi failed, expected:%.20Lf, actual:%.20Lf\n",
269                 creal(testZ[i]), cimag(testZ[i]), expected[i], resultval);
270             sum++;
271         }
272     }
273     return sum;
274 }
275 
TestCargfnull276 int TestCargf()
277 {
278     const int testCount = 3;
279     float _Complex testZ[testCount];
280     testZ[0] = 3.0 + 4.0 * I;
281     testZ[1] = 0.0 - 3.0 * I;
282     testZ[2] = 1.23456 - 2.0 * I;
283     float expected[] = {0.9272952180, -1.5707963268, -1.0177677870};
284 
285     int sum = 0;
286     for (int i = 0; i < testCount; ++i) {
287         float resultval = cargf(testZ[i]);
288         if (!Equalf(resultval, expected[i])) {
289             LOG("cargf of %f+%fi failed, \n expected:%.10f,\n actual:%.10f\n",
290                 creal(testZ[i]), cimag(testZ[i]), expected[i], resultval);
291             sum++;
292         }
293     }
294     return sum;
295 }
296 
TestCarglnull297 int TestCargl()
298 {
299     const int testCount = 3;
300     long double _Complex testZ[testCount];
301     testZ[0] = 3.0 + 4.0 * I;
302     testZ[1] = 0.0 - 3.0 * I;
303     testZ[2] = 1.23456 - 2.0 * I;
304     long double expected[] = {0.92729521800161218703, -1.57079632679489655800, -1.01776774326071883792};
305 
306     int sum = 0;
307     for (int i = 0; i < testCount; ++i) {
308         long double resultval = cargl(testZ[i]);
309         if (!Equall(resultval, expected[i])) {
310             LOG("cargl of %Lf+%Lfi failed, expected:%.20Lf, actual:%.20Lf\n",
311                 creal(testZ[i]), cimag(testZ[i]), expected[i], resultval);
312             sum++;
313         }
314     }
315     return sum;
316 }
317 
TestCasinnull318 int TestCasin()
319 {
320     const int testCount = 3;
321     double _Complex testZ[testCount];
322     testZ[0] = 3.0 + 4.0 * I;
323     testZ[1] = 0.0 - 3.0 * I;
324     testZ[2] = 1.23456789 - 2.0 * I;
325     double _Complex expected[testCount];
326     double _Complex resultval[testCount];
327 
328     expected[0] = 0.63398400000000000000 + 2.30550900000000000000 * I;
329     expected[1] = 0.00000000000000000000 - 1.81844600000000000000 * I;
330     expected[2] = 0.51505965148270682619 + -1.56954262407246969424 * I;
331 
332     int sum = 0;
333     for (int i = 0; i < testCount; ++i) {
334         resultval[i] = casin(testZ[i]);
335         if ((!Equal(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
336             LOG("casin of %.20Lf+%.20Lfi failed,\n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf+%.20Lfi\n",
337                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
338                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
339             sum++;
340         }
341     }
342     return sum;
343 }
344 
TestCasinfnull345 int TestCasinf()
346 {
347     const int testCount = 3;
348     float _Complex testZ[testCount];
349     testZ[0] = 3.0 + 4.0 * I;
350     testZ[1] = 0.0 - 3.0 * I;
351     testZ[2] = 1.123456 - 2.0 * I;
352     float _Complex expected[testCount];
353     float _Complex resultval[testCount];
354 
355     expected[0] = 0.6339831948 + 2.3055081367 * I;
356     expected[1] = 0.0000000000 - 1.8184460000 * I;
357     expected[2] = 0.4741830000 - 1.5493590000 * I;
358 
359     int sum = 0;
360     for (int i = 0; i < testCount; ++i) {
361         resultval[i] = casinf(testZ[i]);
362         if ((!Equalf(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
363             LOG("casinf of %.10f+%.10fi failed,\n expected:%.10f+%.10fi,\n actual:%.10f+%.10fi\n",
364                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
365                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
366             sum++;
367         }
368     }
369     return sum;
370 }
371 
TestCasinhnull372 int TestCasinh()
373 {
374     const int testCount = 3;
375     double _Complex testZ[testCount];
376     testZ[0] = 3.0 + 4.0 * I;
377     testZ[1] = 0.0 - 3.0 * I;
378     testZ[2] = 1.23456789 - 2.0 * I;
379     double _Complex expected[testCount];
380     double _Complex resultval[testCount];
381 
382     expected[0] = 2.29991404087926865074 + 0.91761685335147724629 * I;
383     expected[1] = 1.76274717403908720570 + -1.57079632679489655800 * I;
384     expected[2] = 1.52957806263130779989 + -0.97493960889397524028 * I;
385 
386     int sum = 0;
387     for (int i = 0; i < testCount; ++i) {
388         resultval[i] = casinh(testZ[i]);
389         if ((!Equal(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
390             LOG("casinh of %.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf +%.20Lfi\n",
391                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
392                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
393             sum++;
394         }
395     }
396     return sum;
397 }
398 
TestCasinhfnull399 int TestCasinhf()
400 {
401     const int testCount = 3;
402     float _Complex testZ[testCount];
403     testZ[0] = 3.0 + 4.0 * I;
404     testZ[1] = 0.0 - 3.0 * I;
405     testZ[2] = 1.23456 - 2.0 * I;
406     float _Complex expected[testCount];
407     float _Complex resultval[testCount];
408 
409     expected[0] = 2.2999134064 + 0.9176163673 * I;
410     expected[1] = 1.7627469301 + -1.5707963705 * I;
411     expected[2] = 1.5295758247 + -0.9749425054 * I;
412 
413     int sum = 0;
414     for (int i = 0; i < testCount; ++i) {
415         resultval[i] = casinhf(testZ[i]);
416         if ((!Equalf(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
417             LOG("casinhf of %.10f+%.10fi failed, \n expected:%.10f+%.10fi,\n actual:%.10f +%.10fi\n",
418                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
419                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
420             sum++;
421         }
422     }
423     return sum;
424 }
425 
TestCasinhlnull426 int TestCasinhl()
427 {
428     const int testCount = 3;
429     long double _Complex testZ[testCount];
430     testZ[0] = 3.0 + 4.0 * I;
431     testZ[1] = 0.0 - 3.0 * I;
432     testZ[2] = 1.23456 - 2.0 * I;
433     long double _Complex expected[testCount];
434     long double _Complex resultval[testCount];
435 
436     expected[0] = 2.29991404087926865074 + 0.91761685335147724629 * I;
437     expected[1] = 1.76274717403908720570 + -1.57079632679489655800 * I;
438     expected[2] = 1.52957598661739924140 + -0.97494239607734123343 * I;
439 
440     int sum = 0;
441     for (int i = 0; i < testCount; ++i) {
442         resultval[i] = casinhl(testZ[i]);
443         if ((!Equall(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
444             LOG("casinhl of %.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf +%.20Lfi\n",
445                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
446                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
447             sum++;
448         }
449     }
450     return sum;
451 }
452 
TestCasinlnull453 int TestCasinl()
454 {
455     const int testCount = 3;
456     long double _Complex testZ[testCount];
457     testZ[0] = 3.0 + 4.0 * I;
458     testZ[1] = 0.0 - 3.0 * I;
459     testZ[2] = 1.23456 - 2.0 * I;
460     long double _Complex expected[testCount];
461     long double _Complex resultval[testCount];
462 
463     expected[0] = 0.63398400000000000000 + 2.30550900000000000000 * I;
464     expected[1] = 0.00000000000000000000 - 1.81844600000000000000 * I;
465     expected[2] = 0.51505680174746037991 + -1.56954114502494923578 * I;
466 
467     int sum = 0;
468     for (int i = 0; i < testCount; ++i) {
469         resultval[i] = casinl(testZ[i]);
470         if ((!Equall(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
471             LOG("casinl of %.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf +%.20Lfi\n",
472                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
473                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
474             sum++;
475         }
476     }
477     return sum;
478 }
479 
TestCatannull480 int TestCatan()
481 {
482     const int testCount = 3;
483     double _Complex testZ[testCount];
484     testZ[0] = 3.0 + 4.0 * I;
485     testZ[1] = 0.0 - 3.0 * I;
486     testZ[2] = 1.23456789 - 2.0 * I;
487     double _Complex expected[testCount];
488     double _Complex resultval[testCount];
489 
490     expected[0] = 1.44830699523146444463 + 0.15899719167999917802 * I;
491     expected[1] = -1.57079632679489655800 + -0.34657359027997264311 * I;
492     expected[2] = 1.32100260208930864181 + -0.35694146805942778000 * I;
493 
494     int sum = 0;
495     for (int i = 0; i < testCount; ++i) {
496         resultval[i] = catan(testZ[i]);
497         if ((!Equal(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
498             LOG("catan of %.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf +%.20Lfi\n",
499                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
500                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
501             sum++;
502         }
503     }
504     return sum;
505 }
506 
TestCatanfnull507 int TestCatanf()
508 {
509     const int testCount = 3;
510     float _Complex testZ[testCount];
511     testZ[0] = 3.0 + 4.0 * I;
512     testZ[1] = 0.0 - 3.0 * I;
513     testZ[2] = 1.23456 - 2.0 * I;
514     float _Complex expected[testCount];
515     float _Complex resultval[testCount];
516     expected[0] = 1.4483070000 + 0.1589970000 * I;
517     expected[1] = -1.5707962513 + -0.3465735912 * I;
518     expected[2] = 1.3210030794 + -0.3569429517 * I;
519 
520     int sum = 0;
521     for (int i = 0; i < testCount; ++i) {
522         resultval[i] = catanf(testZ[i]);
523         if ((!Equalf(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
524             LOG("catanf of %.10f+%.10fi failed, \n expected:%.10f+%.10fi,\n actual:%.10f +%.10fi\n",
525                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
526                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
527             sum++;
528         }
529     }
530     return sum;
531 }
532 
TestCatanhnull533 int TestCatanh()
534 {
535     const int testCount = 3;
536     double _Complex testZ[testCount];
537     testZ[0] = 3.0 + 4.0 * I;
538     testZ[1] = 0.0 - 3.0 * I;
539     testZ[2] = 1.23456789 - 2.0 * I;
540     double _Complex expected[testCount];
541     double _Complex resultval[testCount];
542 
543     expected[0] = 0.11750100000000000000 + 1.40992100000000000000 * I;
544     expected[1] = 0.00000000000000000000 - 1.24904600000000000000 * I;
545     expected[2] = 0.19913075343655456395 + -1.20880401646302515495 * I;
546 
547     int sum = 0;
548     for (int i = 0; i < testCount; ++i) {
549         resultval[i] = catanh(testZ[i]);
550         if ((!Equal(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
551             LOG("catanh of %.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf +%.20Lfi\n",
552                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
553                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
554             sum++;
555         }
556     }
557     return sum;
558 }
559 
TestCatanhfnull560 int TestCatanhf()
561 {
562     const int testCount = 3;
563     float _Complex testZ[testCount];
564     testZ[0] = 3.0 + 4.0 * I;
565     testZ[1] = 0.0 - 3.0 * I;
566     testZ[2] = 1.23456 - 2.0 * I;
567     float _Complex expected[testCount];
568     float _Complex resultval[testCount];
569 
570     expected[0] = 0.1175010000 + 1.4099210000 * I;
571     expected[1] = 0.0000000000 - 1.2490460000 * I;
572     expected[2] = 0.1991299987 + -1.2088029385 * I;
573 
574     int sum = 0;
575     for (int i = 0; i < testCount; ++i) {
576         resultval[i] = catanhf(testZ[i]);
577         if ((!Equalf(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
578             LOG("catanhf of %.10f+%.10fi failed, \n expected:%.10f+%.10fi,\n actual:%.10f +%.10fi\n",
579                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
580                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
581             sum++;
582         }
583     }
584     return sum;
585 }
586 
TestCatanhlnull587 int TestCatanhl()
588 {
589     const int testCount = 3;
590     long double _Complex testZ[testCount];
591     testZ[0] = 3.0 + 4.0 * I;
592     testZ[1] = 0.0 - 3.0 * I;
593     testZ[2] = 1.23456 - 2.0 * I;
594     long double _Complex expected[testCount];
595     long double _Complex resultval[testCount];
596 
597     expected[0] = 0.11750100000000000000 + 1.40992100000000000000 * I;
598     expected[1] = 0.00000000000000000000 - 1.24904600000000000000 * I;
599     expected[2] = 0.19913000142015302441 + -1.20880294804886800897 * I;
600 
601     int sum = 0;
602     for (int i = 0; i < testCount; ++i) {
603         resultval[i] = catanhl(testZ[i]);
604         if ((!Equall(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
605             LOG("catanhl of %.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf +%.20Lfi\n",
606                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
607                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
608             sum++;
609         }
610     }
611     return sum;
612 }
613 
TestCatanlnull614 int TestCatanl()
615 {
616     const int testCount = 3;
617     long double _Complex testZ[testCount];
618     testZ[0] = 3.0 + 4.0 * I;
619     testZ[1] = 0.0 - 3.0 * I;
620     testZ[2] = 1.23456 - 2.0 * I;
621     long double _Complex expected[testCount];
622     long double _Complex resultval[testCount];
623 
624     expected[0] = 1.44830699523146444463 + 0.15899719167999917802 * I;
625     expected[1] = -1.57079632679489655800 + -0.34657359027997264311 * I;
626     expected[2] = 1.32100304043625027539 + -0.35694293478475969117 * I;
627 
628     int sum = 0;
629     for (int i = 0; i < testCount; ++i) {
630         resultval[i] = catanl(testZ[i]);
631         if ((!Equall(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
632             LOG("catanl of %.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf +%.20Lfi\n",
633                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
634                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
635             sum++;
636         }
637     }
638     return sum;
639 }
640 
TestCcosnull641 int TestCcos()
642 {
643     const int testCount = 3;
644     double _Complex testZ[testCount];
645     testZ[0] = 3.0 + 4.0 * I;
646     testZ[1] = 0.0 - 3.0 * I;
647     testZ[2] = 1.23456789 - 2.0 * I;
648     double _Complex expected[testCount];
649     double _Complex resultval[testCount];
650 
651     expected[0] = -27.03494560 - 3.85115333 * I;
652     expected[1] = 10.06766200;
653     expected[2] = 1.24125772 + 3.42377699 * I;
654 
655     int sum = 0;
656     for (int i = 0; i < testCount; ++i) {
657         resultval[i] = ccos(testZ[i]);
658         if ((!Equal(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
659             LOG("ccos of %.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf +%.20Lfi\n",
660                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
661                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
662             sum++;
663         }
664     }
665     return sum;
666 }
667 
TestCcosfnull668 int TestCcosf()
669 {
670     const int testCount = 3;
671     float _Complex testZ[testCount];
672     testZ[0] = 3.0 + 4.0 * I;
673     testZ[1] = 0.0 - 3.0 * I;
674     testZ[2] = 1.23456 - 2.0 * I;
675     float _Complex expected[testCount];
676     float _Complex resultval[testCount];
677 
678     expected[0] = -27.0349445343 + -3.8511533737 * I;
679     expected[1] = 10.0676620000;
680     expected[2] = 1.2412856817 + 3.4237675667 * I;
681 
682     int sum = 0;
683     for (int i = 0; i < testCount; ++i) {
684         resultval[i] = ccosf(testZ[i]);
685         if ((!Equalf(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
686             LOG("ccosf of %.10f+%.10fi failed, \n expected:%.10f+%.10fi,\n actual:%.10f +%.10fi\n",
687                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
688                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
689             sum++;
690         }
691     }
692     return sum;
693 }
694 
TestCcoshnull695 int TestCcosh()
696 {
697     const int testCount = 3;
698     double _Complex testZ[testCount];
699     testZ[0] = 3.0 + 4.0 * I;
700     testZ[1] = 0.0 - 3.0 * I;
701     testZ[2] = 1.23456789 - 2.0 * I;
702     double _Complex expected[testCount];
703     double _Complex resultval[testCount];
704 
705     expected[0] = -6.58066304 - 7.58155274 * I;
706     expected[1] = -0.98999249;
707     expected[2] = -0.77566723 - 1.43029421 * I;
708 
709     int sum = 0;
710     for (int i = 0; i < testCount; ++i) {
711         resultval[i] = ccosh(testZ[i]);
712         if ((!Equal(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
713             LOG("ccosh of %.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf +%.20Lfi\n",
714                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
715                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
716             sum++;
717         }
718     }
719     return sum;
720 }
721 
TestCcoshfnull722 int TestCcoshf()
723 {
724     const int testCount = 3;
725     float _Complex testZ[testCount];
726     testZ[0] = 3.0 + 4.0 * I;
727     testZ[1] = 0.0 - 3.0 * I;
728     testZ[2] = 1.23456 - 2.0 * I;
729     float _Complex expected[testCount];
730     float _Complex resultval[testCount];
731 
732     expected[0] = -6.5806630000 - 7.5815530000 * I;
733     expected[1] = -0.9899920000;
734     expected[2] = -0.7756620646 + -1.4302809238 * I;
735 
736     int sum = 0;
737     for (int i = 0; i < testCount; ++i) {
738         resultval[i] = ccoshf(testZ[i]);
739         if ((!Equalf(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
740             LOG("ccoshf of %.10f+%.10fi failed, \n expected:%.10f+%.10fi,\n actual:%.10f +%.10fi\n",
741                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
742                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
743             sum++;
744         }
745     }
746     return sum;
747 }
748 
TestCcoshlnull749 int TestCcoshl()
750 {
751     const int testCount = 3;
752     long double _Complex testZ[testCount];
753     testZ[0] = 3.0 + 4.0 * I;
754     testZ[1] = 0.0 - 3.0 * I;
755     testZ[2] = 1.23456 - 2.0 * I;
756     long _Complex expected[testCount];
757     long _Complex resultval[testCount];
758 
759     expected[0] = -6.580663 - 7.581553 * I;
760     expected[1] = -0.989992;
761     expected[2] = -0.775667 - 1.430294 * I;
762 
763     int sum = 0;
764     for (int i = 0; i < testCount; ++i) {
765         resultval[i] = ccoshl(testZ[i]);
766         if ((!Equall(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
767             LOG("ccoshl of %.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf +%.20Lfi\n",
768                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
769                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
770             sum++;
771         }
772     }
773     return sum;
774 }
775 
TestCcoslnull776 int TestCcosl()
777 {
778     const int testCount = 3;
779     long double _Complex testZ[testCount];
780     testZ[0] = 3.0 + 4.0 * I;
781     testZ[1] = 0.0 - 3.0 * I;
782     testZ[2] = 1.23456 - 2.0 * I;
783     long double _Complex expected[testCount];
784     long double _Complex resultval[testCount];
785 
786     expected[0] = -27.03494560307422389656 + -3.85115333481177701813 * I;
787     expected[1] = 10.06766200000000000000;
788     expected[2] = 1.24128574667119084829 + 3.42376754746658606976 * I;
789 
790     int sum = 0;
791     for (int i = 0; i < testCount; ++i) {
792         resultval[i] = ccosl(testZ[i]);
793         if ((!Equall(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
794             LOG("ccosl of %.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf +%.20Lfi\n",
795                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
796                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
797             sum++;
798         }
799     }
800     return sum;
801 }
802 
TestCexpnull803 int TestCexp()
804 {
805     const int testCount = 3;
806     double _Complex testZ[testCount];
807     testZ[0] = 3.0 + 4.0 * I;
808     testZ[1] = 0.0 - 3.0 * I;
809     testZ[2] = 1.23456789 - 2.0 * I;
810     double _Complex expected[testCount];
811     double _Complex resultval[testCount];
812 
813     expected[0] = -13.12878308146215822205 + -15.20078446306795427745 * I;
814     expected[1] = -0.989992000000000000000 - 0.141120000000000000000 * I;
815     expected[2] = -1.43025218442476775849 + -3.12515803748498344206 * I;
816 
817     int sum = 0;
818     for (int i = 0; i < testCount; ++i) {
819         resultval[i] = cexp(testZ[i]);
820         if ((!Equall(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
821             LOG("cexp of %.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf +%.20Lfi\n",
822                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
823                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
824             sum++;
825         }
826     }
827     return sum;
828 }
829 
TestCexpfnull830 int TestCexpf()
831 {
832     const int testCount = 3;
833     float _Complex testZ[testCount];
834     testZ[0] = 3.0 + 4.0 * I;
835     testZ[1] = 0.0 - 3.0 * I;
836     testZ[2] = 1.23456 - 2.0 * I;
837     float _Complex expected[testCount];
838     float _Complex resultval[testCount];
839 
840     expected[0] = -13.1287830000 - 15.2007840000 * I;
841     expected[1] = -0.9899920000 - 0.1411200000 * I;
842     expected[2] = -1.4302409887 + -3.1251332760 * I;
843 
844     int sum = 0;
845     for (int i = 0; i < testCount; ++i) {
846         resultval[i] = cexpf(testZ[i]);
847         if ((!Equalf(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
848             LOG("cexpf of %.10f+%.10fi failed, \n expected:%.10f+%.10fi,\n actual:%.10f +%.10fi\n",
849                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
850                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
851             sum++;
852         }
853     }
854     return sum;
855 }
856 
TestCexplnull857 int TestCexpl()
858 {
859     const int testCount = 3;
860     long double _Complex testZ[testCount];
861     testZ[0] = 3.0 + 4.0 * I;
862     testZ[1] = 0.0 - 3.0 * I;
863     testZ[2] = 1.23456 - 2.0 * I;
864     long double _Complex expected[testCount];
865     long double _Complex resultval[testCount];
866 
867     expected[0] = -13.12878308146215822205 + -15.20078446306795427745 * I;
868     expected[1] = -0.98999200000000000000 - 0.14112000000000000000 * I;
869     expected[2] = -1.43024089977955104480 + -3.12513338008534180545 * I;
870 
871     int sum = 0;
872     for (int i = 0; i < testCount; ++i) {
873         resultval[i] = cexpl(testZ[i]);
874         if ((!Equall(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
875             LOG("cexpl of %.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf +%.20Lfi\n",
876                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
877                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
878             sum++;
879         }
880     }
881     return sum;
882 }
883 
TestCimagnull884 int TestCimag()
885 {
886     const int testCount = 3;
887     double _Complex testZ[testCount];
888     testZ[0] = 3.0 + 4.0 * I;
889     testZ[1] = 0.0 - 3.0 * I;
890     testZ[2] = 1.23456789 - 2.0 * I;
891     double expected[] = {4.000000, -3.000000, -2.000000};
892 
893     int sum = 0;
894     for (int i = 0; i < testCount; ++i) {
895         double d = cimag(testZ[i]);
896         if (!Equal(d, expected[i])) {
897             LOG("cimag of %.20Lf+%.20Lfi failed, expected:%.20Lf, actual:%.20Lf",
898                 creal(testZ[i]), cimag(testZ[i]), expected[i], d);
899             sum++;
900         }
901     }
902     return sum;
903 }
904 
TestCimagfnull905 int TestCimagf()
906 {
907     const int testCount = 3;
908     float _Complex testZ[testCount];
909     testZ[0] = 3.0 + 4.0 * I;
910     testZ[1] = 0.0 - 3.0 * I;
911     testZ[2] = 1.23456 - 2.0 * I;
912     float _Complex expected[] = {4.000000, -3.000000, -2.000000};
913 
914     int sum = 0;
915     for (int i = 0; i < testCount; ++i) {
916         float  d = cimagf(testZ[i]);
917         if (!Equalf(d, expected[i])) {
918             LOG("cimagf of %.10f+%.10fi failed, expected:%.10f, actual:%.10f",
919                 creal(testZ[i]), cimag(testZ[i]), expected[i], d);
920             sum++;
921         }
922     }
923     return sum;
924 }
925 
TestCimaglnull926 int TestCimagl()
927 {
928     const int testCount = 3;
929     long double _Complex testZ[testCount];
930     testZ[0] = 3.0 + 4.0 * I;
931     testZ[1] = 0.0 - 3.0 * I;
932     testZ[2] = 1.23456 - 2.0 * I;
933     long double  expected[testCount];
934 
935     expected[0] = 4.000000;
936     expected[1] = -3.000000;
937     expected[2] = -2.000000;
938 
939     int sum = 0;
940     for (int i = 0; i < testCount; ++i) {
941         long double  d = cimagl(testZ[i]);
942         if (!Equall(d, expected[i])) {
943             LOG("cimagl of %.20Lf+%.20Lfi failed, expected:%.20Lf, actual:%.20Lf",
944                 creal(testZ[i]), cimag(testZ[i]), expected[i], d);
945             sum++;
946         }
947     }
948     return sum;
949 }
950 
TestClognull951 int TestClog()
952 {
953     const int testCount = 3;
954     double _Complex testZ[testCount];
955     testZ[0] = 3.0 + 4.0 * I;
956     testZ[1] = 0.0 - 3.0 * I;
957     testZ[2] = 1.23456789 - 2.0 * I;
958     double _Complex expected[testCount];
959     double _Complex resultval[testCount];
960 
961     expected[0] = 1.60943791243410028180 + 0.92729521800161218703 * I;
962     expected[1] = 1.09861228866810978211 + -1.57079632679489655800 * I;
963     expected[2] = 0.85456540748777654048 + -1.01776488671168796607 * I;
964 
965     int sum = 0;
966     for (int i = 0; i < testCount; ++i) {
967         resultval[i] = clog(testZ[i]);
968         if ((!Equal(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
969             LOG("clog of %.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf +%.20Lfi\n",
970                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
971                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
972             sum++;
973         }
974     }
975     return sum;
976 }
977 
TestClogfnull978 int TestClogf()
979 {
980     const int testCount = 3;
981     float _Complex testZ[testCount];
982     testZ[0] = 3.0 + 4.0 * I;
983     testZ[1] = 0.0 - 3.0 * I;
984     testZ[2] = 1.23456 - 2.0 * I;
985     float _Complex expected[testCount];
986     float _Complex resultval[testCount];
987 
988     expected[0] = 1.6094380000 + 0.9272950000 * I;
989     expected[1] = 1.0986123085 + -1.5707963705 * I;
990     expected[2] = 0.8545635939 + -1.0177677870 * I;
991 
992     int sum = 0;
993     for (int i = 0; i < testCount; ++i) {
994         resultval[i] = clogf(testZ[i]);
995         if ((!Equalf(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
996             LOG("clogf of %.10f+%.10fi failed, \n expected:%.10f+%.10fi,\n actual:%.10f +%.10fi\n",
997                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
998                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
999             sum++;
1000         }
1001     }
1002     return sum;
1003 }
1004 
TestCloglnull1005 int TestClogl()
1006 {
1007     const int testCount = 3;
1008     long double _Complex testZ[testCount];
1009     testZ[0] = 3.0 + 4.0 * I;
1010     testZ[1] = 0.0 - 3.0 * I;
1011     testZ[2] = 1.23456 - 2.0 * I;
1012     long double _Complex expected[testCount];
1013     long double _Complex resultval[testCount];
1014 
1015     expected[0] = 1.60943791243410028180 + 0.92729521800161218703 * I;
1016     expected[1] = 1.09861228866810978211 + -1.57079632679489655800 * I;
1017     expected[2] = 0.85456364419155605994 + -1.01776774326071883792 * I;
1018     int sum = 0;
1019     for (int i = 0; i < testCount; ++i) {
1020         resultval[i] = clogl(testZ[i]);
1021         if ((!Equall(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
1022             LOG("clogl of %.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf +%.20Lfi\n",
1023                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
1024                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
1025             sum++;
1026         }
1027     }
1028     return sum;
1029 }
1030 
TestConjnull1031 int TestConj()
1032 {
1033     const int testCount = 3;
1034     double _Complex testZ[testCount];
1035     testZ[0] = 4.0 + 3.0 * I;
1036     testZ[1] = 0.0 + 3.0 * I;
1037     testZ[2] = 2.256 + 1.03 * I;
1038     double _Complex expected[testCount];
1039     double _Complex resultval[testCount];
1040     expected[0] = 4.000000 - 3.000000 * I;
1041     expected[1] = 0.000000 - 3.000000 * I;
1042     expected[2] = 2.256000 - 1.030000 * I;
1043     int sum = 0;
1044     for (int i = 0; i < testCount; ++i) {
1045         resultval[i] = conj(testZ[i]);
1046         if ((!Equal(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
1047             LOG("conj of %.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf +%.20Lfi\n",
1048                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
1049                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
1050             sum++;
1051         }
1052     }
1053     return sum;
1054 }
1055 
TestConjfnull1056 int TestConjf()
1057 {
1058     const int testCount = 3;
1059     float _Complex testZ[testCount];
1060     testZ[0] = 4.0 + 3.0 * I;
1061     testZ[1] = 0.0 + 3.0 * I;
1062     testZ[2] = 2.256 + 1.03 * I;
1063     float _Complex expected[testCount];
1064     float _Complex resultval[testCount];
1065 
1066     expected[0] = 4.000000 - 3.000000 * I;
1067     expected[1] = 0.000000 - 3.000000 * I;
1068     expected[2] = 2.256000 - 1.030000 * I;
1069     int sum = 0;
1070     for (int i = 0; i < testCount; ++i) {
1071         resultval[i] = conjf(testZ[i]);
1072         if ((!Equalf(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
1073             LOG("conjf of %.10f+%.10fi failed, \n expected:%.10f+%.10fi,\n actual:%.10f +%.10fi\n",
1074                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
1075                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
1076             sum++;
1077         }
1078     }
1079     return sum;
1080 }
1081 
TestConjlnull1082 int TestConjl()
1083 {
1084     const int testCount = 3;
1085     long double _Complex testZ[testCount];
1086     testZ[0] = 4.0 + 3.0 * I;
1087     testZ[1] = 0.0 + 3.0 * I;
1088     testZ[2] = 2.256 + 1.03 * I;
1089     long double _Complex expected[testCount];
1090     long double _Complex resultval[testCount];
1091 
1092     expected[0] = 4.000000 - 3.000000 * I;
1093     expected[1] = 0.000000 - 3.000000 * I;
1094     expected[2] = 2.256000 - 1.030000 * I;
1095 
1096     int sum = 0;
1097     for (int i = 0; i < testCount; ++i) {
1098         resultval[i] = conjl(testZ[i]);
1099         if ((!Equall(creal(expected[i]), creal(resultval[i]))) && (!Equall(cimag(expected[i]), cimag(resultval[i])))) {
1100             LOG("conjl of %.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf +%.20Lfi\n",
1101                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
1102                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
1103             sum++;
1104         }
1105     }
1106     return sum;
1107 }
1108 
TestCpownull1109 int TestCpow()
1110 {
1111     const int testCount = 3;
1112     double _Complex testZ[testCount];
1113     double _Complex expected[testCount];
1114     double _Complex resultval[testCount];
1115     double _Complex power[testCount];
1116 
1117     testZ[0] = 3.0 + 4.0 * I;
1118     testZ[1] = 0.0 - 3.0 * I;
1119     testZ[2] = 1.23456789 - 2.0 * I;
1120 
1121     power[0] = 2.0 + 3.0 * I;
1122     power[1] = 2.0 - 2.0 * I;
1123     power[2] = 0.0 - 3.0 * I;
1124 
1125     expected[0] = 1.42600947539257538743 + 0.60243463019053899998 * I;
1126     expected[1] = 0.22800935530979718480 + 0.31507871264107617515 * I;
1127     expected[2] = -0.03953800026646088484 + -0.02578534206891676742 * I;
1128 
1129     int sum = 0;
1130     for (int i = 0; i < testCount; ++i) {
1131         resultval[i] = cpow(testZ[i], power[i]);
1132         if ((!Equal(creal(expected[i]), creal(resultval[i]))) && (!Equal(cimag(expected[i]), cimag(resultval[i])))) {
1133             LOG("cpow of %.20Lf+%.20Lfi,%.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf +%.20Lfi\n",
1134                 creal(testZ[i]), cimag(testZ[i]), creal(power[i]), cimag(power[i]),
1135                 creal(expected[i]), cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
1136             sum++;
1137         }
1138     }
1139     return sum;
1140 }
1141 
TestCpowfnull1142 int TestCpowf()
1143 {
1144     const int testCount = 3;
1145     float _Complex testZ[testCount];
1146     float _Complex expected[testCount];
1147     float _Complex resultval[testCount];
1148     float _Complex power[testCount];
1149 
1150     testZ[0] = 3.0 + 4.0 * I;
1151     testZ[1] = 0.0 - 3.0 * I;
1152     testZ[2] = 1.23456 - 2.0 * I;
1153 
1154     power[0] = 2.0 + 3.0 * I;
1155     power[1] = 2.0 - 2.0 * I;
1156     power[2] = 0.0 - 3.0 * I;
1157 
1158     expected[0] = 1.4260095358 + 0.6024347544 * I;
1159     expected[1] = 0.2280094773 + 0.3150786161 * I;
1160     expected[2] = -0.0395375155 + -0.0257853400 * I;
1161 
1162     int sum = 0;
1163     for (int i = 0; i < testCount; ++i) {
1164         resultval[i] = cpowf(testZ[i], power[i]);
1165         if ((!Equalf(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
1166             LOG("cpowf of %.10f+%.10fi,%.20Lf+%.20Lfi failed, \n expected:%.10f+%.10fi,\n actual:%.10f +%.10fi\n",
1167                 creal(testZ[i]), cimag(testZ[i]), creal(power[i]), cimag(power[i]),
1168                 creal(expected[i]), cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
1169             sum++;
1170         }
1171     }
1172     return sum;
1173 }
1174 
TestCpowlnull1175 int TestCpowl()
1176 {
1177     const int testCount = 3;
1178     long double _Complex testZ[testCount];
1179     long double _Complex expected[testCount];
1180     long double _Complex resultval[testCount];
1181     long double _Complex power[testCount];
1182 
1183     testZ[0] = 3.0 + 4.0 * I;
1184     testZ[1] = 0.0 - 3.0 * I;
1185     testZ[2] = 1.23456 - 2.0 * I;
1186 
1187     power[0] = 2.0 + 3.0 * I;
1188     power[1] = 2.0 - 2.0 * I;
1189     power[2] = 0.0 - 3.0 * I;
1190 
1191     expected[0] = 1.42600947539257538743 + 0.60243463019053899998 * I;
1192     expected[1] = 0.22800935530979718480 + 0.31507871264107617515 * I;
1193     expected[2] = -0.03953752504023075320 + -0.02578533024804808421 * I;
1194 
1195     int sum = 0;
1196     for (int i = 0; i < testCount; ++i) {
1197         resultval[i] = cpowl(testZ[i], power[i]);
1198         if ((!Equall(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
1199             LOG("cpowl of %.20Lf+%.20Lfi,%.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf +%.20Lfi\n",
1200                 creal(testZ[i]), cimag(testZ[i]), creal(power[i]), cimag(power[i]),
1201                 creal(expected[i]), cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
1202             sum++;
1203         }
1204     }
1205     return sum;
1206 }
1207 
TestCprojnull1208 int TestCproj()
1209 {
1210     const int testCount = 3;
1211     double _Complex testZ[testCount];
1212     testZ[0] = 4.0 + 3.0 * I;
1213     testZ[1] = 0.0 + 3.0 * I;
1214     testZ[2] = 2.256 + 1.03 * I;
1215     double _Complex expected[testCount];
1216     double _Complex resultval[testCount];
1217     expected[0] = 4.000000 + 3.000000 * I;
1218     expected[1] = 0.000000 + 3.000000 * I;
1219     expected[2] = 2.256000 + 1.030000 * I;
1220 
1221     int sum = 0;
1222     for (int i = 0; i < testCount; ++i) {
1223         resultval[i] = cproj(testZ[i]);
1224         if ((!Equal (creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
1225             LOG("cprojof %.20f+%.20fi failed, \n expected:%.20f+%.20fi,\n actual:%.20f +%.20fi\n",
1226                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
1227                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
1228             sum++;
1229         }
1230     }
1231     return sum;
1232 }
1233 
TestCprojfnull1234 int TestCprojf()
1235 {
1236     const int testCount = 3;
1237     float _Complex testZ[testCount];
1238     testZ[0] = 4.0 + 3.0 * I;
1239     testZ[1] = 0.0 + 3.0 * I;
1240     testZ[2] = 2.256 + 1.03 * I;
1241     float _Complex expected[testCount];
1242     float _Complex resultval[testCount];
1243     expected[0] = 4.000000 + 3.000000 * I;
1244     expected[1] = 0.000000 + 3.000000 * I;
1245     expected[2] = 2.256000 + 1.030000 * I;
1246 
1247     int sum = 0;
1248     for (int i = 0; i < testCount; ++i) {
1249         resultval[i] = cprojf(testZ[i]);
1250         if ((!Equalf(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
1251             LOG("cprojf of %f+%fi failed, \n expected:%.10f+%.10fi,\n actual:%.10f +%.10fi\n",
1252                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
1253                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
1254             sum++;
1255         }
1256     }
1257     return sum;
1258 }
1259 
TestCprojlnull1260 int TestCprojl()
1261 {
1262     const int testCount = 3;
1263     long double _Complex testZ[testCount];
1264     testZ[0] = 4.0 + 3.0 * I;
1265     testZ[1] = 0.0 + 3.0 * I;
1266     testZ[2] = 2.256 + 1.03 * I;
1267     long double _Complex expected[testCount];
1268     long double _Complex resultval[testCount];
1269     expected[0] = 4.000000 + 3.000000 * I;
1270     expected[1] = 0.000000 + 3.000000 * I;
1271     expected[2] = 2.256000 + 1.030000 * I;
1272 
1273     int sum = 0;
1274     for (int i = 0; i < testCount; ++i) {
1275         resultval[i] = cprojl(testZ[i]);
1276         if ((!Equall(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
1277             LOG("cprojl of %.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf +%.20Lfi\n",
1278                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
1279                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
1280             sum++;
1281         }
1282     }
1283     return sum;
1284 }
1285 
TestCrealnull1286 int TestCreal()
1287 {
1288     const int testCount = 3;
1289     double _Complex testZ[testCount];
1290     testZ[0] = 3.0 + 4.0 * I;
1291     testZ[1] = 0.0 - 3.0 * I;
1292     testZ[2] = 1.23456789 - 2.0 * I;
1293     double expected[] = {3.00000000000000000000, 0.00000000000000000000, 1.23456788999999989009};
1294     int sum = 0;
1295     for (int i = 0; i < testCount; ++i) {
1296         double d = creal(testZ[i]);
1297         if (!Equal(d, expected[i])) {
1298             LOG("creal of %.20Lf+%.20Lfi failed, expected:%.20Lf, actual:%.20Lf",
1299                 creal(testZ[i]), cimag(testZ[i]), expected[i], d);
1300             sum++;
1301         }
1302     }
1303     return sum;
1304 }
1305 
TestCrealfnull1306 int TestCrealf()
1307 {
1308     const int testCount = 3;
1309     float _Complex testZ[testCount];
1310     testZ[0] = 3.0 + 4.0 * I;
1311     testZ[1] = 0.0 - 3.0 * I;
1312     testZ[2] = 1.23456 - 2.0 * I;
1313     float expected[] = {3.000000, 0.000000, 1.234560};
1314 
1315     int sum = 0;
1316     for (int i = 0; i < testCount; ++i) {
1317         float  d = crealf(testZ[i]);
1318         if (!Equalf(d, expected[i])) {
1319             LOG("crealf of %.10f+%.10fi failed, expected:%.10f, actual:%.10f",
1320                 creal(testZ[i]), cimag(testZ[i]), expected[i], d);
1321             sum++;
1322         }
1323     }
1324     return sum;
1325 }
1326 
1327 
TestCreallnull1328 int TestCreall()
1329 {
1330     const int testCount = 3;
1331     long double _Complex testZ[testCount];
1332     testZ[0] = 3.0 + 4.0 * I;
1333     testZ[1] = 0.0 - 3.0 * I;
1334     testZ[2] = 1.23456 - 2.0 * I;
1335     long double  expected[] = {3.000000, 0.000000, 1.234560};
1336 
1337     int sum = 0;
1338     for (int i = 0; i < testCount; ++i) {
1339         long double  d = creall(testZ[i]);
1340         if (!Equall(d, expected[i])) {
1341             LOG("creall of %.20Lf+%.20Lfi failed, expected:%.20Lf, actual:%.20Lf",
1342                 creal(testZ[i]), cimag(testZ[i]), expected[i], d);
1343             sum++;
1344         }
1345     }
1346     return sum;
1347 }
1348 
TestCsinnull1349 int TestCsin()
1350 {
1351     const int testCount = 3;
1352     double _Complex testZ[testCount];
1353     testZ[0] = 4.12 + 3.1 * I;
1354     testZ[1] = 0.0 + 3.0 * I;
1355     testZ[2] = 2.256 + 1.03 * I;
1356     double _Complex expected[testCount];
1357     double _Complex resultval[testCount];
1358     expected[0] = -9.22649862501591755404 + -6.18447589812529496811 * I;
1359     expected[1] = 0.00000000000000000000 + 0.995055000000000000000 * I;
1360     expected[2] = 1.22263236469252678518 + -0.77333777683149840243 * I;
1361 
1362     int sum = 0;
1363     for (int i = 0; i < testCount; ++i) {
1364         resultval[i] = csin(testZ[i]);
1365         if ((!Equal(creal(expected[i]), creal(resultval[i]))) && (!Equal(cimag(expected[i]), cimag(resultval[i])))) {
1366             LOG("csin of %.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf +%.20Lfi\n",
1367                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
1368                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
1369             sum++;
1370         }
1371     }
1372     return sum;
1373 }
1374 
TestCsinfnull1375 int TestCsinf()
1376 {
1377     const int testCount = 3;
1378     float _Complex testZ[testCount];
1379     testZ[0] = 4.0 + 3.0 * I;
1380     testZ[1] = 0.0 + 3.0 * I;
1381     testZ[2] = 2.256 + 1.03 * I;
1382     float _Complex expected[testCount];
1383     float _Complex resultval[testCount];
1384     expected[0] = -7.6192321777 + -6.5481195450 * I;
1385     expected[1] = 0.0000000000 - 0.142547000000 * I;
1386     expected[2] = 1.2226322889 + -0.7733377218 * I;
1387 
1388     int sum = 0;
1389     for (int i = 0; i < testCount; ++i) {
1390         resultval[i] = csinf(testZ[i]);
1391         if ((!Equalf(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
1392             LOG("csinf of %f+%fi failed, \n expected:%.10f+%.10fi,\n actual:%.10f+%.10fi\n",
1393                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
1394                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
1395             sum++;
1396         }
1397     }
1398     return sum;
1399 }
1400 
TestCsinhnull1401 int TestCsinh()
1402 {
1403     const int testCount = 3;
1404     double _Complex testZ[testCount];
1405     testZ[0] = 4.12 + 3.1 * I;
1406     testZ[1] = 0.0 + 3.0 * I;
1407     testZ[2] = 2.256 + 1.03 * I;
1408     double _Complex expected[testCount];
1409     double _Complex resultval[testCount];
1410     expected[0] = -30.74488615260046486810 + 1.28017476495887727594 * I;
1411     expected[1] = 0.00000000000000000000 + 0.99505500000000000000 * I;
1412     expected[2] = 2.42996158979828669189 + 4.13629706118861140141 * I;
1413 
1414     int sum = 0;
1415     for (int i = 0; i < testCount; ++i) {
1416         resultval[i] = csinh(testZ[i]);
1417         if ((!Equal(creal(expected[i]), creal(resultval[i]))) && (!Equal(cimag(expected[i]), cimag(resultval[i])))) {
1418             LOG("csinh of %.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf +%.20Lfi\n",
1419                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
1420                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
1421             sum++;
1422         }
1423     }
1424     return sum;
1425 }
1426 
TestCsinhfnull1427 int TestCsinhf()
1428 {
1429     const int testCount = 3;
1430     float _Complex testZ[testCount];
1431     testZ[0] = 4.0 + 3.0 * I;
1432     testZ[1] = 0.0 + 3.0 * I;
1433     testZ[2] = 2.256 + 1.03 * I;
1434     float _Complex expected[testCount];
1435     float _Complex resultval[testCount];
1436     expected[0] = -27.0168151855 + 3.8537375927 * I;
1437     expected[1] = 0.0000000000 - 0.1425470000 * I;
1438     expected[2] = 2.4299616814 + 4.1362972260 * I;
1439 
1440     int sum = 0;
1441     for (int i = 0; i < testCount; ++i) {
1442         resultval[i] = csinhf(testZ[i]);
1443         if ((!Equalf(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
1444             LOG("csinhf of %f+%fi failed, \n expected:%.10f+%.10fi,\n actual:%.10f+%.10fi\n",
1445                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
1446                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
1447             sum++;
1448         }
1449     }
1450     return sum;
1451 }
1452 
TestCsinhlnull1453 int TestCsinhl()
1454 {
1455     const int testCount = 3;
1456     long double _Complex testZ[testCount];
1457     testZ[0] = 4.12 + 3.1 * I;
1458     testZ[1] = 0.0 + 3.0 * I;
1459     testZ[2] = 2.256 + 1.03 * I;
1460     long double _Complex expected[testCount];
1461     long double _Complex resultval[testCount];
1462     expected[0] = -30.74488615260046486810 + 1.28017476495887727594 * I;
1463     expected[1] = 0.00000000000000000000 + 0.995055000000000000000 * I;
1464     expected[2] = 2.42996158979828669189 + 4.13629706118861140141 * I;
1465 
1466     int sum = 0;
1467     for (int i = 0; i < testCount; ++i) {
1468         resultval[i] = csinhl(testZ[i]);
1469         if ((!Equall(creal(expected[i]), creal(resultval[i]))) && (!Equall(cimag(expected[i]), cimag(resultval[i])))) {
1470             LOG("csinhl of %.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf +%.20Lfi\n",
1471                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
1472                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
1473             sum++;
1474         }
1475     }
1476     return sum;
1477 }
1478 
TestCsinlnull1479 int TestCsinl()
1480 {
1481     const int testCount = 3;
1482     long double _Complex testZ[testCount];
1483     testZ[0] = 4.12 + 3.1 * I;
1484     testZ[1] = 0.0 + 3.0 * I;
1485     testZ[2] = 2.256 + 1.03 * I;
1486     long double _Complex expected[testCount];
1487     long double _Complex resultval[testCount];
1488     expected[0] = -9.22649862501591755404 + -6.18447589812529496811 * I;
1489     expected[1] = 0.00000000000000000000 + 0.995055000000000000000 * I;
1490     expected[2] = 1.22263236469252678518 + -0.77333777683149840243 * I;
1491 
1492     int sum = 0;
1493     for (int i = 0; i < testCount; ++i) {
1494         resultval[i] = csinl(testZ[i]);
1495         if ((!Equall(creal(expected[i]), creal(resultval[i]))) && (!Equall(cimag(expected[i]), cimag(resultval[i])))) {
1496             LOG("csinl of %.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf +%.20Lfi\n",
1497                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
1498                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
1499             sum++;
1500         }
1501     }
1502     return sum;
1503 }
1504 
TestCsqrtnull1505 int TestCsqrt()
1506 {
1507     const int testCount = 3;
1508     double _Complex testZ[testCount];
1509     testZ[0] = 4.12 + 3.1 * I;
1510     testZ[1] = 0.0 + 3.0 * I;
1511     testZ[2] = 2.256 + 1.03 * I;
1512     double _Complex expected[testCount];
1513     double _Complex resultval[testCount];
1514     expected[0] = 2.15360235493437635057 + 0.71972432443185685447 * I;
1515     expected[1] = 1.22474487139158894067 + 1.22474487139158916271 * I;
1516     expected[2] = 1.53883190408405168270 + 0.33466943246575064919 * I;
1517 
1518     int sum = 0;
1519     for (int i = 0; i < testCount; ++i) {
1520         resultval[i] = csqrt(testZ[i]);
1521         if ((!Equal(creal(expected[i]), creal(resultval[i]))) && (!Equal(cimag(expected[i]), cimag(resultval[i])))) {
1522             LOG("csqrt of %.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf +%.20Lfi\n",
1523                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
1524                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
1525             sum++;
1526         }
1527     }
1528     return sum;
1529 }
1530 
TestCsqrtfnull1531 int TestCsqrtf()
1532 {
1533     const int testCount = 3;
1534     float _Complex testZ[testCount];
1535     testZ[0] = 4.0 + 3.0 * I;
1536     testZ[1] = 0.0 + 3.0 * I;
1537     testZ[2] = 2.256 + 1.03 * I;
1538     float _Complex expected[testCount];
1539     float _Complex resultval[testCount];
1540     expected[0] = 2.1213202477 + 0.7071067691 * I;
1541     expected[1] = 1.2247449160 + 1.2247449160 * I;
1542     expected[2] = 1.5388319492 + 0.3346694112 * I;
1543 
1544     int sum = 0;
1545     for (int i = 0; i < testCount; ++i) {
1546         resultval[i] = csqrtf(testZ[i]);
1547         if ((!Equalf(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
1548             LOG("csqrtf of %f+%fi failed, \n expected:%.10f+%.10fi,\n actual:%.10f+%.10fi\n",
1549                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
1550                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
1551             sum++;
1552         }
1553     }
1554     return sum;
1555 }
1556 
TestCsqrtlnull1557 int TestCsqrtl()
1558 {
1559     const int testCount = 3;
1560     long double _Complex testZ[testCount];
1561     testZ[0] = 4.12 + 3.1 * I;
1562     testZ[1] = 0.0 + 3.0 * I;
1563     testZ[2] = 2.256 + 1.03 * I;
1564     long double _Complex expected[testCount];
1565     long double _Complex resultval[testCount];
1566     expected[0] = 2.15360235493437635057 + 0.71972432443185685447 * I;
1567     expected[1] = 1.22474487139158894067 + 1.22474487139158916271 * I;
1568     expected[2] = 1.53883190408405168270 + 0.33466943246575064919 * I;
1569 
1570     int sum = 0;
1571     for (int i = 0; i < testCount; ++i) {
1572         resultval[i] = csqrtl(testZ[i]);
1573         if ((!Equall(creal(expected[i]), creal(resultval[i]))) && (!Equall(cimag(expected[i]), cimag(resultval[i])))) {
1574             LOG("csqrtl of %.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf +%.20Lfi\n",
1575                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
1576                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
1577             sum++;
1578         }
1579     }
1580     return sum;
1581 }
1582 
TestCtannull1583 int TestCtan()
1584 {
1585     const int testCount = 3;
1586     double _Complex testZ[testCount];
1587     testZ[0] = 1.1 + 2.12 * I;
1588     testZ[1] = 1.0 + 3.12 * I;
1589     testZ[2] = 0.0 + 1.03 * I;
1590     double _Complex expected[testCount];
1591     double _Complex resultval[testCount];
1592     expected[0] = 0.02369384883396526489 + 1.01682442264852812563 * I;
1593     expected[1] = 0.00355174767798756632 + 1.00161786795187368604 * I;
1594     expected[2] = 0.00000000000000000000 + 0.77390833985584200000 * I;
1595 
1596     int sum = 0;
1597     for (int i = 0; i < testCount; ++i) {
1598         resultval[i] = ctan(testZ[i]);
1599         if ((!Equall(creal(expected[i]), creal(resultval[i]))) && (!Equall(cimag(expected[i]), cimag(resultval[i])))) {
1600             LOG("ctan of %.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf +%.20Lfi\n",
1601                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
1602                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
1603             sum++;
1604         }
1605     }
1606     return sum;
1607 }
1608 
TestCtanfnull1609 int TestCtanf()
1610 {
1611     const int testCount = 3;
1612     float _Complex testZ[testCount];
1613     testZ[0] = 1.1 + 2.12 * I;
1614     testZ[1] = 1.0 + 3.12 * I;
1615     testZ[2] = 0.0 + 1.03 * I;
1616     float _Complex expected[testCount];
1617     float _Complex resultval[testCount];
1618     expected[0] = 0.0236938488 + 1.0168244226 * I;
1619     expected[1] = 0.0035517477 + 1.0016178679 * I;
1620     expected[2] = 0.0000000000 + 0.7739083399 * I;
1621 
1622     int sum = 0;
1623     for (int i = 0; i < testCount; ++i) {
1624         resultval[i] = ctanf(testZ[i]);
1625         if ((!Equall(creal(expected[i]), creal(resultval[i]))) && (!Equall(cimag(expected[i]), cimag(resultval[i])))) {
1626             LOG("ctanf of %.10f+%.10fi failed, \n expected:%.10f+%.10fi,\n actual:%.10f +%.10fi\n",
1627                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
1628                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
1629             sum++;
1630         }
1631     }
1632     return sum;
1633 }
1634 
TestCtanhnull1635 int TestCtanh()
1636 {
1637     const int testCount = 3;
1638     double _Complex testZ[testCount];
1639     testZ[0] = 4.12 + 3.1 * I;
1640     testZ[1] = 0.0 + 3.0 * I;
1641     testZ[2] = 2.256 + 1.03 * I;
1642     double _Complex expected[testCount];
1643     double _Complex resultval[testCount];
1644     expected[0] = 0.99947419378454971373 + -0.00004382891481422311 * I;
1645     expected[1] = 0.00000000000000000000 + 0.995055000000000000000 * I;
1646     expected[2] = 1.01017902431788741957 + 0.01957765681621519149 * I;
1647 
1648     int sum = 0;
1649     for (int i = 0; i < testCount; ++i) {
1650         resultval[i] = ctanh(testZ[i]);
1651         if ((!Equall(creal(expected[i]), creal(resultval[i]))) && (!Equall(cimag(expected[i]), cimag(resultval[i])))) {
1652             LOG("ctanh of %.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf +%.20Lfi\n",
1653                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
1654                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
1655             sum++;
1656         }
1657     }
1658     return sum;
1659 }
1660 
TestCtanhfnull1661 int TestCtanhf()
1662 {
1663     const int testCount = 3;
1664     float _Complex testZ[testCount];
1665     testZ[0] = 4.0 + 3.0 * I;
1666     testZ[1] = 0.0 + 3.0 * I;
1667     testZ[2] = 2.256 + 1.03 * I;
1668     float _Complex expected[testCount];
1669     float _Complex resultval[testCount];
1670     expected[0] = 0.999356 + -0.000187 * I;
1671     expected[1] = 0.000000 - 0.142547 * I;
1672     expected[2] = 1.010179 + 0.019578 * I;
1673 
1674     int sum = 0;
1675     for (int i = 0; i < testCount; ++i) {
1676         resultval[i] = ctanhf(testZ[i]);
1677         if ((!Equalf(creal(expected[i]), creal(resultval[i]))) && (!Equalf(cimag(expected[i]), cimag(resultval[i])))) {
1678             LOG("ctanhf of %f+%fi failed, \n expected:%.10f+%.10fi,\n actual:%.10f+%.10fi\n",
1679                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
1680                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
1681             sum++;
1682         }
1683     }
1684     return sum;
1685 }
1686 
TestCtanhlnull1687 int TestCtanhl()
1688 {
1689     const int testCount = 3;
1690     long double _Complex testZ[testCount];
1691     testZ[0] = 4.12 + 3.1 * I;
1692     testZ[1] = 0.0 + 3.0 * I;
1693     testZ[2] = 2.256 + 1.03 * I;
1694     long double _Complex expected[testCount];
1695     long double _Complex resultval[testCount];
1696     expected[0] = 0.99947419378454971373 + -0.00004382891481422311 * I;
1697     expected[1] = 0.00000000000000000000 + 0.995055000000000000000 * I;
1698     expected[2] = 1.01017902431788741957 + 0.01957765681621519149 * I;
1699 
1700     int sum = 0;
1701     for (int i = 0; i < testCount; ++i) {
1702         resultval[i] = ctanhl(testZ[i]);
1703         if ((!Equall(creal(expected[i]), creal(resultval[i]))) && (!Equall(cimag(expected[i]), cimag(resultval[i])))) {
1704             LOG("ctanhl of %.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf +%.20Lfi\n",
1705                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
1706                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
1707             sum++;
1708         }
1709     }
1710     return sum;
1711 }
1712 
TestCtanlnull1713 int TestCtanl()
1714 {
1715     const int testCount = 3;
1716     long double _Complex testZ[testCount];
1717     testZ[0] = 1.1 + 2.12 * I;
1718     testZ[1] = 1.0 + 3.12 * I;
1719     testZ[2] = 0.0 + 1.03 * I;
1720     long double _Complex expected[testCount];
1721     long double _Complex resultval[testCount];
1722     expected[0] = 0.02369384883396526489 + 1.01682442264852812563 * I;
1723     expected[1] = 0.00355174767798756632 + 1.00161786795187368604 * I;
1724     expected[2] = 0.00000000000000000000 + 0.77390833985584200000 * I;
1725 
1726     int sum = 0;
1727     for (int i = 0; i < testCount; ++i) {
1728         resultval[i] = ctanl(testZ[i]);
1729         if ((!Equall(creal(expected[i]), creal(resultval[i]))) && (!Equall(cimag(expected[i]), cimag(resultval[i])))) {
1730             LOG("ctanl of %.20Lf+%.20Lfi failed, \n expected:%.20Lf+%.20Lfi,\n actual:%.20Lf +%.20Lfi\n",
1731                 creal(testZ[i]), cimag(testZ[i]), creal(expected[i]),
1732                 cimag(expected[i]), creal(resultval[i]), cimag(resultval[i]));
1733             sum++;
1734         }
1735     }
1736     return sum;
1737 }
1738 
1739 #ifdef __cplusplus
1740 }
1741 #endif