public void OnSelectTreeView(int state)
{
GameManager.DebugLog("Selecting new view: " + state + " or " + (TreeState)state);
Current_Tree_State = (TreeState)state;
switch (Current_Tree_State)
{
case TreeState.BasicTree:
viewIn3DToggle.isOn = false;
Draw_Tree_In_3D = false;
controllerFunctionPanel.SetActive(true);
break;
case TreeState.TerrainTree:
viewIn3DToggle.isOn = false;
Draw_Tree_In_3D = false;
OnSelectMove();
controllerFunctionPanel.SetActive(false);
break;
case TreeState.CircularTree:
controllerFunctionPanel.SetActive(true);
break;
}
treeBuilder.BuildTree(TreeLoader.CurrentTree);
}
private AiStrategy BuildAiStrategy(TreeSpec spec)
{
var tree = _treeBuilder.BuildTree <TROOTNODE>(_treebuildingstrategy.WithSpec(spec));
var aiStrategyId = new AiStrategy.AiStrategyId();
return(new AiStrategy(tree as Function <ResponseVotes>, aiStrategyId));
}
public void Cycle_indirectly()
{
var records = new[]
{
new TreeBuildingRecord {
RecordId = 5, ParentId = 2
},
new TreeBuildingRecord {
RecordId = 3, ParentId = 2
},
new TreeBuildingRecord {
RecordId = 2, ParentId = 6
},
new TreeBuildingRecord {
RecordId = 4, ParentId = 1
},
new TreeBuildingRecord {
RecordId = 1, ParentId = 0
},
new TreeBuildingRecord {
RecordId = 0, ParentId = 0
},
new TreeBuildingRecord {
RecordId = 6, ParentId = 3
}
};
Assert.Throws <ArgumentException>(() => TreeBuilder.BuildTree(records));
}
private void UpdateForces()
{
TreeBuilder builder = new TreeBuilder(bodies, InitialSizePower);
var node = builder.BuildTree();
CalculateForces(node, node);
}
public void More_than_two_children()
{
var records = new[]
{
new TreeBuildingRecord {
RecordId = 3, ParentId = 0
},
new TreeBuildingRecord {
RecordId = 2, ParentId = 0
},
new TreeBuildingRecord {
RecordId = 1, ParentId = 0
},
new TreeBuildingRecord {
RecordId = 0, ParentId = 0
}
};
var tree = TreeBuilder.BuildTree(records);
AssertTreeIsBranch(tree, id: 0, childCount: 3);
AssertTreeIsLeaf(tree.Children[0], id: 1);
AssertTreeIsLeaf(tree.Children[1], id: 2);
AssertTreeIsLeaf(tree.Children[2], id: 3);
}
public void Cycle_directly()
{
var records = new[]
{
new TreeBuildingRecord {
RecordId = 5, ParentId = 2
},
new TreeBuildingRecord {
RecordId = 3, ParentId = 2
},
new TreeBuildingRecord {
RecordId = 2, ParentId = 2
},
new TreeBuildingRecord {
RecordId = 4, ParentId = 1
},
new TreeBuildingRecord {
RecordId = 1, ParentId = 0
},
new TreeBuildingRecord {
RecordId = 0, ParentId = 0
},
new TreeBuildingRecord {
RecordId = 6, ParentId = 3
}
};
Assert.That(() => TreeBuilder.BuildTree(records), Throws.Exception);
}
private static void Main(string[] args)
{
var seed = new Random().Next();
var rndSource = new RandomWrapper(seed);
var treeBuilder = new TreeBuilder(rndSource);
var tree = treeBuilder.BuildTree();
}
public void BuildTree_SimpleTree()
{
//Arrange
var processor = new InputProcessorMockup();
var leafTree = processor.BuildSimpleTree();
var builder = new TreeBuilder(leafTree);
//Act
builder.BuildTree();
//Assert
Assert.AreEqual(builder.tree.Count, 1);
var root = builder.tree.First();
Assert.IsTrue(root.GetType() != typeof(Leaf));
Assert.AreEqual(root.frequency, 6);
Assert.AreEqual(root.creationId, 2);
Assert.IsTrue(root.left.GetType() == typeof(Leaf));
Assert.AreEqual(root.left.character, Convert.ToByte('a'));
Assert.AreEqual(root.left.frequency, 3);
Assert.IsTrue(root.right.GetType() != typeof(Leaf));
Assert.AreEqual(root.right.frequency, 3);
Assert.AreEqual(root.right.creationId, 1);
Assert.IsTrue(root.right.left.GetType() == typeof(Leaf));
Assert.AreEqual(root.right.left.character, Convert.ToByte('c'));
Assert.AreEqual(root.right.left.frequency, 1);
Assert.IsTrue(root.right.right.GetType() == typeof(Leaf));
Assert.AreEqual(root.right.right.character, Convert.ToByte('b'));
Assert.AreEqual(root.right.right.frequency, 2);
}
/// <summary>
/// Decoding of encoded bytes by Huffman algorithm.
/// </summary>
/// <param name="bytes"> Encoded bytes</param>
/// <returns> Decoded bytes</returns>
public static byte[] Decode(byte[] bytes)
{
var result = DictionarySerializer.Deserialize(bytes);
return(Decode(bytes,
result.SizeOfBytes,
TreeBuilder.BuildTree(new TreeBuilderQueue(result.Dictionary))));
}
private void UpdateSeed(int newSeed)
{
var treeRndSource = new RandomWrapper(newSeed);
var treeBuilder = new TreeBuilder(treeRndSource);
trunk = treeBuilder.BuildTree();
grassRandom = new RandomWrapper(newSeed);
}
public void BuildTreeFromArrayList()
{
var list = new ArrayList()
{
1, 2, 3, null, 5, 6, 7
};
var root = TreeBuilder.BuildTree(list);
}
public ViewResult Manage(string id, string sectionId, string adName)
{
var allNodes = db.Set <NaviNode>().OrderBy(e => e.NodeName).ToList();
TreeBuilder tb = new TreeBuilder(allNodes);
IEnumerable <SelectListItem> sections = tb.BuildTree();
ViewBag.AccessModes = AccessModes;
IEnumerable <SelectListItem> users = db.Set <CmsUser>().OrderBy(e => e.UserName)
.ToList().Select(e => new SelectListItem
{
Value = e.AdName,
Text = e.UserName
});
ViewBag.Users = users;
//pre-selected information
if (!String.IsNullOrWhiteSpace(sectionId))
{
int sid = Convert.ToInt32(sectionId);
NaviNode n = db.Set <NaviNode>().SingleOrDefault(e => e.Id == sid);
if (n != null)
{
ViewBag.SectionId = sid;
}
}
//current user role
if (!String.IsNullOrWhiteSpace(id))
{
int pageId = Convert.ToInt32(id);
CmsPage p = db.Set <CmsPage>().SingleOrDefault(e => e.Id == pageId);
if (p != null)
{
ViewBag.SectionId = p.NaviNode.Id;
ViewBag.PageId = pageId;
}
}
if (!String.IsNullOrWhiteSpace(adName))
{
CmsUser u = db.Set <CmsUser>().SingleOrDefault(e => e.AdName == adName);
if (u != null)
{
ViewBag.AdName = adName;
}
}
ViewBag.RoleId = SecurityHelper.CurrentCmsUserRole(db);
return(View(sections));
}
/// <summary>
/// Encoding bytes to huffman algorithm.
/// </summary>
/// <param name="bytes"> Source bytes </param>
/// <returns> Encoded bytes </returns>
public static byte[] Encode(byte[] bytes)
{
var dictionary = BytesCalculator.Calculate(bytes);
var header = DictionarySerializer.Serialize(dictionary);
var body = Encode(bytes,
BitTable.BuildTable(TreeBuilder.BuildTree(new TreeBuilderQueue(dictionary))));
return(Merage(header, body));
}
public void TestTreeWithTwoTiles()
{
var lyonTile = new TileInfo(50, 0, 5, 5, 1, 1);
var machuPicchuTile = new TileInfo(-10, -75, 5, 5, 1, 1);
var root = TreeBuilder.BuildTree(new[] { lyonTile, machuPicchuTile });
Check.That(root.IsEmpty).IsFalse();
Check.That(root.GetTile(45.75, 4.85)).IsEqualTo(lyonTile);
Check.That(root.GetTile(0, 0)).IsNull();
Check.That(root.GetTile(-13.163, -72.545)).IsEqualTo(machuPicchuTile);
}
private Tree Load(string treeId, XDocument document)
{
Tree tree = TreeBuilder.BuildTree(treeId, document);
//if (tree.BuildResult.ValidationErrors.Count() == 0)
//{
// tree.LogTree();
//}
return(tree);
}
public void No_root_node()
{
var records = new[]
{
new TreeBuildingRecord {
RecordId = 1, ParentId = 0
}
};
Assert.Throws <ArgumentException>(() => TreeBuilder.BuildTree(records));
}
public void One_node()
{
var records = new[]
{
new TreeBuildingRecord {
RecordId = 0, ParentId = 0
}
};
var tree = TreeBuilder.BuildTree(records);
AssertTreeIsLeaf(tree, id: 0);
}
public void Root_node_has_parent()
{
var records = new[]
{
new TreeBuildingRecord {
RecordId = 0, ParentId = 1
},
new TreeBuildingRecord {
RecordId = 1, ParentId = 0
}
};
Assert.That(() => TreeBuilder.BuildTree(records), Throws.Exception);
}
/// <summary>
/// Build a decoder tree.
/// </summary>
private Node BuildTree(Specification spec, TristateBitArray?flags)
{
var stopwatch = Stopwatch.StartNew();
Node?node = TreeBuilder.BuildTree(spec, flags);
stopwatch.Stop();
if (config.Timings)
{
Console.WriteLine($"Generated decoder tree in {stopwatch.ElapsedMilliseconds}ms.");
}
return(node);
}
public void Root_node_is_duplicate()
{
var records = new[]
{
new TreeBuildingRecord {
RecordId = 0, ParentId = 0
},
new TreeBuildingRecord {
RecordId = 0, ParentId = 0
}
};
Assert.Throws <ArgumentException>(() => TreeBuilder.BuildTree(records));
}
public void BuildTree_OneNode()
{
//Arrange
var leafTree = new SortedSet <INode>(new NodeComparer());
var node = new Leaf(Convert.ToByte(0x1f), 4);
leafTree.Add(node);
var builder = new TreeBuilder(leafTree);
//Act
builder.BuildTree();
//Assert
Assert.AreEqual(builder.tree.Count, 1);
Assert.AreEqual(builder.tree.First(), node);
}
// Start is called before the first frame update
void Start()
{
Debug.Log("hello world");
TreeBuilder builder = new TreeBuilder();
var nodes = builder.BuildTree();
/* nodes is now a list of all the questions read in from the file
* Need to use the reverse tree traversal method and build up a tree
* out of DecisionTreeNodes*/
DecisionTreeNode rootNode = new DecisionTreeNode();
rootNode.QuestionToAsk = nodes[0].QuestionToAsk;
rootNode.IsLeafNode = nodes[0].IsLeafNode;
rootNode.TrueResponseNode = null;
rootNode.FalseResponseNode = null;
}
public void Higher_id_parent_of_lower_id()
{
var records = new[]
{
new TreeBuildingRecord {
RecordId = 0, ParentId = 0
},
new TreeBuildingRecord {
RecordId = 2, ParentId = 0
},
new TreeBuildingRecord {
RecordId = 1, ParentId = 2
}
};
Assert.Throws <ArgumentException>(() => TreeBuilder.BuildTree(records));
}
public void PrintTree_PrintSimpleTree()
{
//Arrange
var processor = new InputProcessorMockup();
var leafTree = processor.BuildSimpleTree();
var builder = new TreeBuilder(leafTree);
using (StringWriter stringWriter = new StringWriter())
{
//Act
builder.BuildTree();
Console.SetOut(stringWriter);
builder.PrintTree(builder.tree.First());
//Assert
Assert.AreEqual("6 *97:3 3 *99:1 *98:2", stringWriter.ToString());
}
}
private void LoadTreeView(string directory, bool waitWindow = true)
{
if (waitWindow)
{
ArcWaitWindow.ArcWaitWindow.Show(LoadTreeView, @"Building file tree...", directory);
}
else
{
if (Directory.Exists(directory))
{
//temporarily offload to a variable in order to keep UI responsive when it finally gets updated
var rootNode = new TreeNode();
TreeBuilder.BuildTree(new DirectoryInfo(directory), rootNode.Nodes);
//refresh TreeView
TreeViewRepaint(rootNode.Nodes);
}
}
}
public void Duplicate_Record_ID()
{
var records = new[]
{
new TreeBuildingRecord {
RecordId = 0, ParentId = 0
},
new TreeBuildingRecord {
RecordId = 1, ParentId = 0
},
new TreeBuildingRecord {
RecordId = 2, ParentId = 0
},
new TreeBuildingRecord {
RecordId = 2, ParentId = 1
}
};
Assert.Throws <ArgumentException>(() => TreeBuilder.BuildTree(records));
}
public void Non_continuous()
{
var records = new[]
{
new TreeBuildingRecord {
RecordId = 2, ParentId = 0
},
new TreeBuildingRecord {
RecordId = 4, ParentId = 2
},
new TreeBuildingRecord {
RecordId = 1, ParentId = 0
},
new TreeBuildingRecord {
RecordId = 0, ParentId = 0
}
};
Assert.Throws <ArgumentException>(() => TreeBuilder.BuildTree(records));
}
public void Three_nodes_in_reverse_order()
{
var records = new[]
{
new TreeBuildingRecord {
RecordId = 2, ParentId = 0
},
new TreeBuildingRecord {
RecordId = 1, ParentId = 0
},
new TreeBuildingRecord {
RecordId = 0, ParentId = 0
}
};
var tree = TreeBuilder.BuildTree(records);
AssertTreeIsBranch(tree, id: 0, childCount: 2);
AssertTreeIsLeaf(tree.Children[0], id: 1);
AssertTreeIsLeaf(tree.Children[1], id: 2);
}
public void Binary_tree()
{
var records = new[]
{
new TreeBuildingRecord {
RecordId = 5, ParentId = 1
},
new TreeBuildingRecord {
RecordId = 3, ParentId = 2
},
new TreeBuildingRecord {
RecordId = 2, ParentId = 0
},
new TreeBuildingRecord {
RecordId = 4, ParentId = 1
},
new TreeBuildingRecord {
RecordId = 1, ParentId = 0
},
new TreeBuildingRecord {
RecordId = 0, ParentId = 0
},
new TreeBuildingRecord {
RecordId = 6, ParentId = 2
}
};
var tree = TreeBuilder.BuildTree(records);
AssertTreeIsBranch(tree, id: 0, childCount: 2);
AssertTreeIsBranch(tree.Children[0], id: 1, childCount: 2);
AssertTreeIsBranch(tree.Children[1], id: 2, childCount: 2);
AssertTreeIsLeaf(tree.Children[0].Children[0], id: 4);
AssertTreeIsLeaf(tree.Children[0].Children[1], id: 5);
AssertTreeIsLeaf(tree.Children[1].Children[0], id: 3);
AssertTreeIsLeaf(tree.Children[1].Children[1], id: 6);
}
private int[] UwzglednijPoziomyZagniezdzone(int aktualnyPoziom, bool uwzglednijBrygady)
{
#region przygotowanie drzewa
List <TreeNode> _nodes = new List <TreeNode>();
if (uwzglednijBrygady)
{
var wydzialy = context.Wydzialy;
foreach (Wydzial w in wydzialy)
{
_nodes.Add(new TreeNode {
id = w.ID, text = w.Nazwa, parent = w.IDParent.ToString()
});
}
Tree tree = TreeBuilder.BuildTree(_nodes);
// dodanie podległych działów do wyniku - potomków w drzewie
Tree y = TreeExtensions.FindNode(tree, aktualnyPoziom);
List <Tree> x = TreeExtensions.Descendants(y).ToList();
return(x.Select(t => ( int )t.Id).ToArray());
}
else
{
var wydzialy = context.Wydzialy.Where(w => w.IsBrygada == uwzglednijBrygady);
foreach (Wydzial w in wydzialy)
{
_nodes.Add(new TreeNode {
id = w.ID, text = w.Nazwa, parent = w.IDParent.ToString()
});
}
Tree tree = TreeBuilder.BuildTree(_nodes);
// dodanie podległych działów do wyniku - potomków w drzewie
Tree y = TreeExtensions.FindNode(tree, aktualnyPoziom);
List <Tree> x = TreeExtensions.Descendants(y).ToList();
return(x.Select(t => ( int )t.Id).ToArray());
}
#endregion
}
/// <summary>
/// The background worker add tree do work.
/// </summary>
/// <param name="sender">
/// The sender.
/// </param>
/// <param name="e">
/// The e.
/// </param>
private void BackgroundWorkerAddTreeDoWork(object sender, DoWorkEventArgs e)
{
var factory = e.Argument as ITreeFactory;
var treeBuilder = new TreeBuilder(this.provider, this.textBoxName.Text.Trim(), this.backgroundWorkerAddTree);
if (this.fromFile)
{
if (factory != null && factory.NeedDegree)
{
if (!this.group)
{
if (this.mode == 0)
{
treeBuilder.BuildTreeFromFile<string>(factory, int.Parse(maskedTextBoxDegree.Text));
}
if (this.mode == 1)
{
treeBuilder.BuildTreeFromFile<double>(factory, int.Parse(maskedTextBoxDegree.Text));
}
}
else
{
if (this.mode == 0)
{
treeBuilder.BuildBatchTree<string>(factory, int.Parse(maskedTextBoxDegree.Text));
}
if (this.mode == 1)
{
treeBuilder.BuildBatchTree<double>(factory, int.Parse(maskedTextBoxDegree.Text));
}
this.typeOfTrees = treeBuilder.TypeOfTrees;
this.noOfTrees = treeBuilder.NumberOfTrees;
this.groupTreeName = this.textBoxName.Text.Trim();
}
}
else
{
if (!this.group)
{
if (this.mode == 0)
{
treeBuilder.BuildTreeFromFile<string>(factory);
}
if (this.mode == 1)
{
treeBuilder.BuildTreeFromFile<double>(factory);
}
}
else
{
if (this.mode == 0)
{
treeBuilder.BuildBatchTree<string>(factory);
}
if (this.mode == 1)
{
treeBuilder.BuildBatchTree<double>(factory);
}
this.typeOfTrees = treeBuilder.TypeOfTrees;
this.noOfTrees = treeBuilder.NumberOfTrees;
this.groupTreeName = this.textBoxName.Text.Trim();
}
}
}
else
{
if (factory != null && factory.NeedDegree)
{
if (this.mode == 0)
{
treeBuilder.BuildTree<string>(factory, int.Parse(maskedTextBoxDegree.Text));
}
if (this.mode == 1)
{
treeBuilder.BuildTree<double>(factory, int.Parse(maskedTextBoxDegree.Text));
}
}
else
{
if (this.mode == 0)
{
treeBuilder.BuildTree<string>(factory);
}
if (this.mode == 1)
{
treeBuilder.BuildTree<double>(factory);
}
}
}
e.Result = true;
}
