public BasicRule( ParsedRule parsedInfo, int branchOpenSymbol, int branchCloseSymbol) { _targetSymbolWithParameters = parsedInfo.coreSymbol; ruleGroupIndex = parsedInfo.ruleGroupIndex; possibleOutcomes = new RuleOutcome[] { new RuleOutcome(1, parsedInfo.replacementSymbols) }; conditionalChecker = parsedInfo.conditionalMatch; backwardsMatchBuilder = new SymbolSeriesPrefixBuilder(parsedInfo.backwardsMatch); forwardsMatchBuilder = new SymbolSeriesSuffixBuilder(parsedInfo.forwardsMatch); forwardsMatchBuilder.BuildGraphIndexes(branchOpenSymbol, branchCloseSymbol); CapturedLocalParameterCount = _targetSymbolWithParameters.parameterLength + backwardsMatchBuilder.targetSymbolSeries.Sum(x => x.parameterLength) + forwardsMatchBuilder.targetSymbolSeries.Sum(x => x.parameterLength); }
public void BuildsStructExpressionFromBuilderTree() { var paramInput = Expression.Parameter(typeof(float), "testP"); var operatorData = OperatorBuilder.Binary(OperatorType.MULTIPLY, OperatorBuilder.ConstantValue(1.5f), OperatorBuilder.ParameterReference(paramInput)); var builder = new DynamicExpressionData(operatorData, new ParameterExpression[] { paramInput }); using var nativeOpData = new NativeArray <OperatorDefinition>(builder.OperatorSpaceNeeded, Allocator.Persistent); using var inputParams = new NativeArray <float>(new float[] { 2f }, Allocator.Persistent); var opDataSpace = new JaggedIndexing { index = 0, length = builder.OperatorSpaceNeeded }; var expression = builder.WriteIntoOpDataArray( nativeOpData, opDataSpace); var result = expression.EvaluateExpression( inputParams, new JaggedIndexing { index = 0, length = 1 }, nativeOpData); Assert.AreEqual(3f, result); }
private void AssertFunctionResults(string expressionString, float[,] calls, object[] results, string[] paramNames = null) { var expressionCompiler = new ExpressionCompiler(paramNames == null ? new string[0] : paramNames); var operatorData = expressionCompiler.CompileToExpression(expressionString); var builder = new DynamicExpressionData(operatorData, expressionCompiler.parameters.Values.ToArray()); using var nativeOpData = new NativeArray <OperatorDefinition>(builder.OperatorSpaceNeeded, Allocator.Persistent); var paramSize = (ushort)calls.GetLength(1); var inputParams = new NativeArray <float>(paramSize, Allocator.Persistent); var opDataSpace = new JaggedIndexing { index = 0, length = builder.OperatorSpaceNeeded }; var expression = builder.WriteIntoOpDataArray( nativeOpData, opDataSpace); for (int call = 0; call < calls.GetLength(0); call++) { for (int param = 0; param < calls.GetLength(1); param++) { inputParams[param] = calls[call, param]; } var result = expression.EvaluateExpression( inputParams, new JaggedIndexing { index = 0, length = paramSize }, nativeOpData); if (results[call] is float floatVal) { Assert.AreEqual(result, floatVal); } else if (results[call] is bool boolValue) { if (boolValue) { Assert.IsTrue(result > 0); } else { Assert.IsFalse(result > 0); } } } inputParams.Dispose(); }
/// <summary> /// Create a new basic rule with multiple random outcomes. /// It is garenteed and required that all of the stochastic rules will capture the /// same parameters /// </summary> /// <param name="parsedRules"></param> public BasicRule(IEnumerable <ParsedStochasticRule> parsedRules, int branchOpenSymbol, int branchCloseSymbol) { possibleOutcomes = parsedRules .Select(x => new RuleOutcome(x.probability, x.replacementSymbols) ).ToArray(); var firstOutcome = parsedRules.First(); _targetSymbolWithParameters = firstOutcome.coreSymbol; ruleGroupIndex = firstOutcome.ruleGroupIndex; conditionalChecker = firstOutcome.conditionalMatch; backwardsMatchBuilder = new SymbolSeriesPrefixBuilder(firstOutcome.backwardsMatch); forwardsMatchBuilder = new SymbolSeriesSuffixBuilder(firstOutcome.forwardsMatch); forwardsMatchBuilder.BuildGraphIndexes(branchOpenSymbol, branchCloseSymbol); CapturedLocalParameterCount = _targetSymbolWithParameters.parameterLength + backwardsMatchBuilder.targetSymbolSeries.Sum(x => x.parameterLength) + forwardsMatchBuilder.targetSymbolSeries.Sum(x => x.parameterLength); }