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
28extern "C" {
29#endif
30
31
32int 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
53int 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
74int 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
95int 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
122int 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
149int 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
176int 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
202int 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
228int 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
255int 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
276int 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
297int 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
318int 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
345int 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
372int 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
399int 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
426int 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
453int 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
480int 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
507int 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
533int 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
560int 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
587int 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
614int 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
641int 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
668int 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
695int 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
722int 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
749int 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
776int 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
803int 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
830int 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
857int 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
884int 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
905int 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
926int 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
951int 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
978int 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
1005int 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
1031int 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
1056int 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
1082int 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
1109int 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
1142int 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
1175int 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
1208int 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
1234int 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
1260int 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
1286int 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
1306int 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
1328int 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
1349int 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
1375int 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
1401int 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
1427int 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
1453int 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
1479int 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
1505int 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
1531int 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
1557int 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
1583int 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
1609int 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
1635int 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
1661int 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
1687int 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
1713int 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