#514 - Length Units.

sys27 · Mar 16, 2022 · c824ea6 · c824ea6
1 parent 960b93e
commit c824ea6
Show file tree

Hide file tree

Showing 28 changed files with 1,752 additions and 58 deletions.
diff --git a/xFunc.Maths/Analyzers/Analyzer{TResult,TContext}.cs b/xFunc.Maths/Analyzers/Analyzer{TResult,TContext}.cs
@@ -121,6 +121,10 @@ public virtual TResult Analyze(Temperature exp, TContext context)
     public virtual TResult Analyze(Mass exp, TContext context)
         => Analyze(exp as IExpression, context);
 
+    /// <inheritdoc />
+    public virtual TResult Analyze(Length exp, TContext context)
+        => Analyze(exp as IExpression, context);
+
     /// <inheritdoc />
     public virtual TResult Analyze(ToDegree exp, TContext context)
         => Analyze(exp as IExpression, context);

diff --git a/xFunc.Maths/Analyzers/Analyzer{TResult}.cs b/xFunc.Maths/Analyzers/Analyzer{TResult}.cs
@@ -120,6 +120,10 @@ public virtual TResult Analyze(Temperature exp)
     public virtual TResult Analyze(Mass exp)
         => Analyze(exp as IExpression);
 
+    /// <inheritdoc />
+    public virtual TResult Analyze(Length exp)
+        => Analyze(exp as IExpression);
+
     /// <inheritdoc />
     public virtual TResult Analyze(ToDegree exp)
         => Analyze(exp as IExpression);

diff --git a/xFunc.Maths/Analyzers/Differentiator.cs b/xFunc.Maths/Analyzers/Differentiator.cs
@@ -242,6 +242,14 @@ public override IExpression Analyze(Mass exp, DifferentiatorContext context)
         return Number.Zero;
     }
 
+    /// <inheritdoc />
+    public override IExpression Analyze(Length exp, DifferentiatorContext context)
+    {
+        ValidateArguments(exp, context);
+
+        return Number.Zero;
+    }
+
     /// <inheritdoc />
     public override IExpression Analyze(Pow exp, DifferentiatorContext context)
     {

diff --git a/xFunc.Maths/Analyzers/Formatters/CommonFormatter.cs b/xFunc.Maths/Analyzers/Formatters/CommonFormatter.cs
@@ -165,6 +165,10 @@ public virtual string Analyze(Temperature exp)
     public virtual string Analyze(Mass exp)
         => exp.Value.ToString();
 
+    /// <inheritdoc />
+    public virtual string Analyze(Length exp)
+        => exp.Value.ToString();
+
     /// <inheritdoc />
     public virtual string Analyze(ToDegree exp)
         => ToString(exp, "todegree({0})");

diff --git a/xFunc.Maths/Analyzers/IAnalyzer{TResult,TContext}.cs b/xFunc.Maths/Analyzers/IAnalyzer{TResult,TContext}.cs
@@ -220,6 +220,14 @@ public interface IAnalyzer<out TResult, in TContext>
     /// <returns>The result of analysis.</returns>
     TResult Analyze(Mass exp, TContext context);
 
+    /// <summary>
+    /// Analyzes the specified expression.
+    /// </summary>
+    /// <param name="exp">The expression.</param>
+    /// <param name="context">The context.</param>
+    /// <returns>The result of analysis.</returns>
+    TResult Analyze(Length exp, TContext context);
+
     /// <summary>
     /// Analyzes the specified expression.
     /// </summary>

diff --git a/xFunc.Maths/Analyzers/IAnalyzer{TResult}.cs b/xFunc.Maths/Analyzers/IAnalyzer{TResult}.cs
@@ -193,6 +193,13 @@ public interface IAnalyzer<out TResult>
     /// <returns>The result of analysis.</returns>
     TResult Analyze(Mass exp);
 
+    /// <summary>
+    /// Analyzes the specified expression.
+    /// </summary>
+    /// <param name="exp">The expression.</param>
+    /// <returns>The result of analysis.</returns>
+    TResult Analyze(Length exp);
+
     /// <summary>
     /// Analyzes the specified expression.
     /// </summary>

diff --git a/xFunc.Maths/Analyzers/TypeAnalyzers/ResultTypes.cs b/xFunc.Maths/Analyzers/TypeAnalyzers/ResultTypes.cs
@@ -76,6 +76,11 @@ public enum ResultTypes
     /// </summary>
     MassNumber = 1 << 11,
 
+    /// <summary>
+    /// The expression returns a length number.
+    /// </summary>
+    LengthNumber = 1 << 12,
+
     /// <summary>
     /// The expression returns a number or a complex number.
     /// </summary>
@@ -101,7 +106,7 @@ public enum ResultTypes
     /// <summary>
     /// The expression returns any type of number.
     /// </summary>
-    Numbers = Number | AngleNumber | PowerNumber | TemperatureNumber | MassNumber,
+    Numbers = Number | AngleNumber | PowerNumber | TemperatureNumber | MassNumber | LengthNumber,
 
     /// <summary>
     /// The expression returns a number or a angle number or a complex number or a vector.

diff --git a/xFunc.Maths/Analyzers/TypeAnalyzers/TypeAnalyzer.cs b/xFunc.Maths/Analyzers/TypeAnalyzers/TypeAnalyzer.cs
@@ -780,6 +780,10 @@ public virtual ResultTypes Analyze(Temperature exp)
     public virtual ResultTypes Analyze(Mass exp)
         => CheckArgument(exp, ResultTypes.MassNumber);
 
+    /// <inheritdoc />
+    public virtual ResultTypes Analyze(Length exp)
+        => CheckArgument(exp, ResultTypes.LengthNumber);
+
     /// <inheritdoc />
     public virtual ResultTypes Analyze(ToDegree exp)
         => AngleConversion(exp);

diff --git a/xFunc.Maths/Expressions/Units/Converters/Converter.cs b/xFunc.Maths/Expressions/Units/Converters/Converter.cs
@@ -20,6 +20,7 @@ public Converter()
             new PowerConverter(),
             new TemperatureConverter(),
             new MassConverter(),
+            new LengthConverter(),
         };
 
     /// <inheritdoc />

diff --git a/xFunc.Maths/Expressions/Units/Converters/LengthConverter.cs b/xFunc.Maths/Expressions/Units/Converters/LengthConverter.cs
@@ -0,0 +1,37 @@
+// Copyright (c) Dmytro Kyshchenko. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+namespace xFunc.Maths.Expressions.Units.Converters;
+
+/// <summary>
+/// The length unit converter.
+/// </summary>
+public class LengthConverter : IConverter<LengthValue>, IConverter<object>
+{
+    /// <inheritdoc />
+    public LengthValue Convert(object value, string unit)
+    {
+        if (value is null)
+            throw new ArgumentNullException(nameof(value));
+        if (string.IsNullOrWhiteSpace(unit))
+            throw new ArgumentNullException(nameof(unit));
+
+        if (!LengthUnit.FromName(unit, out var lengthUnit))
+            throw new UnitIsNotSupportedException(unit);
+
+        return value switch
+        {
+            LengthValue lengthValue => lengthValue.To(lengthUnit),
+            NumberValue numberValue => new LengthValue(numberValue, lengthUnit),
+            _ => throw new ValueIsNotSupportedException(value),
+        };
+    }
+
+    /// <inheritdoc/>
+    object IConverter<object>.Convert(object value, string unit)
+        => Convert(value, unit);
+
+    /// <inheritdoc cref="IConverter{TValue}.CanConvertTo" />
+    public bool CanConvertTo(string unit)
+        => LengthUnit.Names.Contains(unit.ToLower());
+}
diff --git a/xFunc.Maths/Expressions/Units/Converters/MassConverter.cs b/xFunc.Maths/Expressions/Units/Converters/MassConverter.cs
@@ -8,11 +8,6 @@ namespace xFunc.Maths.Expressions.Units.Converters;
 /// </summary>
 public class MassConverter : IConverter<MassValue>, IConverter<object>
 {
-    private readonly HashSet<string> units = new HashSet<string>
-    {
-        "mg", "g", "kg", "t", "oz", "lb",
-    };
-
     /// <inheritdoc />
     public MassValue Convert(object value, string unit)
     {
@@ -21,24 +16,14 @@ public MassValue Convert(object value, string unit)
         if (string.IsNullOrWhiteSpace(unit))
             throw new ArgumentNullException(nameof(unit));
 
-        return (value, unit) switch
-        {
-            (MassValue massValue, "mg") => massValue.ToMilligram(),
-            (MassValue massValue, "g") => massValue.ToGram(),
-            (MassValue massValue, "kg") => massValue.ToKilogram(),
-            (MassValue massValue, "t") => massValue.ToTonne(),
-            (MassValue massValue, "oz") => massValue.ToOunce(),
-            (MassValue massValue, "lb") => massValue.ToPound(),
+        if (!MassUnit.FromName(unit, out var massUnit))
+            throw new UnitIsNotSupportedException(unit);
 
-            (NumberValue numberValue, "mg") => MassValue.Milligram(numberValue),
-            (NumberValue numberValue, "g") => MassValue.Gram(numberValue),
-            (NumberValue numberValue, "kg") => MassValue.Kilogram(numberValue),
-            (NumberValue numberValue, "t") => MassValue.Tonne(numberValue),
-            (NumberValue numberValue, "oz") => MassValue.Ounce(numberValue),
-            (NumberValue numberValue, "lb") => MassValue.Pound(numberValue),
-
-            _ when CanConvertTo(unit) => throw new ValueIsNotSupportedException(value),
-            _ => throw new UnitIsNotSupportedException(unit),
+        return value switch
+        {
+            MassValue massValue => massValue.To(massUnit),
+            NumberValue numberValue => new MassValue(numberValue, massUnit),
+            _ => throw new ValueIsNotSupportedException(value),
         };
     }
 
@@ -48,5 +33,5 @@ object IConverter<object>.Convert(object value, string unit)
 
     /// <inheritdoc cref="IConverter{TValue}.CanConvertTo" />
     public bool CanConvertTo(string unit)
-        => units.Contains(unit.ToLower());
+        => MassUnit.Names.Contains(unit.ToLower());
 }
diff --git a/xFunc.Maths/Expressions/Units/Converters/PowerConverter.cs b/xFunc.Maths/Expressions/Units/Converters/PowerConverter.cs
@@ -8,11 +8,6 @@ namespace xFunc.Maths.Expressions.Units.Converters;
 /// </summary>
 public class PowerConverter : IConverter<PowerValue>, IConverter<object>
 {
-    private readonly HashSet<string> units = new HashSet<string>
-    {
-        "w", "kw", "hp",
-    };
-
     /// <inheritdoc />
     public PowerValue Convert(object value, string unit)
     {
@@ -21,18 +16,14 @@ public PowerValue Convert(object value, string unit)
         if (string.IsNullOrWhiteSpace(unit))
             throw new ArgumentNullException(nameof(unit));
 
-        return (value, unit) switch
-        {
-            (PowerValue powerValue, "w") => powerValue.ToWatt(),
-            (PowerValue powerValue, "kw") => powerValue.ToKilowatt(),
-            (PowerValue powerValue, "hp") => powerValue.ToHorsepower(),
+        if (!PowerUnit.FromName(unit, out var powerUnit))
+            throw new UnitIsNotSupportedException(unit);
 
-            (NumberValue numberValue, "w") => PowerValue.Watt(numberValue),
-            (NumberValue numberValue, "kw") => PowerValue.Kilowatt(numberValue),
-            (NumberValue numberValue, "hp") => PowerValue.Horsepower(numberValue),
-
-            _ when CanConvertTo(unit) => throw new ValueIsNotSupportedException(value),
-            _ => throw new UnitIsNotSupportedException(unit),
+        return value switch
+        {
+            PowerValue powerValue => powerValue.To(powerUnit),
+            NumberValue numberValue => new PowerValue(numberValue, powerUnit),
+            _ => throw new ValueIsNotSupportedException(value),
         };
     }
 
@@ -42,5 +33,5 @@ object IConverter<object>.Convert(object value, string unit)
 
     /// <inheritdoc cref="IConverter{TValue}.CanConvertTo" />
     public bool CanConvertTo(string unit)
-        => units.Contains(unit.ToLower());
+        => PowerUnit.Names.Contains(unit.ToLower());
 }
diff --git a/xFunc.Maths/Expressions/Units/Converters/TemperatureConverter.cs b/xFunc.Maths/Expressions/Units/Converters/TemperatureConverter.cs
@@ -8,11 +8,6 @@ namespace xFunc.Maths.Expressions.Units.Converters;
 /// </summary>
 public class TemperatureConverter : IConverter<TemperatureValue>, IConverter<object>
 {
-    private readonly HashSet<string> units = new HashSet<string>
-    {
-        "°c", "°f", "k",
-    };
-
     /// <inheritdoc />
     public TemperatureValue Convert(object value, string unit)
     {
@@ -21,18 +16,14 @@ public TemperatureValue Convert(object value, string unit)
         if (string.IsNullOrWhiteSpace(unit))
             throw new ArgumentNullException(nameof(unit));
 
-        return (value, unit) switch
-        {
-            (TemperatureValue temperatureValue, "°c") => temperatureValue.ToCelsius(),
-            (TemperatureValue temperatureValue, "°f") => temperatureValue.ToFahrenheit(),
-            (TemperatureValue temperatureValue, "k") => temperatureValue.ToKelvin(),
+        if (!TemperatureUnit.FromName(unit, out var temperatureUnit))
+            throw new UnitIsNotSupportedException(unit);
 
-            (NumberValue numberValue, "°c") => TemperatureValue.Celsius(numberValue),
-            (NumberValue numberValue, "°f") => TemperatureValue.Fahrenheit(numberValue),
-            (NumberValue numberValue, "k") => TemperatureValue.Kelvin(numberValue),
-
-            _ when CanConvertTo(unit) => throw new ValueIsNotSupportedException(value),
-            _ => throw new UnitIsNotSupportedException(unit),
+        return value switch
+        {
+            TemperatureValue temperatureValue => temperatureValue.To(temperatureUnit),
+            NumberValue numberValue => new TemperatureValue(numberValue, temperatureUnit),
+            _ => throw new ValueIsNotSupportedException(value),
         };
     }
 
@@ -42,5 +33,5 @@ object IConverter<object>.Convert(object value, string unit)
 
     /// <inheritdoc cref="IConverter{TValue}.CanConvertTo" />
     public bool CanConvertTo(string unit)
-        => units.Contains(unit.ToLower());
+        => TemperatureUnit.Names.Contains(unit.ToLower());
 }
diff --git a/xFunc.Maths/Expressions/Units/LengthUnits/Length.cs b/xFunc.Maths/Expressions/Units/LengthUnits/Length.cs
@@ -0,0 +1,29 @@
+// Copyright (c) Dmytro Kyshchenko. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+namespace xFunc.Maths.Expressions.Units.LengthUnits;
+
+/// <summary>
+/// Represents a length number.
+/// </summary>
+public class Length : Unit<LengthValue>
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="Length"/> class.
+    /// </summary>
+    /// <param name="value">A length value.</param>
+    public Length(LengthValue value)
+        : base(value)
+    {
+    }
+
+    /// <inheritdoc />
+    protected override TResult AnalyzeInternal<TResult>(IAnalyzer<TResult> analyzer)
+        => analyzer.Analyze(this);
+
+    /// <inheritdoc />
+    protected override TResult AnalyzeInternal<TResult, TContext>(
+        IAnalyzer<TResult, TContext> analyzer,
+        TContext context)
+        => analyzer.Analyze(this, context);
+}