private Expression ConvertIterationSumExpression(Mathy.Language.IterationSumExpression e, int parantheseLevel)
{
bool hasParanthese = e.Body is Cherimoya.Expressions.BinaryExpression;
Expression operand = Convert(e.Body, parantheseLevel + (hasParanthese ? 1 : 0));
if (hasParanthese)
{
operand = new ParantheseExpression()
{
Body = operand
};
}
return(new SumExpression()
{
Sigmas = e.Variables.Select(i => new SigmaConfig()
{
To = Convert(i.To, parantheseLevel),
From = new BinaryExpression()
{
Left = new TextExpression(i.Name, true),
Right = Convert(i.From, parantheseLevel),
Operator = new BinaryOperatorNode()
{
Operator = BinaryOperator.Equal
},
ActualOperator = new BinaryOperatorNode()
{
Operator = BinaryOperator.Equal
}
}
}).ToArray(),
Operand = operand
});
}
private Expression ConvertBinaryExpression(Cherimoya.Expressions.BinaryExpression e, int parantheseLevel)
{
Cherimoya.Expressions.BinaryOperator oper = e.Operator;
BinaryOperator op = GetBinaryOpeator(oper);
BinaryOperator prevOp = op;
Cherimoya.Expressions.Expression leftExpr = e.Left;
Cherimoya.Expressions.Expression rightExpr = e.Right;
Boolean swap = false;
if (op == BinaryOperator.Multiply)
{
if (IsInvididualExpression(e.Right) && !IsInvididualExpression(e.Left) &&
!(e.Left is Cherimoya.Expressions.BinaryExpression))
{
swap = true;
}
else if (e.Right is Cherimoya.Expressions.ConstantExpression && !(e.Left is Cherimoya.Expressions.ConstantExpression))
{
swap = true;
}
}
if (swap)
{
Cherimoya.Expressions.Expression t = leftExpr;
leftExpr = rightExpr;
rightExpr = t;
}
bool leftParanthese = false;
bool rightParanthese = false;
if (op != BinaryOperator.Assign)
{
if (op != BinaryOperator.Divide)
{
if (leftExpr is Cherimoya.Expressions.BinaryExpression)
{
Cherimoya.Expressions.BinaryOperator leftOp = (leftExpr as Cherimoya.Expressions.BinaryExpression).Operator;
if (GetOperatorLevel(oper) > GetOperatorLevel(leftOp))
{
leftParanthese = true;
}
}
if (rightExpr is Cherimoya.Expressions.BinaryExpression)
{
Cherimoya.Expressions.BinaryOperator rightOp = (rightExpr as Cherimoya.Expressions.BinaryExpression).Operator;
if (GetBinaryOpeator(rightOp) == op)
{
rightParanthese = true;
}
else if (GetOperatorLevel(oper) > GetOperatorLevel(rightOp))
{
rightParanthese = true;
}
}
}
if (rightExpr is Cherimoya.Expressions.FunctionCallExpression && (rightExpr as Cherimoya.Expressions.FunctionCallExpression).MethodName == "root")
{
rightParanthese = true;
}
}
if (op == BinaryOperator.Multiply)
{
if (!(leftExpr is Cherimoya.Expressions.ConstantExpression & rightExpr is Cherimoya.Expressions.ConstantExpression))
{
op = BinaryOperator.None;
}
}
Expression left = Convert(leftExpr, parantheseLevel + (leftParanthese ? 1 : 0));
Expression right = Convert(rightExpr, parantheseLevel + (rightParanthese ? 1 : 0));
if (leftParanthese)
{
left = new ParantheseExpression()
{
Body = left, ParantheseLevel = parantheseLevel
};
}
if (rightParanthese)
{
right = new ParantheseExpression()
{
Body = right, ParantheseLevel = parantheseLevel
};
}
return(new BinaryExpression()
{
Left = left,
Operator = new BinaryOperatorNode()
{
Operator = op
},
ActualOperator = new BinaryOperatorNode()
{
Operator = prevOp
},
Right = right
});
}
private Expression ConvertFunctionCallExpression(Cherimoya.Expressions.FunctionCallExpression e, int parantheseLevel)
{
if (e.Method.Name == "root")
{
if ((e.Parameters[1] is Cherimoya.Expressions.ConstantExpression) &&
Types.ConvertValue <int>((e.Parameters[1] as Cherimoya.Expressions.ConstantExpression).Value) == 2)
{
return(new RootExpression()
{
X = Convert(e.Parameters[0], parantheseLevel)
});
}
else
{
return(new RootExpression()
{
X = Convert(e.Parameters[0], parantheseLevel), Root = Convert(e.Parameters[1], parantheseLevel)
});
}
}
else if (e.Method.Name == "abs")
{
return(new AbsExpression()
{
Operand = Convert(e.Parameters[0], parantheseLevel)
});
}
else if (e.Method.Name == "pow")
{
bool hasParanthese = e.Parameters[0] is Cherimoya.Expressions.BinaryExpression;
Expression operand = Convert(e.Parameters[0], parantheseLevel + (hasParanthese ? 1 : 0));
if (hasParanthese)
{
operand = new ParantheseExpression()
{
Body = operand
};
}
return(new PowExpression()
{
X = operand, Pow = Convert(e.Parameters[1], parantheseLevel)
});
}
else if (e.Method.Name == "sum")
{
Cherimoya.Expressions.Expression right = e.Parameters[0];
bool hasParanthese = right is Cherimoya.Expressions.BinaryExpression;
Expression operand = Convert(right, parantheseLevel + (hasParanthese ? 1 : 0));
if (hasParanthese)
{
operand = new ParantheseExpression()
{
Body = operand
};
}
return(new SumExpression()
{
Sigmas = new SigmaConfig[] { new SigmaConfig() },
Operand = operand
});
}
else if (e.Method.Name == "lg" || e.Method.Name == "ln" || e.Method.Name == "log")
{
Cherimoya.Expressions.Expression xExpr = e.Method.Name == "log" ? e.Parameters[1] : e.Parameters[0];
bool hasParanthese = xExpr is Cherimoya.Expressions.BinaryExpression && (xExpr as Cherimoya.Expressions.BinaryExpression).Operator != Cherimoya.Expressions.BinaryOperator.Divide;
Expression b = e.Method.Name == "log" ? Convert(e.Parameters[0], parantheseLevel) : null;
Expression x = hasParanthese ? new ParantheseExpression()
{
Body = Convert(xExpr, parantheseLevel + 1)
} : Convert(xExpr, parantheseLevel);
return(new LogExpression(e.Method.Name, b, x));
}
else if (e.Method.Name == "transpose")
{
return(new SuperscriptExpression()
{
Body = Convert(e.Parameters[0], parantheseLevel), Superscript = new TextExpression("T", false), HasBracket = true
});
}
else if (e.Method.Name == "stdvar")
{
return(new SubscriptExpression()
{
Body = new TextExpression("σ", false), Subscript = Convert(e.Parameters[0], parantheseLevel), ShiftOffset = 10
});
}
else if (e.Method.Name == "average")
{
return(new UpperlineExpression()
{
Body = Convert(e.Parameters[0], parantheseLevel)
});
}
else if (e.Method.Name == "diff" || e.Method.Name == "pdiff")
{
return(ConvertDiffExpression(e));
}
else
{
return(new FunctionExpression()
{
Name = e.MethodName,
Operands = e.Parameters.Select(i => Convert(i, parantheseLevel + 1)).ToArray(),
ParantheseLevel = parantheseLevel
});
}
}
