private static void DrawTree(string[] args, IDecisionTree tree) { if (args.Contains(FlagDrawTree)) { Console.WriteLine(tree.Draw()); } }
public void RemoveTree(IDecisionTree tree) { bool CanDelete = false; if (tree.IsDirty) { CanDelete = App.GetFloatingForm( eFloatReason.NotSet, new ucConfirmDropModel(tree, Mode == eDecisionTreeMode.DecisionModel)) .ShowDialog() == DialogResult.OK; } else { CanDelete = true; } if (CanDelete) { Trees.Remove(tree); RefreshTree(tvDecisionTree); App.SelectedTree = Trees.Count > 0 ? Trees[0] : null; App.SelectedObject = Trees.Count > 0 ? Trees[0] : null; } }
public ForexTradingAgentService( IDecisionTreesRepository decisionTreesRepository, IDecisionTree<ForexTreeData> decisionTree) { _decisionTreesRepository = decisionTreesRepository; _decisionTree = decisionTree; }
private void mnuNodesReload_Click(object sender, EventArgs e) { IBaseNode currentNode = TreeNodeAsBaseNode(tvDecisionTree.SelectedNode); if (currentNode != null) { IDecisionTree tree = currentNode.Tree; bool CanDelete = false; if (tree.IsDirty) { CanDelete = App.GetFloatingForm(eFloatReason.NotSet, new ucConfirmDropModel(tree)).ShowDialog() == DialogResult.OK; } else { CanDelete = true; } if (CanDelete) { int treeIndex = Trees.IndexOf(tree); IDecisionTree newTree = App.NewDescisionTree(); newTree.Load(tree.Persistence.Clone(), tree.FullPath); Trees.Remove(tree); Trees.Insert(treeIndex, newTree); RefreshTree(tvDecisionTree); App.SelectedTree = Trees.Count > 0 ? Trees[0] : null; App.SelectedObject = Trees.Count > 0 ? Trees[0] : null; } } }
/// <summary> /// Decision Manager Constructor /// </summary> /// <param name="surveyor">Convertion and table size storage unit. /// (If null [default] - will be instantiated in constructor)</param> /// <param name="ricochetCalc">Ricochet calc unit. NOTE: working in mm. /// (If null [default] - will be instantiated in constructor)</param> /// <param name="predictor">Predictor for ball coordinates /// (If null [default] - will be instantiated in constructor)</param> /// <param name="decisionTree">Full decision tree to make decisions per eacch rod. /// (If null [default] - will be instantiated in constructor)</param> /// <param name="controlledRods">Rods to be controlled by manager /// (If null [default] - will be instantiated in constructor)</param> public DecisionManager(ISurveyor surveyor = null, IInitializableRicochet ricochetCalc = null, IPredictor predictor = null, IDecisionTree decisionTree = null, List<IInitializableRod> controlledRods = null) { _surveyor = surveyor ?? new Surveyor(); IInitializableRicochet ricochetCalculator = ricochetCalc ?? new RicochetCalc(true, eUnits.Mm); _decisionTree = decisionTree ?? new FullDecisionTree(new PartialDecisionTree()); _predictor = predictor ?? new Predictor(_surveyor, ricochetCalculator); //use given rods if not null if (controlledRods != null) { _controlledRods = controlledRods; } //create new rods and init them else { _controlledRods = new List<IInitializableRod>(); foreach (eRod type in Enum.GetValues(typeof(eRod))) { IInitializableRod rod = new ControlRod(type, _surveyor, ricochetCalculator); rod.Initialize(); _controlledRods.Add(rod); } } }
public static void Main(string[] args) { Args = args; int runs = GetRunCount(); int totalAccuracy = 0; for (int i = 0; i < runs; i++) { DataSet dataSets = CreateDataSet(); IDecisionTree tree = BuildTree(dataSets); DrawTree(args, tree); totalAccuracy += ValidateTree(args, dataSets, tree); } if (runs > 1) { Console.WriteLine($"Average accuracy {(double)totalAccuracy / runs}%"); } if (!args.Contains(FlagNoPause)) { Console.WriteLine("Press any key to close program..."); Console.ReadKey(); } }
private void btnNew_Click(object sender, EventArgs e) { if (Control.ModifierKeys == (Keys.Control | Keys.Shift)) { IApplicationInterface.GetFloatingForm( eFloatReason.NotSet, new ucPropertyEditor(DataSourceManager.DataSourceFactories[0])) .ShowDialog(this); return; } // Open NewModel UserControl ucNewModel newModel = new ucNewModel(); string rootName = string.Format("Decision model-{0}", ctrl.Trees.Count + 1); if (IApplicationInterface.GetFloatingForm(eFloatReason.NotSet, newModel) .ShowDialog() == DialogResult.OK) { IDecisionTree tree = IApplicationInterface.NewDescisionTree(rootName); tree.Persistence = new XmlPersistenceImpl(); (tree.RootNode as IRootNode).DomainTemplate = newModel.SelectedDomainModelFile; ctrl.AddTree(tree); } }
public ExpressionString(IDecisionTree tree, string text) { _DecisionTree = tree; _Text = text; ParseRawText(); }
private void AddNode(eNodeType nodeType) { IBaseNode currentNode = TreeNodeAsBaseNode(tvDecisionTree.SelectedNode); IDecisionTree tree = currentNode.Tree; if (tree != null) { IBaseNode newNode = tree.CreateNewNode(nodeType, currentNode); newNode.Updated += Node_Updated; if (newNode.NodeType == eNodeType.VarDefinition) { (newNode as IVariableDef).VariableTypeChanged += VariableTypeChanged; } if (newNode.NodeType == eNodeType.DomainObject) { (newNode as IDomainObject).UpdatedAndRefresh += UpdateAdRefresh; } TreeNode node = modelGUIConfig.BaseNodeAsTreeNode(newNode); tvDecisionTree.SelectedNode.Nodes.Add(node); tvDecisionTree.SelectedNode.Expand(); tvDecisionTree.SelectedNode = node; } App.SelectedTree = tree; }
public void AddTree(IDecisionTree tree) { Trees.Add(tree); RefreshTree(tvDecisionTree); tree.RootNode.UpdatedAndRefresh += UpdateAdRefresh; tree.UpdatedAndRefresh += UpdateAdRefresh; App.SelectedTree = tree.RootNode.Nodes.Count > 1 ? tree : null; }
public void AddExample(IDecisionTree <ValueType> example) { if (_examples.Any(x => x.Equals(example))) { return; } _examples.Add(example); }
/// <summary> /// Create new if/then/else decision tree. /// </summary> /// <param name="condition">Condition subtree.</param> /// <param name="consequent">Consequent (true) subtree.</param> /// <param name="alternative">Alternative (false) subtree.</param> internal BooleanDecision( IDecisionTree <bool> condition, IDecisionTree <T> consequent, IDecisionTree <T> alternative) : base(consequent, alternative) { this.condition = condition; }
public ucConfirmDropModel(IDecisionTree tree, bool isModel = true) { InitializeComponent(); if (!isModel) { label2.Text = label2.Text.Replace(UI_Constants.ModelName, UI_Constants.TemplateName); counterPanel1.Text = counterPanel1.Text.Replace(UI_Constants.ModelName, UI_Constants.TemplateName); } }
public DataConnectionForm(IBaseNode selectedNode) { InitializeComponent(); lbxAvailable.DrawItem += lbxAvailable_DrawItem; lbxSelected.DrawItem += lbxAvailable_DrawItem; IDecisionTree tree = selectedNode.Tree; AddDataNodesToAvailable(tree.RootNode.GetNode(eNodeType.DataObjects)); }
public LinkDataDefinitionsForm(IBaseNode baseNode) { InitializeComponent(); lbxAvailable.DrawItem += lbxAvailable_DrawItem; lbxSelected.DrawItem += lbxAvailable_DrawItem; IDecisionTree tree = baseNode.Tree; AddDataNodesToAvailable(tree.RootNode.GetNode(eNodeType.DataSources)); }
private void SaveTreeFile(IDecisionTree tree, string fileName) { IPersistence persistence = new XmlPersistenceImpl(fileName, true); if (tree.Save(persistence, fileName)) { if (persistence.SaveAs(fileName)) { IApplicationInterface.StatusLine = string.Format("{0} saved to disk", Path.GetFileName(fileName)); } } }
private void LoadFile(string fileName) { LastUsedFolder = fileName; IDecisionTree tree = IApplicationInterface.NewDescisionTree(); IPersistence persistence = new XmlPersistenceImpl(fileName); if (tree.Load(persistence, fileName)) { ctrl.AddTree(tree); IApplicationInterface.StatusLine = string.Format("Opened {0} from disk", Path.GetFileName(fileName)) + UI_Constants.ZoomPanHint; } }
public static string Draw(this IDecisionTree tree) { numberOfLeafNodes = 0; maxDepth = 0; var treeView = new StringBuilder(); DrawTree(tree, depth: 0, treeView); treeView.Append($"\nMax depth: {maxDepth}, Leaf nodes: {numberOfLeafNodes}\n"); return(treeView.ToString()); }
public NodeLinkForm(IBaseNode selectedNode, eNodeType rootNodeType, string title) { InitializeComponent(); Text = title; lbxAvailable.DrawItem += lbxAvailable_DrawItem; lbxSelected.DrawItem += lbxAvailable_DrawItem; IDecisionTree tree = selectedNode.Tree; AddDataNodesToAvailable(tree.RootNode.GetNode(rootNodeType)); }
bool IModelGraphics.ParseDecisionModel(IDecisionTree tree) { if (tree != null) { //IGraphBase connectedTo = AddGraphicCommand(new VerticalLine(0, 0)); IGraphBase connectedTo = AddGraphicCommand(new ModelStart(0, 0)); ParseNodes(tree.RootNode.Nodes, 0, 1, connectedTo); } //foreach (IGraphBase gb in GraphicCommands) // log.Debug(string.Format("{4} - {0}, ({1},{2}) {3}", gb.GetType().ToString(), gb.HorizontalOffset, gb.VerticalOffset, gb.Label, gb.Index)); return(GraphicCommands.Count > 0); }
private void btnNew_Click(object sender, EventArgs e) { string rootName = string.Format("Domain template-{0}", ctrl.Trees.Count + 1); IDecisionTree tree = IApplicationInterface.NewDescisionTree(rootName); IBaseNode dataObjects = tree.CreateNewNode(eNodeType.DataObjects, null, Constants.DataNodesTreeName); tree.RootNode.AddNode(dataObjects); IBaseNode dataSources = tree.CreateNewNode(eNodeType.DataSources, null, Constants.DataSourcesTreeName); tree.RootNode.AddNode(dataSources); ctrl.AddTree(tree); }
public override object EditValue(ITypeDescriptorContext context, System.IServiceProvider provider, object value) { IWindowsFormsEditorService svc = provider.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService; if (svc != null) { IBaseNode baseNode = context.Instance as IBaseNode; if (baseNode != null) { using (DataConnectionForm frm = new DataConnectionForm(baseNode)) { IDataPersistence dp = getDataPersistence(baseNode); if (dp != null) { IDecisionTree tree = baseNode.Tree; List <string> Elements = new List <string>(); foreach (string reference in dp.DataConnections) { IBaseNode node = tree.GetNodeByReference(reference); if (node != null) { Elements.Add(node.Name); } } frm.Elements = Elements; if (svc.ShowDialog(frm) == DialogResult.OK) { List <string> result = new List <string>(); IBaseNode dataNodes = tree.RootNode.GetNode(eNodeType.DataObjects); foreach (string name in frm.Elements) { IBaseNode dc = dataNodes.GetNode(name); if (dc != null) { result.Add(dc.Reference); } } value = result.ToArray(); } } } } } return(value); }
bool IDecisionTree.LoadDomainTemplate(IRootNode rootNode) { IPersistence persistence = Persistence.Clone(rootNode.DomainTemplate); if (persistence != null) { IDecisionTree subTree = IDecisionTreeInterface.Clone(); IBaseNode variables = subTree.LoadVariables(persistence); IDecisionTreeInterface.ImportVariables(variables); return(true); } return(false); }
public static void DecisionManager_ClassInitialize(TestContext context) { _surveyorMock = Substitute.For<ISurveyor>(); _ricochetCalcMock = Substitute.For<IInitializableRicochet>(); _predictorMock = Substitute.For<IPredictor>(); _decisionTreeMock = Substitute.For<IDecisionTree>(); _rodGoalKeaperMock = Substitute.For<IInitializableRod>(); _rodDefenceMock = Substitute.For<IInitializableRod>(); _rodMidFieldMock = Substitute.For<IInitializableRod>(); _rodAttackMock = Substitute.For<IInitializableRod>(); _rodMockList = new List<IInitializableRod>() { _rodGoalKeaperMock, _rodDefenceMock, _rodMidFieldMock, _rodAttackMock }; }
public static void DecisionManager_ClassInitialize(TestContext context) { _surveyorMock = Substitute.For <ISurveyor>(); _ricochetCalcMock = Substitute.For <IInitializableRicochet>(); _predictorMock = Substitute.For <IPredictor>(); _decisionTreeMock = Substitute.For <IDecisionTree>(); _rodGoalKeaperMock = Substitute.For <IInitializableRod>(); _rodDefenceMock = Substitute.For <IInitializableRod>(); _rodMidFieldMock = Substitute.For <IInitializableRod>(); _rodAttackMock = Substitute.For <IInitializableRod>(); _rodMockList = new List <IInitializableRod>() { _rodGoalKeaperMock, _rodDefenceMock, _rodMidFieldMock, _rodAttackMock }; }
public EnumFromModelForm(IBaseNode selectedNode) { InitializeComponent(); lbxAvailable.DrawItem += lbxAvailable_DrawItem; lbxSelected.DrawItem += lbxAvailable_DrawItem; IDecisionTree tree = selectedNode.Tree; AddBranchToAvailable(tree.RootNode); toolTip.SetToolTip(btnOk, UI_Constants.CommitEnumToolTip); toolTip.SetToolTip(btnClose, UI_Constants.RevertEnumToolTip); toolTip.SetToolTip(btnAdd, UI_Constants.AddEnumToolTip); toolTip.SetToolTip(btnRemove, UI_Constants.RemoveEnumToolTip); toolTip.SetToolTip(btnNew, UI_Constants.NewEnumToolTip); toolTip.SetToolTip(btnMoveUp, UI_Constants.MoveUpEnumToolTip); toolTip.SetToolTip(btnMoveDown, UI_Constants.MoveDownEnumToolTip); }
public override object EditValue(ITypeDescriptorContext context, System.IServiceProvider provider, object value) { IWindowsFormsEditorService svc = provider.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService; if (svc != null) { IBaseNode baseNode = context.Instance as IBaseNode; if (baseNode != null) { using (LinkDataDefinitionsForm frm = new LinkDataDefinitionsForm(baseNode)) { IDataPersistence dp = getDataPersistence(baseNode); if (dp != null) { IDecisionTree tree = baseNode.Tree; List <LinkDataDefinitionsForm.ListBoxItem> Elements = new List <LinkDataDefinitionsForm.ListBoxItem>(); foreach (string reference in dp.DataConnections) { IBaseNode node = tree.GetNodeByReference(reference); if (node != null) { Elements.Add(new LinkDataDefinitionsForm.ListBoxItem(node, 0)); } } frm.Elements = Elements; if (svc.ShowDialog(frm) == DialogResult.OK) { dp.DataConnections.Clear(); foreach (LinkDataDefinitionsForm.ListBoxItem lbi in frm.Elements) { dp.DataConnections.Add(lbi.Node.Reference); } } } } } } return(value); }
} //FloatingForm IApplication.GetFloatingForm( ... IDecisionTree IApplication.NewDescisionTree(string rootName, PostNodeInitialize nodeInitialization) { Assembly asm = Assembly.GetCallingAssembly(); SakwaMapping mapping = new SakwaMapping("0.0"); mapping.SakwaObjectMapping.Add(typeof(IBaseNodeImpl).ToString(), typeof(UI_BaseNode).ToString()); mapping.SakwaObjectMapping.Add(typeof(IRootNodeImpl).ToString(), typeof(UI_RootNode).ToString()); mapping.SakwaObjectMapping.Add(typeof(CharVariableImpl).ToString(), typeof(UI_CharVariable).ToString()); mapping.SakwaObjectMapping.Add(typeof(NumericVariableImpl).ToString(), typeof(UI_NumericVariable).ToString()); mapping.SakwaObjectMapping.Add("sakwa.IntVariableImpl", typeof(UI_NumericVariable).ToString()); mapping.SakwaObjectMapping.Add(typeof(EnumVariableImpl).ToString(), typeof(UI_EnumVariable).ToString()); mapping.SakwaObjectMapping.Add(typeof(BoolVariableImpl).ToString(), typeof(UI_BoolVariable).ToString()); mapping.SakwaObjectMapping.Add(typeof(DateVariableImpl).ToString(), typeof(UI_DateVariable).ToString()); mapping.SakwaObjectMapping.Add(typeof(IDomainObjectImpl).ToString(), typeof(UI_DomainObject).ToString()); mapping.SakwaObjectMapping.Add(typeof(IExpressionImpl).ToString(), typeof(UI_Expression).ToString()); mapping.SakwaObjectMapping.Add("sakwa.IAssignmentImpl", typeof(UI_Expression).ToString()); mapping.SakwaObjectMapping.Add(typeof(IBranchImpl).ToString(), typeof(UI_Branch).ToString()); mapping.SakwaObjectMapping.Add(typeof(IDataObjectImpl).ToString(), typeof(UI_DataObject).ToString()); mapping.SakwaObjectMapping.Add(typeof(IDataSourceImpl).ToString(), typeof(UI_DataSource).ToString()); mapping.SakwaObjectMapping.Add(typeof(IDataDefinitionImpl).ToString(), typeof(UI_DataDefinition).ToString()); if (nodeInitialization == null) { nodeInitialization = Result_PostNodeInitialize; } IDecisionTree result = rootName != "" ? new IDecisionTreeImpl(asm, mapping, nodeInitialization, rootName) : new IDecisionTreeImpl(asm, mapping, nodeInitialization); result.LinkSubtreeError += LinkSubtreeError; return(result); } //IApplication.NewDescisionTree
private void ShowTemplatePreview() { tvTemplate.Nodes.Clear(); IDecisionTree tree = App.NewDescisionTree(); IBaseNode baseNode = tree.CreateNewNode(eNodeType.Root, null, "Domain template"); TreeNode rootNode = modelGUIConfig.BaseNodeAsTreeNode(baseNode); modelGUIConfig.ConfigureTreeNode(rootNode); tvTemplate.Nodes.Add(modelGUIConfig.ConfigureTreeNode(rootNode)); baseNode = tree.CreateNewNode(eNodeType.DataObjects, null, "Data objects"); TreeNode dataobjs = modelGUIConfig.BaseNodeAsTreeNode(baseNode); rootNode.Nodes.Add(modelGUIConfig.ConfigureTreeNode(dataobjs)); baseNode = tree.CreateNewNode(eNodeType.DataObject, null, "Data object"); TreeNode node = modelGUIConfig.BaseNodeAsTreeNode(baseNode); dataobjs.Nodes.Add(modelGUIConfig.ConfigureTreeNode(node)); baseNode = tree.CreateNewNode(eNodeType.DataSources, null, "Data sources"); TreeNode dataSources = modelGUIConfig.BaseNodeAsTreeNode(baseNode); rootNode.Nodes.Add(modelGUIConfig.ConfigureTreeNode(dataSources)); baseNode = tree.CreateNewNode(eNodeType.DataSource, null, "Data source"); TreeNode dataSource = modelGUIConfig.BaseNodeAsTreeNode(baseNode); dataSources.Nodes.Add(modelGUIConfig.ConfigureTreeNode(dataSource)); baseNode = tree.CreateNewNode(eNodeType.DataDefinition, null, "Data definition"); node = modelGUIConfig.BaseNodeAsTreeNode(baseNode); dataSource.Nodes.Add(modelGUIConfig.ConfigureTreeNode(node)); tvTemplate.ExpandAll(); }
private void ShowModelPreview() { tvModel.Nodes.Clear(); IDecisionTree tree = App.NewDescisionTree(); IBaseNode baseNode = tree.CreateNewNode(eNodeType.Root, null, "Decision model"); TreeNode rootNode = modelGUIConfig.BaseNodeAsTreeNode(baseNode); modelGUIConfig.ConfigureTreeNode(rootNode); tvModel.Nodes.Add(modelGUIConfig.ConfigureTreeNode(rootNode)); baseNode = tree.CreateNewNode(eNodeType.VariableDefinitions, null, "Variable definitions"); TreeNode vars = modelGUIConfig.BaseNodeAsTreeNode(baseNode); rootNode.Nodes.Add(modelGUIConfig.ConfigureTreeNode(vars)); baseNode = tree.CreateNewNode(eNodeType.VarDefinition, null, "Variable definition"); TreeNode node = modelGUIConfig.BaseNodeAsTreeNode(baseNode); vars.Nodes.Add(modelGUIConfig.ConfigureTreeNode(node)); baseNode = tree.CreateNewNode(eNodeType.DomainObject, null, "Domain object"); TreeNode decision = modelGUIConfig.BaseNodeAsTreeNode(baseNode); vars.Nodes.Add(modelGUIConfig.ConfigureTreeNode(decision)); baseNode = tree.CreateNewNode(eNodeType.Expression, null, "Expression"); node = modelGUIConfig.BaseNodeAsTreeNode(baseNode); rootNode.Nodes.Add(modelGUIConfig.ConfigureTreeNode(node)); baseNode = tree.CreateNewNode(eNodeType.Branch, null, "Branch"); node = modelGUIConfig.BaseNodeAsTreeNode(baseNode); rootNode.Nodes.Add(modelGUIConfig.ConfigureTreeNode(node)); tvModel.ExpandAll(); }
private void RootNode_NodeLoaded(object sender, EventArgs e) { IBaseNode node = sender as IBaseNode; if (node != null && node.NodeType == eNodeType.VariableDefinitions) { if (Persistence != null) { int i = 0; while (i < SubModels.Keys.Count) { IPersistence persistence = getSubModel(i); if (persistence != null) { IDecisionTree subTree = IDecisionTreeInterface.Clone(); IBaseNode variables = subTree.LoadVariables(persistence); foreach (IBaseNode subModel in subTree.SubModels.Keys) { IDecisionTreeInterface.AddSubModel(subModel as IDomainObject); } IBaseNode baseNode = SubModels.Keys.ElementAt(i); List <IBaseNode> linkedVariables = LinkVariables(node, variables); foreach (IBaseNode linkedNode in linkedVariables) { baseNode.AddNode(linkedNode); } } i++; } } } }
private static int ValidateTree(string[] args, DataSet dataSets, IDecisionTree tree) { int totalPredictions = 0; int correctPredictions = 0; foreach (var row in dataSets.TestData.Rows()) { string predictedClassification = tree.Classify(row); string @class = row[dataSets.TargetAttribute]; if (@class == predictedClassification) { correctPredictions++; } totalPredictions++; } int accuracy = (int)((double)correctPredictions / totalPredictions * 100); Console.WriteLine($"Total predictions: {totalPredictions}, correct: {correctPredictions} ({accuracy}%)"); return(accuracy); }
private void LoadFile(string fileName) { LastUsedFolder = fileName; IDecisionTree tree = IApplicationInterface.NewDescisionTree(); IPersistence persistence = new XmlPersistenceImpl(fileName); if (tree.Load(persistence, fileName)) { if (tree.RootNode.GetNode(eNodeType.DataObjects) == null) { IBaseNode dataObjects = tree.CreateNewNode(eNodeType.DataObjects, null, Constants.DataNodesTreeName); tree.RootNode.AddNode(dataObjects); } if (tree.RootNode.GetNode(eNodeType.DataSources) == null) { IBaseNode dataSources = tree.CreateNewNode(eNodeType.DataSources, null, Constants.DataSourcesTreeName); tree.RootNode.AddNode(dataSources); } ctrl.AddTree(tree); IApplicationInterface.StatusLine = string.Format("Opened {0} from disk", Path.GetFileName(fileName)) + UI_Constants.ZoomPanHint; } }
/// <summary> /// Decision Tree Constructor /// </summary> /// <param name="subtree">Decision Sub Tree</param> /// <param name="decisionHelper">Decision Helper [default is null then will be constructed using Configuration File]</param> /// <param name="ballRadius">Ball Radius in mm [default is -1 will be taken from Configuration File]</param> /// <param name="tableWidth">Table Width (Y Axe) in mm [default is -1 will be taken from Configuration File]</param> /// <param name="playerWidth">Player Width in mm [default is -1 will be taken from Configuration File]</param> public FullDecisionTree(IDecisionTree subtree, IDecisionHelper decisionHelper = null, int ballRadius = -1, int tableWidth = -1, int playerWidth = -1) : base(subtree, decisionHelper, ballRadius, tableWidth, playerWidth) { }
/// <summary> /// Decision Tree Constructor for Tree with a Subtree /// </summary> /// <param name="subTree">Decision Subtree</param> /// <param name="decisionHelper">Decision Helper Instance [default is null then will be constructed using Configuration File]</param> /// <param name="ballRadius">Ball Radius in mm [default is -1 will be taken from Configuration File]</param> /// <param name="tableWidth">Table Width (Y Axe) in mm [default is -1 will be taken from Configuration File]</param> /// <param name="playerWidth">Player Width in mm [default is -1 will be taken from Configuration File]</param> public DecisionTree(IDecisionTree subTree, IDecisionHelper helper = null, int ballRadius = -1, int tableWidth = -1, int playerWidth = -1) :this(helper, ballRadius, tableWidth, playerWidth) { _subTree = subTree; }