Ejemplo n.º 1
0
 public static UInt64 FromFixedPoint32(UInt32 mantissa, int numDigits)
 {
     // TODO: Unsigned comparison could be slightly faster, maybe
     return(numDigits + (Int32.MinValue + BiasedExponentMaxValue - BaseExponent) > (Int32.MinValue + BiasedExponentMaxValue)
                         ? NativeImpl.fromFixedPointU32(mantissa, numDigits)
                         : FromFixedPointFastUnsignedUnchecked(mantissa, numDigits));
 }
Ejemplo n.º 2
0
 public static UInt64 FromFixedPointLimitedU64(UInt64 mantissa, int numDigits)
 {
     Debug.Assert(mantissa < (1UL << 53));
     return(numDigits + (Int32.MinValue + BiasedExponentMaxValue - BaseExponent) > (Int32.MinValue + BiasedExponentMaxValue)
                         ? NativeImpl.fromFixedPoint64((Int64)mantissa, numDigits)
                         : FromFixedPointFastUnsignedUnchecked(mantissa, numDigits));
 }
Ejemplo n.º 3
0
 public static Decimal64 FromFixedPoint(long mantissa, int numberOfDigits)
 {
     // TODO: More optimizations
     return(new Decimal64(
                0 == (mantissa & (-1L << 53))
                         ? DotNetImpl.FromFixedPointLimitedU64((UInt64)mantissa, numberOfDigits)
                         : NativeImpl.fromFixedPoint64(mantissa, numberOfDigits)));
 }
Ejemplo n.º 4
0
        public Decimal64 RoundToNearestTiesAwayFromZero(Decimal64 multiple)
        {
            if (!multiple.IsFinite() || multiple.IsNonPositive())
            {
                throw new ArgumentException("Multiple must be a positive finite number.");
            }
            if (IsNaN())
            {
                return(this);
            }

            UInt64 ratio = NativeImpl.roundToNearestTiesAwayFromZero(NativeImpl.divide(Bits, multiple.Bits));

            return(new Decimal64(NativeImpl.multiply2(ratio, multiple.Bits)));
        }
Ejemplo n.º 5
0
 public Decimal64 Multiply(Decimal64 b)
 {
     return(new Decimal64(NativeImpl.multiply2(Bits, b.Bits)));
 }
Ejemplo n.º 6
0
 public static Decimal ToDecimalFallback(UInt64 value)
 {
     return(new Decimal(NativeImpl.toFloat64(value)));
 }
Ejemplo n.º 7
0
 public long ToLong()
 {
     return(NativeImpl.toInt64(Bits));
 }
Ejemplo n.º 8
0
 public Int64 ToFixedPoint(int numberOfDigits)
 {
     return(NativeImpl.toFixedPoint(Bits, numberOfDigits));
 }
Ejemplo n.º 9
0
 public static Decimal64 operator /(Decimal64 a, Decimal64 b)
 {
     return(new Decimal64(NativeImpl.divide(a.Bits, b.Bits)));
 }
Ejemplo n.º 10
0
 public Decimal64 Divide(Decimal64 b)
 {
     return(new Decimal64(NativeImpl.divide(Bits, b.Bits)));
 }
Ejemplo n.º 11
0
 public static Decimal64 operator *(Int64 a, Decimal64 b)
 {
     return(new Decimal64(NativeImpl.multiplyByInt64(b.Bits, a)));
 }
Ejemplo n.º 12
0
 public static Decimal64 operator *(Decimal64 a, Int64 b)
 {
     return(new Decimal64(NativeImpl.multiplyByInt64(a.Bits, b)));
 }
Ejemplo n.º 13
0
 public Decimal64 MultiplyByInteger(Int64 b)
 {
     return(new Decimal64(NativeImpl.multiplyByInt64(Bits, b)));
 }
Ejemplo n.º 14
0
 public static Decimal64 operator *(Decimal64 a, Decimal64 b)
 {
     return(new Decimal64(NativeImpl.multiply2(a.Bits, b.Bits)));
 }
Ejemplo n.º 15
0
 public Decimal64 Multiply(Decimal64 b, Decimal64 c, Decimal64 d)
 {
     return(new Decimal64(NativeImpl.multiply4(Bits, b.Bits, c.Bits, d.Bits)));
 }
Ejemplo n.º 16
0
 public Decimal64 RoundTowardsZero()
 {
     return(new Decimal64(NativeImpl.roundTowardsZero(Bits)));
 }
Ejemplo n.º 17
0
 public Decimal64 RoundToNearestTiesAwayFromZero()
 {
     return(new Decimal64(NativeImpl.roundToNearestTiesAwayFromZero(Bits)));
 }
Ejemplo n.º 18
0
 public Decimal64 DivideByInteger(Int64 b)
 {
     return(new Decimal64(NativeImpl.divideByInt64(Bits, b)));
 }
Ejemplo n.º 19
0
 public Decimal64 NextDown()
 {
     return(new Decimal64(NativeImpl.nextDown(Bits)));
 }
Ejemplo n.º 20
0
 public static Decimal64 operator /(Decimal64 a, Int64 b)
 {
     return(new Decimal64(NativeImpl.divideByInt64(a.Bits, b)));
 }
Ejemplo n.º 21
0
 public Int32 CompareTo(Decimal64 other)
 {
     return(NativeImpl.compare(Bits, other.Bits));
 }
Ejemplo n.º 22
0
 public Decimal64 MultiplyAndAdd(Decimal64 b, Decimal64 c)
 {
     return(new Decimal64(NativeImpl.multiplyAndAdd(Bits, b.Bits, c.Bits)));
 }
Ejemplo n.º 23
0
 public static Decimal64 FromLong(long value)
 {
     return(new Decimal64(NativeImpl.fromInt64(value)));
 }
Ejemplo n.º 24
0
 public Decimal64 ScaleByPowerOfTen(Int32 n)
 {
     return(new Decimal64(NativeImpl.scaleByPowerOfTen(Bits, n)));
 }
Ejemplo n.º 25
0
 public Decimal64 Mean(Decimal64 b)
 {
     return(new Decimal64(NativeImpl.mean2(Bits, b.Bits)));
 }
Ejemplo n.º 26
0
 public Decimal64 Ceiling()
 {
     return(new Decimal64(NativeImpl.roundTowardsPositiveInfinity(Bits)));
 }
Ejemplo n.º 27
0
 public static UInt64 FromDecimalFallback(Decimal dec)
 {
     return(NativeImpl.fromFloat64((double)dec));
 }
Ejemplo n.º 28
0
 public Decimal64 RoundTowardsNegativeInfinity()
 {
     return(new Decimal64(NativeImpl.roundTowardsNegativeInfinity(Bits)));
 }
Ejemplo n.º 29
0
        internal static UInt64 FromDecimalFloat64(Double x)
        {
            unchecked
            {
                UInt64 y = NativeImpl.fromFloat64(x);
                // Using signed values because unsigned division optimizations are worse than signed
                // in MS .NET, esp. Core2.0 while it should be opposite
                Int64  m;
                UInt64 signAndExp;

                UInt64 notY = ~y;
                if ((SpecialEncodingMask & notY) == 0)
                {
                    // Special value or large coefficient
                    if ((InfinityMask & notY) == 0)
                    {
                        return(y);                        // Infinity etc.
                    }
                    m = (Int64)((y & LargeCoefficientMask) + LargeCoefficientHighBits);
                    //signAndExp = ((y << 2) & SmallCoefficientExponentMask) + (y & SignMask);
                    signAndExp = (y & LargeCoefficientExponentMask) * 4 + (y & SignMask);
                    if ((y & 1) != 0)
                    {
                        goto NeedAdjustment;
                    }
                }
                else
                {
                    // "Normal" value
                    m = (Int64)(y & SmallCoefficientMask);
                    // 16 digits + odd
                    signAndExp = y & (UInt64.MaxValue << ExponentShiftSmall);
                    if ((y & 1) != 0 && (UInt64)m > MaxCoefficient / 10 + 1)
                    {
                        goto NeedAdjustment;
                    }

                    if (0 == m)
                    {
                        return(Zero);
                    }
                }

NeedCanonize:
                for (Int64 n = m; ;)
                {
                    Int64 mNext = n / 10;
                    if (mNext * 10 != n)
                    {
                        return(signAndExp + (UInt64)n);
                    }

                    n           = mNext;
                    signAndExp += 1L << ExponentShiftSmall;
                }

NeedAdjustment:
                // Check the last digit

                Int64 m1 = m + 1;
                m        = m1 / 10;
                if (m1 - m * 10 > 2)
                {
                    return(y);
                }

                signAndExp += 1L << ExponentShiftSmall;
                if (NativeImpl.toFloat64(signAndExp + (UInt64)m) != x)
                {
                    return(y);
                }

                goto NeedCanonize;
            }
        }
Ejemplo n.º 30
0
 public static Decimal64 operator -(Decimal64 a, Decimal64 b)
 {
     return(new Decimal64(NativeImpl.subtract(a.Bits, b.Bits)));
 }