private static string HubTreeAddChildren(TreeDictionary<TreeDictionaryItem> treeDictionary, int rootId, bool enableCheckbox, bool enableIcons) { var htmlOutput = string.Empty; var children = treeDictionary.GetChildren(rootId).OrderBy(t => t.DisplaySequence).ThenBy(t => t.Name); if (children.Any()) { htmlOutput += "<ul>"; foreach (var treeDictionaryItem in children) { htmlOutput += "<li id=\"TreeLi" + treeDictionaryItem.Id + "\" data-item-id=\"" + treeDictionaryItem.Id + "\"" + " data-entity-id=\"" + treeDictionaryItem.EntityId + "\" data-entity-type=\"" + treeDictionaryItem.EntityType; if (enableIcons) { htmlOutput += "\" data-entity-icontype=\"" + treeDictionaryItem.IconType + "\">"; htmlOutput += "<span id=\"TreeIcon" + treeDictionaryItem.Id + "\" class=\"" + treeDictionaryItem.IconType + "\"></span>"; } else htmlOutput += "\">"; if (enableCheckbox) { htmlOutput += "<input type=\"checkbox\" id=\"TreeCheckBox" + treeDictionaryItem.Id + "\" value=\"" + treeDictionaryItem.Id + "\">"; } htmlOutput += "<a id=\"TreeAnchor" + treeDictionaryItem.Id + "\" data-item-id=\"" + treeDictionaryItem.Id + "\" title=\"" + treeDictionaryItem.Title + "\" href=\"#\" >" + treeDictionaryItem.Name + "</a>"; htmlOutput += HubTreeAddChildren(treeDictionary, treeDictionaryItem.Id, enableCheckbox, enableIcons); htmlOutput += "</li>"; } htmlOutput += "</ul>"; } return htmlOutput; }
static IDictionary <String, TreeSet <int> > IndexFile(String filename) { IDictionary <String, TreeSet <int> > index = new TreeDictionary <String, TreeSet <int> >(); Regex delim = new Regex("[^a-zA-Z0-9]+"); using (TextReader rd = new StreamReader(filename)) { int lineno = 0; for (String line = rd.ReadLine(); line != null; line = rd.ReadLine()) { String[] res = delim.Split(line); lineno++; foreach (String s in res) { if (s != "") { if (!index.Contains(s)) { index[s] = new TreeSet <int>(); } index[s].Add(lineno); } } } } return(index); }
public void ItemRemove_Test() { treeDict = new TreeDictionary <int, int>(true); treeDict.Add(0, 44); treeDict.Add(1, 55); treeDict.Add(2, 66); treeDict.Add(3, 99); treeDict.Add(3, 101); treeDict.Add(4, 88); treeDict.Add(5, 77); treeDict.Add(8, 45); treeDict.Add(9, 34); treeDict.Remove(new KeyValuePair <int, int>(8, 45)); treeDict.Remove(new KeyValuePair <int, int>(3, 99)); treeDict.Remove(new KeyValuePair <int, int>(9, 34)); Assert.AreEqual(6, treeDict.Count); Assert.AreEqual(false, treeDict.ContainsKey(6), "Contains"); Assert.AreEqual(true, treeDict.Contains(new KeyValuePair <int, int>(0, 44))); Assert.AreEqual(true, treeDict.Contains(new KeyValuePair <int, int>(1, 55))); Assert.AreEqual(false, treeDict.Contains(new KeyValuePair <int, int>(8, 45)), "8, 45"); Assert.AreEqual(false, treeDict.Contains(new KeyValuePair <int, int>(3, 99)), "3, 99"); Assert.AreEqual(false, treeDict.Contains(new KeyValuePair <int, int>(9, 34)), "9, 34"); }
public void SortTest() { var rnd = new Random(); var list = new int[1000]; int i; for (i = 0; i < list.Length; ++i) { list[i] = rnd.Next(); } // create sorted list #if (SILVERLIGHT) var sortedList = new TreeDictionary<int, object>(); #else var sortedList = new SortedList(); #endif foreach (int key in list) { sortedList.Add(key, null); } // sort table this.Sorter.Sort(list); Assert.AreEqual(sortedList.Keys, list); }
public static TreeDictionary <int, Page> DeepCopy(this TreeDictionary <int, Page> item) { var result = new TreeDictionary <int, Page>(); item.ForEach(i => result.Add(i.Key, i.Value)); return(result); }
public void SortTest() { var rnd = new Random(); var list = new int[1000]; int i; for (i = 0; i < list.Length; ++i) { list[i] = rnd.Next(); } // create sorted list #if (SILVERLIGHT) var sortedList = new TreeDictionary <int, object>(); #else var sortedList = new SortedList(); #endif foreach (int key in list) { sortedList.Add(key, null); } // sort table this.Sorter.Sort(list); Assert.AreEqual(sortedList.Keys, list); }
public static List <int> ProcessOutput(TreeDictionary <int, int> summedRangeEdges, List <int> numbers) { var outputs = new List <int>(); var firstSummedRangeEdge = summedRangeEdges.First().Key; foreach (var number in numbers) { if (summedRangeEdges.TryPredecessor(number, out var floorEntry)) { var value = floorEntry.Value; // Use the value of the summed range this number belongs to // If this number is on top of the left boundary of that range, if there is another range before this one, count that as well by adding 1 if (floorEntry.Key != firstSummedRangeEdge && floorEntry.Key == number) { value++; } Debug.WriteLine(value); outputs.Add(value); } else { Debug.WriteLine(0); outputs.Add(0); } } return(outputs); }
/// <summary> /// Lookup words in text. /// </summary> /// <param name="chars">Text.</param> /// <param name="off">Offset into text.</param> /// <param name="len">Length of text.</param> /// <returns>Array of {wordId, position, length}.</returns> public int[][] Lookup(char[] chars, int off, int len) { // TODO: can we avoid this treemap/toIndexArray? TreeDictionary <int, int[]> result = new TreeDictionary <int, int[]>(); // index, [length, length...] bool found = false; // true if we found any results FST.BytesReader fstReader = fst.GetBytesReader(); FST.Arc <long?> arc = new FST.Arc <long?>(); int end = off + len; for (int startOffset = off; startOffset < end; startOffset++) { arc = fst.GetFirstArc(arc); int output = 0; int remaining = end - startOffset; for (int i = 0; i < remaining; i++) { int ch = chars[startOffset + i]; if (fst.FindTargetArc(ch, arc, arc, i == 0, fstReader) == null) { break; // continue to next position } output += (int)arc.Output; if (arc.IsFinal) { int finalOutput = output + (int)arc.NextFinalOutput; result[startOffset - off] = segmentations[finalOutput]; found = true; } } } return(found ? ToIndexArray(result) : EMPTY_RESULT); }
private static IDictionary <string, TreeSet <int> > IndexFile(string filename) { var index = new TreeDictionary <string, TreeSet <int> >(); var delimiter = new Regex("[^a-zA-Z0-9]+"); using (var reader = File.OpenText(filename)) { var lineNumber = 0; for (var line = reader.ReadLine(); line != null; line = reader.ReadLine()) { var res = delimiter.Split(line); lineNumber++; foreach (var s in res) { if (s != "") { if (!index.Contains(s)) { index[s] = new TreeSet <int>(); } index[s].Add(lineNumber); } } } } return(index); }
public void TestEmptyDictionary() { var dictionary = new TreeDictionary <int, int>(); TreeDictionary <int, int> .KeyCollection keys = dictionary.Keys; TreeDictionary <int, int> .ValueCollection values = dictionary.Values; Assert.Empty(dictionary); Assert.Empty(keys); Assert.Empty(values); #pragma warning disable xUnit2013 // Do not use equality check to check for collection size. Assert.Equal(0, dictionary.Count); Assert.Equal(0, keys.Count); Assert.Equal(0, values.Count); #pragma warning restore xUnit2013 // Do not use equality check to check for collection size. Assert.False(dictionary.ContainsKey(0)); Assert.False(dictionary.ContainsValue(0)); Assert.False(dictionary.TryGetValue(0, out _)); Assert.Throws <KeyNotFoundException>(() => dictionary[0]); #pragma warning disable xUnit2017 // Do not use Contains() to check if a value exists in a collection Assert.False(keys.Contains(0)); Assert.False(values.Contains(0)); #pragma warning restore xUnit2017 // Do not use Contains() to check if a value exists in a collection }
public DensityHintContainer( TreeDictionary <uint, double> seconds, TreeDictionary <uint, double> minutes) { _seconds = seconds; _minutes = minutes; }
internal TreeDictionaryKeyValuePairEnumerator(TreeDictionary <TKey, TValue> tree, TreeDictionary <TKey, TValue> .TreeNode node, bool isGoingDown, uint statusBits) { this.comparer = tree.Comparer; this.loopbackNode = tree.loopbackNode; this.node = node; this.isGoingDown = isGoingDown; this.statusBits = statusBits; }
public TreeDictionaryKeyValuePairEnumerator(TreeDictionaryValueEnumerator <TKey, TValue> enumerator) { this.comparer = enumerator.comparer; this.loopbackNode = enumerator.loopbackNode; this.node = enumerator.node; this.isGoingDown = enumerator.isGoingDown; this.statusBits = enumerator.statusBits; }
public BTreeContainer(BTreeAddress address, TreeDictionary <int, Page> tree, DbStorage storage, TableSchema2 schema, Process process) { _tree = tree; _address = address; _storage = storage; _schema = schema; _process = process; }
public void Init() { dict = new TreeDictionary <string, string>(new SC()); dict["S"] = "A"; dict["T"] = "B"; dict["R"] = "C"; dictenum = dict.GetEnumerator(); }
public static TreeDictionary <int, int> ProcessRanges(IEnumerable <Tuple <int, int> > ranges) { var summedRangeEdges = new TreeDictionary <int, int>(); foreach (var currentRange in ranges) { var currentRangeLeft = currentRange.Item1; var currentRangeRight = currentRange.Item2; // Add left boundary if it isn't already there, with its value set as the value of the summed range it is included in, otherwise zero // E.g.: 1 to 10 with value 1 becomes 1 to 5 with value 1, 5 to 10 with value 1 // Check if the node exists in the Tree if (!summedRangeEdges.Exists(x => x.Key == currentRangeLeft)) { summedRangeEdges.Add(currentRangeLeft, summedRangeEdges.TryPredecessor(currentRangeLeft, out var predecessor) ? predecessor.Value : 0); } // Increment the value of all summed range edges between the left boundary (inclusive) and the right boundary (exclusive) var summedRangesSubMap = summedRangeEdges.RangeFromTo(currentRangeLeft, currentRangeRight); var keys = new SortedArray <int>(); foreach (var key in summedRangesSubMap) { keys.Add(key.Key); } foreach (var key in keys) { summedRangeEdges[key]++; } // Add the right boundary // If there isn't a summed range edge to its left, use 0 for the value (should never happen as per the "put" above) // If the right boundary was already in the map, leave it as is // If the right boundary wasn't in the map, use the value to its left minus 1 (since this is a right boundary, which means a range was closed) if (summedRangeEdges.Exists(x => x.Key == currentRangeRight)) { continue; } { if (summedRangeEdges.TryPredecessor(currentRangeRight, out var predecessor)) { summedRangeEdges.Add(currentRangeRight, predecessor.Value - 1); } else { summedRangeEdges.Add(currentRangeRight, 0); } } } return(summedRangeEdges); }
private TreeDictionary <TKey, TValue, DefaultComparer <TKey> > CreateDictionary <TKey, TValue>( TKey[] keys, TValue[] values) where TKey : struct { PexAssume.IsNotNull(keys); PexAssume.IsNotNull(values); PexAssume.AreEqual(keys.Length, values.Length); PexAssume.AreDistinctValues(keys); return(TreeDictionary.Empty <TKey, TValue>().AddAll(keys.Zip(values))); }
public void Init() { ISortedDictionary <string, string> dict = new TreeDictionary <string, string>(new SC()); dict.Add("A", "1"); dict.Add("C", "2"); dict.Add("E", "3"); this.dict = new GuardedSortedDictionary <string, string>(dict); }
public void Init() { dict = new TreeDictionary <string, string>(new SC()); dict["S"] = "A"; dict["T"] = "B"; dict["R"] = "C"; dict["V"] = "G"; snap = (TreeDictionary <string, string>)dict.Snapshot(); }
public PointLocator(SCG.IEnumerable <Edge <T> > edges) { //htree = new TreeDictionary<double,TreeSet<Edge<T>>>(dc); endpoints = new TreeDictionary <EndPoint, Edge <T> >(epc); foreach (Edge <T> edge in edges) { add(edge); } }
public static void Main(string[] args) { System.Console.WriteLine("Hello World!"); var characterInfo = new CharacterInfo(); characterInfo.Input = new Brawler.Input.Packets.ControllerState(); characterInfo.Input.AttackStick = new Brawler.Input.Packets.AnalogStick(); characterInfo.Input.MoveStick = new Brawler.Input.Packets.AnalogStick(); characterInfo.Current = new Brawler.Simulation.PlayerInfo(); characterInfo.Previous = new Brawler.Simulation.PlayerInfo(); var dictionary = new TreeDictionary(); var builder = new BlackboardTreeBuilder <CharacterInfo>( new TreeBuilder(), dictionary); var plan = builder .Selector() .Begin() //.Success() .Failed() .Success() .Success() .End(); var compiled = builder.Build(); //var compiled = BuildSM (builder); var walker = new NodeWalker(compiled); walker.Restart(); walker.ComputeStep(); System.Console.WriteLine("walker.IsComplete : " + walker.IsComplete); System.Console.WriteLine("walker.Outcome : " + walker.Outcome); walker.ComputeStep(); System.Console.WriteLine("walker.IsComplete : " + walker.IsComplete); System.Console.WriteLine("walker.Outcome : " + walker.Outcome); walker.ComputeStep(); System.Console.WriteLine("walker.IsComplete : " + walker.IsComplete); System.Console.WriteLine("walker.Outcome : " + walker.Outcome); walker.ComputeStep(); System.Console.WriteLine("walker.IsComplete : " + walker.IsComplete); System.Console.WriteLine("walker.Outcome : " + walker.Outcome); walker.ComputeStep(); System.Console.WriteLine("walker.IsComplete : " + walker.IsComplete); System.Console.WriteLine("walker.Outcome : " + walker.Outcome); walker.ComputeStep(); System.Console.WriteLine("walker.IsComplete : " + walker.IsComplete); System.Console.WriteLine("walker.Outcome : " + walker.Outcome); //Test1 (characterInfo, walker); //Test2 (characterInfo, walker, timer, MAX_TIMES); }
public void TreeDictionaryBug_no_42() { var tree = new TreeDictionary<int, int>(); tree.Values.LastOrDefault(); tree.UpdateOrAdd(0, 0); var last = tree.Values.LastOrDefault(); Assert.AreEqual(0, last); }
public WorldLoadingThread() { objectRunningList = new TreeDictionary <long, NifLoadJob>(); terrainRunningList = new TreeDictionary <long, NifLoadJob>(); objectPositions = new SCG.List <ObjectPosition>(); MAX_RUNNING_THREADS = ProgramSettings.get("MAX_RUNNING_THREADS", 2); this.loadingQueueSampler = CustomSampler.Create("LoadingQueuesampler"); this.objectRunningListSampler = CustomSampler.Create("LoadingQueuesampler"); this.terrainRunningListSampler = CustomSampler.Create("LoadingQueuesampler"); }
public void TreeDictionaryBug_no_42() { var tree = new TreeDictionary <int, int>(); tree.Values.LastOrDefault(); tree.UpdateOrAdd(0, 0); var last = tree.Values.LastOrDefault(); Assert.AreEqual(0, last); }
public void Indexer_SetValue_GetValue() { //Arrange var d = new TreeDictionary <string, string>(new BinaryTree <string, string>()); //Act d["test"] = "testValue"; //Assert Assert.Equal("testValue", d["test"]); }
public void TestTreeSetBranchingFactorConstructor() { TreeDictionary <int, int> set = new TreeDictionary <int, int>(8); Assert.Empty(set); Assert.Throws <ArgumentOutOfRangeException>(() => new TreeDictionary <int, int>(-1)); Assert.Throws <ArgumentOutOfRangeException>(() => new TreeDictionary <int, int>(0)); Assert.Throws <ArgumentOutOfRangeException>(() => new TreeDictionary <int, int>(1)); }
public void Init() { ISortedDictionary <string, string> dict = new TreeDictionary <string, string>(new SC()) { { "A", "1" }, { "C", "2" }, { "E", "3" } }; this.dict = new GuardedSortedDictionary <string, string>(dict); }
public OptionGroup(string id, string name, string description, OptionGroupRequirement require, bool requireExplicitAssignment, SCG.IComparer<string> keyComparer) { Debug.Assert(!String.IsNullOrEmpty(id)); Debug.Assert(keyComparer != null); mId = id; mName = name; mDescription = description; mRequire = require; mOptions = new TreeDictionary<string, Option>(keyComparer); mRequireExplicitAssignment = requireExplicitAssignment; }
public OptionGroup(string id, string name, string description, OptionGroupRequirement require, bool requireExplicitAssignment, SCG.IComparer <string> keyComparer) { Debug.Assert(!String.IsNullOrEmpty(id)); Debug.Assert(keyComparer != null); mId = id; mName = name; mDescription = description; mRequire = require; mOptions = new TreeDictionary <string, Option>(keyComparer); mRequireExplicitAssignment = requireExplicitAssignment; }
public void Add_Added() { //Arrange var d = new TreeDictionary <int, int>(new BinaryTree <int, int>()); //Act d.Add(100, 1500); //Assert Assert.Single(d); Assert.Equal(1500, d[100]); // ReSharper disable once xUnit2013 Assert.Single(d); }
internal WorldRenderer() { _partDistanceComparer = new PartDistanceComparer(this); _renderObjects = new TreeDictionary <GeoMatPair, RenderObject>(); _renderObjects2 = new List <RenderObject>(); _transparentSet = new TreeSet <Part>(_partDistanceComparer); _cubeRenderer = new RenderObject("Cube", Primitives.CubeGeometry); _cylinderRenderer = new RenderObject("Cylinder", Primitives.CylinderGeometry); _sphereRenderer = new RenderObject("Sphere", Primitives.SphereGeometry); _wedgeRenderer = new RenderObject("Wedge", Primitives.WedgeGeometry); SkyboxRO = new RenderObject("Skybox", Primitives.CubeGeometry); }
public void ContainsKey_InsertNull_ReturnsTrue() { //Arrange var dictionary = new TreeDictionary <string, string>(new BinaryTree <string, string>()); const string key = "testKey"; dictionary.Add(key, null); //Act var result = dictionary.ContainsKey(key); //Assert Assert.True(result); Assert.Single(dictionary); }
public MetaGdl(Parser p) { _relations = new TreeDictionary<int, RelationInfo>(); _functionSymbols = new TreeSet<int>(); _objectSymbols = new TreeSet<int>(); _parser = p; _rules = new TreeDictionary<int, List<Implication>>(); _groundFacts = new TreeDictionary<int, List<GroundFact>>(); _roles = new List<TermObject>(); InsertReservedKeywords(); }
private void Compress() { TDigest newTDigest = new TDigest(Accuracy, CompressionConstant); List <Centroid> temp = centroids.Values.ToList(); temp.Shuffle(); foreach (Centroid centroid in temp) { newTDigest.Add(centroid.Mean, centroid.Count); } centroids = newTDigest.centroids; }
public void Values_works_multiple_times(MemoryType memoryType, int numberOfIterations, int expectedResult) { var dictionary = new TreeDictionary<string, int>(memoryType) { { "One", 1 }, { "Two", 2 }, { "Three", 3 }, { "Four", 4 } }; var sum = 0; for (var i = 0; i < numberOfIterations; i++) { foreach (var value in dictionary.Values) { sum += value; } } Assert.AreEqual(expectedResult, sum); }
public void Keys_works_multiple_times(MemoryType memoryType, int numberOfIterations, int expectedResult) { var dictionary = new TreeDictionary<int, string>(memoryType) { { 1, "One" }, { 2, "Two" }, { 3, "Three" }, { 4, "Four" } }; var sum = 0; for (var i = 0; i < numberOfIterations; i++) { foreach (var value in dictionary.Keys) { sum += value; } } Assert.AreEqual(expectedResult, sum); }
public ExcelWorksheet(IExcelDocument excelDocument, WorksheetPart worksheetPart, IExcelDocumentStyle documentStyle, IExcelSharedStrings excelSharedStrings, ILog logger) { worksheet = worksheetPart.Worksheet; ExcelDocument = excelDocument; this.documentStyle = documentStyle; this.excelSharedStrings = excelSharedStrings; this.logger = logger; rowsCache = new TreeDictionary <uint, Row>(); var sheetData = worksheet.GetFirstChild <SheetData>(); if (sheetData != null) { rowsCache.AddAll(sheetData.Elements <Row>().Select(x => new C5.KeyValuePair <uint, Row>(x.RowIndex, x))); } }
public static IHtmlString HubTree(this HtmlHelper htmlHelper, TreeDictionary<TreeDictionaryItem> treeDictionary, string controlName, int rootId, bool enableCheckbox = false, bool enableIcons = false, bool showRoot = true) { var rootItem = treeDictionary[rootId]; var initialChildren = treeDictionary.GetChildren(rootId).OrderBy(t => t.DisplaySequence).ThenBy(t => t.Name); var htmlOutput = string.Empty; htmlOutput += "<div id=\"" + controlName + "\">"; if (showRoot) { htmlOutput += "<ul><li id=\"TreeLi" + rootItem.Id + "\" rel=\"root" + "\" data-item-id=\"" + rootItem.Id + "\">"; htmlOutput += "<a id=\"TreeAnchor" + rootItem.Id + "\" data-item-id=\"" + rootItem.Id + "\" title=\"" + rootItem.Title + "\" data-entity-id=\"" + rootItem.EntityId + "\" data-entity-type=\"" + rootItem.EntityType + "\" href=\"#\" >" + rootItem.Name + "</a>"; } foreach (var treeDictionaryItem in initialChildren) { htmlOutput += "<ul><li id=\"TreeLi" + treeDictionaryItem.Id + "\" data-item-id=\"" + treeDictionaryItem.Id + "\"" + "data-entity-id=\"" + treeDictionaryItem.EntityId + "\" data-entity-type=\"" + treeDictionaryItem.EntityType; if (enableIcons) { htmlOutput += "\" data-entity-icontype=\"" + treeDictionaryItem.IconType + "\">"; htmlOutput += "<span id=\"TreeIcon" + treeDictionaryItem.Id + "\" class=\"" + treeDictionaryItem.IconType + "\"></span>"; } else htmlOutput += "\">"; if (enableCheckbox) { htmlOutput += "<input type=\"checkbox\" id=\"TreeCheckBox" + treeDictionaryItem.Id + "\" value=\"" + treeDictionaryItem.Id + "\">"; } htmlOutput += "<a id=\"TreeAnchor" + treeDictionaryItem.Id + "\" data-item-id=\"" + treeDictionaryItem.Id + "\" title=\"" + treeDictionaryItem.Title + "\" href=\"#\" >" + treeDictionaryItem.Name + "</a>"; htmlOutput += HubTreeAddChildren(treeDictionary, treeDictionaryItem.Id, enableCheckbox, enableIcons); htmlOutput += "</li></ul>"; } if (showRoot) { htmlOutput += "</li></ul>"; htmlOutput += "</div>"; } return MvcHtmlString.Create(htmlOutput); }
public void KeyValuePairs_works_multiple_times(MemoryType memoryType, int numberOfIterations, int expectedResult) { var dictionary = new TreeDictionary<int, int>(memoryType) { { 1, -1 }, { 2, -2 }, { 3, -3 }, { 4, -4 } }; var keys = 0; var values = 0; for (var i = 0; i < numberOfIterations; i++) { foreach (var kv in dictionary) { keys += kv.Key; values += kv.Value; } } Assert.AreEqual(expectedResult, keys); Assert.AreEqual(-expectedResult, values); }
static IDictionary<String, TreeSet<int>> IndexFile(String filename) { IDictionary<String, TreeSet<int>> index = new TreeDictionary<String, TreeSet<int>>(); Regex delim = new Regex("[^a-zA-Z0-9]+"); using (TextReader rd = new StreamReader(filename)) { int lineno = 0; for (String line = rd.ReadLine(); line != null; line = rd.ReadLine()) { String[] res = delim.Split(line); lineno++; foreach (String s in res) if (s != "") { if (!index.Contains(s)) index[s] = new TreeSet<int>(); index[s].Add(lineno); } } } return index; }
/// <summary> /// Go through the Test tree, building a tree of TestFixures with Test nodes. /// </summary> private void MapTestTreeToFixtures(TreeDictionary<string, TestClosure> source, TestSuite container, Type fixtureType) { foreach (var testClosure in source.Items) { container.Add(new ClosureTest(testClosure)); } foreach (var child in source.Children) { var fixture = new TestFixture(fixtureType); fixture.TestName.Name = child.Key; foreach (var testClosure in child.Value.Items) { fixture.Add(new ClosureTest(testClosure)); } foreach (var sub_child in child.Value.Children) { var sub_fixture = new TestFixture(fixtureType); sub_fixture.TestName.Name = sub_child.Key; MapTestTreeToFixtures(sub_child.Value, sub_fixture, fixtureType); fixture.Add(sub_fixture); } container.Add(fixture); } }
public RedBlackTreeCache(Action<string, object> callback) { CacheItemRemovedCallback = callback; _cache = new TreeDictionary<string, CachedValue>(); }
static Pool() { pool = new TreeDictionary(); }
public CombinedAi(GameState state) { this.heuristic = new CombinedHeuristic (state); this.forwardModel = new ForwardModel(state); this.allPaths = new TreeDictionary<double, StateNode> (); }
public void Dispose() { _cache = null; }
void addChildrenToOpenSet(TreeDictionary<double, StateNode> dict, StateNode parent, GameState state, CombinedHeuristic heuristic) { var parentScore = stateNodeScorer (heuristic, parent); foreach (var input in Input.All.CartesianProduct(Input.All)) { var stateNode = new StateNode (parent, input, state); // var target1 = state.Goal; // var target2 = state.Goal; var targets = heuristic.cpas.NextPlatform (state.P1, state.P2, state.Goal, state.Goal); var target1 = targets.Item1; var target2 = targets.Item2; var score = parentScore + heuristic.EstimateScore (state, input.Item1, input.Item2, target1.Target, target2.Target); var noiseyScore = AStar.addNoise (score); dict.Add (noiseyScore, stateNode); } }
// public TreeDictionary<double, IEnumerable<B>> AStar<A, B>(Func<B, AStarNode<A, B>> nextState, A state) { // var openSet = new TreeDictionary<double, B>(); // Known, but unexplored // var closedSet = new TreeDictionary<double, B>(); // Fully explored // // AStarNode<A, B> parentStub = new AStarNode<A, B> (null, null, state); // addChildrenToOpenSet(openSet, parentStub, state, heuristic); // // int maxIters = 100; // int nRepetitions = 5; // // AStarNode<A, B> best; // // int i = 0; // do { // var bestKV = openSet.First (); // openSet.Remove(bestKV.Key); // // best = bestKV.Value; // // var bestNextMove = best.Input; // // // repeat the same input a few times // B resultState = best.Value; // for (int j = 0; j < nRepetitions; j++) { // resultState = nextState(new AStarNode<A, B>(best, bestNextMove, resultState)); // } // // addChildrenToOpenSet(openSet, best, resultState, heuristic); // // var stateNode = new AStarNode<A, B> (best, bestNextMove, resultState); // var score = AStar.addNoise(stateNodeScorer (heuristic, stateNode)); // // closedSet.Add(score, stateNode); // // } while(i++ < maxIters && closedSet.First().Key > 0 && openSet.Count > 0); // // return closedSet; // } // // public List<Tuple<Input, Input>> nextInputsList2(GameState state) { // // } public List<Tuple<Input, Input>> nextInputsList(GameState state) { var openSet = new TreeDictionary<double, StateNode>(); // Known, but unexplored var closedSet = new TreeDictionary<double, StateNode>(); // Fully explored StateNode parentStub = new StateNode (null, Tuple.Create(Input.Noop, Input.Noop), state); addChildrenToOpenSet(openSet, parentStub, state, heuristic); int maxIters = 100; int nRepetitions = 5; StateNode bestOpen; int i = 0; do { var bestOpenKV = openSet.First (); openSet.Remove(bestOpenKV.Key); bestOpen = bestOpenKV.Value; var bestNextMove = bestOpen.Input; // repeat the same input a few times GameState resultState = bestOpen.Value; for (int j = 0; j < nRepetitions; j++) { resultState = AStar.nextState(forwardModel, resultState, bestNextMove.Item1, bestNextMove.Item2); } addChildrenToOpenSet(openSet, bestOpen, resultState, heuristic); var stateNode = new StateNode (bestOpen, bestNextMove, resultState); var score = AStar.addNoise(stateNodeScorer (heuristic, stateNode)); closedSet.Add(score, stateNode); } while(i++ < maxIters && !closedSet.First().Value.Value.PlayStatus.isWon() && openSet.Count > 0); // Debug.WriteLine ("closedSet size: {0}", closedSet.Count); // int k = 0; // foreach (var pth in closedSet) { // var pathStr = string.Join(", ", pth.Value.ToPath().Select(tup1 => tup1.Item1.Item1 + "|" + tup1.Item1.Item2)); // Debug.WriteLine("closedSet[{0}]: {1} - {2}", k++, pth.Key, pathStr); // } lock (allPaths) { allPaths = closedSet; } var path = closedSet.First().Value.ToPath (); var deRooted = path.Count > 1 ? path.Skip (1) : path; // Ignore the root node // Debug.Print("bestPath1: {0}", moveListStr(deRooted.Select(x => x.Item1.Item1))); // Debug.Print("bestPath2: {0}", moveListStr(deRooted.Select(x => x.Item1.Item2))); var res = deRooted .SelectMany (t => Enumerable.Repeat(t.Item1,nRepetitions)).ToList(); return res; }
public static void Main (string[] args) { // build empty tree var store = new TreeDictionary(); var minorBuilder = new BlackboardTreeBuilder<Enemy>(new TreeBuilder(), store); // gererate a behavior tree as a stub for later reuse minorBuilder .Sequence () .Begin () .Selector () .Begin () .IsTrue ((e) => e.WithinDistance ()) .Step ((e) => e.MoveTowards ()) .End () .Sequence () .Begin () .IsTrue ((e) => e.WithinDistance ()) .Step ((e) => e.HitTarget ()) .End () .End () .BuildAndRegisterAs<BaseEnemyAI> (); var playerOne = new Player{ HealthPoints = 10, X = 10}; var ogre = new Enemy (); var locator = new MockPlayerLocator(playerOne); var situation = new Simulation{Individual=ogre, Locator=locator, Current = playerOne }; var upperTree = new BlackboardTreeBuilder<Simulation>(new TreeBuilder(), store); upperTree .Sequence () .Begin () .Selector () .Begin () .IsTrue ((e) => e.Individual.HasTarget ()) .Step ((e) => { bool result = e.Locator.Find (out e.Individual.Target); return (result) ? Result.SUCCESS : Result.FAILED; } ) .End () .UseStub<BaseEnemyAI, Enemy> () .IsTrue((e) => e.Current.HealthPoints <= 0) .End (); var linker = new BlackboardLinker (); linker.AddDependency<Simulation, Enemy>((es) => es.Individual); var board = new Blackboard<Simulation>{Context = situation}; linker.AddParameter<Simulation>(new StaticParameter<Simulation>(board)); // generate tree as a stub for an BaseEnemyAI implementation var finalTree = upperTree.Build(); var walker = new NodeWalker(finalTree, linker); Result outcome = Result.INCOMPLETE; while (!(outcome == Result.SUCCESS || outcome == Result.UNEXCEPTED_ERROR)) { walker.Restart (); walker.ComputeAllSteps (); outcome = walker.Outcome; Console.WriteLine ("Ogre X:{0}, Player [HP :{1}] X:{2}", ogre.X, playerOne.HealthPoints, playerOne.X); } Console.WriteLine ("PLAYER IS DEAD"); }
public static void Main (string[] args) { System.Console.WriteLine ("Hello World!"); var characterInfo = new CharacterInfo(); characterInfo.Input = new Brawler.Input.Packets.ControllerState(); characterInfo.Input.AttackStick = new Brawler.Input.Packets.AnalogStick(); characterInfo.Input.MoveStick = new Brawler.Input.Packets.AnalogStick(); characterInfo.Current = new Brawler.Simulation.PlayerInfo(); characterInfo.Previous = new Brawler.Simulation.PlayerInfo(); var dictionary = new TreeDictionary(); var builder = new BlackboardTreeBuilder<CharacterInfo>( new TreeBuilder(), dictionary); var plan = builder .Selector() .Begin () //.Success() .Failed () .Success() .Success() .End (); var compiled = builder.Build(); //var compiled = BuildSM (builder); var walker = new NodeWalker(compiled); walker.Restart (); walker.ComputeStep(); System.Console.WriteLine ("walker.IsComplete : " + walker.IsComplete); System.Console.WriteLine ("walker.Outcome : " + walker.Outcome); walker.ComputeStep(); System.Console.WriteLine ("walker.IsComplete : " + walker.IsComplete); System.Console.WriteLine ("walker.Outcome : " + walker.Outcome); walker.ComputeStep(); System.Console.WriteLine ("walker.IsComplete : " + walker.IsComplete); System.Console.WriteLine ("walker.Outcome : " + walker.Outcome); walker.ComputeStep(); System.Console.WriteLine ("walker.IsComplete : " + walker.IsComplete); System.Console.WriteLine ("walker.Outcome : " + walker.Outcome); walker.ComputeStep(); System.Console.WriteLine ("walker.IsComplete : " + walker.IsComplete); System.Console.WriteLine ("walker.Outcome : " + walker.Outcome); walker.ComputeStep(); System.Console.WriteLine ("walker.IsComplete : " + walker.IsComplete); System.Console.WriteLine ("walker.Outcome : " + walker.Outcome); //Test1 (characterInfo, walker); //Test2 (characterInfo, walker, timer, MAX_TIMES); }
private void FindStaticAndInitRelations() { _staticRelations = new TreeDictionary<int, List<GroundFact>>(); foreach (int i in _groundFacts.Keys) { if (i == _parser.TokImpliedby) continue; List<GroundFact> relation = _groundFacts[i]; if (i == _parser.TokInit) { continue; } if (relation.Count > 0) _staticRelations[i] = relation; } }