NumberElement calculate(NumberElement left, NumberElement right, OperatorElement op)
{
Double temp = Double.MaxValue;
if (op.type == OperatorType.ADD)
{
temp = left.getNumber() + right.getNumber();
}
else if (op.type == OperatorType.SUBTRACT)
{
temp = left.getNumber() - right.getNumber();
}
else if (op.type == OperatorType.MULTIPLY)
{
temp = left.getNumber() * right.getNumber();
}
else if (op.type == OperatorType.DIVIDE)
{
temp = left.getNumber() / right.getNumber();
}
else if (op.type == OperatorType.EXPONENTIAL)
{
temp = Math.Pow(left.getNumber(), right.getNumber());
}
return(new NumberElement(temp.ToString()));
}
public Object Clone()
{
OperatorElement result = (OperatorElement)this.MemberwiseClone();
if (this.Left != null)
{
result.Left = (ExpressionElement)this.Left.Clone();
}
if (this.Right != null)
{
result.Right = (ExpressionElement)this.Right.Clone();
}
return(result);
}
public void PeformLogic(OperatorElement input)
{
if (buffer[0] == null)
{
buffer[0] = input;
return;
}
// second input is a '+'
if (input.GetType() == typeof(AddOperator))
{
//Don't do anything if previous operator != '-' > a + - b == a - b
if (buffer[0].GetType() == typeof(SubTractOperator))
{
}
}
if (input.GetType() == typeof(SubTractOperator))
{
if (buffer[0].GetType() == typeof(SubTractOperator))
{
buffer[0] = new AddOperator();
}
if (buffer[0].GetType() == typeof(AddOperator))
{
buffer[0] = input;
}
if (buffer[0].GetType() == typeof(MultiplyOperator) || buffer[0].GetType() == typeof(DivideOperator))
{
buffer[1] = input;
}
}
if (input.GetType() == typeof(DivideOperator))
{
if (buffer[0].GetType() == typeof(SubTractOperator))
{
buffer[0] = input;
buffer[1] = new SubTractOperator();
}
}
if (input.GetType() == typeof(MultiplyOperator))
{
if (buffer[0].GetType() == typeof(SubTractOperator))
{
buffer[0] = input;
buffer[1] = new SubTractOperator();
}
}
}
int Precedence(OperatorElement c)
{
if (c.type == OperatorType.EXPONENTIAL)
{
return(2);
}
else if (c.type == OperatorType.MULTIPLY || c.type == OperatorType.DIVIDE)
{
return(3);
}
else if (c.type == OperatorType.ADD || c.type == OperatorType.SUBTRACT)
{
return(4);
}
else
{
return(Int32.MaxValue);
}
}
public Condition(Element value1, OperatorElement op, Element value2)
{
Value1 = value1;
CompareOperator = op;
Value2 = value2;
}
public Element Calculate(BooleanElement x, BooleanElement y, OperatorElement o)
{
switch (o.)
{
public Element Calculate(Element x, Element y, OperatorElement o)
{
if(x.ElementType == ElementType.Number && y.ElementType == ElementType.Number)
return Calculate( x as NumberElement, y as NumberElement, o);
if (x.ElementType == ElementType.Boolean && y.ElementType == ElementType.Boolean)
return Calculate(x as BooleanElement, y as BooleanElement, o);
if (x.ElementType == ElementType.Text && y.ElementType == ElementType.Text)
return Calculate(x as TextElement, y as TextElement, o);
throw new ArgumentException(String.Concat(x.ElementType.ToString()," 不能和类型 ",y.ElementType.ToString()," 比较"));
}
