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