public void Test_06_Money()
{
SymbolicExpression ident = new SymbolicExpression("symbolic");
Money <SymbolicValue> moneyFromSymbolicValue = new Money <SymbolicValue>(ident, Currency.GBP);
Assert.AreEqual("(symbolic*20) GBP", moneyFromSymbolicValue.ToString(),
"Error in Money from SymbolicExpression.");
SimpleExpression <SymbolicValue> SymbolicSE = new SymbolicExpression("symbolic_exspression");
Money <SymbolicValue> moneyFromSymbolicExpression = new Money <SymbolicValue>(SymbolicSE, Currency.GBP);
Assert.AreEqual("(symbolic_exspression*20) GBP", moneyFromSymbolicExpression.ToString(),
"Error in Money from SimpleExpression<SymbolicValue>.");
NumericExpression n = new NumericExpression(6.7);
Money <NumericValue> moneyFromNumericValue = new Money <NumericValue>(n, Currency.GBP);
Assert.AreEqual("134 GBP", moneyFromNumericValue.ToString(),
"Error in Money from NumericExpression.");
SimpleExpression <NumericValue> NumericSE = new NumericExpression(3.4);
Money <NumericValue> moneyFromNumericExpression = new Money <NumericValue>(NumericSE, Currency.GBP);
Assert.AreEqual("68 GBP", moneyFromNumericExpression.GetValue().ToString(),
"Error in Money from SimpleExpression<NumericValue>.");
}
public void ExitNumericfunctionref(BASICParser.NumericfunctionrefContext context)
{
if (currentNumericDefinedFunction == null)
{
if (currentArgument == null)
{
currentNumericFunctionRef = new NumericFunctionRef(currentNumericSuppliedFunction);
}
else
{
currentNumericFunctionRef = new NumericFunctionRef(currentNumericSuppliedFunction, currentArgument);
}
}
else
{
if (currentArgument == null)
{
currentNumericFunctionRef = new NumericFunctionRef(currentNumericDefinedFunction);
}
else
{
currentNumericFunctionRef = new NumericFunctionRef(currentNumericDefinedFunction, currentArgument);
}
}
currentNumericDefinedFunction = null;
currentArgument = null;
primaryOp = PrimaryOptions.FN;
}
private void WriteNumeric(Expression expression)
{
NumericExpression numeric = (NumericExpression)expression;
object value = numeric.Value;
switch (Type.GetTypeCode(value.GetType()))
{
case TypeCode.Double:
_jsonWriter.WriteValue((double)value);
break;
case TypeCode.Single:
_jsonWriter.WriteValue((float)value);
break;
case TypeCode.Int64:
_jsonWriter.WriteValue((long)value);
break;
case TypeCode.Decimal:
case TypeCode.UInt64:
_jsonWriter.WriteSpecialValue(string.Format("{0}", value));
break;
default:
_jsonWriter.WriteValue((long)Convert.ChangeType(value, typeof(long), CultureInfo.InvariantCulture));
break;
}
}
/// <summary>
/// Handles the AST node visit.
/// </summary>
/// <param name="astNode">AST node.</param>
public override void Visit(FunctionTermAstNode astNode)
{
NumericFunction function = new NumericFunction(astNode.Name);
astNode.Terms.ForEach(term => function.Terms.Add(MasterExporter.ToTerm(term)));
ExpressionData = function;
}
internal BinaryExpression GenBinaryExpression(IScope scope, int maxDepth)
{
BinaryExpression be = new BinaryExpression();
var op = _options.BinaryOperators.ChooseRandom(_rand);
be.Operator = op;
var lhs = GenExpression(scope, maxDepth);
var rhs = GenExpression(scope, maxDepth);
if (op.Has(OperatorRequirement.StringLengthLimit))
{
scope.Require(GlobalFunction.STRL);
}
if (op.Has(OperatorRequirement.NumericOnly))
{
if (!lhs.IsNumeric)
{
lhs = new NumericExpression(scope, lhs, GenNumericLiteral());
}
if (!rhs.IsNumeric)
{
rhs = new NumericExpression(scope, rhs, GenNumericLiteral());
}
if (op.Has(OperatorRequirement.RhsNonzero))
{
rhs = new NonZeroExpression(scope, rhs);
}
}
be.Lhs = lhs;
be.Rhs = rhs;
return(be);
}
static void Main(string[] args)
{
string[] tree;
var context = new Context();
var expressions = new List <IExpression>();
Console.WriteLine("ingrese la operacion en letras: ");
string val = Console.ReadLine();
tree = val.Split(' ');
IExpression exp;
foreach (var t in tree)
{
if (Operators.ConditionalCompareObjectGreaterEqual(context.getInteger(t), 0, false))
{
exp = new NumericExpression(t);
}
else
{
exp = new OperatorExpression(t);
}
exp.interpret(context);
}
Console.WriteLine("El resultado para '" + val + "' es " + context.getResult());
Console.ReadKey();
}
internal AssignmentExpression GenAssignmentExpression(IScope scope, Variable v, int maxDepth)
{
AssignmentOperator op = _options.AssignmentOperators.ChooseRandom(_rand);
AssignmentExpression ae = new AssignmentExpression()
{
Operator = op
};
if (op.Has(OperatorRequirement.NumericOnly))
{
scope.Require(GlobalFunction.CALC);
ae.DefaultValue = GenNumericLiteral();
}
if (!op.Has(OperatorRequirement.WithoutRhs))
{
Expression expr = GenExpression(scope, maxDepth);
if (op.Has(OperatorRequirement.NumericOnly) && !expr.IsNumeric)
{
expr = new NumericExpression(scope, expr, GenNumericLiteral());
}
if (op.Has(OperatorRequirement.RhsNonzero))
{
expr = new NonZeroExpression(scope, expr);
}
ae.Rhs = expr;
}
ae.Variable = v;
return(ae);
}
internal UnaryExpression GenUnaryExpression(IScope scope, int maxDepth)
{
UnaryExpression ue = new UnaryExpression();
UnaryOperator op = _options.UnaryOperators.ChooseRandom(_rand);
ue.Operator = op;
Expression expr = GenExpression(scope, maxDepth);
if (op.Has(OperatorRequirement.NumericOnly) && !expr.IsNumeric)
{
expr = new NumericExpression(scope, expr, GenNumericLiteral());
}
if (op.Has(OperatorRequirement.RhsNonnegative))
{
expr = new NonNegativeExpression(scope, expr);
}
if (op.Has(OperatorRequirement.RhsNonzero))
{
expr = new NonZeroExpression(scope, expr);
}
if (op.Has(OperatorRequirement.LimitedPrecision))
{
scope.Require(GlobalFunction.PREC);
}
ue.Value = expr;
return(ue);
}
public void WriteNumber(object value)
{
NumericExpression expr = new NumericExpression(value);
_exprWriter.Write(expr);
Assert.AreEqual(String.Format(CultureInfo.InvariantCulture, "{0}", value), _stringWriter.ToString());
}
public void Test_10_LimitSpecification()
{
SimpleExpression <SymbolicValue> SymbolicSE = new SymbolicExpression("symbolic_exspression");
Money <SymbolicValue> moneyFromSymbolicExpression = new Money <SymbolicValue>(SymbolicSE, Currency.GBP);
LimitSpecification <MoneyValue <SymbolicValue> > moneyFromSymbolicExpressionPayoutSpec =
new LimitSpecification <MoneyValue <SymbolicValue> >(moneyFromSymbolicExpression);
Assert.AreEqual("PAYOUTEXPRESSION((symbolic_exspression*20) GBP)", moneyFromSymbolicExpressionPayoutSpec.ToString(),
"Error in LimitSpecification<MoneyValue<SymbolicValue>> from Money<SymbolicValue>.");
NumericExpression n = new NumericExpression(6.7);
Money <NumericValue> moneyFromNumericValue = new Money <NumericValue>(n, Currency.GBP);
LimitSpecification <MoneyValue <NumericValue> > moneyFromNumericValuePayoutSpec =
new LimitSpecification <MoneyValue <NumericValue> >(moneyFromNumericValue, true);
Assert.AreEqual("PAYOUTEXPRESSION(PAY 134 GBP)", moneyFromNumericValuePayoutSpec.ToString(),
"Error in LimitSpecification<MoneyValue<NumericValue>> from Money<NumericValue>.");
Percentage <NumericValue> numPerc = new Percentage <NumericValue>(n);
LimitSpecification <NumericValue> numPercPayoutSpec =
new LimitSpecification <NumericValue>(numPerc, true);
Assert.AreEqual("PAYOUTEXPRESSION(PAY 6.7%)", numPercPayoutSpec.ToString(),
"Error in LimitSpecification<NumericValue> from Percentage<NumericValue>.");
}
public void Test_09_Participation()
{
SymbolicExpression ident = new SymbolicExpression("symbolic");
Ratio <SymbolicValue> symbolicRatio = new Ratio <SymbolicValue>(ident);
Participation <SymbolicValue> symbolicRatioParticipation = new Participation <SymbolicValue>(symbolicRatio);
Assert.AreEqual("PARTICIPATION(RATIO(symbolic))", symbolicRatioParticipation.ToString(),
"Error in Participation<SymbolicValue> from Ratio<SymbolicValue>.");
FunctionInvocation <int> f = new FunctionInvocation <int>(
delegate(object[] parameters)
{
int sum = 0;
foreach (object parameter in parameters)
{
sum += (int)parameter;
}
return(new NumericValue(sum));
},
5, 7, 8);
Ratio <Value> funcInvRatio = new Ratio <Value>(f);
Participation <Value> funcInvRatioParticipation = new Participation <Value>(funcInvRatio);
Assert.AreEqual("PARTICIPATION(RATIO(<Test_09_Participation>b__d(5,7,8)))", funcInvRatioParticipation.ToString(),
"error in Participation<Value> from Ratio<Value> from FunctionInvocation<int>.");
NumericExpression n = new NumericExpression(6.7);
Percentage <NumericValue> numPerc = new Percentage <NumericValue>(n);
Ratio <NumericValue> percNumRatio = new Ratio <NumericValue>(numPerc);
Participation <NumericValue> percNumRatioParticipation = new Participation <NumericValue>(percNumRatio);
Assert.AreEqual("PARTICIPATION(RATIO(6.7%))", percNumRatioParticipation.ToString(),
"Error in Participation<NumericValue> from Ratio<NumericValue>.");
}
public void FloatingPoint()
{
Assert.AreEqual(0.01d, NumericExpression.Solve("0.1^2"));
Assert.AreEqual(2, NumericExpression.Solve("4^0.5"));
Assert.AreEqual(0.12d, NumericExpression.Solve("0.1 + 0.2 * 0.1"));
Assert.AreEqual(0.001d, NumericExpression.Solve("-0.1 * -0.1"));
Assert.AreEqual(10, NumericExpression.Solve("1/0.1"));
Assert.AreEqual(0.1d, NumericExpression.Solve("-0.1 + 0.2 * 0.01/0.1^2"));
}
/// <summary>
/// 下一条表达式
/// </summary>
/// <param name="exprStack"></param>
/// <param name="tokens"></param>
/// <returns></returns>
public static dynamic NextExpression(Stack <Expression> exprStack, List <Token> tokens, int startPos = 0)
{
var currPos = startPos;
var currToken = tokens[currPos];
switch (currToken.Type)
{
case "Identifier":
var idExpr = new IdentiferExpression
{
StartPos = exprStack.Peek().EndPos
};
idExpr.EndPos = idExpr.StartPos + 1;
exprStack.Push(idExpr);
break;
case "Numeric":
var numExpr = new NumericExpression
{
StartPos = exprStack.Peek().EndPos
};
numExpr.EndPos = numExpr.StartPos + 1;
exprStack.Push(numExpr);
break;
case "String":
var strExpr = new StringExpression();
strExpr.StartPos = exprStack.Peek().EndPos;
strExpr.EndPos = strExpr.StartPos + 1;
exprStack.Push(strExpr);
break;
case "Punctuator":
switch (tokens[currPos].Value)
{
// 成员操作符
case ".":
var last = exprStack.Pop();
var memExpr = new MemberExpression();
NextExpression(exprStack, tokens.Skip(currPos + 1).Take(tokens.Count).ToList()); // 这里会push一个表达式
memExpr.Object = last;
memExpr.Property = exprStack.Pop();
memExpr.StartPos = memExpr.Object.StartPos;
memExpr.EndPos = memExpr.Property.EndPos;
exprStack.Push(memExpr);
break;
}
break;
}
return(null);
}
public void Test_04_SimpleNumericExpressionValue()
{
string msg = "Error: expected value of {0} should be {1}.";
double d = 6.7;
NumericExpression n = new NumericExpression(d);
Assert.AreEqual(d.ToString(), n.GetValue().ToString(), msg, "NumericExpression", d);
d = 3.4;
SimpleExpression <NumericValue> NumericSE = new NumericExpression(3.4);
Assert.AreEqual(d.ToString(), NumericSE.GetValue().ToString(), msg, "SimpleExpression<NumericValue>", d);
}
public void Test_07_Percentage()
{
SimpleExpression <SymbolicValue> SymbolicSE = new SymbolicExpression("symbolic_exspression");
Percentage <SymbolicValue> symSEPerc = new Percentage <SymbolicValue>(SymbolicSE);
Assert.AreEqual("symbolic_exspression%", symSEPerc.ToString(),
"Error in Percentage<SymbolicValue> from SimpleExpression<SymbolicValue>.");
NumericExpression n = new NumericExpression(6.7);
Percentage <NumericValue> numPerc = new Percentage <NumericValue>(n);
Assert.AreEqual("6.7%", numPerc.ToString(),
"Error in Percentage<NumericValue> from NumericExpression");
}
internal ForLoop GenForLoop(IScope scope, Statement parent, int maxDepth)
{
var fl = new ForLoop(scope);
Variable i = fl.IteratorVariable = GenVariable(fl, false, true);
i.Initializer = GenNumericLiteral(NumericLiteralType.SmallInteger);
bool decrease = _rand.FlipCoin();
Expression iteratorExpr = null;
if (_rand.FlipCoin(_options.ForLoopVariableBoundsChance))
{
Variable v = _varSelector.ChooseVariable(scope);
if (v != null)
{
iteratorExpr = new NumericExpression(fl, new VariableExpression(v), GenNumericLiteral());
}
}
if (iteratorExpr == null)
{
iteratorExpr = GenNumericLiteral();
}
iteratorExpr = new BinaryExpression()
{
Operator = _rand.FlipCoin() ? BinaryOperator.Less : BinaryOperator.Greater,
Lhs = new VariableExpression(i),
Rhs = iteratorExpr
};
fl.Control = new LoopControlExpression(iteratorExpr, _cyclesProtection);
var op = _options.AssignmentInForLoop.ChooseRandom(_rand);
Expression rhs = null;
if (!op.Has(OperatorRequirement.WithoutRhs))
{
rhs = GenNumericLiteral();
if (op.Has(OperatorRequirement.RhsNonzero))
{
rhs = new NonZeroExpression(fl, rhs);
}
}
fl.IteratorExpression = new AssignmentExpression()
{
Operator = op,
Variable = i,
Rhs = rhs
};
fl.Body = GenStatement(fl, fl, maxDepth - 1);
return(fl);
}
/// <summary>
/// Handles the AST node visit.
/// </summary>
/// <param name="astNode">AST node.</param>
public override void Visit(NumericOpAstNode astNode)
{
NumericExpressions arguments = new NumericExpressions();
astNode.Arguments.ForEach(arg => arguments.Add(MasterExporter.ToNumericExpression(arg)));
switch (astNode.Operator)
{
case Traits.NumericOperator.PLUS:
{
ExpressionData = new Plus(arguments);
break;
}
case Traits.NumericOperator.MINUS:
{
if (arguments.Count == 1)
{
ExpressionData = new UnaryMinus(arguments[0]);
}
else
{
ExpressionData = new Minus(arguments[0], arguments[1]);
}
break;
}
case Traits.NumericOperator.MUL:
{
ExpressionData = new Multiply(arguments);
break;
}
case Traits.NumericOperator.DIV:
{
ExpressionData = new Divide(arguments[0], arguments[1]);
break;
}
default:
{
Debug.Assert(false);
break;
}
}
}
public void SimpleExpressions()
{
Assert.AreEqual(1, NumericExpression.Solve("1/1"));
Assert.AreEqual(0.5d, NumericExpression.Solve("1/2"));
Assert.AreEqual(1, NumericExpression.Solve("1*1"));
Assert.AreEqual(2, NumericExpression.Solve("1+1"));
Assert.AreEqual(0, NumericExpression.Solve("1-1"));
Assert.AreEqual(0, NumericExpression.Solve("-1+1"));
Assert.AreEqual(1, NumericExpression.Solve("1^1"));
Assert.AreEqual(1, NumericExpression.Solve("-1^2"));
Assert.AreEqual(3, NumericExpression.Solve("-1+2*2"));
Assert.AreEqual(-3, NumericExpression.Solve("-2*2+1"));
Assert.AreEqual(49, NumericExpression.Solve("(3 + 4)^2"));
Assert.AreEqual(0.25d, NumericExpression.Solve("2^-2"));
Assert.AreEqual(0.25d, NumericExpression.Solve("1/(2^2)"));
Assert.AreEqual(4.25d, NumericExpression.Solve("1/4+2*2"));
Assert.AreEqual(0.25d, NumericExpression.Solve("1/4+2*2-2^2(2/2)"));
Assert.AreEqual(1, NumericExpression.Solve("-1 * -1"));
Assert.AreEqual(16, NumericExpression.Solve("(2^2)2^2"));
Assert.AreEqual(0, NumericExpression.Solve("1^0"));
}
public void Test_11_Cover()
{
SimpleExpression <SymbolicValue> SymbolicSE = new SymbolicExpression("symbolic_exspression");
Money <SymbolicValue> moneyFromSymbolicExpression = new Money <SymbolicValue>(SymbolicSE, Currency.GBP);
LimitSpecification <MoneyValue <SymbolicValue> > moneyFromSymbolicExpressionPayoutSpec =
new LimitSpecification <MoneyValue <SymbolicValue> >(moneyFromSymbolicExpression);
Limit <MoneyValue <SymbolicValue> > moneyFromSymbolicExpressionPayout =
new Limit <MoneyValue <SymbolicValue> >(moneyFromSymbolicExpressionPayoutSpec, 1);
SimpleExpression <NumericValue> NumericSE = new NumericExpression(3.4);
Attachment <NumericValue> NumericSEAttachment = new Attachment <NumericValue>(NumericSE);
NumericExpression n = new NumericExpression(6.7);
Percentage <NumericValue> numPerc = new Percentage <NumericValue>(n);
Ratio <NumericValue> percNumRatio = new Ratio <NumericValue>(numPerc);
Participation <NumericValue> percNumRatioParticipation = new Participation <NumericValue>(percNumRatio);
Cover <NumericValue, MoneyValue <SymbolicValue>, NumericValue> coverNumSymbNum
= new Cover <NumericValue, MoneyValue <SymbolicValue>, NumericValue>(
percNumRatioParticipation,
moneyFromSymbolicExpressionPayout,
NumericSEAttachment);
string str = "COVER \n{\n\tShare: PARTICIPATION(RATIO(6.7%))\n\t_Limit: PAYOUT(PAYOUTEXPRESSION((symbolic_exspression*20) GBP), Occurrence)\n\t_Attachment: XS(3.4, Occurrence, IsItFranchise=False)\n}";
Assert.AreEqual(str, coverNumSymbNum.ToString(),
"Error in Cover<NumericValue, MoneyValue<SymbolicValue>, NumericValue> Constructor.");
ICover <Value, Value, Value> cNSN
= (ICover <Value, Value, Value>)coverNumSymbNum;
SymbolicExpression ident = new SymbolicExpression("symbolic");
Ratio <SymbolicValue> symbolicRatio = new Ratio <SymbolicValue>(ident);
Participation <SymbolicValue> symbolicRatioParticipation = new Participation <SymbolicValue>(symbolicRatio);
Cover <SymbolicValue> coverNumShareNumPayout
= new Cover <SymbolicValue>(symbolicRatioParticipation, "\"MyCoverLabel\"");
str = "COVER \"MyCoverLabel\"\n{\n\tShare: PARTICIPATION(RATIO(symbolic))\n\t_Limit: \n\t_Attachment: \n}";
Assert.AreEqual(str, coverNumShareNumPayout.ToString(),
"Error in Cover<SymbolicValue> Constructor.");
}
public void MathExpression_Can_Evaluate_Numeric_Expression()
{
var expression = new NumericExpression(42);
var visitor = new EvaluationVisitor();
Assert.AreEqual(42, visitor.Evaluate(expression, new MathExpressionContext()));
}
