Line data Source code
1 : /* Simple multiprecision - small MP library for testing
2 : * Copyright (C) 2022-2024 Frediano Ziglio
3 : *
4 : * This library is free software; you can redistribute it and/or
5 : * modify it under the terms of the GNU Library General Public
6 : * License as published by the Free Software Foundation; either
7 : * version 2 of the License, or (at your option) any later version.
8 : *
9 : * This library is distributed in the hope that it will be useful,
10 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 : * Library General Public License for more details.
13 : *
14 : * You should have received a copy of the GNU Library General Public
15 : * License along with this library; if not, write to the
16 : * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 : * Boston, MA 02111-1307, USA.
18 : */
19 :
20 : #undef NDEBUG
21 : #include <config.h>
22 :
23 : #include <assert.h>
24 : #include <string.h>
25 :
26 : #include <freetds/utils/smp.h>
27 : #include <freetds/sysdep_private.h>
28 :
29 : #define SMP_NUM_COMPONENTS \
30 : (sizeof(((smp*)0)->comp) / sizeof(((smp*)0)->comp[0]))
31 :
32 : const smp smp_zero = {
33 : { 0, 0, 0, 0, 0, 0, 0, 0 },
34 : };
35 :
36 : const smp smp_one = {
37 : { 1, 0, 0, 0, 0, 0, 0, 0 },
38 : };
39 :
40 : smp
41 8268590 : smp_add(smp a, smp b)
42 : {
43 : size_t i;
44 8268590 : uint32_t carry = 0;
45 : smp res;
46 :
47 74417310 : for (i = 0; i < SMP_NUM_COMPONENTS; ++i) {
48 66148720 : uint32_t sum = carry + a.comp[i] + b.comp[i];
49 66148720 : res.comp[i] = (uint16_t) (sum & 0xffffu);
50 66148720 : carry = sum >> 16;
51 : }
52 8268590 : assert(smp_is_negative(a) != smp_is_negative(b) || smp_is_negative(a) == smp_is_negative(res));
53 8268590 : return res;
54 : }
55 :
56 : smp
57 1099010 : smp_not(smp a)
58 : {
59 : size_t i;
60 : smp res;
61 9891090 : for (i = 0; i < SMP_NUM_COMPONENTS; ++i)
62 8792080 : res.comp[i] = a.comp[i] ^ 0xffffu;
63 1099010 : return res;
64 : }
65 :
66 : smp
67 1099010 : smp_negate(smp a)
68 : {
69 1099010 : return smp_add(smp_not(a), smp_one);
70 : }
71 :
72 : smp
73 2006740 : smp_from_int(int64_t n)
74 : {
75 : size_t i;
76 : uint64_t un;
77 : smp res;
78 :
79 2006740 : if (n >= 0) {
80 1593710 : un = (uint64_t) n;
81 : } else {
82 413030 : un = (uint64_t) -n;
83 : }
84 16053920 : for (i = 0; i < SMP_NUM_COMPONENTS; ++i) {
85 16053920 : res.comp[i] = (uint16_t) (un & 0xffffu);
86 16053920 : un = un >> 16;
87 : }
88 2006740 : if (n < 0)
89 413030 : return smp_negate(res);
90 1593710 : return res;
91 : }
92 :
93 : bool
94 32378440 : smp_is_negative(smp a)
95 : {
96 32378440 : return (a.comp[SMP_NUM_COMPONENTS-1] >> 15) != 0;
97 : }
98 :
99 : bool
100 9149980 : smp_is_zero(smp a)
101 : {
102 : size_t i;
103 9149980 : uint16_t or = 0;
104 :
105 82349820 : for (i = 0; i < SMP_NUM_COMPONENTS; ++i)
106 73199840 : or |= a.comp[i];
107 9149980 : return or == 0;
108 : }
109 :
110 : smp
111 540 : smp_sub(smp a, smp b)
112 : {
113 540 : smp c = smp_negate(b);
114 540 : return smp_add(a, c);
115 : }
116 :
117 : double
118 127820 : smp_to_double(smp a)
119 : {
120 : size_t i;
121 127820 : double n = 0;
122 127820 : double mult = 1.0;
123 127820 : smp b = a;
124 127820 : if (smp_is_negative(a))
125 63780 : b = smp_negate(b);
126 1150380 : for (i = 0; i < SMP_NUM_COMPONENTS; ++i) {
127 1022560 : n += b.comp[i] * mult;
128 1022560 : mult = mult * 65536.0;
129 : }
130 127820 : if (smp_is_negative(a))
131 63780 : return -n;
132 : return n;
133 : }
134 :
135 : int
136 30 : smp_cmp(smp a, smp b)
137 : {
138 30 : smp diff = smp_sub(a, b);
139 30 : if (smp_is_negative(diff))
140 : return -1;
141 20 : if (smp_is_zero(diff))
142 : return 0;
143 10 : return 1;
144 : }
145 :
146 : // divide and return remainder
147 : static uint16_t
148 : div_small(smp *n, uint16_t div)
149 : {
150 : size_t i;
151 9114670 : uint32_t remainder = 0;
152 91146700 : for (i = SMP_NUM_COMPONENTS; i > 0;) {
153 72917360 : uint32_t comp = remainder * 0x10000u + n->comp[--i];
154 72917360 : remainder = comp % div;
155 72917360 : n->comp[i] = (uint16_t) (comp / div);
156 : }
157 : return (uint16_t) remainder;
158 : }
159 :
160 : char *
161 993830 : smp_to_string(smp a)
162 : {
163 : char buf[SMP_NUM_COMPONENTS * 16 * 4 / 10 + 2];
164 993830 : char *p = buf+sizeof(buf);
165 993830 : const bool negative = smp_is_negative(a);
166 993830 : smp n = negative ? smp_negate(a) : a;
167 :
168 993830 : *--p = 0;
169 : do
170 9114670 : *--p = (char) div_small(&n, 10) + '0';
171 9114670 : while (!smp_is_zero(n));
172 993830 : if (negative)
173 495630 : *--p = '-';
174 993830 : return strdup(p);
175 : }
176 :
177 : // multiple a number
178 : static void
179 1135980 : mul_small(smp *n, uint16_t factor)
180 : {
181 : size_t i;
182 1135980 : uint32_t carry = 0;
183 10223820 : for (i = 0; i < SMP_NUM_COMPONENTS; ++i) {
184 9087840 : uint32_t comp = (uint32_t) n->comp[i] * factor + carry;
185 9087840 : carry = comp >> 16;
186 9087840 : n->comp[i] = (uint16_t) (comp & 0xffffu);
187 : }
188 1135980 : assert(carry == 0);
189 1135980 : }
190 :
191 : smp
192 123590 : smp_from_string(const char *s)
193 : {
194 123590 : bool negative = false;
195 123590 : smp n = smp_zero;
196 123590 : uint16_t base = 10;
197 :
198 123590 : switch (*s) {
199 61600 : case '-':
200 61600 : negative = true;
201 61600 : case '+':
202 61600 : ++s;
203 : }
204 123590 : if (*s == '0') {
205 350 : base = 8;
206 350 : ++s;
207 350 : if (*s == 'x' || *s == 'X') {
208 60 : ++s;
209 60 : base = 16;
210 : }
211 : }
212 1136090 : for (;*s; ++s) {
213 1136090 : int digit = 0;
214 1136090 : if (*s == '\'')
215 110 : continue;
216 1135980 : mul_small(&n, base);
217 1135980 : if (*s >= '0' && *s <= '9')
218 1135980 : digit = *s - '0';
219 0 : else if (*s >= 'a' && *s <= 'z')
220 0 : digit = *s - 'a' + 10;
221 0 : else if (*s >= 'A' && *s <= 'Z')
222 0 : digit = *s - 'A' + 10;
223 : else
224 : assert(!!"Invalid digit entered");
225 1135980 : n = smp_add(n, smp_from_int(digit));
226 : }
227 123590 : if (negative)
228 61600 : return smp_negate(n);
229 61990 : return n;
230 : }
|
