public ProductExpressionList Multiply(AlgebraExpression expression)
{
return(expression is ProductExpressionList
? ExpressionFactory.Product(this.Terms.Concat((expression as ProductExpressionList).Terms).ToImmutableList())
: ExpressionFactory.Multiply(this, expression)
);
}
public override AlgebraExpression Substitute(SymbolExpression variable, AlgebraExpression replacement)
{
return(this
.WithExpression(this.Expression.Substitute(variable, replacement))
.WithTo(this.To.Substitute(variable, replacement))
);
}
public SumExpressionList Add(AlgebraExpression expression)
{
return(expression is SumExpressionList
? ExpressionFactory.Sum(this.Terms.Concat((expression as SumExpressionList).Terms).ToImmutableList())
: ExpressionFactory.Add(this, expression)
);
}
public SumExpressionList Subtract(AlgebraExpression expression)
{
return(expression is SumExpressionList
? ExpressionFactory.Sum(this.Terms.Concat((expression as SumExpressionList).Terms.Select(ExpressionFactory.Negate)).ToImmutableList())
: ExpressionFactory.Subtract(this, expression)
);
}
public IntegralExpression(AlgebraExpression expression, SymbolExpression respectTo, AlgebraExpression from, AlgebraExpression to)
{
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
if (respectTo == null)
{
throw new ArgumentNullException(nameof(respectTo));
}
if (from != null && to == null)
{
throw new ArgumentNullException(nameof(to));
}
if (from == null && to != null)
{
throw new ArgumentNullException(nameof(from));
}
this.Expression = expression;
this.RespectTo = respectTo;
this.From = from;
this.To = to;
}
public ProductExpressionList Divide(AlgebraExpression expression)
{
return(expression is ProductExpressionList
? ExpressionFactory.Product(this, ExpressionFactory.Reciprocal(expression))
: ExpressionFactory.Divide(this, expression)
);
}
public AbsoluteValueExpression(AlgebraExpression expression)
{
if (expression == null)
throw new ArgumentNullException(nameof(expression));
this.Expression = expression;
}
public override AlgebraExpression Substitute(SymbolExpression variable, AlgebraExpression replacement)
{
return(this
.WithBase(this.Base.Substitute(variable, replacement))
.WithExponent(this.Exponent.Substitute(variable, replacement))
);
}
public override AlgebraExpression Substitute(SymbolExpression variable, AlgebraExpression replacement)
{
return(this.WithTerms(
this.Terms
.Select(t => t == variable ? replacement : variable)
.Select(t => t.Substitute(variable, replacement))
.ToImmutableList()
));
}
/// <summary>
///
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
public bool IsEquivalentTo(AlgebraExpression other)
{
if (this.Equals(other))
{
return(true);
}
return(this.Simplify().Equals(other.Simplify()));
}
public static IEnumerable <AlgebraExpression> DescendantsAndSelf(this AlgebraExpression expression)
{
yield return(expression);
foreach (var descendant in expression.Descendants())
{
yield return(descendant);
}
}
public static PowerExpression AsPower(this AlgebraExpression expression)
{
if (expression is PowerExpression power)
{
return(power);
}
return(ExpressionFactory.Exponentiate(expression, ExpressionFactory.One));
}
internal static ProductExpressionList AsProduct(this AlgebraExpression expression)
{
if (expression is ProductExpressionList product)
{
return(product);
}
return(Product(expression));
}
public static IEnumerable <AlgebraExpression> Descendants(this AlgebraExpression expression)
{
foreach (var child in expression.Children())
{
foreach (var descendant in child.DescendantsAndSelf())
{
yield return(descendant);
}
}
}
public static AlgebraExpression TotalDerivative(this AlgebraExpression function, IReadOnlyCollection <SymbolExpression> parameters, SymbolExpression respectTo)
{
if (!parameters.Contains(respectTo))
{
throw new ArgumentException($"Parameter '{nameof(respectTo)}' must be one of the variables provided in parameter '{nameof(parameters)}'.", nameof(respectTo));
}
return(Sum(
parameters
.Select(p => function.PartialDerivative(p) * p.Differentiate(respectTo))
.ToImmutableList()
));
}
public DifferentiationExpression(AlgebraExpression expression, SymbolExpression respectTo)
{
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
if (respectTo == null)
{
throw new ArgumentNullException(nameof(respectTo));
}
this.Expression = expression;
this.RespectTo = respectTo;
}
/// <summary>
/// Simplifies an <see cref="AlgebraExpression"/> as much as it can.
/// </summary>
/// <param name="expression"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public static AlgebraExpression Simplify(this AlgebraExpression expression, CancellationToken cancellationToken = default(CancellationToken))
{
AlgebraExpression simplified = expression;
AlgebraExpression lastResult;
do
{
lastResult = simplified;
// simplify by kind
simplified = SimplifySpecificKind(simplified, cancellationToken);
} while (!lastResult.Equals(simplified));
return(simplified);
}
public PowerExpression(AlgebraExpression @base, AlgebraExpression exponent)
{
if (@base == null)
{
throw new ArgumentNullException(nameof(@base));
}
if (exponent == null)
{
throw new ArgumentNullException(nameof(exponent));
}
this.Base = @base;
this.Exponent = exponent;
}
public LimitExpression(AlgebraExpression expression, SymbolExpression respectTo, AlgebraExpression to)
{
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
if (respectTo == null)
{
throw new ArgumentNullException(nameof(respectTo));
}
if (to == null)
{
throw new ArgumentNullException(nameof(to));
}
this.Expression = expression;
this.RespectTo = respectTo;
this.To = to;
}
private static AlgebraExpression SimplifySpecificKind(AlgebraExpression expression, CancellationToken cancellationToken)
{
AlgebraExpression simplified = expression;
AlgebraExpression lastResult;
// find applicable simplifiers
IReadOnlyCollection <object> simplifiers = GetSimplifiers(expression);
do
{
lastResult = simplified;
// query each simplifier
foreach (var simplifier in simplifiers)
{
cancellationToken.ThrowIfCancellationRequested();
var original = simplified;
MethodInfo method = simplifier.GetType().GetRuntimeMethod(nameof(ISimplifier <AlgebraExpression> .Simplify), new[] { expression.GetType(), typeof(CancellationToken) });
simplified = method.Invoke(simplifier, new object[] { simplified, cancellationToken }) as AlgebraExpression;
// trace
if (!original.Equals(simplified))
{
Debug.WriteLine($"Simplified '{original}' to '{simplified}' using '{simplifier}'");
}
// stop if not the same kind of expression
if (lastResult.GetType() != simplified.GetType())
{
return(simplified);
}
}
} while (!lastResult.Equals(simplified));
return(simplified);
}
public SineFunctionExpression(AlgebraExpression argument)
: base(PrimaryName, ImmutableList <AlgebraExpression> .Empty.Add(argument))
{
}
public static PowerExpression SquareRoot(AlgebraExpression expression)
{
return(Exponentiate(expression, Divide(NumberExpression.One, Constant(2))));
}
public static PowerExpression Square(AlgebraExpression expression)
{
return(Exponentiate(expression, Constant(2)));
}
public static PowerExpression Root(AlgebraExpression @base, AlgebraExpression exponent)
{
return(Exponentiate(@base, Divide(NumberExpression.One, exponent)));
}
public static PowerExpression Exponentiate(AlgebraExpression @base, AlgebraExpression exponent)
{
return(new PowerExpression(@base, exponent));
}
public PowerExpression WithBase(AlgebraExpression newBase)
{
return(ExpressionFactory.Exponentiate(newBase, this.Exponent));
}
/// <summary>
/// Creates a sine function invocation expression.
/// </summary>
public static SineFunctionExpression Sine(AlgebraExpression argument)
{
return(Invoke(WellKnownFunctionNames.Sine, argument) as SineFunctionExpression);
}
/// <summary> /// Replaces every occurrences of <paramref name="subject"/> to <paramref name="replacement"/>. /// </summary> /// <param name="variable"></param> /// <param name="replacement"></param> /// <returns></returns> public abstract AlgebraExpression Substitute(SymbolExpression variable, AlgebraExpression replacement);
public PowerExpression WithExponent(AlgebraExpression newExponent)
{
return(ExpressionFactory.Exponentiate(this.Base, newExponent));
}
public static bool DependsUpon(this AlgebraExpression expression, SymbolExpression respectTo)
{
return(expression.DescendantsAndSelf().Contains(respectTo));
}