public EquationTermBase Invoke(EquationTermBase term) { var operation = (EquationBinaryOperationBase)term; decimal constantValue = ((EquationConstant)operation.Right).Value; return(new AdditionOperation(operation.Left, new EquationConstant(constantValue * decimal.MinusOne))); }
public EquationTermBase Invoke(EquationTermBase term) { var operation = (EquationBinaryOperationBase)term; EquationTermBase result; if (MatchShiftRight(operation)) { var leftOperation = (EquationBinaryOperationBase)operation.Left; decimal multiplier = ((EquationConstant)leftOperation.Left).Value; leftOperation.Left = CreateConstant(multiplier + decimal.One); result = leftOperation; } else { var rightOperation = (EquationBinaryOperationBase)operation.Right; decimal multiplier = ((EquationConstant)rightOperation.Left).Value; rightOperation.Left = CreateConstant(multiplier + decimal.One); result = rightOperation; } return(result); }
public bool TermMatchRule(EquationTermBase term) { bool matched = term is EquationBinaryOperationBase operation && operation.Type == OperationsEnum.Subtraction && operation.Right is EquationVariable; return(matched); }
public EquationTermBase Invoke(EquationTermBase term) { var operation = (EquationBinaryOperationBase)term; return(new AdditionOperation( left: operation.Left, right: new MultiplicationOperation(CreateConstant(decimal.MinusOne), operation.Right))); }
public bool TermMatchRule(EquationTermBase term) { bool matched = term is EquationBinaryOperationBase operation && operation.Left is EquationConstant && operation.Right is EquationConstant; return(matched); }
public override bool TermMatchRule(EquationTermBase term) { bool matched = term is EquationBinaryOperationBase operation && operation.Type == OperationsEnum.Multiplication && operation.Left is EquationVariable && operation.Right is EquationConstant; return(matched); }
public bool TermMatchRule(EquationTermBase term) { bool matched = term is EquationBinaryOperationBase operation && operation.Type == OperationsEnum.Addition && ( MatchShiftRight(operation) || MatchShiftLeft(operation) ); }
public bool TermMatchRule(EquationTermBase term) { if (!(term is EquationBinaryOperationBase operation)) { return false; } return operation.Right.IsZero() || operation.Left.IsZero(); }
public bool TermMatchRule(EquationTermBase term) { bool matched = term is EquationBinaryOperationBase operation && operation.Type == OperationsEnum.Multiplication && operation.Left is EquationVariable left && operation.Right is EquationVariable right && left.Name.CompareTo(right.Name) > 0; return(matched); }
public bool TermMatchRule(EquationTermBase term) { bool matched = term is EquationBinaryOperationBase operation && ( MatchShiftRight(operation) || MatchShiftLeft(operation) ); return(matched); }
public EquationTermBase Invoke(EquationTermBase term) { var operation = (EquationBinaryOperationBase)term; var buffer = operation.Left; operation.Left = operation.Right; operation.Right = buffer; return(term); }
public bool TermMatchRule(EquationTermBase term) { bool matched = term is EquationBinaryOperationBase operation && operation.Type == OperationsEnum.Addition && operation.Left is EquationVariable left && operation.Right is EquationVariable right && left.Name == right.Name; return(matched); }
public EquationTermBase Invoke(EquationTermBase term) { var operation = (EquationBinaryOperationBase) term; return operation.Type switch { OperationsEnum.Addition => ProcessAddition(operation), OperationsEnum.Subtraction => ProcessSubtraction(operation), OperationsEnum.Multiplication => ProcessMultiplication(operation), OperationsEnum.Division => ProcessDivision(operation), OperationsEnum.Exponentiation => ProcessExponentiation(operation), _ => throw new InvalidEnumArgumentException(nameof(operation.Type), (int) operation.Type, typeof(OperationsEnum)) }; }
public EquationTermBase Invoke(EquationTermBase term) { var operation = (EquationBinaryOperationBase)term; decimal value = operation.Type switch { OperationsEnum.Addition => Left(operation) + Right(operation), OperationsEnum.Subtraction => Left(operation) - Right(operation), OperationsEnum.Multiplication => Left(operation) * Right(operation), OperationsEnum.Division => Left(operation) / Right(operation), //теряется разрядность, в случае требования к большей точности - переработать OperationsEnum.Exponentiation => (decimal)Math.Pow((double)Left(operation), (double)Right(operation)), _ => throw new InvalidEnumArgumentException(nameof(operation.Type)) }; return(new EquationConstant(value)); }
public EquationTermBase Invoke(EquationTermBase term) { var operation = (EquationBinaryOperationBase)term; AdditionOperation result; if (MatchShiftRight(operation)) { var leftOperation = (EquationBinaryOperationBase)operation.Left; result = new AdditionOperation(leftOperation.Right, new AdditionOperation(leftOperation.Left, operation.Right)); } else { var rightOperation = (EquationBinaryOperationBase)operation.Right; result = new AdditionOperation(rightOperation.Right, new AdditionOperation(rightOperation.Left, operation.Left)); } return(result); }
public EquationTermBase Simplify(EquationTermBase term) { var simplified = false; do { foreach (var rule in _rules) { simplified = TrySimplify(rule, term, out var simplifiedTerm); if (!simplified) { continue; } term = simplifiedTerm; break; } } while (simplified); return(term); }
private static bool TrySimplify(IRule rule, EquationTermBase term, out EquationTermBase simplified) { if (!(term is EquationBinaryOperationBase operation)) { simplified = term; return(false); } var termSimplified = false; bool leftSimplified = TrySimplify(rule, operation.Left, out var simplifiedLeft); if (leftSimplified) { operation.Left = simplifiedLeft; } bool rightSimplified = TrySimplify(rule, operation.Right, out var simplifiedRight); if (rightSimplified) { operation.Right = simplifiedRight; } termSimplified |= leftSimplified; termSimplified |= rightSimplified; if (rule.TermMatchRule(operation)) { simplified = rule.Invoke(operation); return(true); } simplified = operation; return(termSimplified); }
public static bool IsZero(this EquationTermBase term) => term is EquationConstant constant &&
public DivisionOperation(EquationTermBase left, EquationTermBase right) : base(OperationsEnum.Division, left, right) { }
public EquationTermBase Invoke(EquationTermBase term) { throw new System.NotImplementedException(); }
public EquationTermBase SwapSides(EquationTermBase left, EquationTermBase right) { return(new SubtractionOperation(left, right)); }
public AdditionOperation(EquationTermBase left, EquationTermBase right) : base(OperationsEnum.Addition, left, right) { }
protected EquationBinaryOperationBase(OperationsEnum type, EquationTermBase left, EquationTermBase right) : base(type) { this.Left = left; this.Right = right; }
public abstract bool TermMatchRule(EquationTermBase term);
public EquationTermBase Invoke(EquationTermBase term) { return(CreateZero()); }
public MultiplicationOperation(EquationTermBase left, EquationTermBase right) : base(OperationsEnum.Multiplication, left, right) { }
private static decimal Value(EquationTermBase term) => term is EquationConstant constant ? constant.Value : throw new ArgumentException("Unsupported type");
public string Display(EquationTermBase term) => term switch {
public ExponentiationOperation(EquationTermBase left, EquationTermBase right) : base(OperationsEnum.Exponentiation, left, right) { }
public EquationTermBase Invoke(EquationTermBase term) { char variableName = ((EquationVariable)((EquationBinaryOperationBase)term).Left).Name; return(new MultiplicationOperation(new EquationConstant(2), new EquationVariable(variableName))); }