#131 - Support aliases for simplify, deriv and etc.

xFunc.Maths/Analyzers/TypeAnalyzers/ResultTypes.cs

@@ -47,7 +47,7 @@ public enum ResultTypes
     /// <summary>
     /// The expression returns other expression.
     /// </summary>
-    Expression = 1 << 6,
+    Function = 1 << 6,
 
     /// <summary>
     /// The expression returns an angle.
@@ -95,9 +95,4 @@ public enum ResultTypes
     /// The expression returns a volume number.
     /// </summary>
     VolumeNumber = 1 << 15,
-
-    /// <summary>
-    /// The expression return a function.
-    /// </summary>
-    Function = 1 << 16,
 }

xFunc.Maths/Analyzers/TypeAnalyzers/TypeAnalyzer.cs

@@ -566,7 +566,7 @@ public virtual ResultTypes Analyze(Assign exp)
 
     /// <inheritdoc />
     public virtual ResultTypes Analyze(Del exp)
-        => CheckArgument(exp, ResultTypes.Expression);
+        => CheckArgument(exp, ResultTypes.Function);
 
     /// <inheritdoc />
     public virtual ResultTypes Analyze(Derivative exp)
@@ -575,10 +575,10 @@ public virtual ResultTypes Analyze(Derivative exp)
             ArgNull(ExceptionArgument.exp);
 
         if (exp.ParametersCount == 1)
-            return ResultTypes.Expression;
+            return ResultTypes.Function;
 
         if (exp.ParametersCount == 2 && exp[1] is Variable)
-            return ResultTypes.Expression;
+            return ResultTypes.Function;
 
         if (exp.ParametersCount == 3 && exp[1] is Variable && exp[2] is Number)
             return ResultTypes.Number;
@@ -1170,7 +1170,7 @@ public virtual ResultTypes Analyze(Round exp)
 
     /// <inheritdoc />
     public virtual ResultTypes Analyze(Simplify exp)
-        => CheckArgument(exp, ResultTypes.Undefined);
+        => CheckArgument(exp, ResultTypes.Function);
 
     /// <inheritdoc />
     public virtual ResultTypes Analyze(Sqrt exp)

xFunc.Maths/Expressions/Del.cs

@@ -3,6 +3,7 @@
 
 using System.Collections.Immutable;
 using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
 using static xFunc.Maths.ThrowHelpers;
 
 namespace xFunc.Maths.Expressions;
@@ -54,21 +55,34 @@ public Del(IDifferentiator differentiator, ISimplifier simplifier, IExpression e
     /// <inheritdoc />
     public override object Execute(ExpressionParameters? parameters)
     {
+        var result = Argument.Execute(parameters);
+        if (result is not Lambda lambda)
+            throw new ResultIsNotSupportedException(this, result);
+
         var context = new DifferentiatorContext(parameters);
+        var body = lambda.Body;
+        var variables = Helpers.GetAllVariables(body);
+        if (!variables.TryGetNonEnumeratedCount(out var variablesCount))
+            variablesCount = variables.Count();
 
-        var variables = Helpers.GetAllVariables(Argument).ToList();
-        var vector = ImmutableArray.CreateBuilder<IExpression>(variables.Count);
+        var vectorItems = new IExpression[variablesCount];
+        var i = 0;
 
         foreach (var variable in variables)
         {
             context.Variable = variable;
 
-            vector.Add(Argument
+            vectorItems[i] = body
                 .Analyze(differentiator, context)
-                .Analyze(simplifier));
+                .Analyze(simplifier);
+
+            i++;
         }
 
-        return new Vector(vector.ToImmutableArray());
+        var resultLambda = new Vector(Unsafe.As<IExpression[], ImmutableArray<IExpression>>(ref vectorItems))
+            .ToLambda();
+
+        return resultLambda;
     }
 
     /// <inheritdoc />

xFunc.Maths/Expressions/Derivative.cs

@@ -84,20 +84,26 @@ public class Derivative : DifferentParametersExpression
     /// <inheritdoc />
     public override object Execute(ExpressionParameters? parameters)
     {
+        var result = Expression.Execute(parameters);
+        if (result is not Lambda lambda)
+            throw new ResultIsNotSupportedException(this, result);
+
         var variable = Variable;
         var context = new DifferentiatorContext(parameters, variable);
-        var diff = Analyze(Differentiator, context);
+        var derivative = lambda.Body.Analyze(Differentiator, context);
 
         var point = DerivativePoint;
         if (point is not null)
         {
             parameters ??= new ExpressionParameters();
             parameters[variable.Name] = point.Value;
 
-            return diff.Execute(parameters);
+            return derivative.Execute(parameters);
         }
 
-        return diff.Analyze(Simplifier);
+        return derivative
+            .Analyze(Simplifier)
+            .ToLambda();
     }
 
     /// <inheritdoc />

xFunc.Maths/Expressions/Lambda.cs

@@ -11,6 +11,15 @@ namespace xFunc.Maths.Expressions;
 /// </summary>
 public readonly struct Lambda : IEquatable<Lambda>
 {
+    /// <summary>
+    /// Initializes a new instance of the <see cref="Lambda"/> struct.
+    /// </summary>
+    /// <param name="body">The body of the function.</param>
+    public Lambda(IExpression body)
+        : this(ImmutableArray.Create<string>(), body)
+    {
+    }
+
     /// <summary>
     /// Initializes a new instance of the <see cref="Lambda"/> struct.
     /// </summary>

xFunc.Maths/Expressions/LambdaExtensions.cs

@@ -0,0 +1,44 @@
+// 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;
+
+/// <summary>
+/// Extension methods for <see cref="Lambda"/> and <see cref="LambdaExpression"/>.
+/// </summary>
+public static class LambdaExtensions
+{
+    /// <summary>
+    /// Converts <paramref name="exp"/> to <see cref="Lambda"/> without parameters.
+    /// </summary>
+    /// <param name="exp">The expression to convert.</param>
+    /// <returns>The lambda.</returns>
+    public static Lambda ToLambda(this IExpression exp)
+        => new Lambda(exp);
+
+    /// <summary>
+    /// Converts <paramref name="exp"/> to <see cref="Lambda"/> without parameters.
+    /// </summary>
+    /// <param name="exp">The expression to convert.</param>
+    /// <param name="variables">The list of lambda parameters.</param>
+    /// <returns>The lambda.</returns>
+    public static Lambda ToLambda(this IExpression exp, params string[] variables)
+        => new Lambda(variables, exp);
+
+    /// <summary>
+    /// Converts <paramref name="exp"/> to <see cref="LambdaExpression"/> without parameters.
+    /// </summary>
+    /// <param name="exp">The expression to convert.</param>
+    /// <returns>The lambda expression.</returns>
+    public static LambdaExpression ToLambdaExpression(this IExpression exp)
+        => ToLambda(exp).AsExpression();
+
+    /// <summary>
+    /// Converts <paramref name="exp"/> to <see cref="LambdaExpression"/> without parameters.
+    /// </summary>
+    /// <param name="exp">The expression to convert.</param>
+    /// <param name="variables">The list of lambda parameters.</param>
+    /// <returns>The lambda expression.</returns>
+    public static LambdaExpression ToLambdaExpression(this IExpression exp, params string[] variables)
+        => ToLambda(exp, variables).AsExpression();
+}

xFunc.Maths/Expressions/Simplify.cs

@@ -49,7 +49,17 @@ internal Simplify(ISimplifier simplifier, ImmutableArray<IExpression> arguments)
     /// <exception cref="ArgumentNullException">Simplifier is null.</exception>
     /// <seealso cref="ExpressionParameters" />
     public override object Execute(ExpressionParameters? parameters)
-        => Analyze(simplifier);
+    {
+        var result = Argument.Execute(parameters);
+        if (result is not Lambda lambda)
+            throw new ResultIsNotSupportedException(this, result);
+
+        var simplifiedExpression = lambda.Body
+            .Analyze(simplifier)
+            .ToLambda();
+
+        return simplifiedExpression;
+    }
 
     /// <inheritdoc />
     protected override TResult AnalyzeInternal<TResult>(IAnalyzer<TResult> analyzer)

xFunc.Maths/Processor.cs

@@ -139,12 +139,6 @@ bool boolean
             string str
                 => new StringResult(str),
 
-            IExpression expression when simplify
-                => new ExpressionResult(Simplify(expression)),
-
-            IExpression expression
-                => new ExpressionResult(expression),
-
             Lambda lambda
                 => new LambdaResult(lambda),
 

xFunc.Tests/Analyzers/DifferentiatorTests/NullArgumentTest.cs

@@ -179,7 +179,7 @@ public void VariableContextArgumentTest()
     public void CallExpressionContextNullArgument()
     {
         var exp = new CallExpression(
-            new Lambda(new[] { "x" }, Variable.X).AsExpression(),
+            Variable.X.ToLambdaExpression(Variable.X.Name),
             new IExpression[] { Variable.X }.ToImmutableArray());
 
         Assert.Throws<NotSupportedException>(() => exp.Analyze(differentiator, null));
@@ -188,7 +188,7 @@ public void CallExpressionContextNullArgument()
     [Fact]
     public void LambdaExpressionContextNullArgument()
     {
-        var exp = new Lambda(new[] { "x" }, Variable.X).AsExpression();
+        var exp = Variable.X.ToLambdaExpression(Variable.X.Name);
 
         Assert.Throws<NotSupportedException>(() => exp.Analyze(differentiator, null));
     }

xFunc.Tests/Analyzers/Formatters/CommonFormatterTest.cs

@@ -496,8 +496,8 @@ public void UndefineToStringTest()
     [Fact]
     public void LambdaExpressionToStringArgTest()
     {
-        var exp = new Lambda(new[] { "x", "y" }, new Add(Variable.X, Variable.Y))
-            .AsExpression();
+        var exp = new Add(Variable.X, Variable.Y)
+            .ToLambdaExpression(Variable.X, Variable.Y);
 
         Assert.Equal("(x, y) => x + y", exp.ToString());
     }
@@ -516,7 +516,7 @@ public void CallExpressionToStringArgTest()
     public void InlineCallExpressionToStringArgTest()
     {
         var exp = new CallExpression(
-            new Lambda(new[] { "x" }, Variable.X).AsExpression(),
+            Variable.X.ToLambdaExpression(Variable.X.Name),
             new IExpression[] { new Number(5) }.ToImmutableArray());
 
         Assert.Equal("((x) => x)(5)", exp.ToString());

xFunc.Tests/Analyzers/TypeAnalyzerTests/StandardTests.cs

@@ -23,7 +23,7 @@ public void TestDelVector()
         var simp = new Simplifier();
         var exp = new Del(diff, simp, Number.Two);
 
-        Test(exp, ResultTypes.Expression);
+        Test(exp, ResultTypes.Function);
     }
 
     [Fact]
@@ -33,7 +33,7 @@ public void TestDerivExpression()
         var simp = new Simplifier();
         var exp = new Derivative(diff, simp, Variable.X);
 
-        Test(exp, ResultTypes.Expression);
+        Test(exp, ResultTypes.Function);
     }
 
     [Fact]
@@ -43,7 +43,7 @@ public void TestDerivExpressionWithVar()
         var simp = new Simplifier();
         var exp = new Derivative(diff, simp, Variable.X, Variable.X);
 
-        Test(exp, ResultTypes.Expression);
+        Test(exp, ResultTypes.Function);
     }
 
     [Fact]
@@ -384,7 +384,7 @@ public void TestNumber()
     public void TestSimplify()
     {
         var simp = new Simplifier();
-        Test(new Simplify(simp, Variable.X), ResultTypes.Undefined);
+        Test(new Simplify(simp, Variable.X), ResultTypes.Function);
     }
 
     [Fact]
@@ -408,8 +408,7 @@ public void TestCallExpression()
     [Fact]
     public void TestLambdaExpression()
     {
-        var exp = new Lambda(Array.Empty<string>(), Number.One)
-            .AsExpression();
+        var exp = Number.One.ToLambdaExpression();
 
         Test(exp, ResultTypes.Function);
     }

xFunc.Tests/Expressions/AssignTest.cs

@@ -58,8 +58,7 @@ public void OverrideConstTest()
     [Fact]
     public void DefineFuncTest()
     {
-        var function = new Lambda(Array.Empty<string>(), Number.One)
-            .AsExpression();
+        var function = Number.One.ToLambdaExpression();
         var variable = new Variable("f");
         var exp = new Assign(variable, function);
 
@@ -72,10 +71,8 @@ public void DefineFuncTest()
     [Fact]
     public void DefineFuncWithParamsTest()
     {
-        var function = new Lambda(
-                new[] { "x", "y" },
-                new Add(Variable.X, Variable.Y))
-            .AsExpression();
+        var function = new Add(Variable.X, Variable.Y)
+            .ToLambdaExpression(Variable.X.Name, Variable.Y.Name);
         var variable = new Variable("f");
         var exp = new Assign(variable, function);