?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
**** Merged from MCS ****
[mono-project.git] / mcs / class / System.Data / System.Data.SqlTypes / SqlDecimal.cs
blob85e33561c69900eaabfafab059244793f1846237
1 //
2 // System.Data.SqlTypes.SqlDecimal
3 //
4 // Author:
5 // Tim Coleman <tim@timcoleman.com>
6 // Ville Palo <vi64pa@koti.soon.fi>
7 //
8 // (C) Copyright 2002 Tim Coleman
9 //
10
11 //
12 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
13 //
14 // Permission is hereby granted, free of charge, to any person obtaining
15 // a copy of this software and associated documentation files (the
16 // "Software"), to deal in the Software without restriction, including
17 // without limitation the rights to use, copy, modify, merge, publish,
18 // distribute, sublicense, and/or sell copies of the Software, and to
19 // permit persons to whom the Software is furnished to do so, subject to
20 // the following conditions:
21 //
22 // The above copyright notice and this permission notice shall be
23 // included in all copies or substantial portions of the Software.
24 //
25 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
26 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
27 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
28 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
29 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
30 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
31 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
32 //
33
34 using Mono.Data.Tds.Protocol;
35 using System;
36 using System.Text;
37 using System.Globalization;
38
39 namespace System.Data.SqlTypes
40 {
41 public struct SqlDecimal : INullable, IComparable
42 {
43 #region Fields
44
45 int[] value;
46 byte precision;
47 byte scale;
48 bool positive;
49
50 private bool notNull;
51
52 // borrowed from System.Decimal
53 const int SCALE_SHIFT = 16;
54 const int SIGN_SHIFT = 31;
55 const int RESERVED_SS32_BITS = 0x7F00FFFF;
56 const ulong LIT_GUINT64_HIGHBIT = 0x8000000000000000;
57 const ulong LIT_GUINT32_HIGHBIT = 0x80000000;
58 const byte DECIMAL_MAX_INTFACTORS = 9;
59 static uint [] constantsDecadeInt32Factors = new uint [10]
60 {
61 1u, 10u, 100u, 1000u, 10000u, 100000u, 1000000u,
62 10000000u, 100000000u, 1000000000u
63 };
64
65 public static readonly byte MaxPrecision = 38;
66 public static readonly byte MaxScale = 38;
67
68 // This should be 99999999999999999999999999999999999999
69 public static readonly SqlDecimal MaxValue = new SqlDecimal (MaxPrecision,
70 (byte)0,
71 true,
72 (int)-1,
73 160047679,
74 1518781562,
75 1262177448);
76 // This should be -99999999999999999999999999999999999999
77 public static readonly SqlDecimal MinValue = new SqlDecimal (MaxPrecision,
78 (byte)0, false,
79 -1,
80 160047679,
81 1518781562,
82 1262177448);
83
84 public static readonly SqlDecimal Null;
85
86 #endregion
87
88 #region Constructors
89
90 public SqlDecimal (decimal value)
91 {
92 int[] binData = Decimal.GetBits (value);
93
94 this.precision = MaxPrecision; // this value seems unclear
95
96 this.scale = (byte)(((uint)binData [3]) >> SCALE_SHIFT);
97
98 if (this.scale > MaxScale || ((uint)binData [3] & RESERVED_SS32_BITS) != 0)
99 throw new ArgumentException(Locale.GetText ("Invalid scale"));
100
101 this.value = new int[4];
102 this.value[0] = binData[0];
103 this.value[1] = binData[1];
104 this.value[2] = binData[2];
105 this.value[3] = 0;
106
107 if (value >= 0)
108 positive = true;
109 else
110 positive = false;
111
112 notNull = true;
113 precision = GetPrecision (value);
114 }
115
116 public SqlDecimal (double value) : this ((decimal)value)
117 {
118 SqlDecimal n = this;
119 int digits = 17 - precision;
120 if (digits > 0)
121 n = AdjustScale (this, digits, false);
122 else
123 n = Round (this, 17);
124 this.notNull = n.notNull;
125 this.positive = n.positive;
126 this.precision = n.precision;
127 this.scale = n.scale;
128 this.value = n.value;
129 }
130 public SqlDecimal (int value) : this ((decimal)value) { }
131 public SqlDecimal (long value) : this ((decimal)value) { }
132
133 public SqlDecimal (byte bPrecision, byte bScale, bool fPositive, int[] bits) : this (bPrecision, bScale, fPositive, bits[0], bits[1], bits[2], bits[3]) { }
134
135 public SqlDecimal (byte bPrecision, byte bScale, bool fPositive, int data1, int data2, int data3, int data4)
136 {
137 this.precision = bPrecision;
138 this.scale = bScale;
139 this.positive = fPositive;
140 this.value = new int[4];
141 this.value[0] = data1;
142 this.value[1] = data2;
143 this.value[2] = data3;
144 this.value[3] = data4;
145 notNull = true;
146
147 if (precision < scale)
148 throw new SqlTypeException (Locale.GetText ("Invalid presicion/scale combination."));
149
150 if (precision > 38)
151 throw new SqlTypeException (Locale.GetText ("Invalid precision/scale combination."));
152
153 if (this.ToDouble () > (Math.Pow (10, 38) - 1) ||
154 this.ToDouble () < -(Math.Pow (10, 38)))
155 throw new SqlTypeException ("Can't convert to SqlDecimal, Out of range ");
156 }
157
158 #endregion
159
160 #region Properties
161
162 public byte[] BinData {
163 get {
164
165 byte [] b = new byte [value.Length * 4];
166
167 int j = 0;
168 for (int i = 0; i < value.Length; i++) {
169
170 b [j++] = (byte)(0xff & value [i]);
171 b [j++] = (byte)(0xff & value [i] >> 8);
172 b [j++] = (byte)(0xff & value [i] >> 16);
173 b [j++] = (byte)(0xff & value [i] >> 24);
174 }
175
176 return b;
177 }
178 }
179
180 public int[] Data {
181 get {
182 if (this.IsNull)
183 throw new SqlNullValueException ();
184 // Data should always return clone, not to be modified
185 int [] ret = new int [4];
186 ret [0] = value [0];
187 ret [1] = value [1];
188 ret [2] = value [2];
189 ret [3] = value [3];
190 return ret;
191 }
192 }
193
194 public bool IsNull {
195 get { return !notNull; }
196 }
197
198 public bool IsPositive {
199 get { return positive; }
200 }
201
202 public byte Precision {
203 get { return precision; }
204 }
205
206 public byte Scale {
207 get { return scale; }
208 }
209
210 public decimal Value {
211 get {
212 if (this.IsNull)
213 throw new SqlNullValueException ();
214
215 if (this.value[3] > 0)
216 throw new OverflowException ();
217
218 return new decimal (value[0], value[1], value[2], !positive, scale);
219 }
220 }
221
222 #endregion
223
224 #region Methods
225
226 public static SqlDecimal Abs (SqlDecimal n)
227 {
228 if (!n.notNull)
229 return n;
230 return new SqlDecimal (n.Precision, n.Scale, true, n.Data);
231 }
232
233 public static SqlDecimal Add (SqlDecimal x, SqlDecimal y)
234 {
235 return (x + y);
236 }
237
238 public static SqlDecimal AdjustScale (SqlDecimal n, int digits, bool fRound)
239 {
240 byte prec = n.Precision;
241 if (n.IsNull)
242 throw new SqlNullValueException ();
243
244 int [] data;
245 byte newScale;
246 if (digits == 0)
247 return n;
248 else if (digits > 0) {
249 prec = (byte)(prec + digits);
250 decimal d = n.Value;
251 if (digits > 0)
252 for (int i = 0; i < digits; i++)
253 d *= 10;
254 data = Decimal.GetBits (d);
255 data [3] = 0;
256 newScale = (byte) (n.scale + digits);
257 } else {
258 if (fRound)
259 n = Round (n, digits + n.scale);
260 else
261 n = Round (Truncate (n, digits + n.scale), digits + n.scale);
262 data = n.Data;
263 newScale = n.scale;
264 }
265
266 return new SqlDecimal (prec, newScale, n.positive, data);
267 }
268
269 public static SqlDecimal Ceiling (SqlDecimal n)
270 {
271 if (!n.notNull)
272 return n;
273 return AdjustScale (n, -(n.Scale), true);
274 }
275
276 public int CompareTo (object value)
277 {
278 if (value == null)
279 return 1;
280 else if (!(value is SqlDecimal))
281 throw new ArgumentException (Locale.GetText ("Value is not a System.Data.SqlTypes.SqlDecimal"));
282 else if (((SqlDecimal)value).IsNull)
283 return 1;
284 else
285 return this.Value.CompareTo (((SqlDecimal)value).Value);
286 }
287
288 public static SqlDecimal ConvertToPrecScale (SqlDecimal n, int precision, int scale)
289 {
290 // return new SqlDecimal ((byte)precision, (byte)scale, n.IsPositive, n.Data);
291 // FIXME: precision
292 return AdjustScale (n, scale - n.scale, true);
293 }
294
295 public static SqlDecimal Divide (SqlDecimal x, SqlDecimal y)
296 {
297 return (x / y);
298 }
299
300 public override bool Equals (object value)
301 {
302 if (!(value is SqlDecimal))
303 return false;
304 else if (this.IsNull && ((SqlDecimal)value).IsNull)
305 return true;
306 else if (((SqlDecimal)value).IsNull)
307 return false;
308 else
309 return (bool) (this == (SqlDecimal)value);
310 }
311
312 public static SqlBoolean Equals (SqlDecimal x, SqlDecimal y)
313 {
314 return (x == y);
315 }
316
317 public static SqlDecimal Floor (SqlDecimal n)
318 {
319 return AdjustScale (n, -(n.Scale), false);
320 }
321
322 internal static SqlDecimal FromTdsBigDecimal (TdsBigDecimal x)
323 {
324 if (x == null)
325 return Null;
326 else
327 return new SqlDecimal (x.Precision, x.Scale, !x.IsNegative, x.Data);
328 }
329
330 public override int GetHashCode ()
331 {
332 int result = 10;
333 result = 91 * result + this.Data[0];
334 result = 91 * result + this.Data[1];
335 result = 91 * result + this.Data[2];
336 result = 91 * result + this.Data[3];
337 result = 91 * result + (int)this.Scale;
338 result = 91 * result + (int)this.Precision;
339
340 return result;
341 }
342
343 public static SqlBoolean GreaterThan (SqlDecimal x, SqlDecimal y)
344 {
345 return (x > y);
346 }
347
348 public static SqlBoolean GreaterThanOrEqual (SqlDecimal x, SqlDecimal y)
349 {
350 return (x >= y);
351 }
352
353 public static SqlBoolean LessThan (SqlDecimal x, SqlDecimal y)
354 {
355 return (x < y);
356 }
357
358 public static SqlBoolean LessThanOrEqual (SqlDecimal x, SqlDecimal y)
359 {
360 return (x <= y);
361 }
362
363 public static SqlDecimal Multiply (SqlDecimal x, SqlDecimal y)
364 {
365 return (x * y);
366 }
367
368 public static SqlBoolean NotEquals (SqlDecimal x, SqlDecimal y)
369 {
370 return (x != y);
371 }
372
373 public static SqlDecimal Parse (string s)
374 {
375 if (s == null)
376 throw new ArgumentNullException (Locale.GetText ("string s"));
377 else
378 return new SqlDecimal (Decimal.Parse (s));
379 }
380
381 public static SqlDecimal Power (SqlDecimal n, double exp)
382 {
383 if (n.IsNull)
384 return SqlDecimal.Null;
385
386 return new SqlDecimal (Math.Pow (n.ToDouble (), exp));
387 }
388
389 public static SqlDecimal Round (SqlDecimal n, int position)
390 {
391 if (n.IsNull)
392 throw new SqlNullValueException ();
393
394 decimal d = n.Value;
395 d = Decimal.Round (d, position);
396 return new SqlDecimal (d);
397 }
398
399 public static SqlInt32 Sign (SqlDecimal n)
400 {
401 SqlInt32 result = 0;
402
403 if (n >= new SqlDecimal (0))
404 result = 1;
405 else
406 result = -1;
407
408 return result;
409 }
410
411 public static SqlDecimal Subtract (SqlDecimal x, SqlDecimal y)
412 {
413 return (x - y);
414 }
415
416 private byte GetPrecision (decimal value)
417 {
418 string str = value.ToString ();
419 byte result = 0;
420
421 foreach (char c in str) {
422
423 if (c >= '0' && c <= '9')
424 result++;
425 }
426
427 return result;
428 }
429
430 public double ToDouble ()
431 {
432 // FIXME: This is wrong way to do this
433 double d = (uint)this.Data [0];
434 d += ((uint)this.Data [1]) * Math.Pow (2, 32);
435 d += ((uint)this.Data [2]) * Math.Pow (2, 64);
436 d += ((uint)this.Data [3]) * Math.Pow (2, 96);
437 d = d / Math.Pow (10, scale);
438
439 return d;
440 }
441
442 public SqlBoolean ToSqlBoolean ()
443 {
444 return ((SqlBoolean)this);
445 }
446
447 public SqlByte ToSqlByte ()
448 {
449 return ((SqlByte)this);
450 }
451
452 public SqlDouble ToSqlDouble ()
453 {
454 return ((SqlDouble)this);
455 }
456
457 public SqlInt16 ToSqlInt16 ()
458 {
459 return ((SqlInt16)this);
460 }
461
462 public SqlInt32 ToSqlInt32 ()
463 {
464 return ((SqlInt32)this);
465 }
466
467 public SqlInt64 ToSqlInt64 ()
468 {
469 return ((SqlInt64)this);
470 }
471
472 public SqlMoney ToSqlMoney ()
473 {
474 return ((SqlMoney)this);
475 }
476
477 public SqlSingle ToSqlSingle ()
478 {
479 return ((SqlSingle)this);
480 }
481
482 public SqlString ToSqlString ()
483 {
484 return ((SqlString)this);
485 }
486
487 public override string ToString ()
488 {
489 if (this.IsNull)
490 return "Null";
491
492 // convert int [4] --> ulong [2]
493 ulong lo = (uint)this.Data [0];
494 lo += (ulong)((ulong)this.Data [1] << 32);
495 ulong hi = (uint)this.Data [2];
496 hi += (ulong)((ulong)this.Data [3] << 32);
497
498 uint rest = 0;
499 String result = "";
500 StringBuilder Result = new StringBuilder ();
501 for (int i = 0; lo != 0 || hi != 0; i++) {
502
503 Div128By32 (ref hi, ref lo, 10, ref rest);
504 Result.Insert (0, rest.ToString ());
505 }
506
507 while (Result.Length < this.Precision)
508 Result.Append ("0");
509
510 while (Result.Length > this.Precision)
511 Result.Remove (Result.Length - 1, 1);
512
513 if (this.Scale > 0)
514 Result.Insert (Result.Length - this.Scale, ".");
515
516 if (!positive)
517 Result.Insert (0, '-');
518
519 return Result.ToString ();
520 }
521
522 // From decimal.c
523 private static int Div128By32(ref ulong hi, ref ulong lo, uint divider)
524 {
525 uint t = 0;
526 return Div128By32 (ref hi, ref lo, divider, ref t);
527 }
528
529 // From decimal.c
530 private static int Div128By32(ref ulong hi, ref ulong lo, uint divider, ref uint rest)
531 {
532 ulong a = 0;
533 ulong b = 0;
534 ulong c = 0;
535
536 a = (uint)(hi >> 32);
537 b = a / divider;
538 a -= b * divider;
539 a <<= 32;
540 a |= (uint)hi;
541 c = a / divider;
542 a -= c * divider;
543 a <<= 32;
544 hi = b << 32 | (uint)c;
545
546 a |= (uint)(lo >> 32);
547 b = a / divider;
548 a -= b * divider;
549 a <<= 32;
550 a |= (uint)lo;
551 c = a / divider;
552 a -= c * divider;
553 lo = b << 32 | (uint)c;
554 rest = (uint)a;
555 a <<= 1;
556
557 return (a > divider || (a == divider && (c & 1) == 1)) ? 1 : 0;
558
559 }
560
561 [MonoTODO("Find out what is the right way to set scale and precision")]
562 private static SqlDecimal DecimalDiv (SqlDecimal x, SqlDecimal y)
563 {
564 ulong lo = 0;
565 ulong hi = 0;
566 int sc = 0; // scale
567 int texp = 0;
568 int rc = 0;
569 byte prec = 0; // precision
570 bool positive = ! (x.positive ^ y.positive);
571
572 prec = x.Precision >= y.Precision ? x.Precision : y.Precision;
573 DecimalDivSub (ref x, ref y, ref lo, ref hi, ref texp);
574
575 sc = x.Scale - y.Scale;
576
577 Rescale128 (ref lo, ref hi, ref sc, texp, 0, 38, 1);
578
579 uint r = 0;
580 while (prec < sc) {
581 Div128By32(ref hi, ref lo, 10, ref r);
582 sc--;
583 }
584
585 if (r >= 5)
586 lo++;
587
588 while ((((double)hi) * Math.Pow(2,64) + lo) - Math.Pow (10, prec) > 0)
589 prec++;
590
591 while ((prec + sc) > MaxScale) {
592 Div128By32(ref hi, ref lo, 10, ref r);
593 sc--;
594 if (r >= 5)
595 lo++;
596 }
597
598 int resultLo = (int)lo;
599 int resultMi = (int)(lo >> 32);
600 int resultMi2 = (int)(hi);
601 int resultHi = (int)(hi >> 32);
602
603 return new SqlDecimal (prec, (byte)sc, positive, resultLo,
604 resultMi, resultMi2,
605 resultHi);
606 }
607
608 // From decimal.c
609 private static void Rescale128 (ref ulong clo, ref ulong chi,
610 ref int scale, int texp,
611 int minScale, int maxScale,
612 int roundFlag)
613 {
614 uint factor = 0;
615 uint overhang = 0;
616 int sc = 0;
617 int i = 0;
618 int rc = 0;
619 int roundBit = 0;
620
621 sc = scale;
622 if (texp > 0) {
623
624 // reduce exp
625 while (texp > 0 && sc <= maxScale) {
626
627 overhang = (uint)(chi >> 64);
628 while (texp > 0 && (((clo & 1) == 0) || overhang > 0)) {
629
630 if (--texp == 0)
631 roundBit = (int)(clo & 1);
632 RShift128 (ref clo, ref chi);
633
634 overhang = (uint)(chi >> 32);
635 }
636
637 if (texp > DECIMAL_MAX_INTFACTORS)
638 i = DECIMAL_MAX_INTFACTORS;
639 else
640 i = texp;
641
642 if (sc + i > maxScale)
643 i = maxScale - sc;
644
645 if (i == 0)
646 break;
647
648 texp -= i;
649 sc += i;
650
651 // 10^i/2^i=5^i
652 factor = constantsDecadeInt32Factors [i] >> i;
653 // System.Console.WriteLine ("***");
654 Mult128By32 (ref clo, ref chi, factor, 0);
655 // System.Console.WriteLine ((((double)chi) * Math.Pow (2,64) + clo));
656
657 }
658
659 while (texp > 0) {
660 if (--texp == 0)
661 roundBit = (int)(clo & 1);
662 RShift128 (ref clo, ref chi);
663 }
664 }
665
666 while (sc > maxScale) {
667 i = scale - maxScale;
668 if (i > DECIMAL_MAX_INTFACTORS)
669 i = DECIMAL_MAX_INTFACTORS;
670 sc -= i;
671 roundBit = Div128By32 (ref clo, ref chi,
672 constantsDecadeInt32Factors[i]);
673 }
674
675 while (sc < minScale) {
676 if (roundFlag == 0)
677 roundBit = 0;
678 i = minScale - sc;
679 if (i > DECIMAL_MAX_INTFACTORS)
680 i = DECIMAL_MAX_INTFACTORS;
681 sc += i;
682 Mult128By32 (ref clo, ref chi,
683 constantsDecadeInt32Factors[i], roundBit);
684 roundBit = 0;
685 }
686 scale = sc;
687 Normalize128 (ref clo, ref chi, ref sc, roundFlag, roundBit);
688 }
689
690 // From decimal.c
691 private static void Normalize128(ref ulong clo, ref ulong chi, ref int scale, int roundFlag, int roundBit)
692 {
693 int sc = scale;
694 int deltaScale;
695
696 scale = sc;
697 if ((roundFlag != 0) && (roundBit != 0))
698 RoundUp128 (ref clo, ref chi);
699 }
700
701 // From decimal.c
702 private static void RoundUp128(ref ulong lo, ref ulong hi)
703 {
704 if ((++lo) == 0)
705 ++hi;
706 }
707
708 // From decimal.c
709 private static void DecimalDivSub (ref SqlDecimal x, ref SqlDecimal y, ref ulong clo, ref ulong chi, ref int exp)
710 {
711 ulong xlo, xmi, xhi;
712 ulong tlo = 0;
713 ulong tmi = 0;
714 ulong thi = 0;;
715 uint ylo = 0;
716 uint ymi = 0;
717 uint ymi2 = 0;
718 uint yhi = 0;
719 int ashift = 0;
720 int bshift = 0;
721 int extraBit = 0;
722
723 xhi = (ulong)((ulong)x.Data [3] << 32) | (ulong)x.Data [2];
724 xmi = (ulong)((ulong)x.Data [1] << 32) | (ulong)x.Data [0];
725 xlo = (uint)0;
726 ylo = (uint)y.Data [0];
727 ymi = (uint)y.Data [1];
728 ymi2 = (uint)y.Data [2];
729 yhi = (uint)y.Data [3];
730
731 if (ylo == 0 && ymi == 0 && ymi2 == 0 && yhi == 0)
732 throw new DivideByZeroException ();
733
734 if (xmi == 0 && xhi == 0) {
735 clo = chi = 0;
736 return;
737 }
738
739 // enlarge dividend to get maximal precision
740 for (ashift = 0; (xhi & LIT_GUINT64_HIGHBIT) == 0; ++ashift)
741 LShift128 (ref xmi, ref xhi);
742
743 // ensure that divisor is at least 2^95
744 for (bshift = 0; (yhi & LIT_GUINT32_HIGHBIT) == 0; ++bshift)
745 LShift128 (ref ylo, ref ymi, ref ymi2, ref yhi);
746
747 thi = ((ulong)yhi) << 32 | (ulong)ymi2;
748 tmi = ((ulong)ymi) << 32 | (ulong)ylo;
749 tlo = 0;
750
751 if (xhi > thi || (xhi == thi && xmi >=tmi)) {
752 Sub192(xlo, xmi, xhi, tlo, tmi, thi, ref xlo, ref xmi, ref xhi);
753 extraBit = 1;
754 } else {
755 extraBit = 0;
756 }
757
758 Div192By128To128 (xlo, xmi, xhi, ylo, ymi, ymi2, yhi, ref clo, ref chi);
759
760 exp = 128 + ashift - bshift;
761
762 if (extraBit != 0) {
763 RShift128 (ref clo, ref chi);
764 chi += LIT_GUINT64_HIGHBIT;
765 exp--;
766 }
767
768 // try loss free right shift
769 while (exp > 0 && (clo & 1) == 0) {
770 RShift128 (ref clo, ref chi);
771 exp--;
772 }
773 }
774
775 // From decimal.c
776 private static void RShift192(ref ulong lo, ref ulong mi, ref ulong hi)
777 {
778
779 lo >>= 1;
780 if ((mi & 1) != 0)
781 lo |= LIT_GUINT64_HIGHBIT;
782
783 mi >>= 1;
784 if ((hi & 1) != 0)
785 mi |= LIT_GUINT64_HIGHBIT;
786
787 hi >>= 1;
788 }
789
790 // From decimal.c
791 private static void RShift128(ref ulong lo, ref ulong hi)
792 {
793 lo >>=1;
794 if ((hi & 1) != 0)
795 lo |= LIT_GUINT64_HIGHBIT;
796 hi >>= 1;
797 }
798
799 // From decimal.c
800 private static void LShift128(ref ulong lo, ref ulong hi)
801 {
802 hi <<= 1;
803
804 if ((lo & LIT_GUINT64_HIGHBIT) != 0)
805 hi++;
806
807 lo <<= 1;
808 }
809
810 // From decimal.c
811 private static void LShift128(ref uint lo, ref uint mi, ref uint mi2, ref uint hi)
812 {
813 hi <<= 1;
814 if ((mi2 & LIT_GUINT32_HIGHBIT) != 0)
815 hi++;
816
817 mi2 <<= 1;
818 if ((mi & LIT_GUINT32_HIGHBIT) != 0)
819 mi2++;
820
821 mi <<= 1;
822 if ((lo & LIT_GUINT32_HIGHBIT) != 0)
823 mi++;
824
825 lo <<= 1;
826 }
827
828 // From decimal.c
829 private static void Div192By128To128 (ulong xlo, ulong xmi, ulong xhi,
830 uint ylo, uint ymi, uint ymi2,
831 uint yhi, ref ulong clo, ref ulong chi)
832 {
833 ulong rlo, rmi, rhi; // remainders
834 uint h, c;
835
836 rlo = xlo;
837 rmi = xmi;
838 rhi = xhi;
839
840 h = Div192By128To32WithRest (ref rlo, ref rmi, ref rhi, ylo, ymi, ymi2, yhi);
841
842 // mid 32 bit
843 rhi = (rhi << 32) | (rmi >> 32);
844 rmi = (rmi << 32) | (rlo >> 32);
845 rlo <<= 32;
846
847 chi = (((ulong)h) << 32) | Div192By128To32WithRest (
848 ref rlo, ref rmi, ref rhi, ylo, ymi, ymi2, yhi);
849
850 // low 32 bit
851 rhi = (rhi << 32) | (rmi >> 32);
852 rmi = (rmi << 32) | (rlo >> 32);
853 rlo <<= 32;
854
855 h = Div192By128To32WithRest (ref rlo, ref rmi, ref rhi,
856 ylo, ymi, ymi2, yhi);
857
858 // estimate lowest 32 bit (two last bits may be wrong)
859 if (rhi >= yhi)
860 c = 0xFFFFFFFF;
861 else {
862 rhi <<= 32;
863 c = (uint)(rhi / yhi);
864 }
865
866 clo = (((ulong)h) << 32) | c;
867 }
868
869 // From decimal.c
870 private static uint Div192By128To32WithRest(ref ulong xlo, ref ulong xmi,
871 ref ulong xhi, uint ylo,
872 uint ymi, uint ymi2, uint yhi)
873 {
874 ulong rlo, rmi, rhi; // remainder
875 ulong tlo = 0;
876 ulong thi = 0;
877 uint c;
878
879 rlo = xlo;
880 rmi = xmi;
881 rhi = xhi;
882
883 if (rhi >= (((ulong)yhi << 32)))
884 c = 0xFFFFFFFF;
885 else
886 c = (uint) (rhi / yhi);
887
888 Mult128By32To128 (ylo, ymi, ymi2, yhi, c, ref tlo, ref thi);
889 Sub192 (rlo, rmi, rhi, 0, tlo, thi, ref rlo, ref rmi, ref rhi);
890
891 while (((long)rhi) < 0) {
892 c--;
893 Add192 (rlo, rmi, rhi, 0, (((ulong)ymi) << 32) | ylo, yhi | ymi2, ref rlo, ref rmi, ref rhi);
894 }
895 xlo = rlo;
896 xmi = rmi;
897 xhi = rhi;
898
899 return c;
900 }
901
902 // From decimal.c
903 private static void Mult192By32 (ref ulong clo, ref ulong cmi, ref ulong chi, ulong factor, int roundBit)
904 {
905 ulong a = 0;
906 uint h0 = 0;
907 uint h1 = 0;
908 uint h2 = 0;
909
910 a = ((ulong)(uint)clo) * factor;
911
912 if (roundBit != 0)
913 a += factor / 2;
914
915 h0 = (uint)a;
916 a >>= 32;
917 a += (clo >> 32) * factor;
918 h1 = (uint)a;
919
920 clo = ((ulong)h1) << 32 | h0;
921
922 a >>= 32;
923 a += ((ulong)(uint)cmi) * factor;
924 h0 = (uint)a;
925
926 a >>= 32;
927 a += (cmi >> 32) * factor;
928 h1 = (uint)a;
929
930 cmi = ((ulong)h1) << 32 | h0;
931 a >>= 32;
932 a += ((ulong)(uint)chi) * factor;
933 h0 = (uint)a;
934
935 a >>= 32;
936 a += (chi >> 32) * factor;
937 h1 = (uint)a;
938 chi = ((ulong)h1) << 32 | h0;
939 }
940
941 // From decimal.c
942 private static void Mult128By32 (ref ulong clo, ref ulong chi, uint factor, int roundBit)
943 {
944 ulong a = 0;
945 uint h0 = 0;
946 uint h1 = 0;
947 uint h2 = 0;
948
949 a = ((ulong)(uint)clo) * factor;
950
951 if (roundBit != 0)
952 a += factor / 2;
953
954 h0 = (uint)a;
955
956 a >>= 32;
957 a += (clo >> 32) * factor;
958 h1 = (uint)a;
959
960 clo = ((ulong)h1) << 32 | h0;
961
962 a >>= 32;
963 a += ((ulong)(uint)chi) * factor;
964 h0 = (uint)a;
965
966 a >>= 32;
967 a += (chi >> 32) * factor;
968 h1 = (uint)a;
969
970 chi = ((ulong)h1) << 32 | h0;
971 }
972
973
974 // From decimal.c
975 private static void Mult128By32To128(uint xlo, uint xmi, uint xmi2, uint xhi,
976 uint factor, ref ulong clo, ref ulong chi)
977 {
978 ulong a;
979 uint h0, h1, h2;
980
981 a = ((ulong)xlo) * factor;
982 h0 = (uint)a;
983
984 a >>= 32;
985 a += ((ulong)xmi) * factor;
986 h1 = (uint)a;
987
988 a >>= 32;
989 a += ((ulong)xmi2) * factor;
990 h2 = (uint)a;
991
992 a >>= 32;
993 a += ((ulong)xhi) * factor;
994
995 clo = ((ulong)h1) << 32 | h0;
996 chi = a | h2;
997 }
998
999 // From decimal.c
1000 private static void Add192 (ulong xlo, ulong xmi, ulong xhi,
1001 ulong ylo, ulong ymi, ulong yhi,
1002 ref ulong clo, ref ulong cmi, ref ulong chi)
1003 {
1004 xlo += ylo;
1005 if (xlo < ylo) {
1006 xmi++;
1007 if (xmi == 0)
1008 xhi++;
1009 }
1010
1011 xmi += ymi;
1012
1013 if (xmi < ymi)
1014 xmi++;
1015
1016 xhi += yhi;
1017 clo = xlo;
1018 cmi = xmi;
1019 chi = xhi;
1020 }
1021
1022 // From decimal.c
1023 private static void Sub192 (ulong xlo, ulong xmi, ulong xhi,
1024 ulong ylo, ulong ymi, ulong yhi,
1025 ref ulong lo, ref ulong mi, ref ulong hi)
1026 {
1027
1028 ulong clo = 0;
1029 ulong cmi = 0;
1030 ulong chi = 0;
1031
1032 clo = xlo - ylo;
1033 cmi = xmi - ymi;
1034 chi = xhi - yhi;
1035
1036 if (xlo < ylo) {
1037 if (cmi == 0)
1038 chi--;
1039 cmi--;
1040 }
1041
1042 if (xmi < ymi)
1043 chi--;
1044
1045 lo = clo;
1046 mi = cmi;
1047 hi = chi;
1048 }
1049
1050 public static SqlDecimal Truncate (SqlDecimal n, int position)
1051 {
1052 int diff = n.scale - position;
1053 if (diff == 0)
1054 return n;
1055 int [] data = n.Data;
1056 decimal d = new decimal (data [0], data [1], data [2], !n.positive, 0);
1057 decimal x = 10;
1058 for (int i = 0; i < diff; i++, x *= 10)
1059 d = d - d % x;
1060 data = Decimal.GetBits (d);
1061 data [3] = 0;
1062 return new SqlDecimal (n.precision, n.scale, n.positive, data);
1063 }
1064
1065 public static SqlDecimal operator + (SqlDecimal x, SqlDecimal y)
1066 {
1067 // if one of them is negative, perform subtraction
1068 if (x.IsPositive && !y.IsPositive) return x - y;
1069 if (y.IsPositive && !x.IsPositive) return y - x;
1070
1071 // adjust the scale to the larger of the two beforehand
1072 if (x.scale > y.scale)
1073 y = SqlDecimal.AdjustScale (y, x.scale - y.scale, true); // FIXME: should be false (fix it after AdjustScale(,,false) is fixed)
1074 else if (y.scale > x.scale)
1075 x = SqlDecimal.AdjustScale (x, y.scale - x.scale, true); // FIXME: should be false (fix it after AdjustScale(,,false) is fixed)
1076
1077 // set the precision to the greater of the two
1078 byte resultPrecision;
1079 if (x.Precision > y.Precision)
1080 resultPrecision = x.Precision;
1081 else
1082 resultPrecision = y.Precision;
1083
1084 int[] xData = x.Data;
1085 int[] yData = y.Data;
1086 int[] resultBits = new int[4];
1087
1088 ulong res;
1089 ulong carry = 0;
1090
1091 // add one at a time, and carry the results over to the next
1092 for (int i = 0; i < 4; i +=1)
1093 {
1094 carry = 0;
1095 res = (ulong)(xData[i]) + (ulong)(yData[i]) + carry;
1096 if (res > Int32.MaxValue)
1097 {
1098 carry = res - Int32.MaxValue;
1099 res = Int32.MaxValue;
1100 }
1101 resultBits [i] = (int)res;
1102 }
1103
1104 // if we have carry left, then throw an exception
1105 if (carry > 0)
1106 throw new OverflowException ();
1107 else
1108 return new SqlDecimal (resultPrecision, x.Scale, x.IsPositive, resultBits);
1109 }
1110
1111 public static SqlDecimal operator / (SqlDecimal x, SqlDecimal y)
1112 {
1113 // return new SqlDecimal (x.Value / y.Value);
1114 return DecimalDiv (x, y);
1115 }
1116
1117 public static SqlBoolean operator == (SqlDecimal x, SqlDecimal y)
1118 {
1119 if (x.IsNull || y.IsNull)
1120 return SqlBoolean.Null;
1121
1122 if (x.Scale > y.Scale)
1123 y = SqlDecimal.AdjustScale(y, x.Scale - y.Scale, false);
1124 else if (y.Scale > x.Scale)
1125 x = SqlDecimal.AdjustScale(y, y.Scale - x.Scale, false);
1126
1127 for (int i = 0; i < 4; i += 1)
1128 {
1129 if (x.Data[i] != y.Data[i])
1130 return new SqlBoolean (false);
1131 }
1132 return new SqlBoolean (true);
1133 }
1134
1135 public static SqlBoolean operator > (SqlDecimal x, SqlDecimal y)
1136 {
1137 if (x.IsNull || y.IsNull)
1138 return SqlBoolean.Null;
1139
1140 if (x.Scale > y.Scale)
1141 y = SqlDecimal.AdjustScale(y, x.Scale - y.Scale, false);
1142 else if (y.Scale > x.Scale)
1143 x = SqlDecimal.AdjustScale(x, y.Scale - x.Scale, false);
1144
1145 for (int i = 3; i >= 0; i--)
1146 {
1147 if (x.Data[i] == 0 && y.Data[i] == 0)
1148 continue;
1149 else
1150 return new SqlBoolean (x.Data[i] > y.Data[i]);
1151 }
1152 return new SqlBoolean (false);
1153 }
1154
1155 public static SqlBoolean operator >= (SqlDecimal x, SqlDecimal y)
1156 {
1157 if (x.IsNull || y.IsNull)
1158 return SqlBoolean.Null;
1159
1160 if (x.Scale > y.Scale)
1161 y = SqlDecimal.AdjustScale(y, x.Scale - y.Scale, true);
1162 else if (y.Scale > x.Scale)
1163 x = SqlDecimal.AdjustScale(x, y.Scale - x.Scale, true);
1164
1165 for (int i = 3; i >= 0; i -= 1)
1166 {
1167 if (x.Data[i] == 0 && y.Data[i] == 0)
1168 continue;
1169 else
1170 return new SqlBoolean (x.Data[i] >= y.Data[i]);
1171 }
1172 return new SqlBoolean (true);
1173 }
1174
1175 public static SqlBoolean operator != (SqlDecimal x, SqlDecimal y)
1176 {
1177 if (x.IsNull || y.IsNull)
1178 return SqlBoolean.Null;
1179
1180 if (x.Scale > y.Scale)
1181 x = SqlDecimal.AdjustScale(x, y.Scale - x.Scale, true);
1182 else if (y.Scale > x.Scale)
1183 y = SqlDecimal.AdjustScale(y, x.Scale - y.Scale, true);
1184
1185 for (int i = 0; i < 4; i += 1)
1186 {
1187 if (x.Data[i] != y.Data[i])
1188 return new SqlBoolean (true);
1189 }
1190 return new SqlBoolean (false);
1191 }
1192
1193 public static SqlBoolean operator < (SqlDecimal x, SqlDecimal y)
1194 {
1195
1196 if (x.IsNull || y.IsNull)
1197 return SqlBoolean.Null;
1198
1199 if (x.Scale > y.Scale)
1200 y = SqlDecimal.AdjustScale(y, x.Scale - y.Scale, true);
1201 else if (y.Scale > x.Scale)
1202 x = SqlDecimal.AdjustScale(x, y.Scale - x.Scale, true);
1203
1204 for (int i = 3; i >= 0; i -= 1)
1205 {
1206 if (x.Data[i] == 0 && y.Data[i] == 0)
1207 continue;
1208
1209 return new SqlBoolean (x.Data[i] < y.Data[i]);
1210 }
1211 return new SqlBoolean (false);
1212
1213 }
1214
1215 public static SqlBoolean operator <= (SqlDecimal x, SqlDecimal y)
1216 {
1217 if (x.IsNull || y.IsNull)
1218 return SqlBoolean.Null;
1219
1220 if (x.Scale > y.Scale)
1221 y = SqlDecimal.AdjustScale(y, x.Scale - y.Scale, true);
1222 else if (y.Scale > x.Scale)
1223 x = SqlDecimal.AdjustScale(x, y.Scale - x.Scale, true);
1224
1225 for (int i = 3; i >= 0; i -= 1)
1226 {
1227 if (x.Data[i] == 0 && y.Data[i] == 0)
1228 continue;
1229 else
1230 return new SqlBoolean (x.Data[i] <= y.Data[i]);
1231 }
1232 return new SqlBoolean (true);
1233 }
1234
1235 public static SqlDecimal operator * (SqlDecimal x, SqlDecimal y)
1236 {
1237 // adjust the scale to the smaller of the two beforehand
1238 if (x.Scale > y.Scale)
1239 x = SqlDecimal.AdjustScale(x, y.Scale - x.Scale, true);
1240 else if (y.Scale > x.Scale)
1241 y = SqlDecimal.AdjustScale(y, x.Scale - y.Scale, true);
1242
1243 // set the precision to the greater of the two
1244 byte resultPrecision;
1245 if (x.Precision > y.Precision)
1246 resultPrecision = x.Precision;
1247 else
1248 resultPrecision = y.Precision;
1249
1250 int[] xData = x.Data;
1251 int[] yData = y.Data;
1252 int[] resultBits = new int[4];
1253
1254 ulong res;
1255 ulong carry = 0;
1256
1257 // multiply one at a time, and carry the results over to the next
1258 for (int i = 0; i < 4; i +=1)
1259 {
1260 carry = 0;
1261 res = (ulong)(xData[i]) * (ulong)(yData[i]) + carry;
1262 if (res > Int32.MaxValue)
1263 {
1264 carry = res - Int32.MaxValue;
1265 res = Int32.MaxValue;
1266 }
1267 resultBits [i] = (int)res;
1268 }
1269
1270 // if we have carry left, then throw an exception
1271 if (carry > 0)
1272 throw new OverflowException ();
1273 else
1274 return new SqlDecimal (resultPrecision, x.Scale, (x.IsPositive == y.IsPositive), resultBits);
1275
1276 }
1277
1278 public static SqlDecimal operator - (SqlDecimal x, SqlDecimal y)
1279 {
1280 if (x.IsPositive && !y.IsPositive) return x + y;
1281 if (!x.IsPositive && y.IsPositive) return -(x + y);
1282 if (!x.IsPositive && !y.IsPositive) return y - x;
1283
1284 // otherwise, x is positive and y is positive
1285 bool resultPositive = (bool)(x > y);
1286 int[] yData = y.Data;
1287
1288 for (int i = 0; i < 4; i += 1) yData[i] = -yData[i];
1289
1290 SqlDecimal yInverse = new SqlDecimal (y.Precision, y.Scale, y.IsPositive, yData);
1291
1292 if (resultPositive)
1293 return x + yInverse;
1294 else
1295 return -(x + yInverse);
1296 }
1297
1298 public static SqlDecimal operator - (SqlDecimal n)
1299 {
1300 return new SqlDecimal (n.Precision, n.Scale, !n.IsPositive, n.Data);
1301 }
1302
1303 public static explicit operator SqlDecimal (SqlBoolean x)
1304 {
1305 if (x.IsNull)
1306 return Null;
1307 else
1308 return new SqlDecimal ((decimal)x.ByteValue);
1309 }
1310
1311 public static explicit operator Decimal (SqlDecimal n)
1312 {
1313 return n.Value;
1314 }
1315
1316 public static explicit operator SqlDecimal (SqlDouble x)
1317 {
1318 checked {
1319 if (x.IsNull)
1320 return Null;
1321 else
1322 return new SqlDecimal ((double)x.Value);
1323 }
1324 }
1325
1326 public static explicit operator SqlDecimal (SqlSingle x)
1327 {
1328 checked {
1329 if (x.IsNull)
1330 return Null;
1331 else
1332 return new SqlDecimal ((double)x.Value);
1333 }
1334 }
1335
1336 public static explicit operator SqlDecimal (SqlString x)
1337 {
1338 checked {
1339 return Parse (x.Value);
1340 }
1341 }
1342
1343 public static implicit operator SqlDecimal (decimal x)
1344 {
1345 return new SqlDecimal (x);
1346 }
1347
1348 public static implicit operator SqlDecimal (SqlByte x)
1349 {
1350 if (x.IsNull)
1351 return Null;
1352 else
1353 return new SqlDecimal ((decimal)x.Value);
1354 }
1355
1356 public static implicit operator SqlDecimal (SqlInt16 x)
1357 {
1358 if (x.IsNull)
1359 return Null;
1360 else
1361 return new SqlDecimal ((decimal)x.Value);
1362 }
1363
1364 public static implicit operator SqlDecimal (SqlInt32 x)
1365 {
1366 if (x.IsNull)
1367 return Null;
1368 else
1369 return new SqlDecimal ((decimal)x.Value);
1370 }
1371
1372 public static implicit operator SqlDecimal (SqlInt64 x)
1373 {
1374 if (x.IsNull)
1375 return Null;
1376 else
1377 return new SqlDecimal ((decimal)x.Value);
1378 }
1379
1380 public static implicit operator SqlDecimal (SqlMoney x)
1381 {
1382 if (x.IsNull)
1383 return Null;
1384 else
1385 return new SqlDecimal ((decimal)x.Value);
1386 }
1387
1388 #endregion
1389 }
1390 }
Mirror of the official Mono project git repository