ComplexNumber.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 ComplexNumber : FieldElement
    {
        private static readonly ComplexNumbers associatedField = new ComplexNumbers();
 
        private Complex value;
 
        public ComplexNumber(Complex Value)
        {
            this.value = Value;
        }
 
        public ComplexNumber(double Re, double Im)
        {
            this.value = new Complex(Re, Im);
        }
 
        public Complex Value
        {
            get => this.value;
            set => this.value = value;
        }
 
        public override string ToString()
        {
            return Expression.ToString(this.value);
        }
 
        public override IField AssociatedField
        {
            get { return associatedField; }
        }
 
        public override object AssociatedObjectValue => this.value;
 
        public override ICommutativeRingElement Multiply(ICommutativeRingElement Element)
        {
            object Obj = Element.AssociatedObjectValue;
 
            if (Obj is Complex z)
                return new ComplexNumber(this.value * z);
            else if (Obj is double d)
                return new ComplexNumber(this.value * d);
            else
                return null;
        }
 
        public override IRingElement Invert()
        {
            return new ComplexNumber(1.0 / this.value);
        }
 
        public override IAbelianGroupElement Add(IAbelianGroupElement Element)
        {
            object Obj = Element.AssociatedObjectValue;
 
            if (Obj is Complex z)
                return new ComplexNumber(this.value + z);
            else if (Obj is double d)
                return new ComplexNumber(this.value + d);
            else
                return null;
        }
 
        public override IGroupElement Negate()
        {
            return new ComplexNumber(-this.value);
        }
 
        public override bool Equals(object obj)
        {
            if (!(obj is IElement E))
                return false;
 
            object Obj = E.AssociatedObjectValue;
 
            if (Obj is Complex z)
                return this.value == z;
            else if (Obj is double d)
                return this.value == d;
            else
                return false;
        }
 
        public override int GetHashCode()
        {
            return this.value.GetHashCode();
        }
 
        public override IAbelianGroupElement Zero
        {
            get { return ComplexNumbers.zero; }
        }
 
        public override ICommutativeRingWithIdentityElement One
        {
            get { return ComplexNumbers.one; }
        }
 
        public override bool TryConvertTo(Type DesiredType, out object Value)
        {
            if (DesiredType.GetTypeInfo().IsAssignableFrom(typeof(Complex).GetTypeInfo()))
            {
                Value = this.value;
                return true;
            }
            else if (this.value.Imaginary == 0)
            {
                double d = this.value.Real;
 
                if (DesiredType == typeof(byte))
                {
                    if (d >= byte.MinValue && d <= byte.MaxValue)
                    {
                        Value = (byte)d;
                        return true;
                    }
                }
                else if (DesiredType == typeof(decimal))
                {
                    Value = (decimal)d;
                    return true;
                }
                else if (DesiredType == typeof(double))
                {
                    Value = (double)d;
                    return true;
                }
                else if (DesiredType == typeof(short))
                {
                    if (d >= short.MinValue && d <= short.MaxValue)
                    {
                        Value = (short)d;
                        return true;
                    }
                }
                else if (DesiredType == typeof(int))
                {
                    if (d >= int.MinValue && d <= int.MaxValue)
                    {
                        Value = (int)d;
                        return true;
                    }
                }
                else if (DesiredType == typeof(long))
                {
                    if (d >= long.MinValue && d <= long.MaxValue)
                    {
                        Value = (long)d;
                        return true;
                    }
                }
                else if (DesiredType == typeof(sbyte))
                {
                    if (d >= sbyte.MinValue && d <= sbyte.MaxValue)
                    {
                        Value = (sbyte)d;
                        return true;
                    }
                }
                else if (DesiredType == typeof(float))
                {
                    Value = (float)d;
                    return true;
                }
                else if (DesiredType == typeof(ushort))
                {
                    if (d >= ushort.MinValue && d <= ushort.MaxValue)
                    {
                        Value = (ushort)d;
                        return true;
                    }
                }
                else if (DesiredType == typeof(uint))
                {
                    if (d >= uint.MinValue && d <= uint.MaxValue)
                    {
                        Value = (uint)d;
                        return true;
                    }
                }
                else if (DesiredType == typeof(ulong))
                {
                    if (d >= ulong.MinValue && d <= ulong.MaxValue)
                    {
                        Value = (ulong)d;
                        return true;
                    }
                }
                else if (DesiredType.GetTypeInfo().IsAssignableFrom(typeof(Complex).GetTypeInfo()))
                {
                    Value = this.value;
                    return true;
                }
                else if (DesiredType == typeof(ComplexNumber))
                {
                    Value = this;
                    return true;
                }
            }
 
            return Expression.TryConvert(this.value, DesiredType, out Value);
        }
    }
}