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));
}
