#175 - Support rational numbers

xFunc.Maths/Analyzers/Analyzer{TResult,TContext}.cs

@@ -225,6 +225,14 @@ public virtual TResult Analyze(StringExpression exp, TContext context)
     public virtual TResult Analyze(Expressions.Units.Convert exp, TContext context)
         => Analyze(exp as IExpression, context);
 
+    /// <inheritdoc />
+    public virtual TResult Analyze(Rational exp, TContext context)
+        => Analyze(exp as IExpression, context);
+
+    /// <inheritdoc />
+    public virtual TResult Analyze(ToRational exp, TContext context)
+        => Analyze(exp as IExpression, context);
+
     #endregion Standard
 
     #region Matrix

xFunc.Maths/Analyzers/Analyzer{TResult}.cs

@@ -224,6 +224,14 @@ public virtual TResult Analyze(StringExpression exp)
     public virtual TResult Analyze(Expressions.Units.Convert exp)
         => Analyze(exp as IExpression);
 
+    /// <inheritdoc />
+    public virtual TResult Analyze(Rational exp)
+        => Analyze(exp as IExpression);
+
+    /// <inheritdoc />
+    public virtual TResult Analyze(ToRational exp)
+        => Analyze(exp as IExpression);
+
     #endregion Standard
 
     #region Matrix

xFunc.Maths/Analyzers/Formatters/CommonFormatter.cs

@@ -287,6 +287,14 @@ public virtual string Analyze(Expressions.Units.Convert exp)
         return $"convert({value}, {unit})";
     }
 
+    /// <inheritdoc />
+    public virtual string Analyze(Rational exp)
+        => ToString(exp, "{0} : {1}");
+
+    /// <inheritdoc />
+    public virtual string Analyze(ToRational exp)
+        => ToString(exp, "torational({0})");
+
     #endregion Standard
 
     #region Matrix

xFunc.Maths/Analyzers/IAnalyzer{TResult,TContext}.cs

@@ -428,6 +428,22 @@ public interface IAnalyzer<out TResult, in TContext>
     /// <returns>The result of analysis.</returns>
     TResult Analyze(Expressions.Units.Convert 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(Rational 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(ToRational exp, TContext context);
+
     #endregion Standard
 
     #region Matrix

xFunc.Maths/Analyzers/IAnalyzer{TResult}.cs

@@ -375,6 +375,20 @@ public interface IAnalyzer<out TResult>
     /// <returns>The result of analysis.</returns>
     TResult Analyze(Expressions.Units.Convert exp);
 
+    /// <summary>
+    /// Analyzes the specified expression.
+    /// </summary>
+    /// <param name="exp">The expression.</param>
+    /// <returns>The result of analysis.</returns>
+    TResult Analyze(Rational exp);
+
+    /// <summary>
+    /// Analyzes the specified expression.
+    /// </summary>
+    /// <param name="exp">The expression.</param>
+    /// <returns>The result of analysis.</returns>
+    TResult Analyze(ToRational exp);
+
     #endregion Standard
 
     #region Matrix

xFunc.Maths/Analyzers/TypeAnalyzers/ResultTypes.cs

@@ -95,4 +95,9 @@ public enum ResultTypes
     /// The expression returns a volume number.
     /// </summary>
     VolumeNumber = 1 << 15,
+
+    /// <summary>
+    /// The returns a rational number.
+    /// </summary>
+    RationalNumber = 1 << 16,
 }

xFunc.Maths/Analyzers/TypeAnalyzers/TypeAnalyzer.cs

@@ -1392,6 +1392,50 @@ ResultTypes.Undefined or
         };
     }
 
+    /// <inheritdoc />
+    public virtual ResultTypes Analyze(Rational exp)
+    {
+        if (exp is null)
+            throw new ArgumentNullException(nameof(exp));
+
+        var leftResult = exp.Left.Analyze(this);
+        var rightResult = exp.Right.Analyze(this);
+
+        return (leftResult, rightResult) switch
+        {
+            (ResultTypes.Undefined, _) or (_, ResultTypes.Undefined)
+                => ResultTypes.Undefined,
+
+            (ResultTypes.Number, ResultTypes.Number)
+                => ResultTypes.RationalNumber,
+
+            (ResultTypes.Number, _)
+                => ResultTypes.Number.ThrowForRight(rightResult),
+
+            (_, ResultTypes.Number)
+                => ResultTypes.Number.ThrowForLeft(leftResult),
+
+            _ => throw new ParameterTypeMismatchException(),
+        };
+    }
+
+    /// <inheritdoc />
+    public virtual ResultTypes Analyze(ToRational exp)
+    {
+        if (exp is null)
+            throw new ArgumentNullException(nameof(exp));
+
+        var argumentResult = exp.Argument.Analyze(this);
+
+        return argumentResult switch
+        {
+            ResultTypes.Undefined => ResultTypes.Undefined,
+            ResultTypes.Number => ResultTypes.RationalNumber,
+
+            _ => throw new ParameterTypeMismatchException(ResultTypes.Number, argumentResult),
+        };
+    }
+
     #endregion Standard
 
     #region Matrix

xFunc.Maths/Expressions/Rational.cs

@@ -0,0 +1,59 @@
+// Copyright (c) Dmytro Kyshchenko. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Collections.Immutable;
+
+namespace xFunc.Maths.Expressions;
+
+/// <summary>
+/// Represents the rational number expression.
+/// </summary>
+public class Rational : BinaryExpression
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="Rational"/> class.
+    /// </summary>
+    /// <param name="left">The left (first) operand.</param>
+    /// <param name="right">The right (second) operand.</param>
+    public Rational(IExpression left, IExpression right)
+        : base(left, right)
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="Rational"/> class.
+    /// </summary>
+    /// <param name="arguments">The list of arguments.</param>
+    internal Rational(ImmutableArray<IExpression> arguments)
+        : base(arguments)
+    {
+    }
+
+    /// <inheritdoc />
+    public override object Execute(ExpressionParameters? parameters)
+    {
+        var leftResult = Left.Execute(parameters);
+        var rightResult = Right.Execute(parameters);
+
+        return (leftResult, rightResult) switch
+        {
+            (NumberValue left, NumberValue right) => new RationalValue(left, right),
+
+            _ => throw new ResultIsNotSupportedException(this, leftResult, rightResult),
+        };
+    }
+
+    /// <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);
+
+    /// <inheritdoc />
+    public override IExpression Clone(IExpression? left = null, IExpression? right = null)
+        => new Rational(left ?? Left, right ?? Right);
+}