public void Evaluate(VariableContext vc)
{
foreach (Expression expression in Expressions)
{
new MathyLanguageService().CreateEvaluator().Evaluate(expression, vc);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CommonSteps"/> class.
/// Привязка общих шагов к работе с переменным через контекст.
/// </summary>
/// <param name="variableContext">Контекст для работы с переменными.</param>
/// <param name="fileSupport">Контекст для работы с файлами.</param>
/// <param name="consoleOutputHelper">Capturing Output.</param>
public CommonSteps(VariableContext variableContext, FileSupport fileSupport,
ITestOutputHelper consoleOutputHelper)
{
this.variableContext = variableContext;
this.fileSupport = fileSupport;
this.consoleOutputHelper = consoleOutputHelper;
}
public static Variable EvaluateDecisionByName(VariableContext runtimeContext, string decisionName)
{
if (runtimeContext == null || runtimeContext.DecisionMetaByName == null)
{
return(null);
}
runtimeContext.DecisionMetaByName.TryGetValue(decisionName, out var decision);
if (decision == null)
{
return(null);
}
//cannot run a decision serivce input without an input override value
if (decision.Id != null)
{
runtimeContext.HrefInputDecisionToDecisionServices.TryGetValue(decision.Id, out var decisionServices);
runtimeContext.InputNameDict.TryGetValue("decisionName", out var decisionInput);
if (decisionServices != null && decisionInput == null)
{
throw new DMNException($"Decision :{decisionName} is part of a decision service input and is missing input data");
}
}
return(decision.Expression
switch {
TLiteralExpression litExpr => EvalLiteralExpression(litExpr.Text, runtimeContext),
TDecisionTable decisionTable => EvalDecisionTable(decisionTable, runtimeContext),
TContext contextDecision => EvalContext(contextDecision, runtimeContext),
TRelation relation => EvalRelation(relation, runtimeContext),
_ =>
throw new DMNException($"Decision expression {decision.Expression.Id} is not supported yet"),
});
public object Execute(VariableContext context = null)
{
var leftVal = this.Left.Execute(context);
var rightVal = this.Right.Execute(context);
if (leftVal is Variable l && rightVal is Variable r)
{
if (l.ValueType != r.ValueType)
{
throw new FEELException("The variable type does not match for the arithmetic action");
}
switch (l.ValueType)
{
case DataTypeEnum.Decimal:
return(new Variable(l.NumericVal + r.NumericVal));
case DataTypeEnum.String:
return(new Variable($"{l.StringVal}{r.StringVal}"));
case DataTypeEnum.Date:
case DataTypeEnum.DateTime:
case DataTypeEnum.Time:
case DataTypeEnum.YearMonthDuration:
case DataTypeEnum.DayTimeDuration:
return(DateAndTimeHelper.Addition(l, r));
default:
throw new FEELException("Failed to perform addition to incorrect FEEL type");
}
}
throw new FEELException("Failed to perform addition due to values not being a variable");
}
public GenericVariable(VariableContext context, string name, string value)
{
this.Context = context;
this.ContextString = context.ToString();
this.Name = name;
this.Value = value;
}
public object Execute(VariableContext context = null)
{
var funcName = _function.Execute(context);
if (funcName is Variable outFuncVar && outFuncVar.ValueType == DataTypeEnum.Function)
{
if (_parameters is PositionalParameters)
{
var lVars = RetrieveListOfParameters(context);
return(outFuncVar.UserFunction.Execute(lVars, context));
}
if (_parameters is NamedParameters nParams)
{
return(outFuncVar.UserFunction.Execute(null, context, nParams));
}
}
if (funcName is Variable outFuncName && outFuncName.ValueType == DataTypeEnum.String)
{
List <Variable> lVars = new List <Variable> ();
if (_parameters is PositionalParameters)
{
lVars = RetrieveListOfParameters(context);
if (VariableContextHelper.RetrieveBkm(outFuncName, context, out var bkmMeta))
{
return(DMNDoerHelper.EvalBkm(bkmMeta.BKMModel, context, lVars));
}
if (context.DecisionServiceMetaByName.TryGetValue(outFuncName, out var decisionService))
{
return(DMNDoerHelper.EvalDecisionService(decisionService, context, lVars));
}
}
if (_parameters is NamedParameters namedParam)
{
if (VariableContextHelper.RetrieveBkm(outFuncName, context, out var bkmMeta))
{
lVars = BKMConvertNamedParameter(namedParam, bkmMeta.BKMModel, context);
return(DMNDoerHelper.EvalBkm(bkmMeta.BKMModel, context, lVars));
}
if (context.DecisionServiceMetaByName.TryGetValue(outFuncName, out var decisionService))
{
lVars = DecisionServiceConvertNamedParameter(namedParam, decisionService, context);
return(DMNDoerHelper.EvalDecisionService(decisionService, context, lVars));
}
}
var funcMeta = BuiltInFactory.GetFunc(outFuncName);
if (_parameters is NamedParameters nParam)
{
lVars = BuiltInFactory.ConvertNamedParameter(nParam, funcMeta.Item2, context);
}
return(funcMeta.Item1.Execute(lVars));
}
throw new FEELException("Function name is not a variable of string type");
}
private object EvaluteMultiIndexingExpression(MultiIndexingExpression e, VariableContext context)
{
object value = Evaluate(e.Operand, context);
int[] indexers = e.Indexers.Select(i => Types.ConvertValue <int>(Evaluate(i, context))).ToArray();
if (e.Operand.Type.IsArray)
{
Array array = value as Array;
return(array.GetValue(indexers[0]));
}
else if (e.Operand.Type.Equals(typeof(Matrix)))
{
Matrix m = value as Matrix;
if (indexers.Length == 1)
{
return(m.GetRow(indexers[0] - 1));
}
else
{
return(m[indexers[0] - 1, indexers[1] - 1]);
}
}
else
{
Vector v = value as Vector;
return(v[indexers[0] - 1]);
}
}
public Variable Execute(List <Variable> inputParams, VariableContext mainContext, NamedParameters nParams = null)
{
if (_isExternal)
{
//TODO: add error logging for no support for external java/PMML function types
return(new Variable());
}
var context = mainContext ?? new VariableContext();
if (nParams != null)
{
inputParams = BuiltInFactory.ConvertNamedParameter(nParams, _formalParams.Select(v => v.TwoTuple.a.StringVal).ToArray(), context);
}
if (inputParams != null && _formalParams.Count > 0)
{
if (_formalParams.Count != inputParams.Count)
{
//TODO: Add to error logging for missmatch expected input
return(new Variable());
}
for (int i = _formalParams.Count - 1; i >= 0; i--)
{
context.AddToFunctionInputs(_formalParams[i].TwoTuple.a.StringVal, inputParams[i]);
}
}
try {
return((Variable)_body.Execute(context));
} catch (Exception) {
return(new Variable());
}
}
public object Execute(VariableContext context = null)
{
var contextInput = new ContextInputs();
if (context == null)
{
context = new VariableContext();
}
if (context.LocalContext == null)
{
context.LocalContext = contextInput;
}
else if (context.LocalContext.ContextDict.ContainsKey("__currentContextX__"))
{
context.LocalContext.ContextDict["__currentContextX__"] = contextInput;
}
else
{
context.LocalContext.Add("__currentContextX__", contextInput);
}
foreach (var item in ContextEntries)
{
var itemVal = (Variable)item.Execute(context);
contextInput.Add(itemVal.TwoTuple.a, itemVal.TwoTuple.b);
}
if (context.LocalContext != null)
{
context.LocalContext.ContextDict.Remove("__currentContextX__");
}
return(new Variable(contextInput));
}
/// <summary>
/// Initializes a new instance of the <see cref="UtilsTest"/> class.
/// Инициализация переменных.
/// </summary>
public UtilsTest()
{
this.variableContext = new VariableContext();
this.variableContext.SetVariable("first", typeof(string), "1");
this.variableContext.SetVariable("second", typeof(string), "2");
this.variableContext.SetVariable("third", typeof(string), "3");
}
private bool ParseAndEval(string exprText, VariableContext context, string inputName)
{
var eval = new Evaluation();
var boolVal = eval.EvaluateUnaryTestsBase(exprText, context, inputName);
return(boolVal);
}
public static MultiVariableFunction FromString(string expression, params string[] variableNames)
{
var ctx = VariableContext.FromVariableNames(variableNames);
var root = StringTokenizer.ToExpression(expression, ctx);
return(new MultiVariableFunction(root, variableNames));
}
public static void CanBuildExpressionWithComplexParentheses()
{
var ctx = new VariableContext(new Dictionary <string, ISymbol> {
{ "x", new Variable("x") }
});
var result = StringTokenizer.ToExpression("3*x + 3*x + ((3*x * 1)/(3*x * 1))", ctx);
}
public object Execute(VariableContext context = null)
{
var leftVal = _left.Execute(context);
var whichTypeVal = _whichType.Execute(context);
if (whichTypeVal is Variable outType && outType.ValueType == DataTypeEnum.String)
{
ValidTypeNames.StringTypeToEnum.TryGetValue(outType.StringVal, out DataTypeEnum outDataType);
if (leftVal is Variable outLeftVal)
{
if (outDataType == DataTypeEnum.Any && outLeftVal.ValueType != DataTypeEnum.Null)
{
return(new Variable(true));
}
if (outLeftVal.ValueType == outDataType)
{
return(new Variable(true));
}
return(new Variable(false));
}
return(new Variable());
}
return(new Variable());
}
public static VariableContextExpression diff(VariableContextExpression expression, string variableName)
{
VariableContext c = expression.VariableContext;
Expression diff = new Differ(expression.Expression, variableName).Calculate(c);
TypeCheckingContext context = new MathyLanguageService().CreateTypeCheckingContext(c);
foreach (VariableInfo variable in expression.Variables)
{
c.Set(variable.Name, context.CreateAutoCreatedVariableValue(variable.Type));
}
VariableContextExpression result = new VariableContextExpression(diff, expression.Variables, 0, 0)
{
VariableContext = expression.VariableContext
};
new MathyLanguageService().CreateTypeChecker().PerformTypeChecking(result, context);
result = new VariableContextExpression(new Cherimoya.Reduction.ExpressionReductor(new MathyLanguageService()).Reduce(diff), expression.Variables, 0, 0)
{
VariableContext = expression.VariableContext
};
new MathyLanguageService().CreateTypeChecker().PerformTypeChecking(result, context);
foreach (VariableInfo variable in expression.Variables)
{
context.VariableContext.Remove(variable.Name);
}
return(result);
}
// a b a and b a or b
// true true true true
// true false false true
// true otherwise null true
// false true false true
// false false false false
// false otherwise false null
// otherwise true null true
// otherwise false false null
// otherwise otherwise null null
public object Execute(VariableContext context = null)
{
var leftVar = Left.Execute(context);
var rightVar = Right.Execute(context);
if (leftVar is Variable outLVar && rightVar is Variable outRVar)
{
if (outLVar.ValueType == DataTypeEnum.Boolean && outRVar.ValueType == DataTypeEnum.Boolean)
{
return(new Variable(outLVar.BoolVal || outRVar.BoolVal));
}
if (outLVar.ValueType == DataTypeEnum.Boolean && outLVar.BoolVal == true)
{
return(new Variable(true));
}
if (outRVar.ValueType == DataTypeEnum.Boolean && outRVar.BoolVal == true)
{
return(new Variable(true));
}
return(new Variable());
}
throw new FEELException("Expected both left and right values to be a variable");
}
private object EvaluteIndexingExpression(IndexingExpression expression, VariableContext context)
{
object instance = Evaluate(expression.Operand, context);
int index = (int)Evaluate(expression.Indexer, context);
return(((object[])instance)[index]);
}
public static void Test()
{
Assembly a;
var bs = BinarySerializerWithString.Create();
using (var s = Streams.OpenReadable("Assembly.bin"))
{
a = bs.Read <Assembly>(s);
}
var vc = new VariableContext <int>();
foreach (var m in a.Modules)
{
foreach (var f in m.Functions)
{
vc.Replace(f.Name, f);
}
}
var c = new Calculation(a);
Trace.Assert(c.Character.GetUpgradeExperience(1, 2) == 2);
TestBasic(vc);
TestInteractive(vc);
}
private object EvaluteCastExpression(CastExpression expression, VariableContext context)
{
object value = Evaluate(expression.Operand, context);
return(Types.CoerceValue(value, expression.TargetType));
}
public object Execute(VariableContext context = null)
{
var dateExprVar = DateExpression.Execute();
if (dateExprVar is Variable dateExprOut)
{
switch (DateFunction)
{
case "date":
return(DateAndTimeHelper.DateVal(dateExprOut.StringVal));
case "date and time":
return(DateAndTimeHelper.DateTimeVal(dateExprOut.StringVal));
case "time":
return(DateAndTimeHelper.TimeVal(dateExprOut.StringVal));
case "duration":
return(DateAndTimeHelper.DurationVal(dateExprOut.StringVal));
default:
throw new FEELException($"The following date function {DateFunction} is not supported");
}
}
throw new FEELException($"Failed executing date function {DateFunction}");
}
public ISymbol MakeSubstitutions(VariableContext ctx)
{
var o1 = Operand1.MakeSubstitutions(ctx);
var o2 = Operand2.MakeSubstitutions(ctx);
return(FromValues(Type, o1, o2));
}
public void EvaluateForStatement(string exprText, Variable expected)
{
VariableContext context = new VariableContext();
Variable variable = ParseAndEval(exprText, context);
Assert.True(variable.Equals(expected));
}
public void EvaluateQuantifiedStatement(string exprText, bool expectedBool)
{
VariableContext context = new VariableContext();
Variable variable = ParseAndEval(exprText, context);
Assert.Equal <bool> (expectedBool, variable);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testEmptyVariableContext()
public virtual void testEmptyVariableContext()
{
VariableContext varContext = emptyVariableContext();
assertTrue(varContext.Keys.Count == 0);
assertNull(varContext.resolve("nonExisting"));
assertFalse(varContext.containsVariable("nonExisting"));
}
public override object Evaluate(Expression expression, VariableContext context)
{
if (expression is CastExpression)
{
return(EvaluteCastExpression((CastExpression)expression, context));
}
else if (expression is CreateObjectExpression)
{
return(EvaluteCreateObjectExpression((CreateObjectExpression)expression, context));
}
else if (expression is CreateArrayExpression)
{
return(EvaluteCreateArrayExpression((CreateArrayExpression)expression, context));
}
else if (expression is BinaryExpression)
{
return(EvaluteBinaryExpression((BinaryExpression)expression, context));
}
else if (expression is VariableExpression)
{
return(EvaluateVariableExpression((VariableExpression)expression, context));
}
else if (expression is MethodCallExpression)
{
return(EvaluteMethodCallExpression((MethodCallExpression)expression, context));
}
else if (expression is FunctionCallExpression)
{
return(EvaluteFunctionCallExpression((FunctionCallExpression)expression, context));
}
else if (expression is IndexingExpression)
{
return(EvaluteIndexingExpression((IndexingExpression)expression, context));
}
else if (expression is FieldExpression)
{
return(EvaluteFieldExpression((FieldExpression)expression, context));
}
else if (expression is LambdaExpression)
{
return(expression);
}
else if (expression is ConstantExpression)
{
return(EvaluateConstantExpression((ConstantExpression)expression));
}
else if (expression is UnaryExpression)
{
return(EvaluateUnaryExpression((UnaryExpression)expression, context));
}
else if (expression is IfElseExpression)
{
return(EvaluateIfElseExpression((IfElseExpression)expression, context));
}
return(null);
}
public static Matrix map(Matrix m, LambdaExpression mapper, VariableContext vc)
{
ExpressionEvaluator evaluator = new MathyLanguageService().CreateEvaluator();
List <List <double> > result = new List <List <double> >();
double[] row = new double[m.ColumnCount];
for (int i = 0; i <= m.RowCount - 1; i++)
{
for (int j = 0; j <= m.ColumnCount - 1; j++)
{
row[j] = m[i, j];
}
vc.Set(mapper.VariableNames[0], row.Where(c => !double.IsNaN(c)).ToArray());
if (mapper.VariableNames.Length > 1)
{
vc.Set(mapper.VariableNames[1], i);
}
double[] mappedRow;
var obj = evaluator.Evaluate(mapper.Body, vc);
try
{
mappedRow = (double[])obj;
}
catch (Exception ex)
{
var a = (object[])obj;
mappedRow = (double[])a[0];
}
result.Add(new List <double>());
for (int j = 0; j <= mappedRow.Length - 1; j++)
{
result[i].Add(mappedRow[j]);
}
}
vc.Remove(mapper.VariableNames[0]);
List <double> cells = new List <double>();
foreach (List <double> resultRow in result)
{
foreach (double cell in resultRow)
{
cells.Add(cell);
}
}
return(new Matrix(m.RowCount, result[0].Count, cells.ToArray()));
}
public static SingleVariableFunction FromString(string expression, string variableName)
{
var ctx = VariableContext.FromVariableNames(new List <string> {
variableName
});
var root = StringTokenizer.ToExpression(expression, ctx);
return(new SingleVariableFunction(root, variableName));
}
// TODO Remove
//public static bool IsPropertyGetterOverride(this Object node, Property prop)
//{
// var bt = node.BaseType;
// while (bt != null)
// {
// if (bt.Properties.Any(bp => bp.Name == prop.Name))
// return true;
// bt = bt.BaseType;
// }
// return false;
//}
//public static bool IsPropertySetterOverride(this Object node, Property prop)
//{
// if (!prop.IsReadOnly)
// return false;
// var bt = node.BaseType;
// while (bt != null)
// {
// if (bt.Properties.Any(bp => bp.Name == prop.Name && !bp.IsReadOnly))
// return true;
// bt = bt.BaseType;
// }
// return false;
//}
public static IVariable ToVariable(this Type node, VariableContext ctx = VariableContext.Member, string name = null)
{
return(new Parameter()
{
Type = node,
Name = name,
Context = ctx
});
}
public Parameter(Type type, string name, VariableContext ctx, bool isArray, bool hasDefaultValue = false, object defaultValue = null) : base(Construct.Parameter)
{
Type = type;
Name = name;
Context = ctx;
IsArray = isArray;
HasDefaultValue = hasDefaultValue;
DefaultValue = defaultValue;
}
public static Bitmap Visualize(string expressions, Dictionary <string, object> variables)
{
VariableContext c = Funcs.CreateVariableContext(variables);
return(new NodeVisualizer(
new MathyLanguageService().Compile(expressions, c)
.Select(i => new NodeConverter().Convert(i))
.ToArray()).VisulizeAsBitmap());
}
/// <summary>
/// Pushes the current in-scope Graph onto the Graph stack and creates a new empty Graph to be the in-scope Graph
/// </summary>
/// <remarks>
/// Used for Graph Literal parsing - Base Uri and Namespace Maps of the outermost Graph is propogated to the innermost Graph
/// </remarks>
public void PushGraph()
{
Graph h = new Graph();
h.NamespaceMap.Import(this.Namespaces);
h.BaseUri = this.BaseUri;
this._handlers.Push(this._handler);
this._handler = new GraphHandler(h);
this._handler.StartRdf();
this._subgraphs.Push(this._g);
this._g = h;
VariableContext v = new VariableContext(VariableContextType.None);
this._varContexts.Push(this._varContext);
this._varContext = v;
}
private bool GenerateVariableQuantificationOutput(CompressingTurtleWriterContext context, VariableContext varContext)
{
if (varContext.Type == VariableContextType.None)
{
return false;
}
else if (varContext.Type == VariableContextType.Existential)
{
context.Output.Write("@forSome ");
}
else
{
context.Output.Write("@forAll ");
}
foreach (INode var in varContext.Variables)
{
context.Output.Write(context.NodeFormatter.Format(var));
context.Output.Write(' ');
}
context.Output.WriteLine('.');
if (varContext.InnerContext != null)
{
this.GenerateVariableQuantificationOutput(context, varContext.InnerContext);
}
return true;
}
/// <summary>
/// Pops a Graph from the Graph stack to become the in-scope Graph
/// </summary>
/// <remarks>
/// Used for Graph Literal parsing
/// </remarks>
public void PopGraph()
{
if (this._handlers.Count > 0)
{
this._g = this._subgraphs.Pop();
this._handler.EndRdf(true);
this._handler = this._handlers.Pop();
this._varContext = this._varContexts.Pop();
}
else
{
throw new RdfParseException("Cannot pop a RDF Handler from the Parser Context to become the in-scope RDF Handler since there are no RDF Handlers on the stack");
}
}
