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