/// <summary>
/// Rule: AddExpr -> MultExpr ((PLUSMINUS) MultExpr )* ;
/// </summary>
protected override object EvalAddExpr(ParseTree tree, params object[] paramlist)
{
if (GetNode(TokenType.PLUSMINUS) == null)
{
return((ExpressionBase)GetNode(TokenType.MultExpr).Eval(tree));
}
var expressions = new Stack <ExpressionBase>(nodes.OfTokenType(TokenType.MultExpr).Select(n => n.Eval(tree)).Cast <ExpressionBase>().Reverse());
var operations = new Stack <string>(nodes.OfTokenType(TokenType.PLUSMINUS).Select(x => x.Token.Text).Reverse());
while (expressions.Count > 1)
{
var leftExpr = expressions.Pop();
var rightExpr = expressions.Pop();
var newExpr = new AddExpr
{
First = leftExpr,
Second = rightExpr,
Node = this,
OperationText = operations.Pop()
};
expressions.Push(newExpr);
}
return(expressions.First());
}
public Expr Add(AddExpr multi)
{
Expr result = null;
multi.Args.Accumulate(x => {
result = x.Visit(this);
}, x => {
result = Builder.Add(result, x.Visit(this));
});
return result;
}
static void Main(string[] args)
{
Console.WriteLine("1_______________________________________________________________________________");
// (3*x^2 + 7) / (x + 5) 82 / 10 = 8.2
Expression exp = new DivExpr(
new AddExpr(
MonomialExpr.createObject(3, 2),
ConstExpr.createObject(7)),
new AddExpr(
MonomialExpr.createObject(1, 1),
ConstExpr.createObject(5)));
Console.WriteLine("f(x)=" + exp.ToString());
Console.WriteLine("f(5)=" + exp.Evaluate(5));
Console.WriteLine("f'(x)=" + exp.Derive().ToString());
Console.WriteLine("2_______________________________________________________________________________");
// (0 + 10) - 0 * (x^1 + 0)
Expression exp5 = new AddExpr(MonomialExpr.createObject(0, 2),
ConstExpr.createObject(10));
Expression exp6 = new SubExpr(exp5,
new MulExpr(ConstExpr.createObject(0),
new AddExpr(MonomialExpr.createObject(1, 1),
ConstExpr.createObject(0))));
Console.WriteLine("f(x)=" + exp6.ToString());
Console.WriteLine("f(2)=" + exp6.Evaluate(2));
Console.WriteLine("f'(x)=" + exp6.Derive().ToString());
Console.WriteLine("3_______________________________________________________________________________");
//(((x^2 + 2) / (x + 1)) + 10) / (x^2 + 5)
Expression exp3 = new DivExpr(
new AddExpr(
MonomialExpr.createObject(1, 2),
ConstExpr.createObject(2)),
new AddExpr(
MonomialExpr.createObject(1, 1),
ConstExpr.createObject(1)));
Expression exp4 = new DivExpr(
new AddExpr(
exp3,
ConstExpr.createObject(10)),
new AddExpr(
MonomialExpr.createObject(1, 2),
ConstExpr.createObject(5)));
Console.WriteLine("f(x)=" + exp4.ToString());
Console.WriteLine("f(1)=" + exp4.Evaluate(1));
Console.WriteLine("f'(x)=" + exp4.Derive().ToString());
}
public dynamic Visit(AddExpr expr)
{
var left = _codeGen.Local(Visit((dynamic)expr.First)) as Operand;
var right = _codeGen.Local(Visit((dynamic)expr.Second)) as Operand;
switch (expr.Type)
{
case AddType.Plus:
return(left + right);
case AddType.Minus:
return(left - right);
default:
throw new ArgumentOutOfRangeException();
}
}
public dynamic Visit(AddExpr expr)
{
if (expr.Types.Contains(SymbolType.Bool))
{
throw new ParseException("Невозможно применить эту операцию к Bool", expr.Node);
}
if (expr.Types.Contains(SymbolType.String))
{
if (expr.Type == AddType.Minus)
{
throw new ParseException("Вычитание строк не поддерживается", expr.Node);
}
return(SymbolType.String);
}
if (expr.Types.Contains(SymbolType.Double))
{
return(SymbolType.Double);
}
return(SymbolType.Integer);
}
public dynamic Visit(AddExpr expr)
{
var node = new TreeNode("Expression")
{
Tag = expr.Node
};
if (expr.First != null)
{
node.Nodes.Add(Visit((dynamic)expr.First));
}
if (expr.Second != null)
{
node.Nodes.Add(Visit((dynamic)expr.Second));
}
if (expr.Third != null)
{
node.Nodes.Add(Visit((dynamic)expr.Third));
}
node.Text = expr.Type.ToString();
return(node);
}
public void Visit(AddExpr addExpr, object[] args)
{
addExpr.FirstOp.Accept(this);
addExpr.SecondOp.Accept(this);
RightValue v1 = readRightValue(addExpr.FirstOp);
RightValue v2 = readRightValue(addExpr.SecondOp);
if (v1 is StringConst || v2 is StringConst)
{
StringConst result = new StringConst();
result.Value = v1.ToString() + v2.ToString();
addExpr.RightValue = result;
//addExpr.DataType = DataType.String;
}
else
{
DataType resultType = readAlgoOperand(v1, v2, addExpr.Location);
if (resultType == DataType.Int)
{
IntConst result = new IntConst();
result.Value = Convert.ToInt32(v1.GetValueObject()) + Convert.ToInt32(v2.GetValueObject());
addExpr.RightValue = result;
//addExpr.DataType = DataType.Int;
}
else if (resultType == DataType.Float)
{
FloatConst result = new FloatConst();
result.Value = Convert.ToDouble(v1.GetValueObject()) + Convert.ToDouble(v2.GetValueObject());
addExpr.RightValue = result;
//addExpr.DataType = DataType.Float;
}
else
{
throw new Exception();
}
}
}
private Expr parseAddExpr()
{
Expr expr = parseMulExpr();
while (true)
{
int token = parseToken();
switch (token)
{
case '+':
expr = new AddExpr(expr, parseMulExpr());
break;
case '-':
expr = new SubExpr(expr, parseMulExpr());
break;
default:
_peekToken = token;
return(expr);
}
}
}
public dynamic Visit(AddExpr expr)
{
Visit((ExpressionBase)expr);
if (OptimizeMode.ExpressionSimplify)
{
var left = expr.First as LiteralExpr;
var right = expr.Second as LiteralExpr;
if (left != null && right != null)
{
var literal = new LiteralExpr {
Namespace = expr.Namespace, Node = expr.Node, SymbolType = expr.GetExprType()
};
dynamic result;
switch (expr.Type)
{
case AddType.Plus:
result = left.Value + right.Value;
break;
case AddType.Minus:
result = left.Value - right.Value;
break;
default:
throw new ArgumentOutOfRangeException();
}
if (literal.SymbolType == SymbolType.Integer)
{
result = Convert.ToInt32(result);
}
literal.Value = result;
return(literal);
}
}
return(expr);
}
public dynamic Visit(AddExpr expr)
{
Visit((ExpressionBase)expr);
return(null);
}
/// <summary>
/// Validate an additon expression.
/// </summary>
/// <param name="addex">
/// is the expression. </param>
/// <returns> null. </returns>
public virtual object visit(AddExpr addex)
{
printBinExpr("ADD", addex);
return(null);
}
protected IType CheckExpr(AddExpr expr)
{
IType a = CheckExpr(expr.Expr1);
IType b = CheckExpr(expr.Expr2);
if (!(a is NumericType) || !a.CompatibleWith(b))
{
AddError(String.Format("Addition not possible. Incompatible types: '{0}', '{1}'. Only numeric types are supported.",
a.ToString(), b.ToString()), true, expr.SourcePosition);
return NumericType.Instance;
}
return (a is RealType || b is RealType) ? (IType)RealType.Instance : (IType)IntType.Instance;
}
/// <param name="ex">
/// is the add expression. </param>
/// <returns> a new function. </returns>
public virtual object visit(AddExpr ex)
{
ex.left().accept(this);
ex.right().accept(this);
return(null);
}
public Number Add(AddExpr multi)
{
return EvaluateMulti(multi, (x1, x2) => x1 + x2);
}
/// <param name="e">
/// is the plus expression. </param>
/// <returns> new add expression </returns>
public virtual object visit(PlusExpr e)
{
AddExpr ae = new AddExpr(make_int_lit(0), e.arg());
return(ae.accept(this));
}
/// <param name="addex">
/// is the add expression. </param>
/// <returns> a new function. </returns>
public virtual object visit(AddExpr addex)
{
return(make_ArithOp(addex, new QName("fs", "plus", OpFunctionLibrary.XPATH_OP_NS)));
}
