6 #include "cln/number.h"
7 #include "cln/lfloat_class.h"
8 #include "cln/integer_class.h"
12 struct cl_heap_lfloat : cl_heap {
13 unsigned int len; // length of mantissa (in digits)
14 int sign; // sign (0 or -1)
15 uint32 expo; // exponent
16 uintD data[1]; // mantissa
19 // Minimum number of mantissa digits,
20 // so that a LF has not fewer mantissa bits than a DF.
21 #define LF_minlen ceiling(53,intDsize)
23 // Define as 'unsigned int', not 'unsigned long', so that
24 // LF_exp_high+1 wraps around to 0 just like the 'expo' field does.
26 #define LF_exp_mid 0x80000000U
27 #define LF_exp_high 0xFFFFFFFFU
29 inline cl_heap_lfloat* TheLfloat (cl_heap_lfloat* p)
31 inline cl_heap_lfloat* TheLfloat (const cl_number& obj)
32 { return (cl_heap_lfloat*)(obj.pointer); }
35 // Liefert zu einem Long-Float x : (futruncate x), ein LF.
36 // x wird von der 0 weg zur nächsten ganzen Zahl gerundet.
37 extern const cl_LF futruncate (const cl_LF& x);
39 // shorten(x,len) verkürzt ein Long-Float x auf gegebene Länge len
41 // > cl_LF x: ein Long-FLoat
42 // > uintC len: gewünschte Länge (>= LF_minlen, < TheLfloat(x)->len)
43 // < cl_LF ergebnis: verkürztes Long-Float
44 extern const cl_LF shorten (const cl_LF& x, uintC len);
46 // extend(x,len) verlängert ein Long-Float x auf gegebene Länge len.
47 // > cl_LF x: ein Long-FLoat
48 // > uintC len: gewünschte Länge (> TheLfloat(x)->len)
49 // < cl_LF ergebnis: verlängertes Long-Float
50 extern const cl_LF extend (const cl_LF& x, uintC len);
52 // LF_to_LF(x,len) wandelt ein Long-Float x in ein Long-Float gegebener Länge
53 // len um und rundet dabei nötigenfalls.
54 // > cl_LF x: ein Long-FLoat
55 // > uintC len: gewünschte Länge (>= LF_minlen)
56 // < cl_LF ergebnis: Long-Float gegebener Länge
57 extern const cl_LF LF_to_LF (const cl_LF& x, uintC len);
59 // GEN_LF_OP2(arg1,arg2,LF_OP,ergebnis_zuweisung)
60 // generates the body of a LF operation with two arguments.
61 // LF_OP is only executed once both arguments have been converted to the same
62 // float format (the longer one of arg1 and arg2). The result is then
63 // converted the shorter of the two float formats.
64 #define GEN_LF_OP2(arg1,arg2,LF_OP,ergebnis_zuweisung) \
66 var uintC len1 = TheLfloat(arg1)->len; \
67 var uintC len2 = TheLfloat(arg2)->len; \
68 if (len1==len2) /* gleich -> direkt ausführen */ \
69 return LF_OP(arg1,arg2); \
70 elif (len1>len2) /* -> arg2 auf die Länge von arg1 bringen */ \
71 return shorten(LF_OP(arg1,extend(arg2,len1)),len2); \
72 else /* (len1<len2) -> arg1 auf die Länge von arg2 bringen */ \
73 return shorten(LF_OP(extend(arg1,len2),arg2),len1); \
76 // Liefert zu zwei gleichlangen Long-Float x und y : (+ x y), ein LF.
78 extern const cl_LF LF_LF_plus_LF (const cl_LF& x, const cl_LF& y);
80 // Liefert zu zwei gleichlangen Long-Float x und y : (- x y), ein LF.
82 extern const cl_LF LF_LF_minus_LF (const cl_LF& x, const cl_LF& y);
84 // Use this macro if ALL of your cl_LF operations (+, -, *, /) in the
85 // rest of your file ALWAYS get two operands of the same precision.
86 #define ALL_cl_LF_OPERATIONS_SAME_PRECISION() \
88 inline const cl_LF operator+ (const cl_LF& x, const cl_LF& y) \
90 return LF_LF_plus_LF(x,y); \
93 inline const cl_LF operator- (const cl_LF& x, const cl_LF& y) \
95 return LF_LF_minus_LF(x,y); \
98 // LF_to_I(x) wandelt ein Long-Float x, das eine ganze Zahl darstellt,
100 extern const cl_I cl_LF_to_I (const cl_LF& x);
102 // cl_I_to_LF(x,len) wandelt ein Integer x in ein Long-Float um und rundet dabei.
103 extern const cl_LF cl_I_to_LF (const cl_I& x, uintC len);
105 // cl_RA_to_LF(x,len) wandelt eine rationale Zahl x in ein Long-Float um
107 extern const cl_LF cl_RA_to_LF (const cl_RA& x, uintC len);
109 // cl_LF_I_mul(x,y) multipliziert ein Long-Float x und ein Integer y.
110 extern const cl_R cl_LF_I_mul (const cl_LF& x, const cl_I& y);
112 // cl_LF_I_div(x,y) dividiert ein Long-Float x durch ein Integer y.
113 extern const cl_LF cl_LF_I_div (const cl_LF& x, const cl_I& y);
115 // cl_I_LF_div(x,y) dividiert ein Integer x durch ein Long-Float y.
116 extern const cl_R cl_I_LF_div (const cl_I& x, const cl_LF& y);
118 // cl_LF_RA_mul(x,y) multipliziert ein Long-Float x und eine rationale Zahl y.
119 extern const cl_R cl_LF_RA_mul (const cl_LF& x, const cl_RA& y);
121 // cl_LF_RA_div(x,y) dividiert ein Long-Float x durch eine rationale Zahl y.
122 extern const cl_LF cl_LF_RA_div (const cl_LF& x, const cl_RA& y);
124 // cl_RA_LF_div(x,y) dividiert eine rationale Zahl x durch ein Long-Float y.
125 extern const cl_R cl_RA_LF_div (const cl_RA& x, const cl_LF& y);
127 // Vergrößert eine Long-Float-Länge n, so daß aus d = intDsize*n
128 // mindestens d+sqrt(d)+2 wird.
129 extern uintC cl_LF_len_incsqrt (uintC len);
131 // Vergrößert eine Long-Float-Länge n, so daß aus d = intDsize*n
132 // mindestens d+sqrt(d)+2+(LF_exp_len-1) wird.
133 extern uintC cl_LF_len_incsqrtx (uintC len);
135 // cl_LF_shortenrelative(x,y) tries to reduce the size of x, such that one
136 // wouldn't notice it when adding x to y. y must be /= 0. More precisely,
137 // this returns a float approximation of x, such that 1 ulp(x) < 1 ulp(y).
138 extern const cl_LF cl_LF_shortenrelative (const cl_LF& x, const cl_LF& y);
140 // cl_LF_shortenwith(x,y) tries to reduce the size of x, such that still
141 // 1 ulp(x) < y. y must be >0.
142 extern const cl_LF cl_LF_shortenwith (const cl_LF& x, const cl_LF& y);
146 #endif /* _CL_LF_H */