Measurement.cs

using System;
using System.Reflection;
using System.Text;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Abstraction.Sets;
using Waher.Script.Exceptions;
using Waher.Script.Units;
 
namespace Waher.Script.Objects
{
    public sealed class Measurement : FieldElement, IComparable, IPhysicalQuantity     // Not a proper field, as division is not the inversion of multiplication
    {
        public static readonly Measurement ZeroElement = new Measurement(0, Unit.Empty, 0);
 
        public static readonly Measurement OneElement = new Measurement(1, Unit.Empty, 1);
 
        private static readonly Measurements associatedField = new Measurements();
 
        private double magnitude;
        private double error;
        private Unit unit;
 
        public Measurement(double Magnitude, Unit Unit, double Error)
        {
            this.magnitude = Magnitude;
            this.unit = Unit;
            this.error = Math.Abs(Error);
        }
 
        public double Magnitude
        {
            get => this.magnitude;
            set => this.magnitude = value;
        }
 
        public Unit Unit
        {
            get => this.unit;
            set => this.unit = value;
        }
 
        public double Error
        {
            get => this.error;
            set => this.error = value;
        }
 
        public PhysicalQuantity Estimate => new PhysicalQuantity(this.magnitude, this.unit);
 
        public PhysicalQuantity Max => new PhysicalQuantity(this.magnitude + this.error, this.unit);
 
        public PhysicalQuantity Min => new PhysicalQuantity(this.magnitude - this.error, this.unit);
 
        public PhysicalQuantity ToPhysicalQuantity() => this.Estimate;
 
        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();
 
            sb.Append(Expression.ToString(this.magnitude));
            if (!this.unit.IsEmpty)
            {
                sb.Append(' ');
                sb.Append(this.unit.ToString());
            }
 
            if (this.error != 0)
            {
                sb.Append(" ± ");
                sb.Append(Expression.ToString(this.error));
 
                if (!this.unit.IsEmpty)
                {
                    sb.Append(' ');
                    sb.Append(this.unit.ToString());
                }
            }
 
            return sb.ToString();
        }
 
        public override IField AssociatedField => associatedField;
 
        public override object AssociatedObjectValue => this;
 
        public override ICommutativeRingElement Multiply(ICommutativeRingElement Element)
        {
            if (Element is Measurement E)
            {
                Unit Unit = Unit.Multiply(this.unit, E.unit, out int ResidueExponential);
                double Magnitude = this.magnitude * E.magnitude;
                if (ResidueExponential != 0)
                    Magnitude *= Math.Pow(10, ResidueExponential);
 
                double Error1 = this.error / this.magnitude;
                double Error2 = E.error / E.magnitude;
                double Error = (Error1 + Error2) * Magnitude;
 
                return new Measurement(Magnitude, Unit, Error);
            }
            else if (Element.AssociatedObjectValue is double d)
                return new Measurement(this.magnitude * d, this.unit, this.error * d);
            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);
 
            double Error = this.error / this.magnitude * Magnitude;
 
            return new Measurement(Magnitude, Unit, Error);
        }
 
        public override IAbelianGroupElement Add(IAbelianGroupElement Element)
        {
            if (Element is Measurement E)
            {
                if (!Unit.TryConvert(E.magnitude, E.unit, this.unit, out double d))
                    return null;
 
                double Magnitude = this.magnitude + d;
 
                if (!Unit.TryConvert(E.error, E.unit, this.unit, out d))
                    return null;
 
                return new Measurement(Magnitude, this.unit, this.error + d);
            }
            else if (Element.AssociatedObjectValue is double d)
                return new Measurement(this.magnitude + d, this.unit, this.error);
            else
                return null;
        }
 
        public override IGroupElement Negate()
        {
            return new Measurement(-this.magnitude, this.unit, this.error);
        }
 
        public override bool Equals(object obj)
        {
            if (!(obj is Measurement E))
                return false;
 
            if (this.unit.Equals(E.unit, true))
                return this.magnitude == E.magnitude && this.error == E.error;
            else
            {
                double m1 = this.magnitude;
                this.unit.ToReferenceUnits(ref m1);
 
                double m2 = E.magnitude;
                E.unit.ToReferenceUnits(ref m2);
 
                if (m1 != m2)
                    return false;
 
                m1 = this.error;
                this.unit.ToReferenceUnits(ref m1);
 
                m2 = E.error;
                E.unit.ToReferenceUnits(ref m2);
 
                return m1 == m2;
            }
        }
 
        public override int GetHashCode()
        {
            int Result = this.magnitude.GetHashCode();
            Result ^= Result << 5 ^ this.unit.GetHashCode();
            Result ^= Result << 5 ^ this.error.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(Measurement).GetTypeInfo()))
            {
                Value = this;
                return true;
            }
 
            return Expression.TryConvert(this, DesiredType, out Value);
        }
 
        public int CompareTo(object obj)
        {
            if (!(obj is Measurement Q))
                throw new ScriptException("Values not comparable.");
 
            int i;
 
            if (this.unit.Equals(Q.unit, true))
            {
                i = this.magnitude.CompareTo(Q.magnitude);
                if (i != 0)
                    return i;
 
                return this.error.CompareTo(Q.error);
            }
 
            if (!Unit.TryConvert(Q.magnitude, Q.unit, this.unit, out double d))
                throw new ScriptException("Values not comparable.");
 
            i = this.magnitude.CompareTo(d);
            if (i != 0)
                return i;
 
            if (!Unit.TryConvert(Q.error, Q.unit, this.unit, out d))
                throw new ScriptException("Values not comparable.");
 
            return this.error.CompareTo(d);
        }
 
        public static bool TryParse(string s, out Measurement Value)
        {
            int i = s.IndexOf('±');
            if (i < 0)
                i = s.IndexOf("+-");
 
            if (i >= 0)
            {
                string s1 = s.Substring(0, i).Trim();
                string s2 = s.Substring(i + 1).Trim();
 
                if (PhysicalQuantity.TryParse(s1, out PhysicalQuantity Q) && PhysicalQuantity.TryParse(s2, out PhysicalQuantity E))
                {
                    if (Unit.TryConvert(E.Magnitude, E.Unit, Q.Unit, out double Error))
                    {
                        Value = new Measurement(Q.Magnitude, Q.Unit, Error);
                        return true;
                    }
                }
                else if (Expression.TryParse(s1, out double d1) && Expression.TryParse(s2, out double d2))
                {
                    Value = new Measurement(d1, Unit.Empty, d2);
                    return true;
                }
            }
 
            Value = null;
            return false;
        }
 
    }
}