Пример #1
0
        public static object LessThanEqual(decimal x, object other)
        {
            object res = FloatOps.Compare((double)x, other);

            if (res != Ops.NotImplemented)
            {
                return(Ops.Bool2Object((int)res <= 0));
            }
            return(res);
        }
Пример #2
0
        public static object Compare(int self, object obj)
        {
            if (obj == null)
            {
                return(1);
            }

            int otherInt;

            if (obj is int)
            {
                otherInt = (int)obj;
            }
            else if (obj is ExtensibleInt)
            {
                otherInt = ((ExtensibleInt)obj).value;
            }
            else if (obj is bool)
            {
                otherInt = ((bool)obj) ? 1 : 0;
            }
            else if (obj is double)
            {
                // compare as double to avoid truncation issues
                return(FloatOps.Compare((double)self, (double)obj));
            }
            else if (obj is ExtensibleFloat)
            {
                // compare as double to avoid truncation issues
                return(FloatOps.Compare((double)self, ((ExtensibleFloat)obj).value));
            }
            else if (obj is Decimal)
            {
                return(FloatOps.Compare((double)self, (double)(decimal)obj));
            }
            else
            {
                Conversion conv;
                otherInt = Converter.TryConvertToInt32(obj, out conv);
                if (conv == Conversion.None)
                {
                    object res = Ops.GetDynamicType(obj).Coerce(obj, self);
                    if (res != Ops.NotImplemented && !(res is OldInstance))
                    {
                        return(Ops.Compare(((Tuple)res)[1], ((Tuple)res)[0]));
                    }
                    return(Ops.NotImplemented);
                }
            }

            return(self == otherInt ? 0 : (self < otherInt ? -1 : +1));
        }
Пример #3
0
        public object CompareTo(object other)
        {
            if (other == null)
            {
                return(1);
            }

            double     otherDbl;
            Conversion conv;

            if (other is float)
            {
                return(FloatOps.Compare(value, (int)other));
            }
            else if (other is ExtensibleFloat)
            {
                return(FloatOps.Compare(value, ((ExtensibleFloat)other).value));
            }
            else if (other is bool)
            {
                return(FloatOps.Compare(value, ((bool)other) ? 1 : 0));
            }
            else if (other is int)
            {
                return(FloatOps.Compare(value, (double)((int)other)));
            }
            else if (other is ExtensibleInt)
            {
                return(FloatOps.Compare(value, (double)((ExtensibleInt)other).value));
            }
            else
            {
                otherDbl = Converter.TryConvertToDouble(other, out conv);
                if (conv != Conversion.None)
                {
                    return(FloatOps.Compare(value, otherDbl));
                }
            }

            return(Ops.NotImplemented);
        }
Пример #4
0
        public static object Compare(BigInteger x, object y)
        {
            if (y == null)
            {
                return(1);
            }

            int intVal;

            if (y is int)
            {
                if (x.AsInt32(out intVal))
                {
                    return(IntOps.Compare(intVal, y));
                }
            }
            else if (y is ExtensibleInt)
            {
                if (x.AsInt32(out intVal))
                {
                    return(IntOps.Compare(intVal, ((ExtensibleInt)y).value));
                }
            }
            else if (y is double)
            {
                double dbl = x.ToFloat64();
                return(FloatOps.Compare(dbl, y));
            }
            else if (y is ExtensibleFloat)
            {
                double dbl = x.ToFloat64();
                return(FloatOps.Compare(dbl, ((ExtensibleFloat)y).value));
            }
            else if (y is bool)
            {
                if (x.AsInt32(out intVal))
                {
                    return(IntOps.Compare(intVal, ((bool)y) ? 1 : 0));
                }
            }
            else if (y is decimal)
            {
                double dbl = x.ToFloat64();
                return(FloatOps.Compare(dbl, y));
            }

            Conversion conv;
            BigInteger bi = Converter.TryConvertToBigInteger(y, out conv);

            if (conv == Conversion.None)
            {
                object res = Ops.GetDynamicType(y).Coerce(y, x);
                if (res != Ops.NotImplemented && !(res is OldInstance))
                {
                    return(Ops.Compare(((Tuple)res)[1], ((Tuple)res)[0]));
                }
                return(Ops.NotImplemented);
            }

            BigInteger diff = x - bi;

            if (diff == 0)
            {
                return(0);
            }
            else if (diff < 0)
            {
                return(-1);
            }
            else
            {
                return(1);
            }
        }
Пример #5
0
 public static object Compare(decimal x, object other)
 {
     return(FloatOps.Compare((double)x, other));
 }