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!"
});
}
