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)); }