1/*
2 * Copyright (c) 2008-2020 Stefan Krah. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 *
11 * 2. Redistributions in binary form must reproduce the above copyright
12 *    notice, this list of conditions and the following disclaimer in the
13 *    documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS "AS IS" AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 */
27
28
29#include "mpdecimal.h"
30
31#include <stddef.h>
32#include <stdint.h>
33
34
35/* Signaling wrappers for the quiet functions in mpdecimal.c. */
36
37
38char *
39mpd_format(const mpd_t *dec, const char *fmt, mpd_context_t *ctx)
40{
41    char *ret;
42    uint32_t status = 0;
43    ret = mpd_qformat(dec, fmt, ctx, &status);
44    mpd_addstatus_raise(ctx, status);
45    return ret;
46}
47
48void
49mpd_import_u16(mpd_t *result, const uint16_t *srcdata, size_t srclen,
50               uint8_t srcsign, uint32_t base, mpd_context_t *ctx)
51{
52    uint32_t status = 0;
53    mpd_qimport_u16(result, srcdata, srclen, srcsign, base, ctx, &status);
54    mpd_addstatus_raise(ctx, status);
55}
56
57void
58mpd_import_u32(mpd_t *result, const uint32_t *srcdata, size_t srclen,
59               uint8_t srcsign, uint32_t base, mpd_context_t *ctx)
60{
61    uint32_t status = 0;
62    mpd_qimport_u32(result, srcdata, srclen, srcsign, base, ctx, &status);
63    mpd_addstatus_raise(ctx, status);
64}
65
66size_t
67mpd_export_u16(uint16_t **rdata, size_t rlen, uint32_t base, const mpd_t *src,
68               mpd_context_t *ctx)
69{
70    size_t n;
71    uint32_t status = 0;
72    n = mpd_qexport_u16(rdata, rlen, base, src, &status);
73    mpd_addstatus_raise(ctx, status);
74    return n;
75}
76
77size_t
78mpd_export_u32(uint32_t **rdata, size_t rlen, uint32_t base, const mpd_t *src,
79               mpd_context_t *ctx)
80{
81    size_t n;
82    uint32_t status = 0;
83    n = mpd_qexport_u32(rdata, rlen, base, src, &status);
84    mpd_addstatus_raise(ctx, status);
85    return n;
86}
87
88void
89mpd_finalize(mpd_t *result, mpd_context_t *ctx)
90{
91    uint32_t status = 0;
92    mpd_qfinalize(result, ctx, &status);
93    mpd_addstatus_raise(ctx, status);
94}
95
96int
97mpd_check_nan(mpd_t *result, const mpd_t *a, mpd_context_t *ctx)
98{
99    uint32_t status = 0;
100    if (mpd_qcheck_nan(result, a, ctx, &status)) {
101        mpd_addstatus_raise(ctx, status);
102        return 1;
103    }
104    return 0;
105}
106
107int
108mpd_check_nans(mpd_t *result, const mpd_t *a, const mpd_t *b, mpd_context_t *ctx)
109{
110    uint32_t status = 0;
111    if (mpd_qcheck_nans(result, a, b, ctx, &status)) {
112        mpd_addstatus_raise(ctx, status);
113        return 1;
114    }
115    return 0;
116}
117
118void
119mpd_set_string(mpd_t *result, const char *s, mpd_context_t *ctx)
120{
121    uint32_t status = 0;
122    mpd_qset_string(result, s, ctx, &status);
123    mpd_addstatus_raise(ctx, status);
124}
125
126void
127mpd_maxcoeff(mpd_t *result, mpd_context_t *ctx)
128{
129    uint32_t status = 0;
130    mpd_qmaxcoeff(result, ctx, &status);
131    mpd_addstatus_raise(ctx, status);
132}
133
134/* set static mpd from signed integer */
135void
136mpd_sset_ssize(mpd_t *result, mpd_ssize_t a, mpd_context_t *ctx)
137{
138    uint32_t status = 0;
139    mpd_qsset_ssize(result, a, ctx, &status);
140    mpd_addstatus_raise(ctx, status);
141}
142
143void
144mpd_sset_i32(mpd_t *result, int32_t a, mpd_context_t *ctx)
145{
146    uint32_t status = 0;
147    mpd_qsset_i32(result, a, ctx, &status);
148    mpd_addstatus_raise(ctx, status);
149}
150
151#ifdef CONFIG_64
152void
153mpd_sset_i64(mpd_t *result, int64_t a, mpd_context_t *ctx)
154{
155    uint32_t status = 0;
156    mpd_qsset_i64(result, a, ctx, &status);
157    mpd_addstatus_raise(ctx, status);
158}
159#endif
160
161/* set static mpd from unsigned integer */
162void
163mpd_sset_uint(mpd_t *result, mpd_uint_t a, mpd_context_t *ctx)
164{
165    uint32_t status = 0;
166    mpd_qsset_uint(result, a, ctx, &status);
167    mpd_addstatus_raise(ctx, status);
168}
169
170void
171mpd_sset_u32(mpd_t *result, uint32_t a, mpd_context_t *ctx)
172{
173    uint32_t status = 0;
174    mpd_qsset_u32(result, a, ctx, &status);
175    mpd_addstatus_raise(ctx, status);
176}
177
178#ifdef CONFIG_64
179void
180mpd_sset_u64(mpd_t *result, uint64_t a, mpd_context_t *ctx)
181{
182    uint32_t status = 0;
183    mpd_qsset_u64(result, a, ctx, &status);
184    mpd_addstatus_raise(ctx, status);
185}
186#endif
187
188/* set mpd from signed integer */
189void
190mpd_set_ssize(mpd_t *result, mpd_ssize_t a, mpd_context_t *ctx)
191{
192    uint32_t status = 0;
193    mpd_qset_ssize(result, a, ctx, &status);
194    mpd_addstatus_raise(ctx, status);
195}
196
197void
198mpd_set_i32(mpd_t *result, int32_t a, mpd_context_t *ctx)
199{
200    uint32_t status = 0;
201    mpd_qset_i32(result, a, ctx, &status);
202    mpd_addstatus_raise(ctx, status);
203}
204
205#ifndef LEGACY_COMPILER
206void
207mpd_set_i64(mpd_t *result, int64_t a, mpd_context_t *ctx)
208{
209    uint32_t status = 0;
210    mpd_qset_i64(result, a, ctx, &status);
211    mpd_addstatus_raise(ctx, status);
212}
213#endif
214
215/* set mpd from unsigned integer */
216void
217mpd_set_uint(mpd_t *result, mpd_uint_t a, mpd_context_t *ctx)
218{
219    uint32_t status = 0;
220    mpd_qset_uint(result, a, ctx, &status);
221    mpd_addstatus_raise(ctx, status);
222}
223
224void
225mpd_set_u32(mpd_t *result, uint32_t a, mpd_context_t *ctx)
226{
227    uint32_t status = 0;
228    mpd_qset_u32(result, a, ctx, &status);
229    mpd_addstatus_raise(ctx, status);
230}
231
232#ifndef LEGACY_COMPILER
233void
234mpd_set_u64(mpd_t *result, uint64_t a, mpd_context_t *ctx)
235{
236    uint32_t status = 0;
237    mpd_qset_u64(result, a, ctx, &status);
238    mpd_addstatus_raise(ctx, status);
239}
240#endif
241
242/* convert mpd to signed integer */
243mpd_ssize_t
244mpd_get_ssize(const mpd_t *a, mpd_context_t *ctx)
245{
246    uint32_t status = 0;
247    mpd_ssize_t ret;
248
249    ret = mpd_qget_ssize(a, &status);
250    mpd_addstatus_raise(ctx, status);
251    return ret;
252}
253
254int32_t
255mpd_get_i32(const mpd_t *a, mpd_context_t *ctx)
256{
257    uint32_t status = 0;
258    int32_t ret;
259
260    ret = mpd_qget_i32(a, &status);
261    mpd_addstatus_raise(ctx, status);
262    return ret;
263}
264
265#ifndef LEGACY_COMPILER
266int64_t
267mpd_get_i64(const mpd_t *a, mpd_context_t *ctx)
268{
269    uint32_t status = 0;
270    int64_t ret;
271
272    ret = mpd_qget_i64(a, &status);
273    mpd_addstatus_raise(ctx, status);
274    return ret;
275}
276#endif
277
278mpd_uint_t
279mpd_get_uint(const mpd_t *a, mpd_context_t *ctx)
280{
281    uint32_t status = 0;
282    mpd_uint_t ret;
283
284    ret = mpd_qget_uint(a, &status);
285    mpd_addstatus_raise(ctx, status);
286    return ret;
287}
288
289mpd_uint_t
290mpd_abs_uint(const mpd_t *a, mpd_context_t *ctx)
291{
292    uint32_t status = 0;
293    mpd_uint_t ret;
294
295    ret = mpd_qabs_uint(a, &status);
296    mpd_addstatus_raise(ctx, status);
297    return ret;
298}
299
300uint32_t
301mpd_get_u32(const mpd_t *a, mpd_context_t *ctx)
302{
303    uint32_t status = 0;
304    uint32_t ret;
305
306    ret = mpd_qget_u32(a, &status);
307    mpd_addstatus_raise(ctx, status);
308    return ret;
309}
310
311#ifndef LEGACY_COMPILER
312uint64_t
313mpd_get_u64(const mpd_t *a, mpd_context_t *ctx)
314{
315    uint32_t status = 0;
316    uint64_t ret;
317
318    ret = mpd_qget_u64(a, &status);
319    mpd_addstatus_raise(ctx, status);
320    return ret;
321}
322#endif
323
324void
325mpd_and(mpd_t *result, const mpd_t *a, const mpd_t *b, mpd_context_t *ctx)
326{
327    uint32_t status = 0;
328    mpd_qand(result, a, b, ctx, &status);
329    mpd_addstatus_raise(ctx, status);
330}
331
332void
333mpd_copy(mpd_t *result, const mpd_t *a, mpd_context_t *ctx)
334{
335    uint32_t status = 0;
336    if (!mpd_qcopy(result, a, &status)) {
337        mpd_addstatus_raise(ctx, status);
338    }
339}
340
341void
342mpd_canonical(mpd_t *result, const mpd_t *a, mpd_context_t *ctx)
343{
344    mpd_copy(result, a, ctx);
345}
346
347void
348mpd_copy_abs(mpd_t *result, const mpd_t *a, mpd_context_t *ctx)
349{
350    uint32_t status = 0;
351    if (!mpd_qcopy_abs(result, a, &status)) {
352        mpd_addstatus_raise(ctx, status);
353    }
354}
355
356void
357mpd_copy_negate(mpd_t *result, const mpd_t *a, mpd_context_t *ctx)
358{
359    uint32_t status = 0;
360    if (!mpd_qcopy_negate(result, a, &status)) {
361        mpd_addstatus_raise(ctx, status);
362    }
363}
364
365void
366mpd_copy_sign(mpd_t *result, const mpd_t *a, const mpd_t *b, mpd_context_t *ctx)
367{
368    uint32_t status = 0;
369    if (!mpd_qcopy_sign(result, a, b, &status)) {
370        mpd_addstatus_raise(ctx, status);
371    }
372}
373
374void
375mpd_invert(mpd_t *result, const mpd_t *a, mpd_context_t *ctx)
376{
377    uint32_t status = 0;
378    mpd_qinvert(result, a, ctx, &status);
379    mpd_addstatus_raise(ctx, status);
380}
381
382void
383mpd_logb(mpd_t *result, const mpd_t *a, mpd_context_t *ctx)
384{
385    uint32_t status = 0;
386    mpd_qlogb(result, a, ctx, &status);
387    mpd_addstatus_raise(ctx, status);
388}
389
390void
391mpd_or(mpd_t *result, const mpd_t *a, const mpd_t *b, mpd_context_t *ctx)
392{
393    uint32_t status = 0;
394    mpd_qor(result, a, b, ctx, &status);
395    mpd_addstatus_raise(ctx, status);
396}
397
398void
399mpd_rotate(mpd_t *result, const mpd_t *a, const mpd_t *b, mpd_context_t *ctx)
400{
401    uint32_t status = 0;
402    mpd_qrotate(result, a, b, ctx, &status);
403    mpd_addstatus_raise(ctx, status);
404}
405
406void
407mpd_scaleb(mpd_t *result, const mpd_t *a, const mpd_t *b, mpd_context_t *ctx)
408{
409    uint32_t status = 0;
410    mpd_qscaleb(result, a, b, ctx, &status);
411    mpd_addstatus_raise(ctx, status);
412}
413
414void
415mpd_shiftl(mpd_t *result, const mpd_t *a, mpd_ssize_t n, mpd_context_t *ctx)
416{
417    uint32_t status = 0;
418    mpd_qshiftl(result, a, n, &status);
419    mpd_addstatus_raise(ctx, status);
420}
421
422mpd_uint_t
423mpd_shiftr(mpd_t *result, const mpd_t *a, mpd_ssize_t n, mpd_context_t *ctx)
424{
425    uint32_t status = 0;
426    mpd_uint_t rnd;
427
428    rnd = mpd_qshiftr(result, a, n, &status);
429    mpd_addstatus_raise(ctx, status);
430    return rnd;
431}
432
433void
434mpd_shiftn(mpd_t *result, const mpd_t *a, mpd_ssize_t n, mpd_context_t *ctx)
435{
436    uint32_t status = 0;
437    mpd_qshiftn(result, a, n, ctx, &status);
438    mpd_addstatus_raise(ctx, status);
439}
440
441void
442mpd_shift(mpd_t *result, const mpd_t *a, const mpd_t *b, mpd_context_t *ctx)
443{
444    uint32_t status = 0;
445    mpd_qshift(result, a, b, ctx, &status);
446    mpd_addstatus_raise(ctx, status);
447}
448
449void
450mpd_xor(mpd_t *result, const mpd_t *a, const mpd_t *b, mpd_context_t *ctx)
451{
452    uint32_t status = 0;
453    mpd_qxor(result, a, b, ctx, &status);
454    mpd_addstatus_raise(ctx, status);
455}
456
457void
458mpd_abs(mpd_t *result, const mpd_t *a, mpd_context_t *ctx)
459{
460    uint32_t status = 0;
461    mpd_qabs(result, a, ctx, &status);
462    mpd_addstatus_raise(ctx, status);
463}
464
465int
466mpd_cmp(const mpd_t *a, const mpd_t *b, mpd_context_t *ctx)
467{
468    uint32_t status = 0;
469    int c;
470    c = mpd_qcmp(a, b, &status);
471    mpd_addstatus_raise(ctx, status);
472    return c;
473}
474
475int
476mpd_compare(mpd_t *result, const mpd_t *a, const mpd_t *b, mpd_context_t *ctx)
477{
478    uint32_t status = 0;
479    int c;
480    c = mpd_qcompare(result, a, b, ctx, &status);
481    mpd_addstatus_raise(ctx, status);
482    return c;
483}
484
485int
486mpd_compare_signal(mpd_t *result, const mpd_t *a, const mpd_t *b, mpd_context_t *ctx)
487{
488    uint32_t status = 0;
489    int c;
490    c = mpd_qcompare_signal(result, a, b, ctx, &status);
491    mpd_addstatus_raise(ctx, status);
492    return c;
493}
494
495void
496mpd_add(mpd_t *result, const mpd_t *a, const mpd_t *b, mpd_context_t *ctx)
497{
498    uint32_t status = 0;
499    mpd_qadd(result, a, b, ctx, &status);
500    mpd_addstatus_raise(ctx, status);
501}
502
503void
504mpd_sub(mpd_t *result, const mpd_t *a, const mpd_t *b, mpd_context_t *ctx)
505{
506    uint32_t status = 0;
507    mpd_qsub(result, a, b, ctx, &status);
508    mpd_addstatus_raise(ctx, status);
509}
510
511void
512mpd_add_ssize(mpd_t *result, const mpd_t *a, mpd_ssize_t b, mpd_context_t *ctx)
513{
514    uint32_t status = 0;
515    mpd_qadd_ssize(result, a, b, ctx, &status);
516    mpd_addstatus_raise(ctx, status);
517}
518
519void
520mpd_add_i32(mpd_t *result, const mpd_t *a, int32_t b, mpd_context_t *ctx)
521{
522    uint32_t status = 0;
523    mpd_qadd_i32(result, a, b, ctx, &status);
524    mpd_addstatus_raise(ctx, status);
525}
526
527#ifndef LEGACY_COMPILER
528void
529mpd_add_i64(mpd_t *result, const mpd_t *a, int64_t b, mpd_context_t *ctx)
530{
531    uint32_t status = 0;
532    mpd_qadd_i64(result, a, b, ctx, &status);
533    mpd_addstatus_raise(ctx, status);
534}
535#endif
536
537void
538mpd_add_uint(mpd_t *result, const mpd_t *a, mpd_uint_t b, mpd_context_t *ctx)
539{
540    uint32_t status = 0;
541    mpd_qadd_uint(result, a, b, ctx, &status);
542    mpd_addstatus_raise(ctx, status);
543}
544
545void
546mpd_add_u32(mpd_t *result, const mpd_t *a, uint32_t b, mpd_context_t *ctx)
547{
548    uint32_t status = 0;
549    mpd_qadd_u32(result, a, b, ctx, &status);
550    mpd_addstatus_raise(ctx, status);
551}
552
553#ifndef LEGACY_COMPILER
554void
555mpd_add_u64(mpd_t *result, const mpd_t *a, uint64_t b, mpd_context_t *ctx)
556{
557    uint32_t status = 0;
558    mpd_qadd_u64(result, a, b, ctx, &status);
559    mpd_addstatus_raise(ctx, status);
560}
561#endif
562
563void
564mpd_sub_ssize(mpd_t *result, const mpd_t *a, mpd_ssize_t b, mpd_context_t *ctx)
565{
566    uint32_t status = 0;
567    mpd_qsub_ssize(result, a, b, ctx, &status);
568    mpd_addstatus_raise(ctx, status);
569}
570
571void
572mpd_sub_i32(mpd_t *result, const mpd_t *a, int32_t b, mpd_context_t *ctx)
573{
574    uint32_t status = 0;
575    mpd_qsub_i32(result, a, b, ctx, &status);
576    mpd_addstatus_raise(ctx, status);
577}
578
579#ifndef LEGACY_COMPILER
580void
581mpd_sub_i64(mpd_t *result, const mpd_t *a, int64_t b, mpd_context_t *ctx)
582{
583    uint32_t status = 0;
584    mpd_qsub_i64(result, a, b, ctx, &status);
585    mpd_addstatus_raise(ctx, status);
586}
587#endif
588
589void
590mpd_sub_uint(mpd_t *result, const mpd_t *a, mpd_uint_t b, mpd_context_t *ctx)
591{
592    uint32_t status = 0;
593    mpd_qsub_uint(result, a, b, ctx, &status);
594    mpd_addstatus_raise(ctx, status);
595}
596
597void
598mpd_sub_u32(mpd_t *result, const mpd_t *a, uint32_t b, mpd_context_t *ctx)
599{
600    uint32_t status = 0;
601    mpd_qsub_u32(result, a, b, ctx, &status);
602    mpd_addstatus_raise(ctx, status);
603}
604
605#ifndef LEGACY_COMPILER
606void
607mpd_sub_u64(mpd_t *result, const mpd_t *a, uint64_t b, mpd_context_t *ctx)
608{
609    uint32_t status = 0;
610    mpd_qsub_u64(result, a, b, ctx, &status);
611    mpd_addstatus_raise(ctx, status);
612}
613#endif
614
615void
616mpd_div(mpd_t *q, const mpd_t *a, const mpd_t *b, mpd_context_t *ctx)
617{
618    uint32_t status = 0;
619    mpd_qdiv(q, a, b, ctx, &status);
620    mpd_addstatus_raise(ctx, status);
621}
622
623void
624mpd_div_ssize(mpd_t *result, const mpd_t *a, mpd_ssize_t b, mpd_context_t *ctx)
625{
626    uint32_t status = 0;
627    mpd_qdiv_ssize(result, a, b, ctx, &status);
628    mpd_addstatus_raise(ctx, status);
629}
630
631void
632mpd_div_i32(mpd_t *result, const mpd_t *a, int32_t b, mpd_context_t *ctx)
633{
634    uint32_t status = 0;
635    mpd_qdiv_i32(result, a, b, ctx, &status);
636    mpd_addstatus_raise(ctx, status);
637}
638
639#ifndef LEGACY_COMPILER
640void
641mpd_div_i64(mpd_t *result, const mpd_t *a, int64_t b, mpd_context_t *ctx)
642{
643    uint32_t status = 0;
644    mpd_qdiv_i64(result, a, b, ctx, &status);
645    mpd_addstatus_raise(ctx, status);
646}
647#endif
648
649void
650mpd_div_uint(mpd_t *result, const mpd_t *a, mpd_uint_t b, mpd_context_t *ctx)
651{
652    uint32_t status = 0;
653    mpd_qdiv_uint(result, a, b, ctx, &status);
654    mpd_addstatus_raise(ctx, status);
655}
656
657void
658mpd_div_u32(mpd_t *result, const mpd_t *a, uint32_t b, mpd_context_t *ctx)
659{
660    uint32_t status = 0;
661    mpd_qdiv_u32(result, a, b, ctx, &status);
662    mpd_addstatus_raise(ctx, status);
663}
664
665#ifndef LEGACY_COMPILER
666void
667mpd_div_u64(mpd_t *result, const mpd_t *a, uint64_t b, mpd_context_t *ctx)
668{
669    uint32_t status = 0;
670    mpd_qdiv_u64(result, a, b, ctx, &status);
671    mpd_addstatus_raise(ctx, status);
672}
673#endif
674
675void
676mpd_divmod(mpd_t *q, mpd_t *r, const mpd_t *a, const mpd_t *b, mpd_context_t *ctx)
677{
678    uint32_t status = 0;
679    mpd_qdivmod(q, r, a, b, ctx, &status);
680    mpd_addstatus_raise(ctx, status);
681}
682
683void
684mpd_divint(mpd_t *q, const mpd_t *a, const mpd_t *b, mpd_context_t *ctx)
685{
686    uint32_t status = 0;
687    mpd_qdivint(q, a, b, ctx, &status);
688    mpd_addstatus_raise(ctx, status);
689}
690
691void
692mpd_exp(mpd_t *result, const mpd_t *a, mpd_context_t *ctx)
693{
694    uint32_t status = 0;
695    mpd_qexp(result, a, ctx, &status);
696    mpd_addstatus_raise(ctx, status);
697}
698
699void
700mpd_fma(mpd_t *result, const mpd_t *a, const mpd_t *b, const mpd_t *c,
701        mpd_context_t *ctx)
702{
703    uint32_t status = 0;
704    mpd_qfma(result, a, b, c, ctx, &status);
705    mpd_addstatus_raise(ctx, status);
706}
707
708void
709mpd_ln(mpd_t *result, const mpd_t *a, mpd_context_t *ctx)
710{
711    uint32_t status = 0;
712    mpd_qln(result, a, ctx, &status);
713    mpd_addstatus_raise(ctx, status);
714}
715
716void
717mpd_log10(mpd_t *result, const mpd_t *a, mpd_context_t *ctx)
718{
719    uint32_t status = 0;
720    mpd_qlog10(result, a, ctx, &status);
721    mpd_addstatus_raise(ctx, status);
722}
723
724void
725mpd_max(mpd_t *result, const mpd_t *a, const mpd_t *b, mpd_context_t *ctx)
726{
727    uint32_t status = 0;
728    mpd_qmax(result, a, b, ctx, &status);
729    mpd_addstatus_raise(ctx, status);
730}
731
732void
733mpd_max_mag(mpd_t *result, const mpd_t *a, const mpd_t *b, mpd_context_t *ctx)
734{
735    uint32_t status = 0;
736    mpd_qmax_mag(result, a, b, ctx, &status);
737    mpd_addstatus_raise(ctx, status);
738}
739
740void
741mpd_min(mpd_t *result, const mpd_t *a, const mpd_t *b, mpd_context_t *ctx)
742{
743    uint32_t status = 0;
744    mpd_qmin(result, a, b, ctx, &status);
745    mpd_addstatus_raise(ctx, status);
746}
747
748void
749mpd_min_mag(mpd_t *result, const mpd_t *a, const mpd_t *b, mpd_context_t *ctx)
750{
751    uint32_t status = 0;
752    mpd_qmin_mag(result, a, b, ctx, &status);
753    mpd_addstatus_raise(ctx, status);
754}
755
756void
757mpd_minus(mpd_t *result, const mpd_t *a, mpd_context_t *ctx)
758{
759    uint32_t status = 0;
760    mpd_qminus(result, a, ctx, &status);
761    mpd_addstatus_raise(ctx, status);
762}
763
764void
765mpd_mul(mpd_t *result, const mpd_t *a, const mpd_t *b, mpd_context_t *ctx)
766{
767    uint32_t status = 0;
768    mpd_qmul(result, a, b, ctx, &status);
769    mpd_addstatus_raise(ctx, status);
770}
771
772void
773mpd_mul_ssize(mpd_t *result, const mpd_t *a, mpd_ssize_t b, mpd_context_t *ctx)
774{
775    uint32_t status = 0;
776    mpd_qmul_ssize(result, a, b, ctx, &status);
777    mpd_addstatus_raise(ctx, status);
778}
779
780void
781mpd_mul_i32(mpd_t *result, const mpd_t *a, int32_t b, mpd_context_t *ctx)
782{
783    uint32_t status = 0;
784    mpd_qmul_i32(result, a, b, ctx, &status);
785    mpd_addstatus_raise(ctx, status);
786}
787
788#ifndef LEGACY_COMPILER
789void
790mpd_mul_i64(mpd_t *result, const mpd_t *a, int64_t b, mpd_context_t *ctx)
791{
792    uint32_t status = 0;
793    mpd_qmul_i64(result, a, b, ctx, &status);
794    mpd_addstatus_raise(ctx, status);
795}
796#endif
797
798void
799mpd_mul_uint(mpd_t *result, const mpd_t *a, mpd_uint_t b, mpd_context_t *ctx)
800{
801    uint32_t status = 0;
802    mpd_qmul_uint(result, a, b, ctx, &status);
803    mpd_addstatus_raise(ctx, status);
804}
805
806void
807mpd_mul_u32(mpd_t *result, const mpd_t *a, uint32_t b, mpd_context_t *ctx)
808{
809    uint32_t status = 0;
810    mpd_qmul_u32(result, a, b, ctx, &status);
811    mpd_addstatus_raise(ctx, status);
812}
813
814#ifndef LEGACY_COMPILER
815void
816mpd_mul_u64(mpd_t *result, const mpd_t *a, uint64_t b, mpd_context_t *ctx)
817{
818    uint32_t status = 0;
819    mpd_qmul_u64(result, a, b, ctx, &status);
820    mpd_addstatus_raise(ctx, status);
821}
822#endif
823
824void
825mpd_next_minus(mpd_t *result, const mpd_t *a, mpd_context_t *ctx)
826{
827    uint32_t status = 0;
828    mpd_qnext_minus(result, a, ctx, &status);
829    mpd_addstatus_raise(ctx, status);
830}
831
832void
833mpd_next_plus(mpd_t *result, const mpd_t *a, mpd_context_t *ctx)
834{
835    uint32_t status = 0;
836    mpd_qnext_plus(result, a, ctx, &status);
837    mpd_addstatus_raise(ctx, status);
838}
839
840void
841mpd_next_toward(mpd_t *result, const mpd_t *a, const mpd_t *b, mpd_context_t *ctx)
842{
843    uint32_t status = 0;
844    mpd_qnext_toward(result, a, b, ctx, &status);
845    mpd_addstatus_raise(ctx, status);
846}
847
848void
849mpd_plus(mpd_t *result, const mpd_t *a, mpd_context_t *ctx)
850{
851    uint32_t status = 0;
852    mpd_qplus(result, a, ctx, &status);
853    mpd_addstatus_raise(ctx, status);
854}
855
856void
857mpd_pow(mpd_t *result, const mpd_t *base, const mpd_t *exp, mpd_context_t *ctx)
858{
859    uint32_t status = 0;
860    mpd_qpow(result, base, exp, ctx, &status);
861    mpd_addstatus_raise(ctx, status);
862}
863
864void
865mpd_powmod(mpd_t *result, const mpd_t *base, const mpd_t *exp, const mpd_t *mod,
866           mpd_context_t *ctx)
867{
868    uint32_t status = 0;
869    mpd_qpowmod(result, base, exp, mod, ctx, &status);
870    mpd_addstatus_raise(ctx, status);
871}
872
873void
874mpd_quantize(mpd_t *result, const mpd_t *a, const mpd_t *b, mpd_context_t *ctx)
875{
876    uint32_t status = 0;
877    mpd_qquantize(result, a, b, ctx, &status);
878    mpd_addstatus_raise(ctx, status);
879}
880
881void
882mpd_rescale(mpd_t *result, const mpd_t *a, mpd_ssize_t exp, mpd_context_t *ctx)
883{
884    uint32_t status = 0;
885    mpd_qrescale(result, a, exp, ctx, &status);
886    mpd_addstatus_raise(ctx, status);
887}
888
889void
890mpd_reduce(mpd_t *result, const mpd_t *a, mpd_context_t *ctx)
891{
892    uint32_t status = 0;
893    mpd_qreduce(result, a, ctx, &status);
894    mpd_addstatus_raise(ctx, status);
895}
896
897void
898mpd_rem(mpd_t *r, const mpd_t *a, const mpd_t *b, mpd_context_t *ctx)
899{
900    uint32_t status = 0;
901    mpd_qrem(r, a, b, ctx, &status);
902    mpd_addstatus_raise(ctx, status);
903}
904
905void
906mpd_rem_near(mpd_t *r, const mpd_t *a, const mpd_t *b, mpd_context_t *ctx)
907{
908    uint32_t status = 0;
909    mpd_qrem_near(r, a, b, ctx, &status);
910    mpd_addstatus_raise(ctx, status);
911}
912
913void
914mpd_round_to_intx(mpd_t *result, const mpd_t *a, mpd_context_t *ctx)
915{
916    uint32_t status = 0;
917    mpd_qround_to_intx(result, a, ctx, &status);
918    mpd_addstatus_raise(ctx, status);
919}
920
921void
922mpd_round_to_int(mpd_t *result, const mpd_t *a, mpd_context_t *ctx)
923{
924    uint32_t status = 0;
925    mpd_qround_to_int(result, a, ctx, &status);
926    mpd_addstatus_raise(ctx, status);
927}
928
929void
930mpd_trunc(mpd_t *result, const mpd_t *a, mpd_context_t *ctx)
931{
932    uint32_t status = 0;
933    mpd_qtrunc(result, a, ctx, &status);
934    mpd_addstatus_raise(ctx, status);
935}
936
937void
938mpd_floor(mpd_t *result, const mpd_t *a, mpd_context_t *ctx)
939{
940    uint32_t status = 0;
941    mpd_qfloor(result, a, ctx, &status);
942    mpd_addstatus_raise(ctx, status);
943}
944
945void
946mpd_ceil(mpd_t *result, const mpd_t *a, mpd_context_t *ctx)
947{
948    uint32_t status = 0;
949    mpd_qceil(result, a, ctx, &status);
950    mpd_addstatus_raise(ctx, status);
951}
952
953void
954mpd_sqrt(mpd_t *result, const mpd_t *a, mpd_context_t *ctx)
955{
956    uint32_t status = 0;
957    mpd_qsqrt(result, a, ctx, &status);
958    mpd_addstatus_raise(ctx, status);
959}
960
961void
962mpd_invroot(mpd_t *result, const mpd_t *a, mpd_context_t *ctx)
963{
964    uint32_t status = 0;
965    mpd_qinvroot(result, a, ctx, &status);
966    mpd_addstatus_raise(ctx, status);
967}
968