public void TestTreeOrderingAfterTreeValueUpdate() { var root = CreateTestTree(); var comparer = Comparer <ObservableSortedTree <ValueClass> > .Default; root.Comparer = comparer; root.EnumerateDescendantsAndSelf() .ForEach(tree => Assert.IsTrue(areItemsInOrder(tree.Children, comparer))); int cnt = 0; foreach (var tree in root.EnumerateDescendantsAndSelf()) { tree.Value.Number = cnt; tree.Value.Text = "Text" + cnt.ToString(); cnt++; } root.EnumerateDescendantsAndSelf() .ForEach(tree => Assert.IsTrue(areItemsInOrder(tree.Children, comparer))); root.EnumerateDescendantsAndSelf().ForEach(tree => tree.Children.Resort()); root.EnumerateDescendantsAndSelf() .ForEach(tree => Assert.IsTrue(areItemsInOrder(tree.Children, comparer))); var testChild = root.Children[0]; var newValue = new ValueClass("Text" + cnt, cnt); testChild.Value = newValue; root.EnumerateDescendantsAndSelf() .ForEach(tree => Assert.IsTrue(areItemsInOrder(tree.Children, comparer))); }
public void ChangingTheObjectAlreadyInsertedInSet() { ValueClass item1 = new ValueClass() { Value = 5 }; ISet <ValueClass> set = new HashSet <ValueClass> { item1 }; Assert.IsTrue(set.Contains(item1)); item1.Value = 10; Assert.IsFalse(set.Contains(item1)); ValueClass item2 = new ValueClass() { Value = 5 }; Assert.IsFalse(set.Contains(item2)); }
public void IsNotEqualToExtension() { var a = new ValueClassFactory().New(); var b = new ValueClass(); var areEqual = a.IsEqualTo(b); Assert.False(areEqual); }
public override bool Equals(object obj) { if (obj == null || GetType() != obj.GetType()) { return(false); } ValueClass other = (ValueClass)obj; return(Value == other.Value); }
/// <summary> /// AddWeightsPreTest is used to modify a Layer with a seires of inputs, training it to either be /// biased towards inputs with similar values, or opposed to inputs with simialr values /// </summary> /// <param name="size">The size of the input arrays</param> /// <param name="tag">The tag that <see cref="DebugWrite"/> method will use as it's 'tag'</param> /// <param name="imageLocation">The File loation of the data to be checked (.png)</param> /// <param name="isCorrect">Whether the Layer will be trained up to bias or anti-bias the inputs' values</param> /// <param name="testLayer">The 'Layer' class that is being trained</param> /// <param name="testAmmounts">How many itterations of training will be performed</param> private static void AddWeightsPreTest(int size, String tag, String imageLocation, bool isCorrect, Layer testLayer, int testAmmounts) { Bitmap[] inputs = new Bitmap[size]; String[] inputstrings = new String[size]; for (int i = 0; i < inputs.Length; i++) { inputstrings[i] = imageLocation + "/Image" + (i + 1) + ".png"; DebugWrite(tag, " Loading Image " + inputstrings[i], true);// Confirm Image Loaded inputs[i] = (Bitmap)Image.FromFile(inputstrings[i]); } imageBeingSearched = inputstrings[0]; DebugWrite(tag, " Image 0 height is " + inputs[0].Height, true); // Confirm Images are valid testLayer.baseCell = new ImageCell(inputs[0]); DebugWrite(tag, " Begining Loop to Test Cells", true); // Section Definition for (int i = 0; i < inputs.Length; i++) { for (int r = 0; r < testAmmounts; r++) { DateTime nowTime = DateTime.Now; imageBeingSearched = inputstrings[i]; DebugWrite(tag, " Testing & Rewarding Image " + inputstrings[i], true); // State Which image is being actioned ImageCell.ChangeImage((ImageCell)testLayer.baseCell, inputs[i]); DebugWrite(tag, " Rebuilding Image " + inputstrings[i], true); // State that image has changed correctly testLayer.baseCell.ReBuild(); DebugWrite(tag, " Getting Call of Image " + inputstrings[i], true); // State that 'GetCall()' Method is running successfully ValueClass debugValueClass = testLayer.baseCell.GetCall(); // DebugWrite(tag, " Image Call was " + debugValueClass.value + "," + debugValueClass.weight, false); // Get the value Class of the training for (int xAxis = 0; xAxis < 2; xAxis++) { for (int yAxis = 0; yAxis < 2; yAxis++) { if (isCorrect) { testLayer.AddValue(testLayer.baseCell); testLayer.baseCell.Reward(); } else { testLayer.baseCell.TellOff(); } } } averageCellTime += DateTime.Now.Subtract(nowTime); double averageCellTimeMili = averageCellTime.TotalMilliseconds; averageCellTime = TimeSpan.FromMilliseconds(averageCellTimeMili / 2); } } DebugWrite(tag, " Average Time Per Cell is " + averageCellTime, true, true); //Optimize time of calculation }
private static IValueInterface<int> GetComposable(IInterceptor interceptor) { var test = Composable.Create<IValueInterface<int>>(composable => { for (var x = 0; x < Count; x++) { var part = new ValueClass<int>(x + 1); composable.AddPart(part); } composable.AddInterceptor(interceptor); }); return test; }
public void MyObservableSortedCollectionTest_ref() { var defaultComparer = Comparer <ValueClass> .Default; var collection = new ObservableSortedCollection <ValueClass>(); var array = Enumerable.Range(0, 5).Select(val => val * 10) .SelectMany(val => Enumerable.Range(val, 10).Reverse()) .Select(val => new ValueClass("Text" + val, val)) .ToArray(); collection.AddRange(array); Assert.IsTrue(areItemsInOrder(collection, defaultComparer)); Assert.IsTrue(array.Length == collection.Count); array.ForEach(val => Assert.IsTrue(collection.Contains(val))); collection[5] = new ValueClass(99); Assert.IsTrue(areItemsInOrder(collection, defaultComparer)); collection.Insert(5, new ValueClass(100)); Assert.IsTrue(areItemsInOrder(collection, defaultComparer)); Assert.IsTrue(collection.Count == array.Length + 1); collection.RemoveAt(5); Assert.IsTrue(collection.Count == array.Length); collection.Remove(collection.First(item => item.Number >= 10)); Assert.IsTrue(collection.Count == array.Length - 1); Assert.IsTrue(areItemsInOrder(collection, defaultComparer)); bool exceptionThrown = false; try { collection.Move(0, 1); } catch (Exception) { exceptionThrown = true; } Assert.IsTrue(exceptionThrown); int oldCount = collection.Count; var oldItems = collection.ToArray(); var reverseComparer = Comparer <ValueClass> .Create((i1, i2) => i2.CompareTo(i1)); collection.Comparer = reverseComparer; Assert.AreEqual(oldCount, collection.Count); oldItems.ForEach(item => Assert.IsTrue(collection.Contains(item))); Assert.IsTrue(areItemsInOrder(collection, reverseComparer)); }
public void TestTreeValueChangedEvent() { var root = CreateTestTree(); var testChild = root.Children[0]; var oldValue = testChild.Value; var newValue = new ValueClass(new Random(0x5588DD99)); bool treeValueChangedEvent_raised = false; testChild.TreeValueChanged += (sender, old) => { treeValueChangedEvent_raised = true; Assert.IsTrue(ReferenceEquals(sender, testChild)); Assert.IsTrue(ReferenceEquals(old, oldValue)); }; testChild.Value = newValue; Assert.IsTrue(treeValueChangedEvent_raised); }
static void SetData(ValueClass newValue1, Value newValue) { int x = newValue1.GetValueX(); int y = newValue1.GetValueY(); newValue1.newMember(); newValue.newMember(); newValue1.Modify(); newValue.Modify(); newValue1.Show(); newValue.Show(); newValue1.newMember(); newValue.newMember(); }
public Layer() { //Color (White,Green,Red,x,y) values = new ValueClass[2, 2, 3]; inputs = new int[2, 2, 3]; for (int f = 0; f < values.GetLength(0); f++) { for (int z = 0; z < values.GetLength(1); z++) { for (int x = 0; x < values.GetLength(2); x++) { values[f, z, x] = new ValueClass(f, 0); inputs[f, z, x] = 1; } } } }
public static List <ValueClass> getFactoryBonus(TypeBuild type_build) { List <ValueClass> bonuses = new List <ValueClass>(); switch (type_build) { case TypeBuild.FACTORY_1: bonuses.Add(ValueClass.createBonus(TypeValues.ROBOTS, 10)); bonuses.Add(ValueClass.createBonus(TypeValues.ECOLOGY, -5)); break; case TypeBuild.FACTORY_2: bonuses.Add(ValueClass.createBonus(TypeValues.ROBOTS, 25)); bonuses.Add(ValueClass.createBonus(TypeValues.ECOLOGY, -7.5f)); break; case TypeBuild.FACTORY_3: bonuses.Add(ValueClass.createBonus(TypeValues.ROBOTS, 50)); bonuses.Add(ValueClass.createBonus(TypeValues.ECOLOGY, -25.0f)); break; case TypeBuild.ORGANIC_TREES: bonuses.Add(ValueClass.createBonus(TypeValues.MONET_ORGANIC, 10)); bonuses.Add(ValueClass.createBonus(TypeValues.ECOLOGY, 10.0f)); break; case TypeBuild.ORGANIC_GREENHOUSE: bonuses.Add(ValueClass.createBonus(TypeValues.MONET_ORGANIC, 5)); bonuses.Add(ValueClass.createBonus(TypeValues.ECOLOGY, 5.0f)); break; case TypeBuild.ORGANIC_BUSHES: bonuses.Add(ValueClass.createBonus(TypeValues.MONET_ORGANIC, 5)); bonuses.Add(ValueClass.createBonus(TypeValues.ECOLOGY, 3.0f)); break; case TypeBuild.LABARATORY: bonuses.Add(ValueClass.createBonus(TypeValues.UPGRADE, 1)); break; default: throw new ArgumentOutOfRangeException(nameof(type_build), type_build, null); } return(bonuses); }
/// <summary> /// Copys the weights and offsets of another Cell so a new input can return an value with this /// cell culmative offsets and weights, for comaprrison purposes. /// </summary> /// <param name="copy"></param> public void CopyCell(Cell copy) { for (int i = 0; i < 2; i++) { for (int f = 0; f < 2; f++) { values[i, f] = new ValueClass(values[i, f].value, values[i, f].weight); for (int r = 0; r < valuesTested; r++) { offsetValues[i, f, r] = new ValueClass(offsetValues[i, f, r].value, offsetValues[i, f, r].weight); } if (!lastSection) { subCells[i, f].CopyCell(copy.subCells[i, f]); } } } }
public Cell() { values = new ValueClass[2, 2]; offsetValues = new ValueClass[2, 2, valuesTested]; lastPickedCell = new bool[2, 2]; //START SECTION FILL ALL VALUES WITH 0.0 for (int i = 0; i < values.GetLength(0); i++) { for (int f = 0; f < values.GetLength(1); f++) { values[i, f] = new ValueClass(0, 0.0); for (int offsets = 0; offsets < valuesTested; offsets++) { offsetValues[i, f, offsets] = new ValueClass(offsets, 0.0); } } } }
{/*This program contains a class and a structure assigning values to member variables.*/ static void Main(string[] args) { int value1, value2; Console.WriteLine("Enter values:"); value1 = int.Parse(Console.ReadLine()); value2 = int.Parse(Console.ReadLine()); Value newValue = new Value(value1, value2); newValue.Show(); ValueClass newValue1 = new ValueClass(value1 + 10, value2 + 10); newValue1.Show(); SetData(newValue1, newValue); Console.ReadLine(); }
public void TwoDifferentButIdenticalItemsAreTreatedAsSame() { ValueClass item1 = new ValueClass() { Value = 15 }; ValueClass item2 = new ValueClass() { Value = 15 }; ISet <ValueClass> set = new HashSet <ValueClass>() { item1 }; Assert.IsTrue(set.Contains(item2)); }
internal virtual void MakeValueClass(ValueClass vClass) { typeIndex = PrimitiveType.ValueType.GetTypeIndex (); }
/// <summary> /// Radomly selects one of it's subsection's values and weights, adds it's own offsets, and return that value /// </summary> /// <returns>a random value and attatched weight, that has weight/1.0 chane of being selected</returns> public ValueClass GetCall() { double pickedWeight = 0.0; Random rand = new Random(); double[] weightTotal = new double[4]; ValueClass pickedValueClass = null; int count = 0; for (int i = 0; i < values.GetLength(0); i++) { for (int f = 0; f < values.GetLength(1); f++) { if (!lastSection) { values[i, f] = subCells[i, f].GetCall(); DebugWrite("Cell-> GetCall() -> Is Not Last Section", "Recursing is Done with value " + values[i, f].value, false); // Confirm recurrsion worked and got values } DebugWrite("Cell->GetCall()", "count is " + count + ", i,f weight values are " + values[i, f].weight, false); //Count isn't being adjusted too much, values are not null for (int v = count; v < weightTotal.Length; v++) { weightTotal[v] += values[i, f].weight; } count++; } } DebugWrite("Cell-> GetCall() -> All Cells", "Values top left " + values[0, 0].value + "," + values[0, 0].weight, false); //Confirm Cell's value DebugWrite("Cell-> GetCall() -> All Cells", "Values top right are " + values[0, 1].value + "," + values[0, 1].weight, false); //Confirm Cell's value DebugWrite("Cell-> GetCall() -> All Cells", "Values bottom left are " + values[1, 0].value + "," + values[1, 0].weight, false); //Confirm Cell's value DebugWrite("Cell-> GetCall() -> All Cells", "Values bottom right are " + values[1, 1].value + "," + values[1, 1].weight, false); //Confirm Cell's value double pickedNumber = (rand.NextDouble() + 1) % weightTotal[3]; for (int i = 0; i < weightTotal.Length; i++) { DebugWrite("Cell->GetCall()", "pickNumber is " + pickedNumber + ", weightTotal[i] is " + weightTotal[i] + ".", false); //See what range of numbers can be randomly picked from if (pickedNumber <= weightTotal[i]) { int x = 0; int y = 0; if (i < 2) { x = 0; y = i; } else { x = 1; y = i - 2; } lastPickedCell[x, y] = true; pickedValueClass = values[x, y]; DebugWrite("Cell->GetCall()-> Pick Made", "x,y is " + x + " " + y + "." + " and returned values are " + values[x, y].value + "," + values[x, y].weight, false); //See that there is a good spread of cells picked ValueClass returnValueClass = new ValueClass(pickedValueClass.value, pickedValueClass.weight); DebugWrite("Cell->GetCall()-> Pick Made", String.Format("offsetValues has lengths {0},{1},{2}", offsetValues.GetLength(0), offsetValues.GetLength(1), offsetValues.GetLength(2)), false);//See that the offset Array is valid returnValueClass.weight += this.offsetValues[x, y, returnValueClass.value].weight; i = weightTotal.Length + 1; pickedValueClass = returnValueClass; break; } } return(pickedValueClass); }
public void PropertyValueEquals() { var item1 = new ValueClass { Item1 = "value1", Item2 = 1, item3 = new ValueClass { Item1 = "value2", Item2 = 2, item3 = null } }; var item2 = new ValueClass { Item1 = "value1", Item2 = 1, item3 = new ValueClass { Item1 = "value2", Item2 = 2, item3 = null } }; var item3 = new ValueClass { Item1 = "value1", Item2 = 1, item3 = null }; var item4 = new ValueClass { Item1 = "value1", Item2 = 1, item3 = new ValueClass { Item1 = "value3", Item2 = 2, item3 = null } }; var item5 = new ValueClass { Item1 = "value1", Item2 = 1, item3 = new ValueClass { Item1 = "value2", Item2 = 2, item3 = new ValueClass() } }; var item6 = new ValueClass { Item1 = "value1", Item2 = 3, item3 = new ValueClass { Item1 = "value2", Item2 = 2, item3 = new ValueClass() } }; var item7 = new ValueClass { Item1 = "value2", Item2 = 2, item3 = null }; var item8 = new ValueClass { Item1 = "value3", Item2 = 2, item3 = null }; ValueClass item9 = null; ValueClass item10 = null; item9.PropertyValueEquals(item10).IsTrue(); item7.PropertyValueEquals(item8).IsFalse(); item1.PropertyValueEquals(item2).IsTrue(); item1.PropertyValueEquals(item3).IsFalse(); item1.PropertyValueEquals(item5).IsFalse(); item1.PropertyValueEquals(item6).IsFalse(); item1.PropertyValueEquals(item4).IsFalse(); }
public ErrorValueStruct(ValueClass <T> value) => Value = value.Value;
public void SetUp() { _assigner = new ArgAssigner(); _valueClass = new ValueClass(); }
public ErrorValueClass(ValueClass <T> value) => Value = value.Value;
/// <summary> /// Add a class which extends System.ValueType to this module /// </summary> /// <param name="attrSet">attributes of this class</param> /// <param name="nsName">name space name</param> /// <param name="name">class name</param> /// <returns>a descriptor for this new class</returns> public ClassDef AddValueClass(TypeAttr attrSet, string nsName, string name, ValueClass vClass) { ClassDef aClass = new ClassDef(attrSet,nsName,name,metaData); aClass.MakeValueClass(vClass); aClass.SetTypeIndex (PrimitiveType.ValueType.GetTypeIndex ()); metaData.AddToTable(MDTable.TypeDef,aClass); return aClass; }
public void init(ValueClass value_class) { img.sprite = Const.getSpriteValue(value_class.type_values); txt_count.text = value_class.value.ToString(); }
/// <summary> /// Add a class which extends System.ValueType to this module /// </summary> /// <param name="attrSet">attributes of this class</param> /// <param name="nsName">name space name</param> /// <param name="name">class name</param> /// <returns>a descriptor for this new class</returns> public ClassDef AddValueClass(TypeAttr attrSet, string nsName, string name, ValueClass vClass) { ClassDef aClass = new ClassDef(attrSet,nsName,name,metaData); if (!ClassDef.IsValueType (nsName, name) && !ClassDef.IsEnum (nsName, name)) { aClass.MakeValueClass(vClass); } else { if (ClassDef.IsEnum (nsName, name)) aClass.SetSuper (metaData.mscorlib.ValueType ()); else aClass.SetSuper (metaData.mscorlib.GetSpecialSystemClass (PrimitiveType.Object)); metaData.mscorlib.SetSpecialSystemClass (nsName, name, aClass); } aClass.SetTypeIndex (PrimitiveType.ValueType.GetTypeIndex ()); metaData.AddToTable(MDTable.TypeDef,aClass); return aClass; }
internal override void MakeValueClass(ValueClass vClass) { if (vClass == ValueClass.Enum) superType = metaData.mscorlib.EnumType(); else superType = metaData.mscorlib.ValueType(); typeIndex = PrimitiveType.ValueType.GetTypeIndex (); }
protected bool Equals(ValueClass other) { return(string.Equals(Value, other.Value)); }
private Statement ParseLuisResult(SimpleModel luisResult) { SimpleModel._Entities Entities = luisResult.Entities; ValueClass firstValue = Entities.value?.FirstOrDefault(); string subject = Entities.subject?.FirstOrDefault(); string property = Entities.obj?.FirstOrDefault(); bool negated = Entities.negate?.FirstOrDefault() != null; bool bigger = Entities.bigger?.FirstOrDefault() != null; bool smaller = Entities.smaller?.FirstOrDefault() != null; bool multipleValues = false; bool dateValues = false; string[] values = { Entities.datetime?.FirstOrDefault()?.Expressions?.FirstOrDefault() ?? firstValue?.geography?.FirstOrDefault()?.ToString() ?? firstValue?.number?.FirstOrDefault().ToString() ?? firstValue?.personName?.FirstOrDefault() ?? firstValue?.text?.FirstOrDefault() }; if (firstValue != null && (firstValue?.date != null || Entities?.datetime != null && firstValue.isEmpty())) { dateValues = true; } if (Entities?.around?.FirstOrDefault() != null) { List <string> vals = new List <string>(); if (dateValues) { var dateString = Entities.datetime?.FirstOrDefault()?.Expressions?.FirstOrDefault() ?? Entities?.datetime?.FirstOrDefault()?.Expressions?.FirstOrDefault(); if (!DateTime.TryParse(dateString, out DateTime date)) { throw new Exception("Can't convert the given string to DateTime!"); } vals.Add(date.AddYears(-1).ToShortDateString()); vals.Add(date.AddYears(1).ToShortDateString()); } else { vals.Add((firstValue?.number?.First() * 0.8).ToString()); vals.Add((firstValue?.number?.First() * 1.2).ToString()); } values = vals.ToArray(); multipleValues = true; } else if (Entities?.between?.FirstOrDefault() != null || dateValues) { List <string> vals = new List <string>(); if (dateValues) { var dateStrings = Entities.datetime?.FirstOrDefault()?.Expressions ?? Entities?.datetime?.FirstOrDefault()?.Expressions.FirstOrDefault().Split(","); if (dateStrings.Count > 1) { vals.Add(dateStrings.First().Remove(0, 1)); vals.Add(dateStrings[1]); } else { vals.Add(dateStrings.First()); } } else { vals.Add((firstValue?.number?.First()).ToString()); vals.Add((firstValue?.number?.Last()).ToString()); } if (vals.Count > 1) { multipleValues = true; } values = vals.ToArray(); } string optionalNegate = negated ? "not " : ""; string optionalSmallerBigger = smaller ? "smaller than " : (bigger ? "bigger than " : ""); string optionalBetween = multipleValues ? "between " : ""; string optionalSecondValue = multipleValues ? " and " + values.LastOrDefault() : ""; return(new Statement { Subject = subject, Property = property, Negated = negated, Bigger = bigger, Smaller = smaller, Value = values, MultipleValues = multipleValues, DateValues = dateValues, Text = $"{ property }: { optionalNegate }{ optionalSmallerBigger }{ optionalBetween }{ values.FirstOrDefault() }{ optionalSecondValue }", ResponseText = $"Recognised {property}: {optionalNegate}{optionalSmallerBigger}{optionalBetween}{values.FirstOrDefault()}{optionalSecondValue}." + Environment.NewLine + $"You can continue adding constraints, or try executing the query!" }); }