Terraria v1.4.4.9
Terraria source code documentation
Loading...
Searching...
No Matches
XPathConvert.cs
Go to the documentation of this file.
1using System.Globalization;
2using System.Runtime.CompilerServices;
3
4namespace System.Xml.Xsl;
5
6internal static class XPathConvert
7{
8 private struct BigNumber
9 {
10 private uint _u0;
11
12 private uint _u1;
13
14 private uint _u2;
15
16 private int _exp;
17
18 private uint _error;
19
20 private static readonly BigNumber[] s_tenPowersPos = new BigNumber[46]
21 {
22 new BigNumber(0u, 0u, 2684354560u, 4, 0u),
23 new BigNumber(0u, 0u, 3355443200u, 7, 0u),
24 new BigNumber(0u, 0u, 4194304000u, 10, 0u),
25 new BigNumber(0u, 0u, 2621440000u, 14, 0u),
26 new BigNumber(0u, 0u, 3276800000u, 17, 0u),
27 new BigNumber(0u, 0u, 4096000000u, 20, 0u),
28 new BigNumber(0u, 0u, 2560000000u, 24, 0u),
29 new BigNumber(0u, 0u, 3200000000u, 27, 0u),
30 new BigNumber(0u, 0u, 4000000000u, 30, 0u),
31 new BigNumber(0u, 0u, 2500000000u, 34, 0u),
32 new BigNumber(0u, 0u, 3125000000u, 37, 0u),
33 new BigNumber(0u, 0u, 3906250000u, 40, 0u),
34 new BigNumber(0u, 0u, 2441406250u, 44, 0u),
35 new BigNumber(0u, 2147483648u, 3051757812u, 47, 0u),
36 new BigNumber(0u, 2684354560u, 3814697265u, 50, 0u),
37 new BigNumber(0u, 67108864u, 2384185791u, 54, 0u),
38 new BigNumber(0u, 3305111552u, 2980232238u, 57, 0u),
39 new BigNumber(0u, 1983905792u, 3725290298u, 60, 0u),
40 new BigNumber(0u, 2313682944u, 2328306436u, 64, 0u),
41 new BigNumber(0u, 2892103680u, 2910383045u, 67, 0u),
42 new BigNumber(0u, 393904128u, 3637978807u, 70, 0u),
43 new BigNumber(0u, 1856802816u, 2273736754u, 74, 0u),
44 new BigNumber(0u, 173519872u, 2842170943u, 77, 0u),
45 new BigNumber(0u, 3438125312u, 3552713678u, 80, 0u),
46 new BigNumber(0u, 1075086496u, 2220446049u, 84, 0u),
47 new BigNumber(0u, 2417599944u, 2775557561u, 87, 0u),
48 new BigNumber(0u, 4095741754u, 3469446951u, 90, 0u),
49 new BigNumber(1073741824u, 4170451332u, 2168404344u, 94, 0u),
50 new BigNumber(1342177280u, 918096869u, 2710505431u, 97, 0u),
51 new BigNumber(2751463424u, 73879262u, 3388131789u, 100, 0u),
52 new BigNumber(1291845632u, 1166090902u, 4235164736u, 103, 0u),
53 new BigNumber(4028628992u, 728806813u, 2646977960u, 107, 0u),
54 new BigNumber(1019177842u, 4291798741u, 3262652233u, 213, 1u),
55 new BigNumber(3318737231u, 3315274914u, 4021529366u, 319, 1u),
56 new BigNumber(3329176428u, 2162789599u, 2478458825u, 426, 1u),
57 new BigNumber(1467717739u, 2145785770u, 3054936363u, 532, 1u),
58 new BigNumber(2243682900u, 958879082u, 3765499789u, 638, 1u),
59 new BigNumber(2193451889u, 3812411695u, 2320668415u, 745, 1u),
60 new BigNumber(3720056860u, 2650398349u, 2860444667u, 851, 1u),
61 new BigNumber(1937977068u, 1550462860u, 3525770265u, 957, 1u),
62 new BigNumber(3869316483u, 4073513845u, 2172923689u, 1064, 1u),
63 new BigNumber(1589582007u, 3683650258u, 2678335232u, 1170, 1u),
64 new BigNumber(271056885u, 2935532055u, 3301303056u, 1276, 1u),
65 new BigNumber(3051704177u, 3920665688u, 4069170183u, 1382, 1u),
66 new BigNumber(2817170568u, 3958895571u, 2507819745u, 1489, 1u),
67 new BigNumber(2113145460u, 127246946u, 3091126492u, 1595, 1u)
68 };
69
70 private static readonly BigNumber[] s_tenPowersNeg = new BigNumber[46]
71 {
72 new BigNumber(3435973837u, 3435973836u, 3435973836u, -3, 1u),
73 new BigNumber(1030792151u, 1889785610u, 2748779069u, -6, 1u),
74 new BigNumber(1683627180u, 2370821947u, 2199023255u, -9, 1u),
75 new BigNumber(3552796947u, 3793315115u, 3518437208u, -13, 1u),
76 new BigNumber(265257180u, 457671715u, 2814749767u, -16, 1u),
77 new BigNumber(2789186122u, 2943117749u, 2251799813u, -19, 1u),
78 new BigNumber(1026723958u, 3849994940u, 3602879701u, -23, 1u),
79 new BigNumber(4257353003u, 2221002492u, 2882303761u, -26, 1u),
80 new BigNumber(828902025u, 917808535u, 2305843009u, -29, 1u),
81 new BigNumber(3044230158u, 3186480574u, 3689348814u, -33, 1u),
82 new BigNumber(4153371045u, 3408177918u, 2951479051u, -36, 1u),
83 new BigNumber(4181690295u, 1867548875u, 2361183241u, -39, 1u),
84 new BigNumber(677750258u, 1270091283u, 3777893186u, -43, 1u),
85 new BigNumber(1401193666u, 157079567u, 3022314549u, -46, 1u),
86 new BigNumber(261961473u, 984657113u, 2417851639u, -49, 1u),
87 new BigNumber(1278131816u, 3293438299u, 3868562622u, -53, 1u),
88 new BigNumber(163511994u, 916763721u, 3094850098u, -56, 1u),
89 new BigNumber(989803054u, 2451397895u, 2475880078u, -59, 1u),
90 new BigNumber(724691428u, 3063243173u, 3961408125u, -63, 1u),
91 new BigNumber(2297740061u, 2450594538u, 3169126500u, -66, 1u),
92 new BigNumber(3556178967u, 1960475630u, 2535301200u, -69, 1u),
93 new BigNumber(1394919051u, 3136761009u, 4056481920u, -73, 1u),
94 new BigNumber(1974928700u, 2509408807u, 3245185536u, -76, 1u),
95 new BigNumber(3297929878u, 1148533586u, 2596148429u, -79, 1u),
96 new BigNumber(981720510u, 3555640657u, 4153837486u, -83, 1u),
97 new BigNumber(2503363326u, 1985519066u, 3323069989u, -86, 1u),
98 new BigNumber(2002690661u, 2447408712u, 2658455991u, -89, 1u),
99 new BigNumber(2345311598u, 2197867021u, 4253529586u, -93, 1u),
100 new BigNumber(158262360u, 899300158u, 3402823669u, -96, 1u),
101 new BigNumber(2703590266u, 1578433585u, 2722258935u, -99, 1u),
102 new BigNumber(2162872213u, 1262746868u, 2177807148u, -102, 1u),
103 new BigNumber(1742608622u, 1161401530u, 3484491437u, -106, 1u),
104 new BigNumber(1059297495u, 2772036005u, 2826955303u, -212, 1u),
105 new BigNumber(299617026u, 4252324763u, 2293498615u, -318, 1u),
106 new BigNumber(2893853687u, 1690100896u, 3721414268u, -425, 1u),
107 new BigNumber(1508712807u, 3681788051u, 3019169939u, -531, 1u),
108 new BigNumber(2070087331u, 1411632134u, 2449441655u, -637, 1u),
109 new BigNumber(2767765334u, 1244745405u, 3974446316u, -744, 1u),
110 new BigNumber(4203811158u, 1668946233u, 3224453925u, -850, 1u),
111 new BigNumber(1323526137u, 2204812663u, 2615987810u, -956, 1u),
112 new BigNumber(2300620953u, 1199716560u, 4244682903u, -1063, 1u),
113 new BigNumber(9598332u, 1190350717u, 3443695891u, -1169, 1u),
114 new BigNumber(2296094720u, 2971338839u, 2793858024u, -1275, 1u),
115 new BigNumber(441364487u, 1073506470u, 2266646913u, -1381, 1u),
116 new BigNumber(2227594191u, 3053929028u, 3677844889u, -1488, 1u),
117 new BigNumber(1642812130u, 2030073654u, 2983822260u, -1594, 1u)
118 };
119
120 public uint Error => _error;
121
122 private bool IsZero
123 {
124 get
125 {
126 if (_u2 == 0 && _u1 == 0)
127 {
128 return _u0 == 0;
129 }
130 return false;
131 }
132 }
133
134 public BigNumber(uint u0, uint u1, uint u2, int exp, uint error)
135 {
136 _u0 = u0;
137 _u1 = u1;
138 _u2 = u2;
139 _exp = exp;
140 _error = error;
141 }
142
143 public BigNumber(FloatingDecimal dec)
144 {
145 int num = 0;
146 int exponent = dec.Exponent;
147 int mantissaSize = dec.MantissaSize;
148 _u2 = (uint)(dec[num] << 28);
149 _u1 = 0u;
150 _u0 = 0u;
151 _exp = 4;
152 _error = 0u;
153 exponent--;
154 Normalize();
155 while (++num < mantissaSize)
156 {
157 uint num2 = MulTenAdd(dec[num]);
158 exponent--;
159 if (num2 != 0)
160 {
161 Round(num2);
162 if (num < mantissaSize - 1)
163 {
164 _error++;
165 }
166 break;
167 }
168 }
169 if (exponent != 0)
170 {
171 BigNumber[] array;
172 if (exponent < 0)
173 {
174 array = s_tenPowersNeg;
175 exponent = -exponent;
176 }
177 else
178 {
179 array = s_tenPowersPos;
180 }
181 int num3 = exponent & 0x1F;
182 if (num3 > 0)
183 {
184 Mul(ref array[num3 - 1]);
185 }
186 num3 = (exponent >> 5) & 0xF;
187 if (num3 > 0)
188 {
189 Mul(ref array[num3 + 30]);
190 }
191 }
192 }
193
194 private unsafe uint MulTenAdd(uint digit)
195 {
196 _exp += 3;
197 uint* ptr = stackalloc uint[5];
198 for (int i = 0; i < 5; i++)
199 {
200 ptr[i] = 0u;
201 }
202 if (digit != 0)
203 {
204 int num = 3 - (_exp >> 5);
205 if (num < 0)
206 {
207 *ptr = 1u;
208 }
209 else
210 {
211 int num2 = _exp & 0x1F;
212 if (num2 < 4)
213 {
214 ptr[num + 1] = digit >> num2;
215 if (num2 > 0)
216 {
217 ptr[num] = digit << 32 - num2;
218 }
219 }
220 else
221 {
222 ptr[num] = digit << 32 - num2;
223 }
224 }
225 }
226 ptr[1] += AddU(ref *ptr, _u0 << 30);
227 ptr[2] += AddU(ref _u0, (_u0 >> 2) + (_u1 << 30));
228 if (ptr[1] != 0)
229 {
230 ptr[2] += AddU(ref _u0, ptr[1]);
231 }
232 ptr[3] += AddU(ref _u1, (_u1 >> 2) + (_u2 << 30));
233 if (ptr[2] != 0)
234 {
235 ptr[3] += AddU(ref _u1, ptr[2]);
236 }
237 ptr[4] = AddU(ref _u2, (_u2 >> 2) + ptr[3]);
238 if (ptr[4] != 0)
239 {
240 *ptr = (*ptr >> 1) | (*ptr & 1u) | (_u0 << 31);
241 _u0 = (_u0 >> 1) | (_u1 << 31);
242 _u1 = (_u1 >> 1) | (_u2 << 31);
243 _u2 = (_u2 >> 1) | 0x80000000u;
244 _exp++;
245 }
246 return *ptr;
247 }
248
249 private void Round(uint uExtra)
250 {
251 if ((uExtra & 0x80000000u) == 0 || ((uExtra & 0x7FFFFFFF) == 0 && (_u0 & 1) == 0))
252 {
253 if (uExtra != 0)
254 {
255 _error++;
256 }
257 return;
258 }
259 _error++;
260 if (AddU(ref _u0, 1u) != 0 && AddU(ref _u1, 1u) != 0 && AddU(ref _u2, 1u) != 0)
261 {
262 _u2 = 2147483648u;
263 _exp++;
264 }
265 }
266
267 private void Normalize()
268 {
269 if (_u2 == 0)
270 {
271 if (_u1 == 0)
272 {
273 if (_u0 == 0)
274 {
275 _exp = 0;
276 return;
277 }
278 _u2 = _u0;
279 _u0 = 0u;
280 _exp -= 64;
281 }
282 else
283 {
284 _u2 = _u1;
285 _u1 = _u0;
286 _u0 = 0u;
287 _exp -= 32;
288 }
289 }
290 int num;
291 if ((num = CbitZeroLeft(_u2)) != 0)
292 {
293 int num2 = 32 - num;
294 _u2 = (_u2 << num) | (_u1 >> num2);
295 _u1 = (_u1 << num) | (_u0 >> num2);
296 _u0 <<= num;
297 _exp -= num;
298 }
299 }
300
301 private void Mul(ref BigNumber numOp)
302 {
303 uint num = 0u;
304 uint u = 0u;
305 uint u2 = 0u;
306 uint u3 = 0u;
307 uint u4 = 0u;
308 uint u5 = 0u;
309 uint uHi;
310 uint u6;
311 uint num2;
312 uint num3;
313 if ((u6 = _u0) != 0)
314 {
315 num2 = MulU(u6, numOp._u0, out uHi);
316 num = num2;
317 u = uHi;
318 num2 = MulU(u6, numOp._u1, out uHi);
319 num3 = AddU(ref u, num2);
320 AddU(ref u2, uHi + num3);
321 num2 = MulU(u6, numOp._u2, out uHi);
322 num3 = AddU(ref u2, num2);
323 AddU(ref u3, uHi + num3);
324 }
325 if ((u6 = _u1) != 0)
326 {
327 num2 = MulU(u6, numOp._u0, out uHi);
328 num3 = AddU(ref u, num2);
329 if (AddU(ref u2, uHi + num3) != 0 && AddU(ref u3, 1u) != 0)
330 {
331 AddU(ref u4, 1u);
332 }
333 num2 = MulU(u6, numOp._u1, out uHi);
334 num3 = AddU(ref u2, num2);
335 if (AddU(ref u3, uHi + num3) != 0)
336 {
337 AddU(ref u4, 1u);
338 }
339 num2 = MulU(u6, numOp._u2, out uHi);
340 num3 = AddU(ref u3, num2);
341 AddU(ref u4, uHi + num3);
342 }
343 u6 = _u2;
344 num2 = MulU(u6, numOp._u0, out uHi);
345 num3 = AddU(ref u2, num2);
346 if (AddU(ref u3, uHi + num3) != 0 && AddU(ref u4, 1u) != 0)
347 {
348 AddU(ref u5, 1u);
349 }
350 num2 = MulU(u6, numOp._u1, out uHi);
351 num3 = AddU(ref u3, num2);
352 if (AddU(ref u4, uHi + num3) != 0)
353 {
354 AddU(ref u5, 1u);
355 }
356 num2 = MulU(u6, numOp._u2, out uHi);
357 num3 = AddU(ref u4, num2);
358 AddU(ref u5, uHi + num3);
359 _exp += numOp._exp;
360 _error += numOp._error;
361 if ((u5 & 0x80000000u) == 0)
362 {
363 if ((u2 & 0x40000000u) != 0 && ((u2 & 0xBFFFFFFFu) != 0 || u != 0 || num != 0) && AddU(ref u2, 1073741824u) != 0 && AddU(ref u3, 1u) != 0 && AddU(ref u4, 1u) != 0)
364 {
365 AddU(ref u5, 1u);
366 if ((u5 & 0x80000000u) != 0)
367 {
368 goto IL_0314;
369 }
370 }
371 _u2 = (u5 << 1) | (u4 >> 31);
372 _u1 = (u4 << 1) | (u3 >> 31);
373 _u0 = (u3 << 1) | (u2 >> 31);
374 _exp--;
375 _error <<= 1;
376 if ((u2 & 0x7FFFFFFFu) != 0 || u != 0 || num != 0)
377 {
378 _error++;
379 }
380 return;
381 }
382 if ((u2 & 0x80000000u) != 0 && ((u3 & (true ? 1u : 0u)) != 0 || (u2 & 0x7FFFFFFFu) != 0 || u != 0 || num != 0) && AddU(ref u3, 1u) != 0 && AddU(ref u4, 1u) != 0 && AddU(ref u5, 1u) != 0)
383 {
384 u5 = 2147483648u;
385 _exp++;
386 }
387 goto IL_0314;
388 IL_0314:
389 _u2 = u5;
390 _u1 = u4;
391 _u0 = u3;
392 if (u2 != 0 || u != 0 || num != 0)
393 {
394 _error++;
395 }
396 }
397
398 public static explicit operator double(BigNumber bn)
399 {
400 int num = bn._exp + 1022;
401 if (num >= 2047)
402 {
403 return double.PositiveInfinity;
404 }
405 uint u;
406 uint u2;
407 uint num2;
408 if (num > 0)
409 {
410 u = (uint)(num << 20) | ((bn._u2 & 0x7FFFFFFF) >> 11);
411 u2 = (bn._u2 << 21) | (bn._u1 >> 11);
412 num2 = (bn._u1 << 21) | NotZero(bn._u0);
413 }
414 else if (num > -20)
415 {
416 int num3 = 12 - num;
417 u = bn._u2 >> num3;
418 u2 = (bn._u2 << 32 - num3) | (bn._u1 >> num3);
419 num2 = (bn._u1 << 32 - num3) | NotZero(bn._u0);
420 }
421 else if (num == -20)
422 {
423 u = 0u;
424 u2 = bn._u2;
425 num2 = bn._u1 | ((bn._u0 != 0) ? 1u : 0u);
426 }
427 else if (num > -52)
428 {
429 int num4 = -num - 20;
430 u = 0u;
431 u2 = bn._u2 >> num4;
432 num2 = (bn._u2 << 32 - num4) | NotZero(bn._u1) | NotZero(bn._u0);
433 }
434 else
435 {
436 if (num != -52)
437 {
438 return 0.0;
439 }
440 u = 0u;
441 u2 = 0u;
442 num2 = bn._u2 | NotZero(bn._u1) | NotZero(bn._u0);
443 }
444 if ((num2 & 0x80000000u) != 0 && ((num2 & 0x7FFFFFFFu) != 0 || (u2 & (true ? 1u : 0u)) != 0) && AddU(ref u2, 1u) != 0)
445 {
446 AddU(ref u, 1u);
447 }
448 return BitConverter.UInt64BitsToDouble(((ulong)u << 32) | u2);
449 }
450
451 private uint UMod1()
452 {
453 if (_exp <= 0)
454 {
455 return 0u;
456 }
457 uint result = _u2 >> 32 - _exp;
458 _u2 &= (uint)(int.MaxValue >>> _exp - 1);
459 Normalize();
460 return result;
461 }
462
463 public void MakeUpperBound()
464 {
465 uint num = _error + 1 >> 1;
466 if (num != 0 && AddU(ref _u0, num) != 0 && AddU(ref _u1, 1u) != 0 && AddU(ref _u2, 1u) != 0)
467 {
468 _u2 = 2147483648u;
469 _u0 = (_u0 >> 1) + (_u0 & 1);
470 _exp++;
471 }
472 _error = 0u;
473 }
474
475 public void MakeLowerBound()
476 {
477 uint num = _error + 1 >> 1;
478 if (num != 0 && AddU(ref _u0, 0 - num) == 0 && AddU(ref _u1, uint.MaxValue) == 0)
479 {
480 AddU(ref _u2, uint.MaxValue);
481 if ((0x80000000u & _u2) == 0)
482 {
483 Normalize();
484 }
485 }
486 _error = 0u;
487 }
488
489 public static bool DblToRgbFast(double dbl, byte[] mantissa, out int exponent, out int mantissaSize)
490 {
491 int num = 0;
492 uint num2 = DblHi(dbl);
493 uint num3 = DblLo(dbl);
494 int num4 = (int)((num2 >> 20) & 0x7FF);
495 Unsafe.SkipInit(out BigNumber bigNumber);
496 BigNumber bigNumber2;
497 BigNumber bigNumber3;
498 int num7;
499 if (num4 > 0)
500 {
501 if (num4 >= 1023 && num4 <= 1075 && dbl == Math.Floor(dbl))
502 {
503 double num5 = dbl;
504 int num6 = 0;
505 if (num5 >= C10toN[num6 + 8])
506 {
507 num6 += 8;
508 }
509 if (num5 >= C10toN[num6 + 4])
510 {
511 num6 += 4;
512 }
513 if (num5 >= C10toN[num6 + 2])
514 {
515 num6 += 2;
516 }
517 if (num5 >= C10toN[num6 + 1])
518 {
519 num6++;
520 }
521 exponent = num6 + 1;
522 num7 = 0;
523 while (0.0 != num5)
524 {
525 byte b = (byte)(num5 / C10toN[num6]);
526 num5 -= (double)(int)b * C10toN[num6];
527 mantissa[num7++] = b;
528 num6--;
529 }
530 mantissaSize = num7;
531 goto IL_05a9;
532 }
533 bigNumber._u2 = 0x80000000u | ((num2 & 0xFFFFFF) << 11) | (num3 >> 21);
534 bigNumber._u1 = num3 << 11;
535 bigNumber._u0 = 0u;
536 bigNumber._exp = num4 - 1022;
537 bigNumber._error = 0u;
538 bigNumber2 = bigNumber;
539 bigNumber2._u1 |= 1024u;
540 bigNumber3 = bigNumber;
541 if (AddU(u2: (int.MinValue != (int)bigNumber3._u2 || bigNumber3._u1 != 0) ? 4294966272u : 4294966784u, u1: ref bigNumber3._u1) == 0)
542 {
543 AddU(ref bigNumber3._u2, uint.MaxValue);
544 if ((0x80000000u & bigNumber3._u2) == 0)
545 {
546 bigNumber3.Normalize();
547 }
548 }
549 }
550 else
551 {
552 bigNumber._u2 = num2 & 0xFFFFFu;
553 bigNumber._u1 = num3;
554 bigNumber._u0 = 0u;
555 bigNumber._exp = -1010;
556 bigNumber._error = 0u;
557 bigNumber2 = bigNumber;
558 bigNumber2._u0 = 2147483648u;
559 bigNumber3 = bigNumber2;
560 if (AddU(ref bigNumber3._u1, uint.MaxValue) == 0)
561 {
562 AddU(ref bigNumber3._u2, uint.MaxValue);
563 }
564 bigNumber.Normalize();
565 bigNumber2.Normalize();
566 bigNumber3.Normalize();
567 }
568 if (bigNumber2._exp >= 32)
569 {
570 int num6 = (bigNumber2._exp - 25) * 15 / -s_tenPowersNeg[45]._exp;
571 if (num6 > 0)
572 {
573 BigNumber numOp = s_tenPowersNeg[30 + num6];
574 bigNumber2.Mul(ref numOp);
575 bigNumber3.Mul(ref numOp);
576 num += num6 * 32;
577 }
578 if (bigNumber2._exp >= 32)
579 {
580 num6 = (bigNumber2._exp - 25) * 32 / -s_tenPowersNeg[31]._exp;
581 BigNumber numOp = s_tenPowersNeg[num6 - 1];
582 bigNumber2.Mul(ref numOp);
583 bigNumber3.Mul(ref numOp);
584 num += num6;
585 }
586 }
587 else if (bigNumber2._exp < 1)
588 {
589 int num6 = (25 - bigNumber2._exp) * 15 / s_tenPowersPos[45]._exp;
590 if (num6 > 0)
591 {
592 BigNumber numOp = s_tenPowersPos[30 + num6];
593 bigNumber2.Mul(ref numOp);
594 bigNumber3.Mul(ref numOp);
595 num -= num6 * 32;
596 }
597 if (bigNumber2._exp < 1)
598 {
599 num6 = (25 - bigNumber2._exp) * 32 / s_tenPowersPos[31]._exp;
600 BigNumber numOp = s_tenPowersPos[num6 - 1];
601 bigNumber2.Mul(ref numOp);
602 bigNumber3.Mul(ref numOp);
603 num -= num6;
604 }
605 }
606 BigNumber bigNumber4 = bigNumber2;
607 bigNumber2.MakeUpperBound();
608 bigNumber4.MakeLowerBound();
609 uint num8 = bigNumber2.UMod1();
610 uint num9 = bigNumber4.UMod1();
611 BigNumber bigNumber5 = bigNumber3;
612 bigNumber5.MakeUpperBound();
613 bigNumber3.MakeLowerBound();
614 uint num10 = bigNumber5.UMod1();
615 uint num11 = bigNumber3.UMod1();
616 uint num12 = 1u;
617 if (num8 >= 100000000)
618 {
619 num12 = 100000000u;
620 num += 8;
621 }
622 else
623 {
624 if (num8 >= 10000)
625 {
626 num12 = 10000u;
627 num += 4;
628 }
629 if (num8 >= 100 * num12)
630 {
631 num12 *= 100;
632 num += 2;
633 }
634 }
635 if (num8 >= 10 * num12)
636 {
637 num12 *= 10;
638 num++;
639 }
640 num++;
641 num7 = 0;
642 while (true)
643 {
644 byte b = (byte)(num8 / num12);
645 num8 %= num12;
646 byte b2 = (byte)(num11 / num12);
647 num11 %= num12;
648 if (b == b2)
649 {
650 mantissa[num7++] = b;
651 if (1 != num12)
652 {
653 num12 /= 10;
654 continue;
655 }
656 num12 = 10000000u;
657 bigNumber2.Mul(ref s_tenPowersPos[7]);
658 bigNumber2.MakeUpperBound();
659 num8 = bigNumber2.UMod1();
660 if (num8 < 100000000)
661 {
662 bigNumber4.Mul(ref s_tenPowersPos[7]);
663 bigNumber4.MakeLowerBound();
664 num9 = bigNumber4.UMod1();
665 bigNumber5.Mul(ref s_tenPowersPos[7]);
666 bigNumber5.MakeUpperBound();
667 num10 = bigNumber5.UMod1();
668 bigNumber3.Mul(ref s_tenPowersPos[7]);
669 bigNumber3.MakeLowerBound();
670 num11 = bigNumber3.UMod1();
671 continue;
672 }
673 }
674 else
675 {
676 byte b3 = (byte)(num10 / num12 % 10);
677 num10 %= num12;
678 byte b4 = (byte)(num9 / num12 % 10);
679 num9 %= num12;
680 if (b3 < b4)
681 {
682 if (b3 == 0 && num10 == 0 && bigNumber5.IsZero && (num3 & 1) == 0)
683 {
684 break;
685 }
686 if (b4 - b3 > 1)
687 {
688 mantissa[num7++] = (byte)((b4 + b3 + 1) / 2);
689 break;
690 }
691 if (num9 != 0 || !bigNumber4.IsZero || (num3 & 1) == 0)
692 {
693 mantissa[num7++] = b4;
694 break;
695 }
696 }
697 }
698 exponent = (mantissaSize = 0);
699 return false;
700 }
701 exponent = num;
702 mantissaSize = num7;
703 goto IL_05a9;
704 IL_05a9:
705 return true;
706 }
707
708 public static void DblToRgbPrecise(double dbl, byte[] mantissa, out int exponent, out int mantissaSize)
709 {
710 BigInteger bigInteger = new BigInteger();
711 BigInteger bigInteger2 = new BigInteger();
712 BigInteger bigInteger3 = new BigInteger();
713 BigInteger bigInteger4 = new BigInteger();
714 BigInteger bigInteger5 = new BigInteger();
715 uint num = DblHi(dbl);
716 uint num2 = DblLo(dbl);
717 bigInteger2.InitFromDigits(1u, 0u, 1);
718 bigInteger3.InitFromDigits(1u, 0u, 1);
719 int num3 = (int)(((num & 0x7FF00000) >> 20) - 1075);
720 uint num4 = num & 0xFFFFFu;
721 uint num5 = num2;
722 int num6 = 2;
723 bool flag = false;
724 double num7;
725 int num8;
726 if (num3 == -1075)
727 {
728 if (num4 == 0)
729 {
730 num6 = 1;
731 }
732 num7 = BitConverter.Int64BitsToDouble(5760103923406864384L);
733 num7 *= dbl;
734 num8 = (int)(((DblHi(num7) & 0x7FF00000) >> 20) - 1279);
735 num = DblHi(num7);
736 num &= 0xFFFFFu;
737 num |= 0x3FF00000u;
738 num7 = BitConverter.UInt64BitsToDouble(((ulong)num << 32) | DblLo(num7));
739 num3++;
740 }
741 else
742 {
743 num &= 0xFFFFFu;
744 num |= 0x3FF00000u;
745 num7 = BitConverter.UInt64BitsToDouble(((ulong)num << 32) | num2);
746 num8 = num3 + 52;
747 if (num5 == 0 && num4 == 0 && num3 > -1074)
748 {
749 num4 = 2097152u;
750 num3--;
751 flag = true;
752 }
753 else
754 {
755 num4 |= 0x100000u;
756 }
757 }
758 num7 = (num7 - 1.5) * 0.289529654602168 + 0.1760912590558 + (double)num8 * 0.301029995663981;
759 int num9 = (int)num7;
760 if (num7 < 0.0 && num7 != (double)num9)
761 {
762 num9--;
763 }
764 int num10;
765 int num11;
766 if (num3 >= 0)
767 {
768 num10 = num3;
769 num11 = 0;
770 }
771 else
772 {
773 num10 = 0;
774 num11 = -num3;
775 }
776 int num12;
777 int num13;
778 if (num9 >= 0)
779 {
780 num12 = 0;
781 num13 = num9;
782 num11 += num9;
783 }
784 else
785 {
786 num10 -= num9;
787 num12 = -num9;
788 num13 = 0;
789 }
790 if (num10 > 0 && num11 > 0)
791 {
792 num8 = ((num10 < num11) ? num10 : num11);
793 num10 -= num8;
794 num11 -= num8;
795 }
796 num10++;
797 num11++;
798 if (num12 > 0)
799 {
800 bigInteger3.MulPow5(num12);
801 bigInteger.InitFromBigint(bigInteger3);
802 if (1 == num6)
803 {
804 bigInteger.MulAdd(num5, 0u);
805 }
806 else
807 {
808 bigInteger.MulAdd(num4, 0u);
809 bigInteger.ShiftLeft(32);
810 if (num5 != 0)
811 {
812 bigInteger5.InitFromBigint(bigInteger3);
813 bigInteger5.MulAdd(num5, 0u);
814 bigInteger.Add(bigInteger5);
815 }
816 }
817 }
818 else
819 {
820 bigInteger.InitFromDigits(num5, num4, num6);
821 if (num13 > 0)
822 {
823 bigInteger2.MulPow5(num13);
824 }
825 }
826 num8 = CbitZeroLeft(bigInteger2[bigInteger2.Length - 1]);
827 num8 = (num8 + 28 - num11) & 0x1F;
828 num10 += num8;
829 num11 += num8;
830 bigInteger.ShiftLeft(num10);
831 if (num10 > 1)
832 {
833 bigInteger3.ShiftLeft(num10 - 1);
834 }
835 bigInteger2.ShiftLeft(num11);
836 BigInteger bigInteger6;
837 if (flag)
838 {
839 bigInteger6 = bigInteger4;
840 bigInteger6.InitFromBigint(bigInteger3);
841 bigInteger3.ShiftLeft(1);
842 }
843 else
844 {
845 bigInteger6 = bigInteger3;
846 }
847 int num14 = 0;
848 while (true)
849 {
850 byte b = (byte)bigInteger.DivRem(bigInteger2);
851 if (num14 == 0 && b == 0)
852 {
853 num9--;
854 goto IL_03c7;
855 }
856 num8 = bigInteger.CompareTo(bigInteger6);
857 int num15;
858 if (bigInteger2.CompareTo(bigInteger3) < 0)
859 {
860 num15 = 1;
861 }
862 else
863 {
864 bigInteger5.InitFromBigint(bigInteger2);
865 bigInteger5.Subtract(bigInteger3);
866 num15 = bigInteger.CompareTo(bigInteger5);
867 }
868 if (num15 == 0 && (num2 & 1) == 0)
869 {
870 if (b != 9)
871 {
872 if (num8 > 0)
873 {
874 b++;
875 }
876 mantissa[num14++] = b;
877 break;
878 }
879 }
880 else
881 {
882 if (num8 < 0 || (num8 == 0 && (num2 & 1) == 0))
883 {
884 if (num15 > 0)
885 {
886 bigInteger.ShiftLeft(1);
887 num15 = bigInteger.CompareTo(bigInteger2);
888 if ((num15 > 0 || (num15 == 0 && ((uint)b & (true ? 1u : 0u)) != 0)) && b++ == 9)
889 {
890 goto IL_0412;
891 }
892 }
893 mantissa[num14++] = b;
894 break;
895 }
896 if (num15 <= 0)
897 {
898 mantissa[num14++] = b;
899 goto IL_03c7;
900 }
901 if (b != 9)
902 {
903 mantissa[num14++] = (byte)(b + 1);
904 break;
905 }
906 }
907 goto IL_0412;
908 IL_0412:
909 while (true)
910 {
911 if (num14 > 0)
912 {
913 if (mantissa[--num14] != 9)
914 {
915 mantissa[num14++]++;
916 break;
917 }
918 continue;
919 }
920 num9++;
921 mantissa[num14++] = 1;
922 break;
923 }
924 break;
925 IL_03c7:
926 bigInteger.MulAdd(10u, 0u);
927 bigInteger3.MulAdd(10u, 0u);
928 if (bigInteger6 != bigInteger3)
929 {
930 bigInteger6.MulAdd(10u, 0u);
931 }
932 }
933 exponent = num9 + 1;
934 mantissaSize = num14;
935 }
936 }
937
938 private sealed class BigInteger : IComparable
939 {
940 private int _capacity;
941
942 private int _length;
943
944 private uint[] _digits;
945
946 public int Length => _length;
947
948 public uint this[int idx] => _digits[idx];
949
950 public BigInteger()
951 {
952 _capacity = 30;
953 _length = 0;
954 _digits = new uint[30];
955 }
956
957 private void Ensure(int cu)
958 {
959 if (cu > _capacity)
960 {
961 cu += cu;
962 uint[] array = new uint[cu];
963 _digits.CopyTo(array, 0);
964 _digits = array;
965 _capacity = cu;
966 }
967 }
968
969 public void InitFromRgu(uint[] rgu, int cu)
970 {
971 Ensure(cu);
972 _length = cu;
973 for (int i = 0; i < cu; i++)
974 {
975 _digits[i] = rgu[i];
976 }
977 }
978
979 public void InitFromDigits(uint u0, uint u1, int cu)
980 {
981 _length = cu;
982 _digits[0] = u0;
983 _digits[1] = u1;
984 }
985
986 public void InitFromBigint(BigInteger biSrc)
987 {
988 InitFromRgu(biSrc._digits, biSrc._length);
989 }
990
991 public void InitFromFloatingDecimal(FloatingDecimal dec)
992 {
993 int cu = (dec.MantissaSize + 8) / 9;
994 int mantissaSize = dec.MantissaSize;
995 Ensure(cu);
996 _length = 0;
997 uint num = 0u;
998 uint num2 = 1u;
999 for (int i = 0; i < mantissaSize; i++)
1000 {
1001 if (1000000000 == num2)
1002 {
1003 MulAdd(num2, num);
1004 num2 = 1u;
1005 num = 0u;
1006 }
1007 num2 *= 10;
1008 num = num * 10 + dec[i];
1009 }
1010 MulAdd(num2, num);
1011 }
1012
1013 public void MulAdd(uint uMul, uint uAdd)
1014 {
1015 for (int i = 0; i < _length; i++)
1016 {
1017 uint uHi;
1018 uint u = MulU(_digits[i], uMul, out uHi);
1019 if (uAdd != 0)
1020 {
1021 uHi += AddU(ref u, uAdd);
1022 }
1023 _digits[i] = u;
1024 uAdd = uHi;
1025 }
1026 if (uAdd != 0)
1027 {
1028 Ensure(_length + 1);
1029 _digits[_length++] = uAdd;
1030 }
1031 }
1032
1033 public void MulPow5(int c5)
1034 {
1035 int num = (c5 + 12) / 13;
1036 if (_length == 0 || c5 == 0)
1037 {
1038 return;
1039 }
1040 Ensure(_length + num);
1041 while (c5 >= 13)
1042 {
1043 MulAdd(1220703125u, 0u);
1044 c5 -= 13;
1045 }
1046 if (c5 > 0)
1047 {
1048 uint num2 = 5u;
1049 while (--c5 > 0)
1050 {
1051 num2 *= 5;
1052 }
1053 MulAdd(num2, 0u);
1054 }
1055 }
1056
1057 public void ShiftLeft(int cbit)
1058 {
1059 if (cbit == 0 || _length == 0)
1060 {
1061 return;
1062 }
1063 int num = cbit >> 5;
1064 cbit &= 0x1F;
1065 uint num3;
1066 int num2;
1067 if (cbit > 0)
1068 {
1069 num2 = _length - 1;
1070 num3 = _digits[num2] >> 32 - cbit;
1071 while (true)
1072 {
1073 _digits[num2] <<= cbit;
1074 if (num2 == 0)
1075 {
1076 break;
1077 }
1078 _digits[num2] |= _digits[num2 - 1] >> 32 - cbit;
1079 num2--;
1080 }
1081 }
1082 else
1083 {
1084 num3 = 0u;
1085 }
1086 if (num <= 0 && num3 == 0)
1087 {
1088 return;
1089 }
1090 num2 = _length + ((num3 != 0) ? 1 : 0) + num;
1091 Ensure(num2);
1092 if (num > 0)
1093 {
1094 int length = _length;
1095 while (length-- != 0)
1096 {
1097 _digits[num + length] = _digits[length];
1098 }
1099 for (int i = 0; i < num; i++)
1100 {
1101 _digits[i] = 0u;
1102 }
1103 _length += num;
1104 }
1105 if (num3 != 0)
1106 {
1107 _digits[_length++] = num3;
1108 }
1109 }
1110
1111 public void ShiftUsRight(int cu)
1112 {
1113 if (cu >= _length)
1114 {
1115 _length = 0;
1116 }
1117 else if (cu > 0)
1118 {
1119 for (int i = 0; i < _length - cu; i++)
1120 {
1121 _digits[i] = _digits[cu + i];
1122 }
1123 _length -= cu;
1124 }
1125 }
1126
1127 public void ShiftRight(int cbit)
1128 {
1129 int num = cbit >> 5;
1130 cbit &= 0x1F;
1131 if (num > 0)
1132 {
1133 ShiftUsRight(num);
1134 }
1135 if (cbit == 0 || _length == 0)
1136 {
1137 return;
1138 }
1139 int num2 = 0;
1140 while (true)
1141 {
1142 _digits[num2] >>= cbit;
1143 if (++num2 >= _length)
1144 {
1145 break;
1146 }
1147 _digits[num2 - 1] |= _digits[num2] << 32 - cbit;
1148 }
1149 if (_digits[num2 - 1] == 0)
1150 {
1151 _length--;
1152 }
1153 }
1154
1155 public int CompareTo(object obj)
1156 {
1157 BigInteger bigInteger = (BigInteger)obj;
1158 if (_length > bigInteger._length)
1159 {
1160 return 1;
1161 }
1162 if (_length < bigInteger._length)
1163 {
1164 return -1;
1165 }
1166 if (_length == 0)
1167 {
1168 return 0;
1169 }
1170 int num = _length - 1;
1171 while (_digits[num] == bigInteger._digits[num])
1172 {
1173 if (num == 0)
1174 {
1175 return 0;
1176 }
1177 num--;
1178 }
1179 if (_digits[num] <= bigInteger._digits[num])
1180 {
1181 return -1;
1182 }
1183 return 1;
1184 }
1185
1186 public void Add(BigInteger bi)
1187 {
1188 int length;
1189 int length2;
1190 if ((length = _length) < (length2 = bi._length))
1191 {
1192 length = bi._length;
1193 length2 = _length;
1194 Ensure(length + 1);
1195 }
1196 uint num = 0u;
1197 int i;
1198 for (i = 0; i < length2; i++)
1199 {
1200 if (num != 0)
1201 {
1202 num = AddU(ref _digits[i], num);
1203 }
1204 num += AddU(ref _digits[i], bi._digits[i]);
1205 }
1206 if (_length < bi._length)
1207 {
1208 for (; i < length; i++)
1209 {
1210 _digits[i] = bi._digits[i];
1211 if (num != 0)
1212 {
1213 num = AddU(ref _digits[i], num);
1214 }
1215 }
1216 _length = length;
1217 }
1218 else
1219 {
1220 while (num != 0 && i < length)
1221 {
1222 num = AddU(ref _digits[i], num);
1223 i++;
1224 }
1225 }
1226 if (num != 0)
1227 {
1228 Ensure(_length + 1);
1229 _digits[_length++] = num;
1230 }
1231 }
1232
1233 public void Subtract(BigInteger bi)
1234 {
1235 if (_length >= bi._length)
1236 {
1237 uint num = 1u;
1238 int i;
1239 for (i = 0; i < bi._length; i++)
1240 {
1241 uint num2 = bi._digits[i];
1242 if (num2 != 0 || num == 0)
1243 {
1244 num = AddU(ref _digits[i], ~num2 + num);
1245 }
1246 }
1247 while (num == 0 && i < _length)
1248 {
1249 num = AddU(ref _digits[i], uint.MaxValue);
1250 }
1251 if (num != 0)
1252 {
1253 if (i == _length)
1254 {
1255 while (--i >= 0 && _digits[i] == 0)
1256 {
1257 }
1258 _length = i + 1;
1259 }
1260 return;
1261 }
1262 }
1263 _length = 0;
1264 }
1265
1266 public uint DivRem(BigInteger bi)
1267 {
1268 int length = bi._length;
1269 if (_length < length)
1270 {
1271 return 0u;
1272 }
1273 uint num = _digits[length - 1] / (bi._digits[length - 1] + 1);
1274 switch (num)
1275 {
1276 case 1u:
1277 Subtract(bi);
1278 break;
1279 default:
1280 {
1281 uint u = 0u;
1282 uint num2 = 1u;
1283 int i;
1284 for (i = 0; i < length; i++)
1285 {
1286 uint uHi;
1287 uint u2 = MulU(num, bi._digits[i], out uHi);
1288 u = uHi + AddU(ref u2, u);
1289 if (u2 != 0 || num2 == 0)
1290 {
1291 num2 = AddU(ref _digits[i], ~u2 + num2);
1292 }
1293 }
1294 while (--i >= 0 && _digits[i] == 0)
1295 {
1296 }
1297 _length = i + 1;
1298 break;
1299 }
1300 case 0u:
1301 break;
1302 }
1303 int num3;
1304 if (num < 9 && (num3 = CompareTo(bi)) >= 0)
1305 {
1306 num++;
1307 if (num3 == 0)
1308 {
1309 _length = 0;
1310 }
1311 else
1312 {
1313 Subtract(bi);
1314 }
1315 }
1316 return num;
1317 }
1318 }
1319
1320 private sealed class FloatingDecimal
1321 {
1322 private int _exponent;
1323
1324 private int _sign;
1325
1326 private int _mantissaSize;
1327
1328 private readonly byte[] _mantissa = new byte[50];
1329
1330 public int Exponent
1331 {
1332 get
1333 {
1334 return _exponent;
1335 }
1336 set
1337 {
1338 _exponent = value;
1339 }
1340 }
1341
1342 public int Sign
1343 {
1344 get
1345 {
1346 return _sign;
1347 }
1348 set
1349 {
1350 _sign = value;
1351 }
1352 }
1353
1354 public byte[] Mantissa => _mantissa;
1355
1356 public int MantissaSize
1357 {
1358 get
1359 {
1360 return _mantissaSize;
1361 }
1362 set
1363 {
1364 _mantissaSize = value;
1365 }
1366 }
1367
1368 public byte this[int ib] => _mantissa[ib];
1369
1370 public FloatingDecimal()
1371 {
1372 _exponent = 0;
1373 _sign = 1;
1374 _mantissaSize = 0;
1375 }
1376
1377 public FloatingDecimal(double dbl)
1378 {
1379 InitFromDouble(dbl);
1380 }
1381
1382 public static explicit operator double(FloatingDecimal dec)
1383 {
1384 int mantissaSize = dec._mantissaSize;
1385 int num = dec._exponent - mantissaSize;
1386 double num3;
1387 if (mantissaSize <= 15 && num >= -22 && dec._exponent <= 37)
1388 {
1389 if (mantissaSize <= 9)
1390 {
1391 uint num2 = 0u;
1392 for (int i = 0; i < mantissaSize; i++)
1393 {
1394 num2 = num2 * 10 + dec[i];
1395 }
1396 num3 = num2;
1397 }
1398 else
1399 {
1400 num3 = 0.0;
1401 for (int j = 0; j < mantissaSize; j++)
1402 {
1403 num3 = num3 * 10.0 + (double)(int)dec[j];
1404 }
1405 }
1406 if (num > 0)
1407 {
1408 if (num > 22)
1409 {
1410 num3 *= C10toN[num - 22];
1411 num3 *= C10toN[22];
1412 }
1413 else
1414 {
1415 num3 *= C10toN[num];
1416 }
1417 }
1418 else if (num < 0)
1419 {
1420 num3 /= C10toN[-num];
1421 }
1422 }
1423 else if (dec._exponent >= 310)
1424 {
1425 num3 = double.PositiveInfinity;
1426 }
1427 else if (dec._exponent <= -325)
1428 {
1429 num3 = 0.0;
1430 }
1431 else
1432 {
1433 BigNumber bigNumber = new BigNumber(dec);
1434 if (bigNumber.Error == 0)
1435 {
1436 num3 = (double)bigNumber;
1437 }
1438 else
1439 {
1440 BigNumber bigNumber2 = bigNumber;
1441 bigNumber2.MakeUpperBound();
1442 BigNumber bigNumber3 = bigNumber;
1443 bigNumber3.MakeLowerBound();
1444 num3 = (double)bigNumber2;
1445 double num4 = (double)bigNumber3;
1446 if (num3 != num4)
1447 {
1448 num3 = dec.AdjustDbl((double)bigNumber);
1449 }
1450 }
1451 }
1452 if (dec._sign >= 0)
1453 {
1454 return num3;
1455 }
1456 return 0.0 - num3;
1457 }
1458
1459 private double AdjustDbl(double dbl)
1460 {
1461 BigInteger bigInteger = new BigInteger();
1462 BigInteger bigInteger2 = new BigInteger();
1463 bigInteger.InitFromFloatingDecimal(this);
1464 int num = _exponent - _mantissaSize;
1465 int num3;
1466 int num5;
1467 int num4;
1468 int num2;
1469 if (num >= 0)
1470 {
1471 num3 = (num2 = num);
1472 num5 = (num4 = 0);
1473 }
1474 else
1475 {
1476 num3 = (num2 = 0);
1477 num5 = (num4 = -num);
1478 }
1479 uint num6 = DblHi(dbl);
1480 uint num7 = DblLo(dbl);
1481 int num8 = (int)((num6 >> 20) & 0x7FF);
1482 num6 &= 0xFFFFFu;
1483 uint u = 1u;
1484 if (num8 != 0)
1485 {
1486 if (num6 == 0 && num7 == 0 && 1 != num8)
1487 {
1488 u = 2u;
1489 num6 = 2097152u;
1490 num8--;
1491 }
1492 else
1493 {
1494 num6 |= 0x100000u;
1495 }
1496 num8 -= 1076;
1497 }
1498 else
1499 {
1500 num8 = -1075;
1501 }
1502 num6 = (num6 << 1) | (num7 >> 31);
1503 num7 <<= 1;
1504 int cu = ((num7 != 0 || num6 != 0) ? ((num6 == 0) ? 1 : 2) : 0);
1505 bigInteger2.InitFromDigits(num7, num6, cu);
1506 if (num8 >= 0)
1507 {
1508 num4 += num8;
1509 }
1510 else
1511 {
1512 num2 += -num8;
1513 }
1514 if (num4 > num2)
1515 {
1516 num4 -= num2;
1517 num2 = 0;
1518 int num9 = 0;
1519 while (num4 >= 32 && bigInteger[num9] == 0)
1520 {
1521 num4 -= 32;
1522 num9++;
1523 }
1524 if (num9 > 0)
1525 {
1526 bigInteger.ShiftUsRight(num9);
1527 }
1528 uint num10 = bigInteger[0];
1529 for (num9 = 0; num9 < num4 && (num10 & (1L << num9)) == 0L; num9++)
1530 {
1531 }
1532 if (num9 > 0)
1533 {
1534 num4 -= num9;
1535 bigInteger.ShiftRight(num9);
1536 }
1537 }
1538 else
1539 {
1540 num2 -= num4;
1541 num4 = 0;
1542 }
1543 if (num5 > 0)
1544 {
1545 bigInteger2.MulPow5(num5);
1546 }
1547 else if (num3 > 0)
1548 {
1549 bigInteger.MulPow5(num3);
1550 }
1551 if (num4 > 0)
1552 {
1553 bigInteger2.ShiftLeft(num4);
1554 }
1555 else if (num2 > 0)
1556 {
1557 bigInteger.ShiftLeft(num2);
1558 }
1559 int num11 = bigInteger2.CompareTo(bigInteger);
1560 if (num11 == 0)
1561 {
1562 return dbl;
1563 }
1564 if (num11 > 0)
1565 {
1566 if (AddU(ref num7, uint.MaxValue) == 0)
1567 {
1568 AddU(ref num6, uint.MaxValue);
1569 }
1570 bigInteger2.InitFromDigits(num7, num6, 1 + ((num6 != 0) ? 1 : 0));
1571 if (num5 > 0)
1572 {
1573 bigInteger2.MulPow5(num5);
1574 }
1575 if (num4 > 0)
1576 {
1577 bigInteger2.ShiftLeft(num4);
1578 }
1579 num11 = bigInteger2.CompareTo(bigInteger);
1580 if (num11 > 0 || (num11 == 0 && (DblLo(dbl) & (true ? 1u : 0u)) != 0))
1581 {
1582 dbl = BitConverter.Int64BitsToDouble(BitConverter.DoubleToInt64Bits(dbl) - 1);
1583 }
1584 }
1585 else
1586 {
1587 if (AddU(ref num7, u) != 0)
1588 {
1589 AddU(ref num6, 1u);
1590 }
1591 bigInteger2.InitFromDigits(num7, num6, 1 + ((num6 != 0) ? 1 : 0));
1592 if (num5 > 0)
1593 {
1594 bigInteger2.MulPow5(num5);
1595 }
1596 if (num4 > 0)
1597 {
1598 bigInteger2.ShiftLeft(num4);
1599 }
1600 num11 = bigInteger2.CompareTo(bigInteger);
1601 if (num11 < 0 || (num11 == 0 && (DblLo(dbl) & (true ? 1u : 0u)) != 0))
1602 {
1603 dbl = BitConverter.Int64BitsToDouble(BitConverter.DoubleToInt64Bits(dbl) + 1);
1604 }
1605 }
1606 return dbl;
1607 }
1608
1609 private void InitFromDouble(double dbl)
1610 {
1611 if (0.0 == dbl || IsSpecial(dbl))
1612 {
1613 _exponent = 0;
1614 _sign = 1;
1615 _mantissaSize = 0;
1616 return;
1617 }
1618 if (dbl < 0.0)
1619 {
1620 _sign = -1;
1621 dbl = 0.0 - dbl;
1622 }
1623 else
1624 {
1625 _sign = 1;
1626 }
1627 if (!BigNumber.DblToRgbFast(dbl, _mantissa, out _exponent, out _mantissaSize))
1628 {
1629 BigNumber.DblToRgbPrecise(dbl, _mantissa, out _exponent, out _mantissaSize);
1630 }
1631 }
1632 }
1633
1634 public static readonly double[] C10toN = new double[23]
1635 {
1636 1.0, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, 10000000.0, 100000000.0, 1000000000.0,
1637 10000000000.0, 100000000000.0, 1000000000000.0, 10000000000000.0, 100000000000000.0, 1000000000000000.0, 10000000000000000.0, 1E+17, 1E+18, 1E+19,
1638 1E+20, 1E+21, 1E+22
1639 };
1640
1641 public static uint DblHi(double dbl)
1642 {
1643 return (uint)(BitConverter.DoubleToUInt64Bits(dbl) >> 32);
1644 }
1645
1646 public static uint DblLo(double dbl)
1647 {
1648 return (uint)BitConverter.DoubleToUInt64Bits(dbl);
1649 }
1650
1651 public static bool IsSpecial(double dbl)
1652 {
1653 return (~DblHi(dbl) & 0x7FF00000) == 0;
1654 }
1655
1656 public static uint NotZero(uint u)
1657 {
1658 if (u == 0)
1659 {
1660 return 0u;
1661 }
1662 return 1u;
1663 }
1664
1665 public static uint AddU(ref uint u1, uint u2)
1666 {
1667 u1 += u2;
1668 if (u1 >= u2)
1669 {
1670 return 0u;
1671 }
1672 return 1u;
1673 }
1674
1675 public static uint MulU(uint u1, uint u2, out uint uHi)
1676 {
1677 ulong num = (ulong)u1 * (ulong)u2;
1678 uHi = (uint)(num >> 32);
1679 return (uint)num;
1680 }
1681
1682 public static int CbitZeroLeft(uint u)
1683 {
1684 int num = 0;
1685 if ((u & 0xFFFF0000u) == 0)
1686 {
1687 num += 16;
1688 u <<= 16;
1689 }
1690 if ((u & 0xFF000000u) == 0)
1691 {
1692 num += 8;
1693 u <<= 8;
1694 }
1695 if ((u & 0xF0000000u) == 0)
1696 {
1697 num += 4;
1698 u <<= 4;
1699 }
1700 if ((u & 0xC0000000u) == 0)
1701 {
1702 num += 2;
1703 u <<= 2;
1704 }
1705 if ((u & 0x80000000u) == 0)
1706 {
1707 num++;
1708 u <<= 1;
1709 }
1710 return num;
1711 }
1712
1713 public static bool IsInteger(double dbl, out int value)
1714 {
1715 if (!IsSpecial(dbl))
1716 {
1717 int num = (int)dbl;
1718 double num2 = num;
1719 if (dbl == num2)
1720 {
1721 value = num;
1722 return true;
1723 }
1724 }
1725 value = 0;
1726 return false;
1727 }
1728
1729 public unsafe static string DoubleToString(double dbl)
1730 {
1731 if (IsInteger(dbl, out var value))
1732 {
1733 return value.ToString(CultureInfo.InvariantCulture);
1734 }
1735 if (IsSpecial(dbl))
1736 {
1737 if (double.IsNaN(dbl))
1738 {
1739 return "NaN";
1740 }
1741 if (!(dbl < 0.0))
1742 {
1743 return "Infinity";
1744 }
1745 return "-Infinity";
1746 }
1747 FloatingDecimal floatingDecimal = new FloatingDecimal(dbl);
1748 int num = floatingDecimal.MantissaSize - floatingDecimal.Exponent;
1749 int num2;
1750 if (num > 0)
1751 {
1752 num2 = ((floatingDecimal.Exponent > 0) ? floatingDecimal.Exponent : 0);
1753 }
1754 else
1755 {
1756 num2 = floatingDecimal.Exponent;
1757 num = 0;
1758 }
1759 int num3 = num2 + num + 4;
1760 char* ptr = stackalloc char[num3];
1761 char* ptr2 = ptr;
1762 if (floatingDecimal.Sign < 0)
1763 {
1764 *(ptr2++) = '-';
1765 }
1766 int num4 = floatingDecimal.MantissaSize;
1767 int num5 = 0;
1768 if (num2 != 0)
1769 {
1770 do
1771 {
1772 if (num4 != 0)
1773 {
1774 *(ptr2++) = (char)(floatingDecimal[num5++] | 0x30u);
1775 num4--;
1776 }
1777 else
1778 {
1779 *(ptr2++) = '0';
1780 }
1781 }
1782 while (--num2 != 0);
1783 }
1784 else
1785 {
1786 *(ptr2++) = '0';
1787 }
1788 if (num != 0)
1789 {
1790 *(ptr2++) = '.';
1791 while (num > num4)
1792 {
1793 *(ptr2++) = '0';
1794 num--;
1795 }
1796 while (num4 != 0)
1797 {
1798 *(ptr2++) = (char)(floatingDecimal[num5++] | 0x30u);
1799 num4--;
1800 }
1801 }
1802 return new string(ptr, 0, (int)(ptr2 - ptr));
1803 }
1804
1805 private static bool IsAsciiDigit(char ch)
1806 {
1807 return (uint)(ch - 48) <= 9u;
1808 }
1809
1810 private static bool IsWhitespace(char ch)
1811 {
1812 if (ch != ' ' && ch != '\t' && ch != '\n')
1813 {
1814 return ch == '\r';
1815 }
1816 return true;
1817 }
1818
1819 private unsafe static char* SkipWhitespace(char* pch)
1820 {
1821 while (IsWhitespace(*pch))
1822 {
1823 pch++;
1824 }
1825 return pch;
1826 }
1827
1828 public unsafe static double StringToDouble(string s)
1829 {
1830 fixed (char* ptr = s)
1831 {
1832 int num = 0;
1833 char* ptr2 = ptr;
1834 char* ptr3 = null;
1835 int num2 = 1;
1836 int num3 = 0;
1837 while (true)
1838 {
1839 char c = *(ptr2++);
1840 if (!IsAsciiDigit(c))
1841 {
1842 if (c != '-')
1843 {
1844 if (c == '.')
1845 {
1846 if (IsAsciiDigit(*ptr2))
1847 {
1848 goto IL_00b8;
1849 }
1850 }
1851 else if (IsWhitespace(c) && num2 > 0)
1852 {
1853 ptr2 = SkipWhitespace(ptr2);
1854 continue;
1855 }
1856 }
1857 else if (num2 >= 0)
1858 {
1859 num2 = -1;
1860 continue;
1861 }
1862 return double.NaN;
1863 }
1864 if (c == '0')
1865 {
1866 do
1867 {
1868 c = *(ptr2++);
1869 }
1870 while (c == '0');
1871 if (!IsAsciiDigit(c))
1872 {
1873 goto IL_00b2;
1874 }
1875 }
1876 ptr3 = ptr2 - 1;
1877 do
1878 {
1879 c = *(ptr2++);
1880 }
1881 while (IsAsciiDigit(c));
1882 num = (int)(ptr2 - ptr3) - 1;
1883 goto IL_00b2;
1884 IL_00b8:
1885 c = *(ptr2++);
1886 if (ptr3 == null)
1887 {
1888 while (c == '0')
1889 {
1890 num3--;
1891 c = *(ptr2++);
1892 }
1893 ptr3 = ptr2 - 1;
1894 }
1895 while (IsAsciiDigit(c))
1896 {
1897 num3--;
1898 num++;
1899 c = *(ptr2++);
1900 }
1901 break;
1902 IL_00b2:
1903 if (c != '.')
1904 {
1905 break;
1906 }
1907 goto IL_00b8;
1908 }
1909 ptr2--;
1910 char* ptr4 = ptr + s.Length;
1911 if (ptr2 < ptr4 && SkipWhitespace(ptr2) < ptr4)
1912 {
1913 return double.NaN;
1914 }
1915 if (num == 0)
1916 {
1917 return 0.0;
1918 }
1919 if (num3 == 0 && num <= 9)
1920 {
1921 int num4 = *ptr3 & 0xF;
1922 while (--num != 0)
1923 {
1924 ptr3++;
1925 num4 = num4 * 10 + (*ptr3 & 0xF);
1926 }
1927 return (num2 < 0) ? (-num4) : num4;
1928 }
1929 if (num > 50)
1930 {
1931 ptr2 -= num - 50;
1932 num3 += num - 50;
1933 num = 50;
1934 }
1935 while (true)
1936 {
1937 if (*(--ptr2) == '0')
1938 {
1939 num--;
1940 num3++;
1941 }
1942 else if (*ptr2 != '.')
1943 {
1944 break;
1945 }
1946 }
1947 ptr2++;
1948 FloatingDecimal floatingDecimal = new FloatingDecimal();
1949 floatingDecimal.Exponent = num3 + num;
1950 floatingDecimal.Sign = num2;
1951 floatingDecimal.MantissaSize = num;
1952 fixed (byte* ptr5 = &floatingDecimal.Mantissa[0])
1953 {
1954 byte* ptr6 = ptr5;
1955 for (; ptr3 < ptr2; ptr3++)
1956 {
1957 if (*ptr3 != '.')
1958 {
1959 *ptr6 = (byte)(*ptr3 & 0xFu);
1960 ptr6++;
1961 }
1962 }
1963 }
1964 return (double)floatingDecimal;
1965 }
1966 }
1967}
System.BitConverter.Int64BitsToDouble
static unsafe double Int64BitsToDouble(long value)
Definition BitConverter.cs:498
System.BitConverter.DoubleToUInt64Bits
static ulong DoubleToUInt64Bits(double value)
Definition BitConverter.cs:544
System.BitConverter.DoubleToInt64Bits
static unsafe long DoubleToInt64Bits(double value)
Definition BitConverter.cs:487
System.BitConverter.UInt64BitsToDouble
static double UInt64BitsToDouble(ulong value)
Definition BitConverter.cs:551
System.Globalization.CultureInfo.InvariantCulture
static CultureInfo InvariantCulture
Definition CultureInfo.cs:144
System.Math.Floor
static double Floor(double d)
System.Xml.Xsl.XPathConvert.BigInteger.InitFromFloatingDecimal
void InitFromFloatingDecimal(FloatingDecimal dec)
Definition XPathConvert.cs:991
System.Xml.Xsl.XPathConvert.BigInteger.InitFromDigits
void InitFromDigits(uint u0, uint u1, int cu)
Definition XPathConvert.cs:979
System.Xml.Xsl.XPathConvert.BigInteger.MulAdd
void MulAdd(uint uMul, uint uAdd)
Definition XPathConvert.cs:1013
System.Xml.Xsl.XPathConvert.BigInteger.InitFromRgu
void InitFromRgu(uint[] rgu, int cu)
Definition XPathConvert.cs:969
System.Xml.Xsl.XPathConvert.BigInteger.InitFromBigint
void InitFromBigint(BigInteger biSrc)
Definition XPathConvert.cs:986
System.Xml.Xsl.XPathConvert.MulU
static uint MulU(uint u1, uint u2, out uint uHi)
Definition XPathConvert.cs:1675
System.Xml.Xsl.XPathConvert.NotZero
static uint NotZero(uint u)
Definition XPathConvert.cs:1656
System.Xml.Xsl.XPathConvert.IsWhitespace
static bool IsWhitespace(char ch)
Definition XPathConvert.cs:1810
System.Xml.Xsl.XPathConvert.CbitZeroLeft
static int CbitZeroLeft(uint u)
Definition XPathConvert.cs:1682
System.Xml.Xsl.XPathConvert.StringToDouble
static unsafe double StringToDouble(string s)
Definition XPathConvert.cs:1828
System.Xml.Xsl.XPathConvert.DoubleToString
static unsafe string DoubleToString(double dbl)
Definition XPathConvert.cs:1729
System.Xml.Xsl.XPathConvert.IsAsciiDigit
static bool IsAsciiDigit(char ch)
Definition XPathConvert.cs:1805
System.Xml.Xsl.XPathConvert.IsInteger
static bool IsInteger(double dbl, out int value)
Definition XPathConvert.cs:1713
System.Xml.Xsl.XPathConvert.C10toN
static readonly double[] C10toN
Definition XPathConvert.cs:1634
System.Xml.Xsl.XPathConvert.IsSpecial
static bool IsSpecial(double dbl)
Definition XPathConvert.cs:1651
System.Xml.Xsl.XPathConvert.SkipWhitespace
static unsafe char * SkipWhitespace(char *pch)
Definition XPathConvert.cs:1819
System.Xml.Xsl.XPathConvert.AddU
static uint AddU(ref uint u1, uint u2)
Definition XPathConvert.cs:1665
System.Xml.Xsl.XPathConvert.DblLo
static uint DblLo(double dbl)
Definition XPathConvert.cs:1646
System.Xml.Xsl.XPathConvert.DblHi
static uint DblHi(double dbl)
Definition XPathConvert.cs:1641
System.Xml.Xsl.XPathConvert.BigNumber.BigNumber
BigNumber(uint u0, uint u1, uint u2, int exp, uint error)
Definition XPathConvert.cs:134
System.Xml.Xsl.XPathConvert.BigNumber.Mul
void Mul(ref BigNumber numOp)
Definition XPathConvert.cs:301
System.Xml.Xsl.XPathConvert.BigNumber.DblToRgbPrecise
static void DblToRgbPrecise(double dbl, byte[] mantissa, out int exponent, out int mantissaSize)
Definition XPathConvert.cs:708
System.Xml.Xsl.XPathConvert.BigNumber.DblToRgbFast
static bool DblToRgbFast(double dbl, byte[] mantissa, out int exponent, out int mantissaSize)
Definition XPathConvert.cs:489
System.Xml.Xsl.XPathConvert.BigNumber.s_tenPowersNeg
static readonly BigNumber[] s_tenPowersNeg
Definition XPathConvert.cs:70
System.Xml.Xsl.XPathConvert.BigNumber.s_tenPowersPos
static readonly BigNumber[] s_tenPowersPos
Definition XPathConvert.cs:20
System.Xml.Xsl.XPathConvert.BigNumber.MulTenAdd
unsafe uint MulTenAdd(uint digit)
Definition XPathConvert.cs:194