public void Test(int treeDepth, string[] nodeProducingRuleToSymbols, string[] expectedProducedSymbols) { SymbolsSet<int> s = new SymbolsSet<int>(new [] { new Symbol<int>("Node0"), new Symbol<int>("Node1"), new Symbol<int>("Node2"), new Symbol<int>("Node") }); // Node -> Node0|Node1|Node2 nodeProducingRuleToSymbols = nodeProducingRuleToSymbols ?? new [] {"Node0", "Node1", "Node2"}; OrRule<int> nodeProducingRule = new OrRule<int>(s["Node"], nodeProducingRuleToSymbols.Select(n => s[n])); TreeBuilder<int> treeBuilder = new TreeBuilder<int>(); TreeGeneratingRuleSelector<int> ruleSelector = new TreeGeneratingRuleSelector<int>(treeDepth, treeBuilder, nodeProducingRule.Rules); List<string> producedSymbols = new List<string>(); while(!treeBuilder.IsTreeReady) { Rule<int> rule = ruleSelector.Next(); string sn = rule.Produce().First().Name; int v = int.Parse(sn.Replace("Node", "")); treeBuilder.Append(v, v); producedSymbols.Add(sn); } Assert.AreElementsEqual(expectedProducedSymbols, producedSymbols); }
public Result <SymbolsSet> GenerateSymbols(int rowsNumber, int columnsNumber) { Result <SymbolsSet> result = new Result <SymbolsSet>(); SymbolsSet symbolsSet = new SymbolsSet(); Random randomGenerator = new Random(); for (int row = 1; row <= rowsNumber; row++) { SymbolsRow symbolsRow = new SymbolsRow(); for (int column = 1; column <= columnsNumber; column++) { try { Symbol symbolRolled = this.GenerateSymbol(randomGenerator); symbolsRow.Symbols.Add(symbolRolled); } catch (Exception ex) { result.SetError(ex.Message); } } symbolsSet.Rows.Add(symbolsRow); } return(result.SetData(symbolsSet)); }
public void TestGenerateTreeWithSeveralTreeGenerationRules(int treeDepth, string expectedSequenceString) { SymbolsSet<string> s = new SymbolsSet<string>(new[] { new Symbol<string>("0", "0"), new Symbol<string>("1", "1"), new Symbol<string>("2", "2"), new Symbol<string>("Val0"), new Symbol<string>("Val1"), new Symbol<string>("Val2"), new Symbol<string>("Node0"), new Symbol<string>("Node1"), new Symbol<string>("Node2"), new Symbol<string>("NodeA"), new Symbol<string>("NodeB") }); Rule<string>[] rules = { // Val0 -> 0 new Rule<string>(s["Val0"], new [] { s["0"] }), // Val1 -> 1 new Rule<string>(s["Val1"], new [] { s["1"] }), // Val2 -> 2 new Rule<string>(s["Val2"], new [] { s["2"] }), // Node0 -> Val0 new Rule<string>(s["Node0"], new [] { s["Val0"] }), // Node1 -> Val1 Node new Rule<string>(s["Node1"], new [] { s["Val1"], s["NodeA"] }), // Node2 -> Val2 Node Node new Rule<string>(s["Node2"], new [] { s["Val2"], s["NodeB"], s["NodeB"] }), // NodeA -> Node0|Node2 new OrRule<string>(s["NodeA"], rs => new TreeGeneratingRuleSelector<string>(treeDepth, rs), new[] {s["Node0"], s["Node2"]}), // NodeB -> Node0|Node1 new OrRule<string>(s["NodeB"], rs => new TreeGeneratingRuleSelector<string>(treeDepth, rs), new[] {s["Node0"], s["Node1"]}) }; Grammar<string> grammar = new Grammar<string>(rules); TreeNode<string> treeRoot = TreeGenerator.Generate(grammar, "NodeB", int.Parse); IEnumerable<string> traversedTree = Tree<string>.Traverse(treeRoot).Select(ni => ni.Node.Value); Assert.AreEqual(expectedSequenceString, string.Join(" ", traversedTree.ToArray())); }
public void TestProduce(string startSymbol, string expectedSequence) { SymbolsSet<string> s = new SymbolsSet<string>(new[] { new Symbol<string>("x", "x"), new Symbol<string>("y", "y"), new Symbol<string>("sin", "sin"), new Symbol<string>("atan", "atan"), new Symbol<string>("sum", "sum"), new Symbol<string>("mul", "mul"), new Symbol<string>("A0"), new Symbol<string>("A1"), new Symbol<string>("A2"), new Symbol<string>("Inf") }); Rule<string>[] rules = { // A0 -> x|y new OrRule<string>(s["A0"], new [] { s["x"], s["y"] }), // A1 -> (sin A1)|(atan A1)|(sin A2)|(atan A2) new OrRule<string>(s["A1"], new [] { new Rule<string>(new []{ s["sin"], s["A1"] }), new Rule<string>(new []{ s["atan"], s["A1"] }), new Rule<string>(new []{ s["sin"], s["A2"] }), new Rule<string>(new []{ s["atan"], s["A2"] }) }), // A2 -> sum A0 A0 new Rule<string>(s["A2"], new [] { s["sum"], s["A0"], s["A0"] }), // Inf -> sum Inf new Rule<string>(s["Inf"], new [] { s["sum"], s["Inf"] }) }; Grammar<string> grammar = new Grammar<string>(rules); IEnumerable<string> sequence = grammar.Produce(startSymbol).Take(10); Assert.AreEqual(expectedSequence, string.Join(" ", sequence.ToArray())); }
public void PrintSymbols(SymbolsSet symbolsSet) { Console.WriteLine(); foreach (SymbolsRow row in symbolsSet.Rows) { foreach (Symbol symbol in row.Symbols) { Console.Write(symbol); } Console.WriteLine(); } Console.WriteLine(); }
public Result <decimal> CalculateTotalCoefficient(SymbolsSet generatedSymbols) { Result <decimal> result = new Result <decimal>(); decimal totalCoefficient = 0; foreach (SymbolsRow symbolsRow in generatedSymbols.Rows) { Result <decimal> rowCoefficentResult = this.CalculateRowCoefficient(symbolsRow); if (rowCoefficentResult.IsError) { return(rowCoefficentResult); } totalCoefficient += rowCoefficentResult.Data; } return(result.SetData(totalCoefficient)); }
public Result <GameTurnResult> ExecuteGameTurn(decimal stakeAmount) { Result <GameTurnResult> result = new Result <GameTurnResult>(); Result validateStakeResult = this.ValidateStakeAmount(stakeAmount); if (validateStakeResult.IsError) { result.SetError(validateStakeResult.Message); return(result); } this.currentBalance -= stakeAmount; Result <SymbolsSet> generateSymbolsResult = this.symbolsGenerator.GenerateSymbols(this.rowsAndColumnsProvider.NumberRowsPerTurn, this.rowsAndColumnsProvider.NumberColumns); if (generateSymbolsResult.IsError) { result.SetError(generateSymbolsResult.Message); return(result); } SymbolsSet generatedSymbols = generateSymbolsResult.Data; //test //SymbolsSet generatedSymbols = new SymbolsSet(); //generatedSymbols.Rows.Add(new SymbolsRow() //{ // Symbols = new List<Symbol>() { Symbol.B, Symbol.A, Symbol.A } //}); //generatedSymbols.Rows.Add(new SymbolsRow() //{ // Symbols = new List<Symbol>() { Symbol.A, Symbol.A, Symbol.A } //}); //generatedSymbols.Rows.Add(new SymbolsRow() //{ // Symbols = new List<Symbol>() { Symbol.W, Symbol.W, Symbol.W } //}); //generatedSymbols.Rows.Add(new SymbolsRow() //{ // Symbols = new List<Symbol>() { Symbol.W, Symbol.A , Symbol.A } //}); //test Result <decimal> coefficientsResult = this.symbolsCoefficientsCalculator.CalculateTotalCoefficient(generatedSymbols); if (coefficientsResult.IsError) { result.SetError(coefficientsResult.Message); return(result); } decimal coefficent = coefficientsResult.Data; decimal amountWon = stakeAmount * coefficent; this.currentBalance += amountWon; GameTurnResult gameTurnResult = new GameTurnResult() { Symbols = generatedSymbols, AmountWon = amountWon, CurrentBalance = this.currentBalance }; return(result.SetData(gameTurnResult)); }