decimal 2.1.0

Decimal floating point arithmetic for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

/* ------------------------------------------------------------------ */
/* decQuad.c -- decQuad operations module                             */
/* ------------------------------------------------------------------ */
/* Copyright (c) IBM Corporation, 2000, 2010.  All rights reserved.   */
/*                                                                    */
/* This software is made available under the terms of the             */
/* ICU License -- ICU 1.8.1 and later.                                */
/*                                                                    */
/* The description and User's Guide ("The decNumber C Library") for   */
/* this software is included in the package as decNumber.pdf.  This   */
/* document is also available in HTML, together with specifications,  */
/* testcases, and Web links, on the General Decimal Arithmetic page.  */
/*                                                                    */
/* Please send comments, suggestions, and corrections to the author:  */
/*   mfc@uk.ibm.com                                                   */
/*   Mike Cowlishaw, IBM Fellow                                       */
/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
/* ------------------------------------------------------------------ */
/* This module comprises decQuad operations (including conversions)   */
/* ------------------------------------------------------------------ */


/* Constant mappings for shared code */
#define DECPMAX     DECQUAD_Pmax

#define DECEMIN     DECQUAD_Emin

#define DECEMAX     DECQUAD_Emax

#define DECEMAXD    DECQUAD_EmaxD

#define DECBYTES    DECQUAD_Bytes

#define DECSTRING   DECQUAD_String

#define DECECONL    DECQUAD_EconL

#define DECBIAS     DECQUAD_Bias

#define DECLETS     DECQUAD_Declets

#define DECQTINY   (-DECQUAD_Bias)


/* Type and function mappings for shared code */
#define decFloat                   decQuad        // Type name


// Utilities and conversions (binary results, extractors, etc.)
#define decFloatFromBCD            decQuadFromBCD

#define decFloatFromInt32          decQuadFromInt32

#define decFloatFromPacked         decQuadFromPacked

#define decFloatFromPackedChecked  decQuadFromPackedChecked

#define decFloatFromString         decQuadFromString

#define decFloatFromUInt32         decQuadFromUInt32

#define decFloatFromWider          decQuadFromWider

#define decFloatGetCoefficient     decQuadGetCoefficient

#define decFloatGetExponent        decQuadGetExponent

#define decFloatSetCoefficient     decQuadSetCoefficient

#define decFloatSetExponent        decQuadSetExponent

#define decFloatShow               decQuadShow

#define decFloatToBCD              decQuadToBCD

#define decFloatToEngString        decQuadToEngString

#define decFloatToInt32            decQuadToInt32

#define decFloatToInt32Exact       decQuadToInt32Exact

#define decFloatToPacked           decQuadToPacked

#define decFloatToString           decQuadToString

#define decFloatToUInt32           decQuadToUInt32

#define decFloatToUInt32Exact      decQuadToUInt32Exact

#define decFloatToWider            decQuadToWider

#define decFloatZero               decQuadZero


// Computational (result is a decFloat)
#define decFloatAbs                decQuadAbs

#define decFloatAdd                decQuadAdd

#define decFloatAnd                decQuadAnd

#define decFloatDivide             decQuadDivide

#define decFloatDivideInteger      decQuadDivideInteger

#define decFloatFMA                decQuadFMA

#define decFloatInvert             decQuadInvert

#define decFloatLogB               decQuadLogB

#define decFloatMax                decQuadMax

#define decFloatMaxMag             decQuadMaxMag

#define decFloatMin                decQuadMin

#define decFloatMinMag             decQuadMinMag

#define decFloatMinus              decQuadMinus

#define decFloatMultiply           decQuadMultiply

#define decFloatNextMinus          decQuadNextMinus

#define decFloatNextPlus           decQuadNextPlus

#define decFloatNextToward         decQuadNextToward

#define decFloatOr                 decQuadOr

#define decFloatPlus               decQuadPlus

#define decFloatQuantize           decQuadQuantize

#define decFloatReduce             decQuadReduce

#define decFloatRemainder          decQuadRemainder

#define decFloatRemainderNear      decQuadRemainderNear

#define decFloatRotate             decQuadRotate

#define decFloatScaleB             decQuadScaleB

#define decFloatShift              decQuadShift

#define decFloatSubtract           decQuadSubtract

#define decFloatToIntegralValue    decQuadToIntegralValue

#define decFloatToIntegralExact    decQuadToIntegralExact

#define decFloatXor                decQuadXor


// Comparisons
#define decFloatCompare            decQuadCompare

#define decFloatCompareSignal      decQuadCompareSignal

#define decFloatCompareTotal       decQuadCompareTotal

#define decFloatCompareTotalMag    decQuadCompareTotalMag


// Copies
#define decFloatCanonical          decQuadCanonical

#define decFloatCopy               decQuadCopy

#define decFloatCopyAbs            decQuadCopyAbs

#define decFloatCopyNegate         decQuadCopyNegate

#define decFloatCopySign           decQuadCopySign


// Non-computational
#define decFloatClass              decQuadClass

#define decFloatClassString        decQuadClassString

#define decFloatDigits             decQuadDigits

#define decFloatIsCanonical        decQuadIsCanonical

#define decFloatIsFinite           decQuadIsFinite

#define decFloatIsInfinite         decQuadIsInfinite

#define decFloatIsInteger          decQuadIsInteger

#define decFloatIsLogical          decQuadIsLogical

#define decFloatIsNaN              decQuadIsNaN

#define decFloatIsNegative         decQuadIsNegative

#define decFloatIsNormal           decQuadIsNormal

#define decFloatIsPositive         decQuadIsPositive

#define decFloatIsSignaling        decQuadIsSignaling

#define decFloatIsSignalling       decQuadIsSignalling

#define decFloatIsSigned           decQuadIsSigned

#define decFloatIsSubnormal        decQuadIsSubnormal

#define decFloatIsZero             decQuadIsZero

#define decFloatRadix              decQuadRadix

#define decFloatSameQuantum        decQuadSameQuantum

#define decFloatVersion            decQuadVersion


/* And now the code itself */
#include "decContext.h"       // public includes

#include "decQuad.h"          // ..

#include "decNumberLocal.h"   // local includes (need DECPMAX)

#include "decCommon.c"        // non-arithmetic decFloat routines

#include "decBasic.c"         // basic formats routines