DoubleNumber.cs

using System;
using System.Reflection;
using Waher.Script.Abstraction.Sets;
using Waher.Script.Abstraction.Elements;
 
namespace Waher.Script.Objects
{
    public sealed class DoubleNumber : FieldElement
    {
        public static readonly DoubleNumber ZeroElement = new DoubleNumber(0);
 
        public static readonly DoubleNumber OneElement = new DoubleNumber(1);
 
        public static readonly DoubleNumber TwoElement = new DoubleNumber(2);
 
        public static readonly DoubleNumber ThreeElement = new DoubleNumber(3);
 
        private double value;
 
        public DoubleNumber(double Value)
        {
            this.value = Value;
        }
 
        public double Value
        {
            get => this.value;
            set => this.value = value;
        }
 
        public override string ToString()
        {
            return Expression.ToString(this.value);
        }
 
        public override IField AssociatedField
        {
            get { return DoubleNumbers.Instance; }
        }
 
        public override object AssociatedObjectValue => this.value;
 
        public override ICommutativeRingElement Multiply(ICommutativeRingElement Element)
        {
            if (Element.AssociatedObjectValue is double d)
                return new DoubleNumber(this.value * d);
            else
                return null;
        }
 
        public override IRingElement Invert()
        {
            return new DoubleNumber(1.0 / this.value);
        }
 
        public override IAbelianGroupElement Add(IAbelianGroupElement Element)
        {
            if (Element.AssociatedObjectValue is double d)
                return new DoubleNumber(this.value + d);
            else
                return null;
        }
 
        public override IGroupElement Negate()
        {
            return new DoubleNumber(-this.value);
        }
 
        public override bool Equals(object obj)
        {
            if (!(obj is IElement E))
                return false;
 
            if (E.AssociatedObjectValue is double d)
                return this.value == d;
            else
                return false;
        }
 
        public override int GetHashCode()
        {
            return this.value.GetHashCode();
        }
 
        public override IAbelianGroupElement Zero
        {
            get { return ZeroElement; }
        }
 
        public override ICommutativeRingWithIdentityElement One
        {
            get { return OneElement; }
        }
 
        public override bool TryConvertTo(Type DesiredType, out object Value)
        {
            if (DesiredType == typeof(byte))
            {
                if (this.value >= byte.MinValue && this.value <= byte.MaxValue)
                {
                    Value = (byte)this.value;
                    return true;
                }
            }
            else if (DesiredType == typeof(decimal))
            {
                Value = (decimal)this.value;
                return true;
            }
            else if (DesiredType == typeof(double))
            {
                Value = (double)this.value;
                return true;
            }
            else if (DesiredType == typeof(short))
            {
                if (this.value >= short.MinValue && this.value <= short.MaxValue)
                {
                    Value = (short)this.value;
                    return true;
                }
            }
            else if (DesiredType == typeof(int))
            {
                if (this.value >= int.MinValue && this.value <= int.MaxValue)
                {
                    Value = (int)this.value;
                    return true;
                }
            }
            else if (DesiredType == typeof(long))
            {
                if (this.value >= long.MinValue && this.value <= long.MaxValue)
                {
                    Value = (long)this.value;
                    return true;
                }
            }
            else if (DesiredType == typeof(sbyte))
            {
                if (this.value >= sbyte.MinValue && this.value <= sbyte.MaxValue)
                {
                    Value = (sbyte)this.value;
                    return true;
                }
            }
            else if (DesiredType == typeof(float))
            {
                Value = (float)this.value;
                return true;
            }
            else if (DesiredType == typeof(ushort))
            {
                if (this.value >= ushort.MinValue && this.value <= ushort.MaxValue)
                {
                    Value = (ushort)this.value;
                    return true;
                }
            }
            else if (DesiredType == typeof(uint))
            {
                if (this.value >= uint.MinValue && this.value <= uint.MaxValue)
                {
                    Value = (uint)this.value;
                    return true;
                }
            }
            else if (DesiredType == typeof(ulong))
            {
                if (this.value >= ulong.MinValue && this.value <= ulong.MaxValue)
                {
                    Value = (ulong)this.value;
                    return true;
                }
            }
            else if (DesiredType == typeof(DoubleNumber))
            {
                Value = this;
                return true;
            }
            else
            {
                TypeInfo TI = DesiredType.GetTypeInfo();
 
                if (TI.IsEnum)
                {
                    Value = Enum.ToObject(DesiredType, (int)this.value);
                    return true;
                }
                else if (TI.IsAssignableFrom(typeof(double).GetTypeInfo()))
                {
                    Value = this.value;
                    return true;
                }
            }
 
            return Expression.TryConvert(this.value, DesiredType, out Value);
        }
    }
}