sebastienros.jint/Jint/Native/JsNumber.cs

using System.Numerics;
using System.Runtime.CompilerServices;
using Jint.Native.Number;
using Jint.Runtime;

namespace Jint.Native
{
    public sealed class JsNumber : JsValue, IEquatable<JsNumber>
    {
        // .NET double epsilon and JS epsilon have different values
        internal const double JavaScriptEpsilon = 2.2204460492503130808472633361816E-16;

        internal readonly double _value;

        // how many decimals to check when determining if double is actually an int
        internal const double DoubleIsIntegerTolerance = double.Epsilon * 100;

        internal static readonly long NegativeZeroBits = BitConverter.DoubleToInt64Bits(-0.0);

        // we can cache most common values, doubles are used in indexing too at times so we also cache
        // integer values converted to doubles
        private const int NumbersMax = 1024 * 10;
        private static readonly JsNumber[] _intToJsValue;

        internal static readonly JsNumber DoubleNaN = new JsNumber(double.NaN);
        internal static readonly JsNumber DoubleNegativeOne = new JsNumber((double) -1);
        internal static readonly JsNumber DoublePositiveInfinity = new JsNumber(double.PositiveInfinity);
        internal static readonly JsNumber DoubleNegativeInfinity = new JsNumber(double.NegativeInfinity);
        internal static readonly JsNumber IntegerNegativeOne = new JsNumber(-1);
        internal static readonly JsNumber NegativeZero = new JsNumber(-0d);
        internal static readonly JsNumber PositiveZero = new JsNumber(+0);
        internal static readonly JsNumber PositiveOne = new JsNumber(1);
        internal static readonly JsNumber PositiveTwo = new JsNumber(2);
        internal static readonly JsNumber PositiveThree = new JsNumber(3);

        internal static readonly JsNumber PI = new JsNumber(System.Math.PI);

        static JsNumber()
        {
            var integers = new JsNumber[NumbersMax];
            for (uint i = 0; i < (uint) integers.Length; i++)
            {
                integers[i] = new JsNumber(i);
            }
            _intToJsValue = integers;
        }

        public JsNumber(double value) : base(Types.Number)
        {
            _value = value;
        }

        public JsNumber(int value) : base(InternalTypes.Integer)
        {
            _value = value;
        }

        public JsNumber(uint value) : base(value <= int.MaxValue ? InternalTypes.Integer : InternalTypes.Number)
        {
            _value = value;
        }

        public JsNumber(ulong value) : base(value <= int.MaxValue ? InternalTypes.Integer : InternalTypes.Number)
        {
            _value = value;
        }

        public JsNumber(long value) : base(value <= int.MaxValue && value >= int.MinValue ? InternalTypes.Integer : InternalTypes.Number)
        {
            _value = value;
        }

        public override object ToObject()
        {
            return _value;
        }

        internal static JsNumber Create(object value)
        {
            var underlyingType = System.Type.GetTypeCode(Enum.GetUnderlyingType(value.GetType()));
            switch (underlyingType)
            {
                case TypeCode.Int64:
                    return Create(Convert.ToInt64(value));

                case TypeCode.UInt32:
                case TypeCode.UInt64:
                    return Create(Convert.ToUInt64(value));

                default:
                    return Create(Convert.ToInt32(value));
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static JsNumber Create(double value)
        {
            // we expect zero to be on the fast path of integer mostly
            var temp = _intToJsValue;
            if (value >= 1 && value < temp.Length && TypeConverter.IsIntegralNumber(value))
            {
                return temp[(uint) value];
            }

            if (value == -1)
            {
                return DoubleNegativeOne;
            }

            return CreateNumberUnlikely(value);
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private static JsNumber CreateNumberUnlikely(double value)
        {
            if (value <= double.MaxValue && value >= double.MinValue)
            {
                return new JsNumber(value);
            }

            if (value == double.NegativeInfinity)
            {
                return DoubleNegativeInfinity;
            }

            if (value == double.PositiveInfinity)
            {
                return DoublePositiveInfinity;
            }

            if (double.IsNaN(value))
            {
                return DoubleNaN;
            }

            return new JsNumber(value);
        }

        public static JsNumber Create(byte value)
        {
            return _intToJsValue[value];
        }

        internal static JsNumber Create(sbyte value)
        {
            var temp = _intToJsValue;
            if ((uint) value < (uint) temp.Length)
            {
                return temp[value];
            }
            return new JsNumber(value);
        }

        public static JsNumber Create(int value)
        {
            var temp = _intToJsValue;
            if ((uint) value < (uint) temp.Length)
            {
                return temp[value];
            }

            if (value == -1)
            {
                return IntegerNegativeOne;
            }

            return new JsNumber(value);
        }

        internal static JsNumber Create(uint value)
        {
            var temp = _intToJsValue;
            if (value < (uint) temp.Length)
            {
                return temp[value];
            }

            return new JsNumber(value);
        }

        internal static JsNumber Create(ulong value)
        {
            if (value < (ulong) _intToJsValue.Length)
            {
                return _intToJsValue[value];
            }

            return new JsNumber(value);
        }

        public static JsNumber Create(long value)
        {
            if ((ulong) value < (ulong) _intToJsValue.Length)
            {
                return _intToJsValue[value];
            }

            return new JsNumber(value);
        }

        public static JsNumber Create(JsValue jsValue)
        {
            if (jsValue is JsNumber number)
            {
                return number;
            }

            return Create(TypeConverter.ToNumber(jsValue));
        }

        public override string ToString()
        {
            return TypeConverter.ToString(_value);
        }

        internal bool IsNaN()
        {
            return double.IsNaN(_value);
        }

        /// <summary>
        /// Either positive or negative zero.
        /// </summary>
        internal bool IsZero()
        {
            return IsNegativeZero() || IsPositiveZero();
        }

        internal bool IsNegativeZero()
        {
            return NumberInstance.IsNegativeZero(_value);
        }

        internal bool IsPositiveZero()
        {
            return NumberInstance.IsPositiveZero(_value);
        }

        internal bool IsPositiveInfinity()
        {
            return double.IsPositiveInfinity(_value);
        }

        internal bool IsNegativeInfinity()
        {
            return double.IsNegativeInfinity(_value);
        }

        public override bool IsLooselyEqual(JsValue value)
        {
            if (value is JsNumber jsNumber)
            {
                return Equals(jsNumber);
            }

            if (value.IsBigInt())
            {
                return TypeConverter.IsIntegralNumber(_value) && new BigInteger(_value) == value.AsBigInt();
            }

            return base.IsLooselyEqual(value);
        }

        public override bool Equals(JsValue? obj)
        {
            return Equals(obj as JsNumber);
        }

        public override bool Equals(object? obj)
        {
            return Equals(obj as JsNumber);
        }

        public bool Equals(JsNumber? other)
        {
            if (other is null)
            {
                return false;
            }

            if (double.IsNaN(_value) || double.IsNaN(other._value))
            {
                return false;
            }

            if (ReferenceEquals(this, other))
            {
                return true;
            }

            return _value == other._value;
        }

        public override int GetHashCode()
        {
            return _value.GetHashCode();
        }
    }
}