PhysicalQuantity.cs

using System;
using System.Reflection;
using Waher.Script.Abstraction.Sets;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Exceptions;
using Waher.Script.Units;
 
namespace Waher.Script.Objects
{
    public sealed class PhysicalQuantity : FieldElement, IComparable, IPhysicalQuantity
    {
        public static readonly PhysicalQuantity ZeroElement = new PhysicalQuantity(0, Unit.Empty);
 
        public static readonly PhysicalQuantity OneElement = new PhysicalQuantity(1, Unit.Empty);
 
        private static readonly PhysicalQuantities associatedField = new PhysicalQuantities();
 
        private double magnitude;
        private Unit unit;
 
        public PhysicalQuantity(double Magnitude, Unit Unit)
        {
            this.magnitude = Magnitude;
            this.unit = Unit;
        }
 
        public double Magnitude
        {
            get => this.magnitude;
            set => this.magnitude = value;
        }
 
        public Unit Unit
        {
            get => this.unit;
            set => this.unit = value;
        }
 
        public PhysicalQuantity ToPhysicalQuantity() => this;
 
        public override string ToString()
        {
            if (this.unit.IsEmpty)
                return Expression.ToString(this.magnitude);
            else
                return Expression.ToString(this.magnitude) + " " + this.unit.ToString();
        }
 
        public override IField AssociatedField => associatedField;
 
        public override object AssociatedObjectValue => this;
 
        public override ICommutativeRingElement Multiply(ICommutativeRingElement Element)
        {
            if (Element.AssociatedObjectValue is IPhysicalQuantity E)
            {
                PhysicalQuantity Q = E.ToPhysicalQuantity();
                Unit Unit = Unit.Multiply(this.unit, Q.unit, out int ResidueExponential);
                double Magnitude = this.magnitude * Q.magnitude;
                if (ResidueExponential != 0)
                    Magnitude *= Math.Pow(10, ResidueExponential);
 
                return new PhysicalQuantity(Magnitude, Unit);
            }
            else if (Element.AssociatedObjectValue is double d)
                return new PhysicalQuantity(this.magnitude * d, this.unit);
            else
                return null;
        }
 
        public override IRingElement Invert()
        {
            Unit Unit = this.unit.Invert(out int ResidueExponential);
            double Magnitude = 1 / this.magnitude;
            if (ResidueExponential != 0)
                Magnitude *= Math.Pow(10, ResidueExponential);
 
            return new PhysicalQuantity(Magnitude, Unit);
        }
 
        public override IAbelianGroupElement Add(IAbelianGroupElement Element)
        {
            if (Element.AssociatedObjectValue is IPhysicalQuantity E)
            {
                PhysicalQuantity Q = E.ToPhysicalQuantity();
                if (Unit.TryConvert(Q.magnitude, Q.unit, this.unit, out double d))
                    return new PhysicalQuantity(this.magnitude + d, this.unit);
            }
            else if (Element.AssociatedObjectValue is double d)
                return new PhysicalQuantity(this.magnitude + d, this.unit);
                
            return null;
        }
 
        public override IGroupElement Negate()
        {
            return new PhysicalQuantity(-this.magnitude, this.unit);
        }
 
        public override bool Equals(object obj)
        {
            if (!(obj is PhysicalQuantity E))
                return false;
 
            if (this.unit.Equals(E.unit, true))
                return this.magnitude == E.magnitude;
            else
            {
                double m1 = this.magnitude;
                this.unit.ToReferenceUnits(ref m1);
 
                double m2 = E.magnitude;
                E.unit.ToReferenceUnits(ref m2);
 
                return m1 == m2;
            }
        }
 
        public override int GetHashCode()
        {
            int Result = this.magnitude.GetHashCode();
            Result ^= Result << 5 ^ this.unit.GetHashCode();
            return Result;
        }
 
        public override IAbelianGroupElement Zero => ZeroElement;
 
        public override ICommutativeRingWithIdentityElement One => OneElement;
 
        public override bool TryConvertTo(Type DesiredType, out object Value)
        {
            if (DesiredType == typeof(byte))
            {
                if (this.magnitude >= byte.MinValue && this.magnitude <= byte.MaxValue)
                {
                    Value = (byte)this.magnitude;
                    return true;
                }
            }
            else if (DesiredType == typeof(decimal))
            {
                Value = (decimal)this.magnitude;
                return true;
            }
            else if (DesiredType == typeof(double))
            {
                Value = (double)this.magnitude;
                return true;
            }
            else if (DesiredType == typeof(short))
            {
                if (this.magnitude >= short.MinValue && this.magnitude <= short.MaxValue)
                {
                    Value = (short)this.magnitude;
                    return true;
                }
            }
            else if (DesiredType == typeof(int))
            {
                if (this.magnitude >= int.MinValue && this.magnitude <= int.MaxValue)
                {
                    Value = (int)this.magnitude;
                    return true;
                }
            }
            else if (DesiredType == typeof(long))
            {
                if (this.magnitude >= long.MinValue && this.magnitude <= long.MaxValue)
                {
                    Value = (long)this.magnitude;
                    return true;
                }
            }
            else if (DesiredType == typeof(sbyte))
            {
                if (this.magnitude >= sbyte.MinValue && this.magnitude <= sbyte.MaxValue)
                {
                    Value = (sbyte)this.magnitude;
                    return true;
                }
            }
            else if (DesiredType == typeof(float))
            {
                Value = (float)this.magnitude;
                return true;
            }
            else if (DesiredType == typeof(ushort))
            {
                if (this.magnitude >= ushort.MinValue && this.magnitude <= ushort.MaxValue)
                {
                    Value = (ushort)this.magnitude;
                    return true;
                }
            }
            else if (DesiredType == typeof(uint))
            {
                if (this.magnitude >= uint.MinValue && this.magnitude <= uint.MaxValue)
                {
                    Value = (uint)this.magnitude;
                    return true;
                }
            }
            else if (DesiredType == typeof(ulong))
            {
                if (this.magnitude >= ulong.MinValue && this.magnitude <= ulong.MaxValue)
                {
                    Value = (ulong)this.magnitude;
                    return true;
                }
            }
            else if (DesiredType.GetTypeInfo().IsAssignableFrom(typeof(PhysicalQuantity).GetTypeInfo()))
            {
                Value = this;
                return true;
            }
 
            return Expression.TryConvert(this, DesiredType, out Value);
        }
 
        public int CompareTo(object obj)
        {
            if (!(obj is IPhysicalQuantity PQ))
                throw new ScriptException("Values not comparable.");
 
            PhysicalQuantity Q = PQ.ToPhysicalQuantity();
 
            if (this.unit.Equals(Q.unit, true))
                return this.magnitude.CompareTo(Q.magnitude);
 
            if (!Unit.TryConvert(Q.magnitude, Q.unit, this.unit, out double d))
                throw new ScriptException("Values not comparable.");
 
            return this.magnitude.CompareTo(d);
        }
 
        public static bool TryParse(string s, out PhysicalQuantity Value)
        {
            int i = s.Length - 1;
 
            while (i >= 0 && char.IsWhiteSpace(s[i]))
                i--;
 
            int j = i;
 
            while (i >= 0 && !char.IsWhiteSpace(s[i]))
                i--;
 
            if (i < 0 ||
                !Unit.TryParse(s.Substring(i + 1, j - i), out Unit ParsedUnit) ||
                !double.TryParse(s.Substring(0, i).Trim().Replace(System.Globalization.NumberFormatInfo.CurrentInfo.NumberDecimalSeparator, "."), out double ParsedValue))
            {
                Value = null;
                return false;
            }
 
            Value = new PhysicalQuantity(ParsedValue, ParsedUnit);
 
            return true;
        }
    }
}