Integer.cs

using System;
using System.Numerics;
using System.Reflection;
using Waher.Script.Abstraction.Sets;
using Waher.Script.Abstraction.Elements;
 
namespace Waher.Script.Objects
{
    public sealed class Integer : EuclidianDomainElement, IOrderedSet
    {
        private static readonly Integers associatedEuclidianDomain = new Integers();
 
        private BigInteger value;
 
        public Integer(BigInteger Value)
        {
            this.value = Value;
        }
 
        public Integer(int Value)
        {
            this.value = Value;
        }
 
        public Integer(uint Value)
        {
            this.value = Value;
        }
 
        public Integer(long Value)
        {
            this.value = Value;
        }
 
        public Integer(ulong Value)
        {
            this.value = Value;
        }
 
        public BigInteger Value
        {
            get => this.value;
            set => this.value = value;
        }
 
        public override string ToString()
        {
            return Expression.ToString(this.value);
        }
 
        public override IEuclidianDomain AssociatedEuclidianDomain
        {
            get { return associatedEuclidianDomain; }
        }
 
        public override object AssociatedObjectValue => this.value;
 
        public override ICommutativeRingElement Multiply(ICommutativeRingElement Element)
        {
            object Obj = Element.AssociatedObjectValue;
 
            if (Obj is BigInteger i)
                return new Integer(this.value * i);
 
            if (Obj is double d)
                return new DoubleNumber((double)this.value * d);
 
            if (Obj is Complex z)
                return new ComplexNumber((double)this.value * z);
 
            return null;
        }
 
        public override IRingElement Invert()
        {
            if (this.value.IsOne || this.value == BigInteger.MinusOne)
                return new Integer(this.value);
            else
                return new RationalNumber(BigInteger.One, this.value);
        }
 
        public override IAbelianGroupElement Add(IAbelianGroupElement Element)
        {
            object Obj = Element.AssociatedObjectValue;
 
            if (Obj is BigInteger i)
                return new Integer(this.value + i);
 
            if (Obj is double d)
                return new DoubleNumber((double)this.value + d);
 
            if (Obj is Complex z)
                return new ComplexNumber((double)this.value + z);
 
            return null;
        }
 
        public override IGroupElement Negate()
        {
            return new Integer(-this.value);
        }
 
        public override bool Equals(object obj)
        {
            if (!(obj is IElement E))
                return false;
 
            object Obj = E.AssociatedObjectValue;
 
            if (Obj is BigInteger i)
                return this.value == i;
 
            if (Obj is double d)
                return (double)this.value == d;
 
            if (Obj is Complex z)
                return (double)this.value == z;
 
            return false;
        }
 
        public override int GetHashCode()
        {
            return this.value.GetHashCode();
        }
 
        public override IAbelianGroupElement Zero
        {
            get { return Integers.zero; }
        }
 
        public override ICommutativeRingWithIdentityElement One
        {
            get { return Integers.one; }
        }
 
        public override bool TryConvertTo(Type DesiredType, out object Value)
        {
            if (DesiredType.GetTypeInfo().IsAssignableFrom(typeof(BigInteger).GetTypeInfo()))
            {
                Value = this.value;
                return true;
            }
            else 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(Integer))
            {
                Value = this;
                return true;
            }
 
            return Expression.TryConvert(this.value, DesiredType, out Value);
        }
 
        public int Compare(IElement x, IElement y)
        {
            return RationalNumbers.CompareNumbers(x, y);
        }
    }
}