1 /*
2  * Copyright (c) 2022 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 testComplex 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 <cstdio>
17 #include <cstring>
18 
19 #include "complex.h"
20 #include "napi/native_api.h"
21 #include <math.h>
22 
23 #define INDEX0 0
24 #define INDEX1 1
25 #define INDEX2 2
26 #define INDEX3 3
27 #define INDEX4 4
28 #define FAIL (-1)
29 
CReal(napi_env env, napi_callback_info info)30 static napi_value CReal(napi_env env, napi_callback_info info)
31 {
32     size_t argc = INDEX2;
33     napi_value args[2] = {nullptr, nullptr};
34     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
35     double firstParam, secondParam, backParam;
36     napi_get_value_double(env, args[INDEX0], &firstParam);
37     napi_get_value_double(env, args[INDEX1], &secondParam);
38     double complex testComplex = {firstParam, secondParam};
39     backParam = creal(testComplex);
40     napi_value result = nullptr;
41     napi_create_double(env, backParam, &result);
42     return result;
43 }
44 
CRealF(napi_env env, napi_callback_info info)45 static napi_value CRealF(napi_env env, napi_callback_info info)
46 {
47     size_t argc = INDEX2;
48     napi_value args[2] = {nullptr, nullptr};
49     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
50     double firstParam, secondParam, backParam;
51     napi_get_value_double(env, args[INDEX0], &firstParam);
52     napi_get_value_double(env, args[INDEX1], &secondParam);
53     float real, image;
54     real = float(firstParam);
55     image = float(secondParam);
56     float complex testComplex = {real, image};
57     backParam = crealf(testComplex);
58     napi_value result = nullptr;
59     napi_create_double(env, backParam, &result);
60     return result;
61 }
62 
CRealL(napi_env env, napi_callback_info info)63 static napi_value CRealL(napi_env env, napi_callback_info info)
64 {
65     size_t argc = INDEX2;
66     napi_value args[2] = {nullptr, nullptr};
67     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
68     double firstParam, secondParam, backParam;
69     napi_get_value_double(env, args[INDEX0], &firstParam);
70     napi_get_value_double(env, args[INDEX1], &secondParam);
71     long double complex testComplex = {firstParam, secondParam};
72     backParam = creall(testComplex);
73     napi_value result = nullptr;
74     napi_create_double(env, backParam, &result);
75     return result;
76 }
77 
Conj(napi_env env, napi_callback_info info)78 static napi_value Conj(napi_env env, napi_callback_info info)
79 {
80     size_t argc = INDEX2;
81     napi_value args[2] = {nullptr, nullptr};
82     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
83     double firstParam, secondParam, getRealAndImage;
84     napi_get_value_double(env, args[INDEX0], &firstParam);
85     napi_get_value_double(env, args[INDEX1], &secondParam);
86     double complex testComplex = {firstParam, secondParam};
87     double complex getComplex = conj(testComplex);
88     getRealAndImage = creal(getComplex);
89     char buffer[20];
90     char backParam[128] = {"("};
91     sprintf(buffer, "%.2f", getRealAndImage);
92     strcat(backParam, buffer);
93     strcat(backParam, ",");
94     getRealAndImage = cimag(getComplex);
95     sprintf(buffer, "%.2f", getRealAndImage);
96     strcat(backParam, buffer);
97     strcat(backParam, ")");
98     napi_value result = nullptr;
99     napi_create_string_utf8(env, backParam, NAPI_AUTO_LENGTH, &result);
100     return result;
101 }
102 
ConjF(napi_env env, napi_callback_info info)103 static napi_value ConjF(napi_env env, napi_callback_info info)
104 {
105     size_t argc = INDEX2;
106     napi_value args[2] = {nullptr, nullptr};
107     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
108     double firstParam, secondParam;
109     napi_get_value_double(env, args[INDEX0], &firstParam);
110     napi_get_value_double(env, args[INDEX1], &secondParam);
111     float real, image, getRealAndImage;
112     real = float(firstParam);
113     image = float(secondParam);
114     float complex testComplex = {real, image};
115     float complex getComplex = conjf(testComplex);
116     getRealAndImage = crealf(getComplex);
117     char buffer[20];
118     char backParam[128] = {"("};
119     sprintf(buffer, "%.2f", getRealAndImage);
120     strcat(backParam, buffer);
121     strcat(backParam, ",");
122     getRealAndImage = cimagf(getComplex);
123     sprintf(buffer, "%.2f", getRealAndImage);
124     strcat(backParam, buffer);
125     strcat(backParam, ")");
126     napi_value result = nullptr;
127     napi_create_string_utf8(env, backParam, NAPI_AUTO_LENGTH, &result);
128     return result;
129 }
130 
ConjL(napi_env env, napi_callback_info info)131 static napi_value ConjL(napi_env env, napi_callback_info info)
132 {
133     size_t argc = INDEX2;
134     napi_value args[2] = {nullptr, nullptr};
135     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
136     double firstParam, secondParam, getRealAndImage;
137     napi_get_value_double(env, args[INDEX0], &firstParam);
138     napi_get_value_double(env, args[INDEX1], &secondParam);
139     long double complex testComplex = {firstParam, secondParam};
140     long double complex getComplex = conjl(testComplex);
141     getRealAndImage = creall(getComplex);
142     char buffer[20];
143     char backParam[128] = {"("};
144     sprintf(buffer, "%.2f", getRealAndImage);
145     strcat(backParam, buffer);
146     strcat(backParam, ",");
147     getRealAndImage = cimagl(getComplex);
148     sprintf(buffer, "%.2f", getRealAndImage);
149     strcat(backParam, buffer);
150     strcat(backParam, ")");
151     napi_value result = nullptr;
152     napi_create_string_utf8(env, backParam, NAPI_AUTO_LENGTH, &result);
153     return result;
154 }
155 
CPow(napi_env env, napi_callback_info info)156 static napi_value CPow(napi_env env, napi_callback_info info)
157 {
158     size_t argc = INDEX4;
159     napi_value args[4] = {nullptr, nullptr, nullptr, nullptr};
160     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
161     double firstParam, secondParam, mid3, mid4, getRealAndImage;
162     napi_get_value_double(env, args[INDEX0], &firstParam);
163     napi_get_value_double(env, args[INDEX1], &secondParam);
164     napi_get_value_double(env, args[INDEX2], &mid3);
165     napi_get_value_double(env, args[INDEX3], &mid4);
166     double complex testComplex = {firstParam, secondParam}, anotherTestComplex = {mid3, mid4};
167     double complex getComplex = cpow(testComplex, anotherTestComplex);
168     getRealAndImage = creal(getComplex);
169     char buffer[20];
170     char backParam[128] = {"("};
171     sprintf(buffer, "%.2f", getRealAndImage);
172     strcat(backParam, buffer);
173     strcat(backParam, ",");
174     getRealAndImage = cimag(getComplex);
175     sprintf(buffer, "%.2f", getRealAndImage);
176     strcat(backParam, buffer);
177     strcat(backParam, ")");
178     napi_value result = nullptr;
179     napi_create_string_utf8(env, backParam, NAPI_AUTO_LENGTH, &result);
180     return result;
181 }
182 
CPowF(napi_env env, napi_callback_info info)183 static napi_value CPowF(napi_env env, napi_callback_info info)
184 {
185     size_t argc = INDEX4;
186     napi_value args[4] = {nullptr, nullptr, nullptr, nullptr};
187     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
188     double firstParam, secondParam, mid3, mid4;
189     napi_get_value_double(env, args[INDEX0], &firstParam);
190     napi_get_value_double(env, args[INDEX1], &secondParam);
191     napi_get_value_double(env, args[INDEX2], &mid3);
192     napi_get_value_double(env, args[INDEX3], &mid4);
193     float real = float(firstParam), image = float(secondParam), anotherReal = float(mid3), anotherImage = float(mid4),
194           getRealAndImage;
195     float complex testComplex = {real, image}, anotherTestComplex = {anotherReal, anotherImage};
196     float complex getComplex = cpow(testComplex, anotherTestComplex);
197     getRealAndImage = crealf(getComplex);
198     char buffer[20];
199     char backParam[128] = {"("};
200     sprintf(buffer, "%.2f", getRealAndImage);
201     strcat(backParam, buffer);
202     strcat(backParam, ",");
203     getRealAndImage = cimagf(getComplex);
204     sprintf(buffer, "%.2f", getRealAndImage);
205     strcat(backParam, buffer);
206     strcat(backParam, ")");
207     napi_value result = nullptr;
208     napi_create_string_utf8(env, backParam, NAPI_AUTO_LENGTH, &result);
209     return result;
210 }
211 
CPowL(napi_env env, napi_callback_info info)212 static napi_value CPowL(napi_env env, napi_callback_info info)
213 {
214     size_t argc = INDEX4;
215     napi_value args[4] = {nullptr, nullptr, nullptr, nullptr};
216     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
217     double firstParam, secondParam, mid3, mid4, getRealAndImage;
218     napi_get_value_double(env, args[INDEX0], &firstParam);
219     napi_get_value_double(env, args[INDEX1], &secondParam);
220     napi_get_value_double(env, args[INDEX2], &mid3);
221     napi_get_value_double(env, args[INDEX3], &mid4);
222     long double complex testComplex = {firstParam, secondParam}, anotherTestComplex = {mid3, mid4};
223     long double complex getComplex = cpowl(testComplex, anotherTestComplex);
224     getRealAndImage = creall(getComplex);
225     char buffer[20];
226     char backParam[128] = {"("};
227     sprintf(buffer, "%.2f", getRealAndImage);
228     strcat(backParam, buffer);
229     strcat(backParam, ",");
230     getRealAndImage = cimagl(getComplex);
231     sprintf(buffer, "%.2f", getRealAndImage);
232     strcat(backParam, buffer);
233     strcat(backParam, ")");
234     napi_value result = nullptr;
235     napi_create_string_utf8(env, backParam, NAPI_AUTO_LENGTH, &result);
236     return result;
237 }
238 
CProj(napi_env env, napi_callback_info info)239 static napi_value CProj(napi_env env, napi_callback_info info)
240 {
241     size_t argc = INDEX2;
242     napi_value args[2] = {nullptr, nullptr};
243     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
244     double firstParam, secondParam, getRealAndImage;
245     napi_get_value_double(env, args[INDEX0], &firstParam);
246     napi_get_value_double(env, args[INDEX1], &secondParam);
247     double complex testComplex = {firstParam, secondParam};
248     double complex getComplex = cproj(testComplex);
249     getRealAndImage = creal(getComplex);
250     char buffer[20];
251     char backParam[128] = {"("};
252     sprintf(buffer, "%.2f", getRealAndImage);
253     strcat(backParam, buffer);
254     strcat(backParam, ",");
255     getRealAndImage = cimag(getComplex);
256     sprintf(buffer, "%.2f", getRealAndImage);
257     strcat(backParam, buffer);
258     strcat(backParam, ")");
259     napi_value result = nullptr;
260     napi_create_string_utf8(env, backParam, NAPI_AUTO_LENGTH, &result);
261     return result;
262 }
263 
CProjF(napi_env env, napi_callback_info info)264 static napi_value CProjF(napi_env env, napi_callback_info info)
265 {
266     size_t argc = INDEX2;
267     napi_value args[2] = {nullptr, nullptr};
268     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
269     double firstParam, secondParam;
270     napi_get_value_double(env, args[INDEX0], &firstParam);
271     napi_get_value_double(env, args[INDEX1], &secondParam);
272     float real, image, getRealAndImage;
273     real = float(firstParam);
274     image = float(secondParam);
275     float complex testComplex = {real, image};
276     float complex getComplex = cprojf(testComplex);
277     getRealAndImage = crealf(getComplex);
278     char buffer[20];
279     char backParam[128] = {"("};
280     sprintf(buffer, "%.2f", getRealAndImage);
281     strcat(backParam, buffer);
282     strcat(backParam, ",");
283     getRealAndImage = cimagf(getComplex);
284     sprintf(buffer, "%.2f", getRealAndImage);
285     strcat(backParam, buffer);
286     strcat(backParam, ")");
287     napi_value result = nullptr;
288     napi_create_string_utf8(env, backParam, NAPI_AUTO_LENGTH, &result);
289     return result;
290 }
291 
CProjL(napi_env env, napi_callback_info info)292 static napi_value CProjL(napi_env env, napi_callback_info info)
293 {
294     size_t argc = INDEX2;
295     napi_value args[2] = {nullptr, nullptr};
296     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
297     double firstParam, secondParam, getRealAndImage;
298     napi_get_value_double(env, args[INDEX0], &firstParam);
299     napi_get_value_double(env, args[INDEX1], &secondParam);
300     long double complex testComplex = {firstParam, secondParam};
301     long double complex getComplex = cprojl(testComplex);
302     getRealAndImage = creall(getComplex);
303     char buffer[20];
304     char backParam[128] = {"("};
305     sprintf(buffer, "%.2f", getRealAndImage);
306     strcat(backParam, buffer);
307     strcat(backParam, ",");
308     getRealAndImage = cimagl(getComplex);
309     sprintf(buffer, "%.2f", getRealAndImage);
310     strcat(backParam, buffer);
311     strcat(backParam, ")");
312     napi_value result = nullptr;
313     napi_create_string_utf8(env, backParam, NAPI_AUTO_LENGTH, &result);
314     return result;
315 }
316 
CSin(napi_env env, napi_callback_info info)317 static napi_value CSin(napi_env env, napi_callback_info info)
318 {
319     size_t argc = INDEX2;
320     napi_value args[2] = {nullptr, nullptr};
321     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
322     double firstParam, secondParam, getRealAndImage;
323     napi_get_value_double(env, args[INDEX0], &firstParam);
324     napi_get_value_double(env, args[INDEX1], &secondParam);
325     long double complex testComplex = {firstParam, secondParam};
326     long double complex getComplex = csin(testComplex);
327     getRealAndImage = creall(getComplex);
328     char buffer[20];
329     char backParam[128] = {"("};
330     sprintf(buffer, "%.2f", getRealAndImage);
331     strcat(backParam, buffer);
332     strcat(backParam, ",");
333     getRealAndImage = cimagl(getComplex);
334     sprintf(buffer, "%.2f", getRealAndImage);
335     strcat(backParam, buffer);
336     strcat(backParam, ")");
337     napi_value result = nullptr;
338     napi_create_string_utf8(env, backParam, NAPI_AUTO_LENGTH, &result);
339     return result;
340 }
341 
CSinF(napi_env env, napi_callback_info info)342 static napi_value CSinF(napi_env env, napi_callback_info info)
343 {
344     size_t argc = INDEX2;
345     napi_value args[2] = {nullptr, nullptr};
346     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
347     double firstParam, secondParam, getRealAndImage;
348     napi_get_value_double(env, args[INDEX0], &firstParam);
349     napi_get_value_double(env, args[INDEX1], &secondParam);
350     long double complex testComplex = {firstParam, secondParam};
351     long double complex getComplex = csinf(testComplex);
352     getRealAndImage = creall(getComplex);
353     char buffer[20];
354     char backParam[128] = {"("};
355     sprintf(buffer, "%.2f", getRealAndImage);
356     strcat(backParam, buffer);
357     strcat(backParam, ",");
358     getRealAndImage = cimagl(getComplex);
359     sprintf(buffer, "%.2f", getRealAndImage);
360     strcat(backParam, buffer);
361     strcat(backParam, ")");
362     napi_value result = nullptr;
363     napi_create_string_utf8(env, backParam, NAPI_AUTO_LENGTH, &result);
364     return result;
365 }
366 
CSinL(napi_env env, napi_callback_info info)367 static napi_value CSinL(napi_env env, napi_callback_info info)
368 {
369     size_t argc = INDEX2;
370     napi_value args[2] = {nullptr, nullptr};
371     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
372     double firstParam, secondParam, getRealAndImage;
373     napi_get_value_double(env, args[INDEX0], &firstParam);
374     napi_get_value_double(env, args[INDEX1], &secondParam);
375     long double complex testComplex = {firstParam, secondParam};
376     long double complex getComplex = csinl(testComplex);
377     getRealAndImage = creall(getComplex);
378     char buffer[20];
379     char backParam[128] = {"("};
380     sprintf(buffer, "%.2f", getRealAndImage);
381     strcat(backParam, buffer);
382     strcat(backParam, ",");
383     getRealAndImage = cimagl(getComplex);
384     sprintf(buffer, "%.2f", getRealAndImage);
385     strcat(backParam, buffer);
386     strcat(backParam, ")");
387     napi_value result = nullptr;
388     napi_create_string_utf8(env, backParam, NAPI_AUTO_LENGTH, &result);
389     return result;
390 }
391 
CSinH(napi_env env, napi_callback_info info)392 static napi_value CSinH(napi_env env, napi_callback_info info)
393 {
394     size_t argc = INDEX2;
395     napi_value args[2] = {nullptr, nullptr};
396     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
397     double firstParam, secondParam, getRealAndImage;
398     napi_get_value_double(env, args[INDEX0], &firstParam);
399     napi_get_value_double(env, args[INDEX1], &secondParam);
400     long double complex testComplex = {firstParam, secondParam};
401     long double complex getComplex = csinh(testComplex);
402     getRealAndImage = creall(getComplex);
403     char buffer[20];
404     char backParam[128] = {"("};
405     sprintf(buffer, "%.2f", getRealAndImage);
406     strcat(backParam, buffer);
407     strcat(backParam, ",");
408     getRealAndImage = cimagl(getComplex);
409     sprintf(buffer, "%.2f", getRealAndImage);
410     strcat(backParam, buffer);
411     strcat(backParam, ")");
412     napi_value result = nullptr;
413     napi_create_string_utf8(env, backParam, NAPI_AUTO_LENGTH, &result);
414     return result;
415 }
416 
CSinHf(napi_env env, napi_callback_info info)417 static napi_value CSinHf(napi_env env, napi_callback_info info)
418 {
419     size_t argc = INDEX2;
420     napi_value args[2] = {nullptr, nullptr};
421     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
422     double firstParam, secondParam, getRealAndImage;
423     napi_get_value_double(env, args[INDEX0], &firstParam);
424     napi_get_value_double(env, args[INDEX1], &secondParam);
425     long double complex testComplex = {firstParam, secondParam};
426     long double complex getComplex = csinhf(testComplex);
427     getRealAndImage = creall(getComplex);
428     char buffer[20];
429     char backParam[128] = {"("};
430     sprintf(buffer, "%.2f", getRealAndImage);
431     strcat(backParam, buffer);
432     strcat(backParam, ",");
433     getRealAndImage = cimagl(getComplex);
434     sprintf(buffer, "%.2f", getRealAndImage);
435     strcat(backParam, buffer);
436     strcat(backParam, ")");
437     napi_value result = nullptr;
438     napi_create_string_utf8(env, backParam, NAPI_AUTO_LENGTH, &result);
439     return result;
440 }
441 
CSinHl(napi_env env, napi_callback_info info)442 static napi_value CSinHl(napi_env env, napi_callback_info info)
443 {
444     size_t argc = INDEX2;
445     napi_value args[2] = {nullptr, nullptr};
446     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
447     double firstParam, secondParam, getRealAndImage;
448     napi_get_value_double(env, args[INDEX0], &firstParam);
449     napi_get_value_double(env, args[INDEX1], &secondParam);
450     long double complex testComplex = {firstParam, secondParam};
451     long double complex getComplex = csinhl(testComplex);
452     getRealAndImage = creall(getComplex);
453     char buffer[20];
454     char backParam[128] = {"("};
455     sprintf(buffer, "%.2f", getRealAndImage);
456     strcat(backParam, buffer);
457     strcat(backParam, ",");
458     getRealAndImage = cimagl(getComplex);
459     sprintf(buffer, "%.2f", getRealAndImage);
460     strcat(backParam, buffer);
461     strcat(backParam, ")");
462     napi_value result = nullptr;
463     napi_create_string_utf8(env, backParam, NAPI_AUTO_LENGTH, &result);
464     return result;
465 }
466 
CSqrt(napi_env env, napi_callback_info info)467 static napi_value CSqrt(napi_env env, napi_callback_info info)
468 {
469     size_t argc = INDEX2;
470     napi_value args[2] = {nullptr, nullptr};
471     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
472     double firstParam, secondParam, getRealAndImage;
473     napi_get_value_double(env, args[INDEX0], &firstParam);
474     napi_get_value_double(env, args[INDEX1], &secondParam);
475     long double complex testComplex = {firstParam, secondParam};
476     long double complex getComplex = csqrt(testComplex);
477     getRealAndImage = creall(getComplex);
478     char buffer[20];
479     char backParam[128] = {"("};
480     sprintf(buffer, "%.2f", getRealAndImage);
481     strcat(backParam, buffer);
482     strcat(backParam, ",");
483     getRealAndImage = cimagl(getComplex);
484     sprintf(buffer, "%.2f", getRealAndImage);
485     strcat(backParam, buffer);
486     strcat(backParam, ")");
487     napi_value result = nullptr;
488     napi_create_string_utf8(env, backParam, NAPI_AUTO_LENGTH, &result);
489     return result;
490 }
491 
CSqrtF(napi_env env, napi_callback_info info)492 static napi_value CSqrtF(napi_env env, napi_callback_info info)
493 {
494     size_t argc = INDEX2;
495     napi_value args[2] = {nullptr, nullptr};
496     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
497     double firstParam, secondParam, getRealAndImage;
498     napi_get_value_double(env, args[INDEX0], &firstParam);
499     napi_get_value_double(env, args[INDEX1], &secondParam);
500     long double complex testComplex = {firstParam, secondParam};
501     long double complex getComplex = csqrtf(testComplex);
502     getRealAndImage = creall(getComplex);
503     char buffer[20];
504     char backParam[128] = {"("};
505     sprintf(buffer, "%.2f", getRealAndImage);
506     strcat(backParam, buffer);
507     strcat(backParam, ",");
508     getRealAndImage = cimagl(getComplex);
509     sprintf(buffer, "%.2f", getRealAndImage);
510     strcat(backParam, buffer);
511     strcat(backParam, ")");
512     napi_value result = nullptr;
513     napi_create_string_utf8(env, backParam, NAPI_AUTO_LENGTH, &result);
514     return result;
515 }
516 
CSqrtL(napi_env env, napi_callback_info info)517 static napi_value CSqrtL(napi_env env, napi_callback_info info)
518 {
519     size_t argc = INDEX2;
520     napi_value args[2] = {nullptr, nullptr};
521     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
522     double firstParam, secondParam, getRealAndImage;
523     napi_get_value_double(env, args[INDEX0], &firstParam);
524     napi_get_value_double(env, args[INDEX1], &secondParam);
525     long double complex testComplex = {firstParam, secondParam};
526     long double complex getComplex = csqrtl(testComplex);
527     getRealAndImage = creall(getComplex);
528     char buffer[20];
529     char backParam[128] = {"("};
530     sprintf(buffer, "%.2f", getRealAndImage);
531     strcat(backParam, buffer);
532     strcat(backParam, ",");
533     getRealAndImage = cimagl(getComplex);
534     sprintf(buffer, "%.2f", getRealAndImage);
535     strcat(backParam, buffer);
536     strcat(backParam, ")");
537     napi_value result = nullptr;
538     napi_create_string_utf8(env, backParam, NAPI_AUTO_LENGTH, &result);
539     return result;
540 }
541 
CTan(napi_env env, napi_callback_info info)542 static napi_value CTan(napi_env env, napi_callback_info info)
543 {
544     size_t argc = INDEX2;
545     napi_value args[2] = {nullptr, nullptr};
546     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
547     double firstParam, secondParam, getRealAndImage;
548     napi_get_value_double(env, args[INDEX0], &firstParam);
549     napi_get_value_double(env, args[INDEX1], &secondParam);
550     long double complex testComplex = {firstParam, secondParam};
551     long double complex getComplex = ctan(testComplex);
552     getRealAndImage = creall(getComplex);
553     char buffer[20];
554     char backParam[128] = {"("};
555     sprintf(buffer, "%.2f", getRealAndImage);
556     strcat(backParam, buffer);
557     strcat(backParam, ",");
558     getRealAndImage = cimagl(getComplex);
559     sprintf(buffer, "%.2f", getRealAndImage);
560     strcat(backParam, buffer);
561     strcat(backParam, ")");
562     napi_value result = nullptr;
563     napi_create_string_utf8(env, backParam, NAPI_AUTO_LENGTH, &result);
564     return result;
565 }
566 
CTanF(napi_env env, napi_callback_info info)567 static napi_value CTanF(napi_env env, napi_callback_info info)
568 {
569     size_t argc = INDEX2;
570     napi_value args[2] = {nullptr, nullptr};
571     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
572     double firstParam, secondParam, getRealAndImage;
573     napi_get_value_double(env, args[INDEX0], &firstParam);
574     napi_get_value_double(env, args[INDEX1], &secondParam);
575     long double complex testComplex = {firstParam, secondParam};
576     long double complex getComplex = ctanf(testComplex);
577     getRealAndImage = creall(getComplex);
578     char buffer[20];
579     char backParam[128] = {"("};
580     sprintf(buffer, "%.2f", getRealAndImage);
581     strcat(backParam, buffer);
582     strcat(backParam, ",");
583     getRealAndImage = cimagl(getComplex);
584     sprintf(buffer, "%.2f", getRealAndImage);
585     strcat(backParam, buffer);
586     strcat(backParam, ")");
587     napi_value result = nullptr;
588     napi_create_string_utf8(env, backParam, NAPI_AUTO_LENGTH, &result);
589     return result;
590 }
591 
CTanL(napi_env env, napi_callback_info info)592 static napi_value CTanL(napi_env env, napi_callback_info info)
593 {
594     size_t argc = INDEX2;
595     napi_value args[2] = {nullptr, nullptr};
596     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
597     double firstParam, secondParam, getRealAndImage;
598     napi_get_value_double(env, args[INDEX0], &firstParam);
599     napi_get_value_double(env, args[INDEX1], &secondParam);
600     long double complex testComplex = {firstParam, secondParam};
601     long double complex getComplex = ctanl(testComplex);
602     getRealAndImage = creall(getComplex);
603     char buffer[20];
604     char backParam[128] = {"("};
605     sprintf(buffer, "%.2f", getRealAndImage);
606     strcat(backParam, buffer);
607     strcat(backParam, ",");
608     getRealAndImage = cimagl(getComplex);
609     sprintf(buffer, "%.2f", getRealAndImage);
610     strcat(backParam, buffer);
611     strcat(backParam, ")");
612     napi_value result = nullptr;
613     napi_create_string_utf8(env, backParam, NAPI_AUTO_LENGTH, &result);
614     return result;
615 }
616 
CTanH(napi_env env, napi_callback_info info)617 static napi_value CTanH(napi_env env, napi_callback_info info)
618 {
619     size_t argc = INDEX2;
620     napi_value args[2] = {nullptr, nullptr};
621     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
622     double firstParam, secondParam, getRealAndImage;
623     napi_get_value_double(env, args[INDEX0], &firstParam);
624     napi_get_value_double(env, args[INDEX1], &secondParam);
625     long double complex testComplex = {firstParam, secondParam};
626     long double complex getComplex = ctanh(testComplex);
627     getRealAndImage = creall(getComplex);
628     char buffer[20];
629     char backParam[128] = {"("};
630     sprintf(buffer, "%.2f", getRealAndImage);
631     strcat(backParam, buffer);
632     strcat(backParam, ",");
633     getRealAndImage = cimagl(getComplex);
634     sprintf(buffer, "%.2f", getRealAndImage);
635     strcat(backParam, buffer);
636     strcat(backParam, ")");
637     napi_value result = nullptr;
638     napi_create_string_utf8(env, backParam, NAPI_AUTO_LENGTH, &result);
639     return result;
640 }
641 
CTanHf(napi_env env, napi_callback_info info)642 static napi_value CTanHf(napi_env env, napi_callback_info info)
643 {
644     size_t argc = INDEX2;
645     napi_value args[2] = {nullptr, nullptr};
646     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
647     double firstParam, secondParam, getRealAndImage;
648     napi_get_value_double(env, args[INDEX0], &firstParam);
649     napi_get_value_double(env, args[INDEX1], &secondParam);
650     long double complex testComplex = {firstParam, secondParam};
651     long double complex getComplex = ctanhf(testComplex);
652     getRealAndImage = creall(getComplex);
653     char buffer[20];
654     char backParam[128] = {"("};
655     sprintf(buffer, "%.2f", getRealAndImage);
656     strcat(backParam, buffer);
657     strcat(backParam, ",");
658     getRealAndImage = cimagl(getComplex);
659     sprintf(buffer, "%.2f", getRealAndImage);
660     strcat(backParam, buffer);
661     strcat(backParam, ")");
662     napi_value result = nullptr;
663     napi_create_string_utf8(env, backParam, NAPI_AUTO_LENGTH, &result);
664     return result;
665 }
666 
CTanHl(napi_env env, napi_callback_info info)667 static napi_value CTanHl(napi_env env, napi_callback_info info)
668 {
669     size_t argc = INDEX2;
670     napi_value args[2] = {nullptr, nullptr};
671     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
672     double firstParam, secondParam, getRealAndImage;
673     napi_get_value_double(env, args[INDEX0], &firstParam);
674     napi_get_value_double(env, args[INDEX1], &secondParam);
675     long double complex testComplex = {firstParam, secondParam};
676     long double complex getComplex = ctanhl(testComplex);
677     getRealAndImage = creall(getComplex);
678     char buffer[20];
679     char backParam[128] = {"("};
680     sprintf(buffer, "%.2f", getRealAndImage);
681     strcat(backParam, buffer);
682     strcat(backParam, ",");
683     getRealAndImage = cimagl(getComplex);
684     sprintf(buffer, "%.2f", getRealAndImage);
685     strcat(backParam, buffer);
686     strcat(backParam, ")");
687     napi_value result = nullptr;
688     napi_create_string_utf8(env, backParam, NAPI_AUTO_LENGTH, &result);
689     return result;
690 }
691 
Cabs(napi_env env, napi_callback_info info)692 static napi_value Cabs(napi_env env, napi_callback_info info)
693 {
694     size_t argc = INDEX2;
695     napi_value args[2] = {nullptr, nullptr};
696     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
697     double real, image;
698     napi_get_value_double(env, args[0], &real);
699     napi_get_value_double(env, args[1], &image);
700     double complex param = {real, image};
701     double resultValue = cabs(param);
702     napi_value result = nullptr;
703     napi_create_double(env, resultValue, &result);
704     return result;
705 }
706 
Cabsf(napi_env env, napi_callback_info info)707 static napi_value Cabsf(napi_env env, napi_callback_info info)
708 {
709     size_t argc = INDEX2;
710     napi_value args[2] = {nullptr, nullptr};
711     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
712     double real, image;
713     napi_get_value_double(env, args[0], &real);
714     napi_get_value_double(env, args[1], &image);
715     float complex param = {(float)real, (float)image};
716     float resultValue = cabsf(param);
717     napi_value result = nullptr;
718     napi_create_double(env, resultValue, &result);
719     return result;
720 }
721 
Cabsl(napi_env env, napi_callback_info info)722 static napi_value Cabsl(napi_env env, napi_callback_info info)
723 {
724     size_t argc = INDEX2;
725     napi_value args[2] = {nullptr, nullptr};
726     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
727     double real, image;
728     napi_get_value_double(env, args[0], &real);
729     napi_get_value_double(env, args[1], &image);
730     double complex param = {real, image};
731     double resultValue = cabsl(param);
732     napi_value result = nullptr;
733     napi_create_double(env, resultValue, &result);
734     return result;
735 }
736 
Cacos(napi_env env, napi_callback_info info)737 static napi_value Cacos(napi_env env, napi_callback_info info)
738 {
739     size_t argc = INDEX2;
740     napi_value args[2] = {nullptr};
741     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
742     double real, image;
743     napi_get_value_double(env, args[0], &real);
744     napi_get_value_double(env, args[1], &image);
745     double complex param = {real, image};
746     double complex resultValue = cacos(param);
747     napi_value result = nullptr;
748     double end;
749     char buffer[20];
750     char value[128] = {"("};
751     end = creal(resultValue);
752     sprintf(buffer, "%.2f", end);
753     strcat(value, buffer);
754     strcat(value, ",");
755     end = cimag(resultValue);
756     sprintf(buffer, "%.2f", end);
757     strcat(value, buffer);
758     strcat(value, ")");
759     napi_create_string_utf8(env, value, NAPI_AUTO_LENGTH, &result);
760     return result;
761 }
762 
Cacosl(napi_env env, napi_callback_info info)763 static napi_value Cacosl(napi_env env, napi_callback_info info)
764 {
765     size_t argc = INDEX2;
766     napi_value args[2] = {nullptr};
767     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
768     double real, image;
769     napi_get_value_double(env, args[0], &real);
770     napi_get_value_double(env, args[1], &image);
771     double complex param = {real, image};
772     double complex resultValue = cacosl(param);
773     napi_value result = nullptr;
774     double end;
775     char buffer[20];
776     char value[128] = {"("};
777     end = creal(resultValue);
778     sprintf(buffer, "%.2f", end);
779     strcat(value, buffer);
780     strcat(value, ",");
781     end = cimag(resultValue);
782     sprintf(buffer, "%.2f", end);
783     strcat(value, buffer);
784     strcat(value, ")");
785     napi_create_string_utf8(env, value, NAPI_AUTO_LENGTH, &result);
786     return result;
787 }
788 
Cacosf(napi_env env, napi_callback_info info)789 static napi_value Cacosf(napi_env env, napi_callback_info info)
790 {
791     size_t argc = INDEX2;
792     napi_value args[2] = {nullptr};
793     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
794     double real, image;
795     napi_get_value_double(env, args[0], &real);
796     napi_get_value_double(env, args[1], &image);
797     double complex param = {real, image};
798     double complex resultValue = cacosf(param);
799     napi_value result = nullptr;
800     double end;
801     char buffer[20];
802     char value[128] = {"("};
803     end = creal(resultValue);
804     sprintf(buffer, "%.2f", end);
805     strcat(value, buffer);
806     strcat(value, ",");
807     end = cimag(resultValue);
808     sprintf(buffer, "%.2f", end);
809     strcat(value, buffer);
810     strcat(value, ")");
811     napi_create_string_utf8(env, value, NAPI_AUTO_LENGTH, &result);
812     return result;
813 }
814 
Cacosh(napi_env env, napi_callback_info info)815 static napi_value Cacosh(napi_env env, napi_callback_info info)
816 {
817     size_t argc = INDEX2;
818     napi_value args[2] = {nullptr};
819     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
820     double real, image;
821     napi_get_value_double(env, args[0], &real);
822     napi_get_value_double(env, args[1], &image);
823     double complex param = {real, image};
824     double complex resultValue = cacosh(param);
825     napi_value result = nullptr;
826     double end;
827     char buffer[20];
828     char value[128] = {"("};
829     end = creal(resultValue);
830     sprintf(buffer, "%.2f", end);
831     strcat(value, buffer);
832     strcat(value, ",");
833     end = cimag(resultValue);
834     sprintf(buffer, "%.2f", end);
835     strcat(value, buffer);
836     strcat(value, ")");
837     napi_create_string_utf8(env, value, NAPI_AUTO_LENGTH, &result);
838     return result;
839 }
840 
Cacoshf(napi_env env, napi_callback_info info)841 static napi_value Cacoshf(napi_env env, napi_callback_info info)
842 {
843     size_t argc = INDEX2;
844     napi_value args[2] = {nullptr};
845     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
846     double real, image;
847     napi_get_value_double(env, args[0], &real);
848     napi_get_value_double(env, args[1], &image);
849     double complex param = {real, image};
850     double complex resultValue = cacoshf(param);
851     napi_value result = nullptr;
852     double end;
853     char buffer[20];
854     char value[128] = {"("};
855     end = creal(resultValue);
856     sprintf(buffer, "%.2f", end);
857     strcat(value, buffer);
858     strcat(value, ",");
859     end = cimag(resultValue);
860     sprintf(buffer, "%.2f", end);
861     strcat(value, buffer);
862     strcat(value, ")");
863     napi_create_string_utf8(env, value, NAPI_AUTO_LENGTH, &result);
864     return result;
865 }
866 
Cacoshl(napi_env env, napi_callback_info info)867 static napi_value Cacoshl(napi_env env, napi_callback_info info)
868 {
869     size_t argc = INDEX2;
870     napi_value args[2] = {nullptr};
871     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
872     double real, image;
873     napi_get_value_double(env, args[0], &real);
874     napi_get_value_double(env, args[1], &image);
875     double complex param = {real, image};
876     double complex resultValue = cacoshl(param);
877     napi_value result = nullptr;
878     double end;
879     char buffer[20];
880     char value[128] = {"("};
881     end = creal(resultValue);
882     sprintf(buffer, "%.2f", end);
883     strcat(value, buffer);
884     strcat(value, ",");
885     end = cimag(resultValue);
886     sprintf(buffer, "%.2f", end);
887     strcat(value, buffer);
888     strcat(value, ")");
889     napi_create_string_utf8(env, value, NAPI_AUTO_LENGTH, &result);
890     return result;
891 }
892 
Carg(napi_env env, napi_callback_info info)893 static napi_value Carg(napi_env env, napi_callback_info info)
894 {
895     size_t argc = INDEX2;
896     napi_value args[2] = {nullptr};
897     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
898     double real, image;
899     napi_get_value_double(env, args[0], &real);
900     napi_get_value_double(env, args[1], &image);
901     double complex param = {real, image};
902     double resultValue = carg(param);
903     napi_value result = nullptr;
904     double finalValue = FAIL;
905     if (resultValue <= M_PI && resultValue >= -M_PI) {
906         finalValue = INDEX1;
907     }
908     napi_create_double(env, finalValue, &result);
909     return result;
910 }
911 
Cargl(napi_env env, napi_callback_info info)912 static napi_value Cargl(napi_env env, napi_callback_info info)
913 {
914     size_t argc = INDEX2;
915     napi_value args[2] = {nullptr};
916     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
917     double real, image;
918     napi_get_value_double(env, args[0], &real);
919     napi_get_value_double(env, args[1], &image);
920     double complex param = {real, image};
921     double resultValue = cargl(param);
922     napi_value result = nullptr;
923     double finalValue = FAIL;
924     if (resultValue <= M_PI && resultValue >= -M_PI) {
925         finalValue = INDEX1;
926     }
927     napi_create_double(env, finalValue, &result);
928     return result;
929 }
930 
Cargf(napi_env env, napi_callback_info info)931 static napi_value Cargf(napi_env env, napi_callback_info info)
932 {
933     size_t argc = INDEX2;
934     napi_value args[2] = {nullptr};
935     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
936     double real, image;
937     napi_get_value_double(env, args[0], &real);
938     napi_get_value_double(env, args[1], &image);
939     double complex param = {real, image};
940     double resultValue = cargf(param);
941     napi_value result = nullptr;
942     double finalValue = FAIL;
943     if (resultValue <= M_PI && resultValue >= -M_PI) {
944         finalValue = INDEX1;
945     }
946     napi_create_double(env, finalValue, &result);
947     return result;
948 }
949 
Casin(napi_env env, napi_callback_info info)950 static napi_value Casin(napi_env env, napi_callback_info info)
951 {
952     size_t argc = INDEX2;
953     napi_value args[2] = {nullptr};
954     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
955     double real, image;
956     napi_get_value_double(env, args[0], &real);
957     napi_get_value_double(env, args[1], &image);
958     double complex param = {real, image};
959     double complex resultValue = casin(param);
960     napi_value result = nullptr;
961     double end;
962     char buffer[20];
963     char value[128] = {"("};
964     end = creal(resultValue);
965     sprintf(buffer, "%.2f", end);
966     strcat(value, buffer);
967     strcat(value, ",");
968     end = cimag(resultValue);
969     sprintf(buffer, "%.2f", end);
970     strcat(value, buffer);
971     strcat(value, ")");
972     napi_create_string_utf8(env, value, NAPI_AUTO_LENGTH, &result);
973     return result;
974 }
975 
Casinl(napi_env env, napi_callback_info info)976 static napi_value Casinl(napi_env env, napi_callback_info info)
977 {
978     size_t argc = INDEX2;
979     napi_value args[2] = {nullptr};
980     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
981     double real, image;
982     napi_get_value_double(env, args[0], &real);
983     napi_get_value_double(env, args[1], &image);
984     double complex param = {real, image};
985     double complex resultValue = casinl(param);
986     napi_value result = nullptr;
987     double end;
988     char buffer[20];
989     char value[128] = {"("};
990     end = creal(resultValue);
991     sprintf(buffer, "%.2f", end);
992     strcat(value, buffer);
993     strcat(value, ",");
994     end = cimag(resultValue);
995     sprintf(buffer, "%.2f", end);
996     strcat(value, buffer);
997     strcat(value, ")");
998     napi_create_string_utf8(env, value, NAPI_AUTO_LENGTH, &result);
999     return result;
1000 }
1001 
Casinf(napi_env env, napi_callback_info info)1002 static napi_value Casinf(napi_env env, napi_callback_info info)
1003 {
1004     size_t argc = INDEX2;
1005     napi_value args[2] = {nullptr};
1006     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1007     double real, image;
1008     napi_get_value_double(env, args[0], &real);
1009     napi_get_value_double(env, args[1], &image);
1010     double complex param = {real, image};
1011     double complex resultValue = casinf(param);
1012     napi_value result = nullptr;
1013     double end;
1014     char buffer[20];
1015     char value[128] = {"("};
1016     end = creal(resultValue);
1017     sprintf(buffer, "%.2f", end);
1018     strcat(value, buffer);
1019     strcat(value, ",");
1020     end = cimag(resultValue);
1021     sprintf(buffer, "%.2f", end);
1022     strcat(value, buffer);
1023     strcat(value, ")");
1024     napi_create_string_utf8(env, value, NAPI_AUTO_LENGTH, &result);
1025     return result;
1026 }
1027 
Casinh(napi_env env, napi_callback_info info)1028 static napi_value Casinh(napi_env env, napi_callback_info info)
1029 {
1030     size_t argc = INDEX2;
1031     napi_value args[2] = {nullptr};
1032     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1033     double real, image;
1034     napi_get_value_double(env, args[0], &real);
1035     napi_get_value_double(env, args[1], &image);
1036     double complex param = {real, image};
1037     double complex resultValue = casinh(param);
1038     napi_value result = nullptr;
1039     double end;
1040     char buffer[20];
1041     char value[128] = {"("};
1042     end = creal(resultValue);
1043     sprintf(buffer, "%.2f", end);
1044     strcat(value, buffer);
1045     strcat(value, ",");
1046     end = cimag(resultValue);
1047     sprintf(buffer, "%.2f", end);
1048     strcat(value, buffer);
1049     strcat(value, ")");
1050     napi_create_string_utf8(env, value, NAPI_AUTO_LENGTH, &result);
1051     return result;
1052 }
1053 
Casinhf(napi_env env, napi_callback_info info)1054 static napi_value Casinhf(napi_env env, napi_callback_info info)
1055 {
1056     size_t argc = INDEX2;
1057     napi_value args[2] = {nullptr};
1058     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1059     double real, image;
1060     napi_get_value_double(env, args[0], &real);
1061     napi_get_value_double(env, args[1], &image);
1062     double complex param = {real, image};
1063     double complex resultValue = casinhf(param);
1064     napi_value result = nullptr;
1065     double end;
1066     char buffer[20];
1067     char value[128] = {"("};
1068     end = creal(resultValue);
1069     sprintf(buffer, "%.2f", end);
1070     strcat(value, buffer);
1071     strcat(value, ",");
1072     end = cimag(resultValue);
1073     sprintf(buffer, "%.2f", end);
1074     strcat(value, buffer);
1075     strcat(value, ")");
1076     napi_create_string_utf8(env, value, NAPI_AUTO_LENGTH, &result);
1077     return result;
1078 }
1079 
Casinhl(napi_env env, napi_callback_info info)1080 static napi_value Casinhl(napi_env env, napi_callback_info info)
1081 {
1082     size_t argc = INDEX2;
1083     napi_value args[2] = {nullptr};
1084     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1085     double real, image;
1086     napi_get_value_double(env, args[0], &real);
1087     napi_get_value_double(env, args[1], &image);
1088     double complex param = {real, image};
1089     double complex resultValue = casinhl(param);
1090     napi_value result = nullptr;
1091     double end;
1092     char buffer[20];
1093     char value[128] = {"("};
1094     end = creal(resultValue);
1095     sprintf(buffer, "%.2f", end);
1096     strcat(value, buffer);
1097     strcat(value, ",");
1098     end = cimag(resultValue);
1099     sprintf(buffer, "%.2f", end);
1100     strcat(value, buffer);
1101     strcat(value, ")");
1102     napi_create_string_utf8(env, value, NAPI_AUTO_LENGTH, &result);
1103     return result;
1104 }
1105 
Catan(napi_env env, napi_callback_info info)1106 static napi_value Catan(napi_env env, napi_callback_info info)
1107 {
1108     size_t argc = INDEX2;
1109     napi_value args[2] = {nullptr};
1110     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1111     double real, image;
1112     napi_get_value_double(env, args[0], &real);
1113     napi_get_value_double(env, args[1], &image);
1114     double complex param = {real, image};
1115     double complex resultValue = catan(param);
1116     napi_value result = nullptr;
1117     double end;
1118     char buffer[20];
1119     char value[128] = {"("};
1120     end = creal(resultValue);
1121     sprintf(buffer, "%.2f", end);
1122     strcat(value, buffer);
1123     strcat(value, ",");
1124     end = cimag(resultValue);
1125     sprintf(buffer, "%.2f", end);
1126     strcat(value, buffer);
1127     strcat(value, ")");
1128     napi_create_string_utf8(env, value, NAPI_AUTO_LENGTH, &result);
1129     return result;
1130 }
1131 
Catanl(napi_env env, napi_callback_info info)1132 static napi_value Catanl(napi_env env, napi_callback_info info)
1133 {
1134     size_t argc = INDEX2;
1135     napi_value args[2] = {nullptr};
1136     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1137     double real, image;
1138     napi_get_value_double(env, args[0], &real);
1139     napi_get_value_double(env, args[1], &image);
1140     double complex param = {real, image};
1141     double complex resultValue = catanl(param);
1142     napi_value result = nullptr;
1143     double end;
1144     char buffer[20];
1145     char value[128] = {"("};
1146     end = creal(resultValue);
1147     sprintf(buffer, "%.2f", end);
1148     strcat(value, buffer);
1149     strcat(value, ",");
1150     end = cimag(resultValue);
1151     sprintf(buffer, "%.2f", end);
1152     strcat(value, buffer);
1153     strcat(value, ")");
1154     napi_create_string_utf8(env, value, NAPI_AUTO_LENGTH, &result);
1155     return result;
1156 }
1157 
Catanf(napi_env env, napi_callback_info info)1158 static napi_value Catanf(napi_env env, napi_callback_info info)
1159 {
1160     size_t argc = INDEX2;
1161     napi_value args[2] = {nullptr};
1162     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1163     double real, image;
1164     napi_get_value_double(env, args[0], &real);
1165     napi_get_value_double(env, args[1], &image);
1166     double complex param = {real, image};
1167     double complex resultValue = catanf(param);
1168     napi_value result = nullptr;
1169     double end;
1170     char buffer[20];
1171     char value[128] = {"("};
1172     end = creal(resultValue);
1173     sprintf(buffer, "%.2f", end);
1174     strcat(value, buffer);
1175     strcat(value, ",");
1176     end = cimag(resultValue);
1177     sprintf(buffer, "%.2f", end);
1178     strcat(value, buffer);
1179     strcat(value, ")");
1180     napi_create_string_utf8(env, value, NAPI_AUTO_LENGTH, &result);
1181     return result;
1182 }
1183 
Catanh(napi_env env, napi_callback_info info)1184 static napi_value Catanh(napi_env env, napi_callback_info info)
1185 {
1186     size_t argc = INDEX2;
1187     napi_value args[2] = {nullptr};
1188     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1189     double real, image;
1190     napi_get_value_double(env, args[0], &real);
1191     napi_get_value_double(env, args[1], &image);
1192     double complex param = {real, image};
1193     double complex resultValue = catanh(param);
1194     napi_value result = nullptr;
1195     double end;
1196     char buffer[20];
1197     char value[128] = {"("};
1198     end = creal(resultValue);
1199     sprintf(buffer, "%.2f", end);
1200     strcat(value, buffer);
1201     strcat(value, ",");
1202     end = cimag(resultValue);
1203     sprintf(buffer, "%.2f", end);
1204     strcat(value, buffer);
1205     strcat(value, ")");
1206     napi_create_string_utf8(env, value, NAPI_AUTO_LENGTH, &result);
1207     return result;
1208 }
1209 
Catanhf(napi_env env, napi_callback_info info)1210 static napi_value Catanhf(napi_env env, napi_callback_info info)
1211 {
1212     size_t argc = INDEX2;
1213     napi_value args[2] = {nullptr};
1214     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1215     double real, image;
1216     napi_get_value_double(env, args[0], &real);
1217     napi_get_value_double(env, args[1], &image);
1218     double complex param = {real, image};
1219     double complex resultValue = catanhf(param);
1220     napi_value result = nullptr;
1221     double end;
1222     char buffer[20];
1223     char value[128] = {"("};
1224     end = creal(resultValue);
1225     sprintf(buffer, "%.2f", end);
1226     strcat(value, buffer);
1227     strcat(value, ",");
1228     end = cimag(resultValue);
1229     sprintf(buffer, "%.2f", end);
1230     strcat(value, buffer);
1231     strcat(value, ")");
1232     napi_create_string_utf8(env, value, NAPI_AUTO_LENGTH, &result);
1233     return result;
1234 }
1235 
Catanhl(napi_env env, napi_callback_info info)1236 static napi_value Catanhl(napi_env env, napi_callback_info info)
1237 {
1238     size_t argc = INDEX2;
1239     napi_value args[2] = {nullptr};
1240     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1241     double real, image;
1242     napi_get_value_double(env, args[0], &real);
1243     napi_get_value_double(env, args[1], &image);
1244     double complex param = {real, image};
1245     double complex resultValue = catanhl(param);
1246     napi_value result = nullptr;
1247     double end;
1248     char buffer[20];
1249     char value[128] = {"("};
1250     end = creal(resultValue);
1251     sprintf(buffer, "%.2f", end);
1252     strcat(value, buffer);
1253     strcat(value, ",");
1254     end = cimag(resultValue);
1255     sprintf(buffer, "%.2f", end);
1256     strcat(value, buffer);
1257     strcat(value, ")");
1258     napi_create_string_utf8(env, value, NAPI_AUTO_LENGTH, &result);
1259     return result;
1260 }
1261 
Ccos(napi_env env, napi_callback_info info)1262 static napi_value Ccos(napi_env env, napi_callback_info info)
1263 {
1264     size_t argc = INDEX2;
1265     napi_value args[2] = {nullptr};
1266     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1267     double real, image;
1268     napi_get_value_double(env, args[0], &real);
1269     napi_get_value_double(env, args[1], &image);
1270     double complex param = {real, image};
1271     double complex resultValue = ccos(param);
1272     napi_value result = nullptr;
1273     double end;
1274     char buffer[20];
1275     char value[128] = {"("};
1276     end = creal(resultValue);
1277     sprintf(buffer, "%.2f", end);
1278     strcat(value, buffer);
1279     strcat(value, ",");
1280     end = cimag(resultValue);
1281     sprintf(buffer, "%.2f", end);
1282     strcat(value, buffer);
1283     strcat(value, ")");
1284     napi_create_string_utf8(env, value, NAPI_AUTO_LENGTH, &result);
1285     return result;
1286 }
1287 
Ccosl(napi_env env, napi_callback_info info)1288 static napi_value Ccosl(napi_env env, napi_callback_info info)
1289 {
1290     size_t argc = INDEX2;
1291     napi_value args[2] = {nullptr};
1292     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1293     double real, image;
1294     napi_get_value_double(env, args[0], &real);
1295     napi_get_value_double(env, args[1], &image);
1296     double complex param = {real, image};
1297     double complex resultValue = ccosl(param);
1298     napi_value result = nullptr;
1299     double end;
1300     char buffer[20];
1301     char value[128] = {"("};
1302     end = creal(resultValue);
1303     sprintf(buffer, "%.2f", end);
1304     strcat(value, buffer);
1305     strcat(value, ",");
1306     end = cimag(resultValue);
1307     sprintf(buffer, "%.2f", end);
1308     strcat(value, buffer);
1309     strcat(value, ")");
1310     napi_create_string_utf8(env, value, NAPI_AUTO_LENGTH, &result);
1311     return result;
1312 }
1313 
Ccosf(napi_env env, napi_callback_info info)1314 static napi_value Ccosf(napi_env env, napi_callback_info info)
1315 {
1316     size_t argc = INDEX2;
1317     napi_value args[2] = {nullptr};
1318     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1319     double real, image;
1320     napi_get_value_double(env, args[0], &real);
1321     napi_get_value_double(env, args[1], &image);
1322     double complex param = {real, image};
1323     double complex resultValue = ccosf(param);
1324     napi_value result = nullptr;
1325     double end;
1326     char buffer[20];
1327     char value[128] = {"("};
1328     end = creal(resultValue);
1329     sprintf(buffer, "%.2f", end);
1330     strcat(value, buffer);
1331     strcat(value, ",");
1332     end = cimag(resultValue);
1333     sprintf(buffer, "%.2f", end);
1334     strcat(value, buffer);
1335     strcat(value, ")");
1336     napi_create_string_utf8(env, value, NAPI_AUTO_LENGTH, &result);
1337     return result;
1338 }
1339 
Ccosh(napi_env env, napi_callback_info info)1340 static napi_value Ccosh(napi_env env, napi_callback_info info)
1341 {
1342     size_t argc = INDEX2;
1343     napi_value args[2] = {nullptr};
1344     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1345     double real, image;
1346     napi_get_value_double(env, args[0], &real);
1347     napi_get_value_double(env, args[1], &image);
1348     double complex param = {real, image};
1349     double complex resultValue = ccosh(param);
1350     napi_value result = nullptr;
1351     double end;
1352     char buffer[20];
1353     char value[128] = {"("};
1354     end = creal(resultValue);
1355     sprintf(buffer, "%.2f", end);
1356     strcat(value, buffer);
1357     strcat(value, ",");
1358     end = cimag(resultValue);
1359     sprintf(buffer, "%.2f", end);
1360     strcat(value, buffer);
1361     strcat(value, ")");
1362     napi_create_string_utf8(env, value, NAPI_AUTO_LENGTH, &result);
1363     return result;
1364 }
1365 
Ccoshf(napi_env env, napi_callback_info info)1366 static napi_value Ccoshf(napi_env env, napi_callback_info info)
1367 {
1368     size_t argc = INDEX2;
1369     napi_value args[2] = {nullptr};
1370     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1371     double real, image;
1372     napi_get_value_double(env, args[0], &real);
1373     napi_get_value_double(env, args[1], &image);
1374     double complex param = {real, image};
1375     double complex resultValue = ccoshf(param);
1376     napi_value result = nullptr;
1377     double end;
1378     char buffer[20];
1379     char value[128] = {"("};
1380     end = creal(resultValue);
1381     sprintf(buffer, "%.2f", end);
1382     strcat(value, buffer);
1383     strcat(value, ",");
1384     end = cimag(resultValue);
1385     sprintf(buffer, "%.2f", end);
1386     strcat(value, buffer);
1387     strcat(value, ")");
1388     napi_create_string_utf8(env, value, NAPI_AUTO_LENGTH, &result);
1389     return result;
1390 }
1391 
Ccoshl(napi_env env, napi_callback_info info)1392 static napi_value Ccoshl(napi_env env, napi_callback_info info)
1393 {
1394     size_t argc = INDEX2;
1395     napi_value args[2] = {nullptr};
1396     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1397     double real, image;
1398     napi_get_value_double(env, args[0], &real);
1399     napi_get_value_double(env, args[1], &image);
1400     double complex param = {real, image};
1401     double complex resultValue = ccoshl(param);
1402     napi_value result = nullptr;
1403     double end;
1404     char buffer[20];
1405     char value[128] = {"("};
1406     end = creal(resultValue);
1407     sprintf(buffer, "%.2f", end);
1408     strcat(value, buffer);
1409     strcat(value, ",");
1410     end = cimag(resultValue);
1411     sprintf(buffer, "%.2f", end);
1412     strcat(value, buffer);
1413     strcat(value, ")");
1414     napi_create_string_utf8(env, value, NAPI_AUTO_LENGTH, &result);
1415     return result;
1416 }
1417 
Cexp(napi_env env, napi_callback_info info)1418 static napi_value Cexp(napi_env env, napi_callback_info info)
1419 {
1420     size_t argc = INDEX2;
1421     napi_value args[2] = {nullptr};
1422     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1423     double real, image;
1424     napi_get_value_double(env, args[0], &real);
1425     napi_get_value_double(env, args[1], &image);
1426     double complex param = {real, image};
1427     double complex resultValue = cexp(param);
1428     napi_value result = nullptr;
1429     double end;
1430     char buffer[20];
1431     char value[128] = {"("};
1432     end = creal(resultValue);
1433     sprintf(buffer, "%.2f", end);
1434     strcat(value, buffer);
1435     strcat(value, ",");
1436     end = cimag(resultValue);
1437     sprintf(buffer, "%.2f", end);
1438     strcat(value, buffer);
1439     strcat(value, ")");
1440     napi_create_string_utf8(env, value, NAPI_AUTO_LENGTH, &result);
1441     return result;
1442 }
1443 
Cexpl(napi_env env, napi_callback_info info)1444 static napi_value Cexpl(napi_env env, napi_callback_info info)
1445 {
1446     size_t argc = INDEX2;
1447     napi_value args[2] = {nullptr};
1448     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1449     double real, image;
1450     napi_get_value_double(env, args[0], &real);
1451     napi_get_value_double(env, args[1], &image);
1452     double complex param = {real, image};
1453     double complex resultValue = cexpl(param);
1454     napi_value result = nullptr;
1455     double end;
1456     char buffer[20];
1457     char value[128] = {"("};
1458     end = creal(resultValue);
1459     sprintf(buffer, "%.2f", end);
1460     strcat(value, buffer);
1461     strcat(value, ",");
1462     end = cimag(resultValue);
1463     sprintf(buffer, "%.2f", end);
1464     strcat(value, buffer);
1465     strcat(value, ")");
1466     napi_create_string_utf8(env, value, NAPI_AUTO_LENGTH, &result);
1467     return result;
1468 }
1469 
Cexpf(napi_env env, napi_callback_info info)1470 static napi_value Cexpf(napi_env env, napi_callback_info info)
1471 {
1472     size_t argc = INDEX2;
1473     napi_value args[2] = {nullptr};
1474     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1475     double real, image;
1476     napi_get_value_double(env, args[0], &real);
1477     napi_get_value_double(env, args[1], &image);
1478     double complex param = {real, image};
1479     double complex resultValue = cexpf(param);
1480     napi_value result = nullptr;
1481     double end;
1482     char buffer[20];
1483     char value[128] = {"("};
1484     end = creal(resultValue);
1485     sprintf(buffer, "%.2f", end);
1486     strcat(value, buffer);
1487     strcat(value, ",");
1488     end = cimag(resultValue);
1489     sprintf(buffer, "%.2f", end);
1490     strcat(value, buffer);
1491     strcat(value, ")");
1492     napi_create_string_utf8(env, value, NAPI_AUTO_LENGTH, &result);
1493     return result;
1494 }
1495 
Clog(napi_env env, napi_callback_info info)1496 static napi_value Clog(napi_env env, napi_callback_info info)
1497 {
1498     size_t argc = INDEX2;
1499     napi_value args[2] = {nullptr};
1500     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1501     double real, image;
1502     napi_get_value_double(env, args[0], &real);
1503     napi_get_value_double(env, args[1], &image);
1504     double complex param = {real, image};
1505     double complex resultValue = clog(param);
1506     napi_value result = nullptr;
1507     double end;
1508     char buffer[20];
1509     char value[128] = {"("};
1510     end = creal(resultValue);
1511     sprintf(buffer, "%.2f", end);
1512     strcat(value, buffer);
1513     strcat(value, ",");
1514     end = cimag(resultValue);
1515     sprintf(buffer, "%.2f", end);
1516     strcat(value, buffer);
1517     strcat(value, ")");
1518     napi_create_string_utf8(env, value, NAPI_AUTO_LENGTH, &result);
1519     return result;
1520 }
1521 
Clogf(napi_env env, napi_callback_info info)1522 static napi_value Clogf(napi_env env, napi_callback_info info)
1523 {
1524     size_t argc = INDEX2;
1525     napi_value args[2] = {nullptr};
1526     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1527     double real, image;
1528     napi_get_value_double(env, args[0], &real);
1529     napi_get_value_double(env, args[1], &image);
1530     double complex param = {real, image};
1531     double complex resultValue = clogf(param);
1532     napi_value result = nullptr;
1533     double end;
1534     char buffer[20];
1535     char value[128] = {"("};
1536     end = creal(resultValue);
1537     sprintf(buffer, "%.2f", end);
1538     strcat(value, buffer);
1539     strcat(value, ",");
1540     end = cimag(resultValue);
1541     sprintf(buffer, "%.2f", end);
1542     strcat(value, buffer);
1543     strcat(value, ")");
1544     napi_create_string_utf8(env, value, NAPI_AUTO_LENGTH, &result);
1545     return result;
1546 }
1547 
Clogl(napi_env env, napi_callback_info info)1548 static napi_value Clogl(napi_env env, napi_callback_info info)
1549 {
1550     size_t argc = INDEX2;
1551     napi_value args[2] = {nullptr};
1552     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1553     double real, image;
1554     napi_get_value_double(env, args[0], &real);
1555     napi_get_value_double(env, args[1], &image);
1556     double complex param = {real, image};
1557     double complex resultValue = clogl(param);
1558     napi_value result = nullptr;
1559     double end;
1560     char buffer[20];
1561     char value[128] = {"("};
1562     end = creal(resultValue);
1563     sprintf(buffer, "%.2f", end);
1564     strcat(value, buffer);
1565     strcat(value, ",");
1566     end = cimag(resultValue);
1567     sprintf(buffer, "%.2f", end);
1568     strcat(value, buffer);
1569     strcat(value, ")");
1570     napi_create_string_utf8(env, value, NAPI_AUTO_LENGTH, &result);
1571     return result;
1572 }
1573 
Cimag(napi_env env, napi_callback_info info)1574 static napi_value Cimag(napi_env env, napi_callback_info info)
1575 {
1576     size_t argc = INDEX2;
1577     napi_value args[2] = {nullptr};
1578     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1579     double real, image;
1580     napi_get_value_double(env, args[0], &real);
1581     napi_get_value_double(env, args[1], &image);
1582     double complex param = {real, image};
1583     double resultValue = cimag(param);
1584     napi_value result = nullptr;
1585     napi_create_double(env, resultValue, &result);
1586     return result;
1587 }
1588 
Cimagf(napi_env env, napi_callback_info info)1589 static napi_value Cimagf(napi_env env, napi_callback_info info)
1590 {
1591     size_t argc = INDEX2;
1592     napi_value args[2] = {nullptr};
1593     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1594     double real, image;
1595     napi_get_value_double(env, args[0], &real);
1596     napi_get_value_double(env, args[1], &image);
1597     double complex param = {real, image};
1598     double resultValue = cimagf(param);
1599     napi_value result = nullptr;
1600     napi_create_double(env, resultValue, &result);
1601     return result;
1602 }
1603 
Cimagl(napi_env env, napi_callback_info info)1604 static napi_value Cimagl(napi_env env, napi_callback_info info)
1605 {
1606     size_t argc = INDEX2;
1607     napi_value args[2] = {nullptr};
1608     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1609     double real, image;
1610     napi_get_value_double(env, args[0], &real);
1611     napi_get_value_double(env, args[1], &image);
1612     double complex param = {real, image};
1613     double resultValue = cimagl(param);
1614     napi_value result = nullptr;
1615     napi_create_double(env, resultValue, &result);
1616     return result;
1617 }
1618 
1619 EXTERN_C_START
Init(napi_env env, napi_value exports)1620 static napi_value Init(napi_env env, napi_value exports)
1621 {
1622     napi_property_descriptor desc[] = {{"creal", nullptr, CReal, nullptr, nullptr, nullptr, napi_default, nullptr},
1623                                        {"crealf", nullptr, CRealF, nullptr, nullptr, nullptr, napi_default, nullptr},
1624                                        {"creall", nullptr, CRealL, nullptr, nullptr, nullptr, napi_default, nullptr},
1625                                        {"conj", nullptr, Conj, nullptr, nullptr, nullptr, napi_default, nullptr},
1626                                        {"conjf", nullptr, ConjF, nullptr, nullptr, nullptr, napi_default, nullptr},
1627                                        {"conjl", nullptr, ConjL, nullptr, nullptr, nullptr, napi_default, nullptr},
1628                                        {"cpow", nullptr, CPow, nullptr, nullptr, nullptr, napi_default, nullptr},
1629                                        {"cpowf", nullptr, CPowF, nullptr, nullptr, nullptr, napi_default, nullptr},
1630                                        {"cpowl", nullptr, CPowL, nullptr, nullptr, nullptr, napi_default, nullptr},
1631                                        {"cproj", nullptr, CProj, nullptr, nullptr, nullptr, napi_default, nullptr},
1632                                        {"cprojf", nullptr, CProjF, nullptr, nullptr, nullptr, napi_default, nullptr},
1633                                        {"cprojl", nullptr, CProjL, nullptr, nullptr, nullptr, napi_default, nullptr},
1634                                        {"csin", nullptr, CSin, nullptr, nullptr, nullptr, napi_default, nullptr},
1635                                        {"csinf", nullptr, CSinF, nullptr, nullptr, nullptr, napi_default, nullptr},
1636                                        {"csinl", nullptr, CSinL, nullptr, nullptr, nullptr, napi_default, nullptr},
1637                                        {"csinh", nullptr, CSinH, nullptr, nullptr, nullptr, napi_default, nullptr},
1638                                        {"csinhf", nullptr, CSinHf, nullptr, nullptr, nullptr, napi_default, nullptr},
1639                                        {"csinhl", nullptr, CSinHl, nullptr, nullptr, nullptr, napi_default, nullptr},
1640                                        {"csqrt", nullptr, CSqrt, nullptr, nullptr, nullptr, napi_default, nullptr},
1641                                        {"csqrtf", nullptr, CSqrtF, nullptr, nullptr, nullptr, napi_default, nullptr},
1642                                        {"csqrtl", nullptr, CSqrtL, nullptr, nullptr, nullptr, napi_default, nullptr},
1643                                        {"ctan", nullptr, CTan, nullptr, nullptr, nullptr, napi_default, nullptr},
1644                                        {"ctanf", nullptr, CTanF, nullptr, nullptr, nullptr, napi_default, nullptr},
1645                                        {"ctanl", nullptr, CTanL, nullptr, nullptr, nullptr, napi_default, nullptr},
1646                                        {"ctanh", nullptr, CTanH, nullptr, nullptr, nullptr, napi_default, nullptr},
1647                                        {"ctanhf", nullptr, CTanHf, nullptr, nullptr, nullptr, napi_default, nullptr},
1648                                        {"ctanhl", nullptr, CTanHl, nullptr, nullptr, nullptr, napi_default, nullptr},
1649                                        {"cabs", nullptr, Cabs, nullptr, nullptr, nullptr, napi_default, nullptr},
1650                                        {"cabsf", nullptr, Cabsf, nullptr, nullptr, nullptr, napi_default, nullptr},
1651                                        {"cacos", nullptr, Cacos, nullptr, nullptr, nullptr, napi_default, nullptr},
1652                                        {"cexpf", nullptr, Cexpf, nullptr, nullptr, nullptr, napi_default, nullptr},
1653                                        {"cexpl", nullptr, Cexpl, nullptr, nullptr, nullptr, napi_default, nullptr},
1654                                        {"cexp", nullptr, Cexp, nullptr, nullptr, nullptr, napi_default, nullptr},
1655                                        {"cacosf", nullptr, Cacosf, nullptr, nullptr, nullptr, napi_default, nullptr},
1656                                        {"cacosl", nullptr, Cacosl, nullptr, nullptr, nullptr, napi_default, nullptr},
1657                                        {"cacosh", nullptr, Cacosh, nullptr, nullptr, nullptr, napi_default, nullptr},
1658                                        {"cacoshl", nullptr, Cacoshl, nullptr, nullptr, nullptr, napi_default, nullptr},
1659                                        {"cacoshf", nullptr, Cacoshf, nullptr, nullptr, nullptr, napi_default, nullptr},
1660                                        {"casin", nullptr, Casin, nullptr, nullptr, nullptr, napi_default, nullptr},
1661                                        {"casinf", nullptr, Casinf, nullptr, nullptr, nullptr, napi_default, nullptr},
1662                                        {"casinl", nullptr, Casinl, nullptr, nullptr, nullptr, napi_default, nullptr},
1663                                        {"casinh", nullptr, Casinh, nullptr, nullptr, nullptr, napi_default, nullptr},
1664                                        {"casinhf", nullptr, Casinhf, nullptr, nullptr, nullptr, napi_default, nullptr},
1665                                        {"casinhl", nullptr, Casinhl, nullptr, nullptr, nullptr, napi_default, nullptr},
1666                                        {"catan", nullptr, Catan, nullptr, nullptr, nullptr, napi_default, nullptr},
1667                                        {"catanf", nullptr, Catanf, nullptr, nullptr, nullptr, napi_default, nullptr},
1668                                        {"catanl", nullptr, Catanl, nullptr, nullptr, nullptr, napi_default, nullptr},
1669                                        {"catanh", nullptr, Catanh, nullptr, nullptr, nullptr, napi_default, nullptr},
1670                                        {"catanhf", nullptr, Catanhf, nullptr, nullptr, nullptr, napi_default, nullptr},
1671                                        {"catanhl", nullptr, Catanhl, nullptr, nullptr, nullptr, napi_default, nullptr},
1672                                        {"ccos", nullptr, Ccos, nullptr, nullptr, nullptr, napi_default, nullptr},
1673                                        {"ccosf", nullptr, Ccosf, nullptr, nullptr, nullptr, napi_default, nullptr},
1674                                        {"ccosl", nullptr, Ccosl, nullptr, nullptr, nullptr, napi_default, nullptr},
1675                                        {"ccosh", nullptr, Ccosh, nullptr, nullptr, nullptr, napi_default, nullptr},
1676                                        {"ccoshf", nullptr, Ccoshf, nullptr, nullptr, nullptr, napi_default, nullptr},
1677                                        {"ccoshl", nullptr, Ccoshl, nullptr, nullptr, nullptr, napi_default, nullptr},
1678                                        {"carg", nullptr, Carg, nullptr, nullptr, nullptr, napi_default, nullptr},
1679                                        {"cargf", nullptr, Cargf, nullptr, nullptr, nullptr, napi_default, nullptr},
1680                                        {"cargl", nullptr, Cargl, nullptr, nullptr, nullptr, napi_default, nullptr},
1681                                        {"clog", nullptr, Clog, nullptr, nullptr, nullptr, napi_default, nullptr},
1682                                        {"clogf", nullptr, Clogf, nullptr, nullptr, nullptr, napi_default, nullptr},
1683                                        {"clogl", nullptr, Clogl, nullptr, nullptr, nullptr, napi_default, nullptr},
1684                                        {"cimag", nullptr, Cimag, nullptr, nullptr, nullptr, napi_default, nullptr},
1685                                        {"cimagf", nullptr, Cimagf, nullptr, nullptr, nullptr, napi_default, nullptr},
1686                                        {"cimagl", nullptr, Cimagl, nullptr, nullptr, nullptr, napi_default, nullptr},
1687                                        {"cabsl", nullptr, Cabsl, nullptr, nullptr, nullptr, napi_default, nullptr}};
1688     napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
1689     return exports;
1690 }
1691 EXTERN_C_END
1692 
1693 static napi_module demoModule = {
1694     .nm_version = 1,
1695     .nm_flags = 0,
1696     .nm_filename = nullptr,
1697     .nm_register_func = Init,
1698     .nm_modname = "complexndk",
1699     .nm_priv = ((void *)0),
1700     .reserved = {0},
1701 };
1702 
RegisterModule(void)1703 extern "C" __attribute__((constructor)) void RegisterModule(void) { napi_module_register(&demoModule); }
1704