Coverage Report

Created: 2024-11-21 07:03

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