public void ChangeSizeOfLastDimension()
{
//we don't use interface because want to check stride
var array = new MultiDimensionalArray();
array.Resize(2, 1);
array[0, 0] = 1; // 0 + 0
array[1, 0] = 2; // 2 + 0
// 1 1 <= stride
Assert.AreEqual(new[] { 1, 1 }, array.Stride);
log.InfoFormat("Before resize: {0}", array.ToString());
array.Resize(new[] { 2, 2 });
log.InfoFormat("After resize: {0}", array.ToString());
Assert.AreEqual(2, array.Rank);
Assert.AreEqual(4, array.Count);
Assert.AreEqual(1, array[0, 0]);
Assert.AreEqual(2, array[1, 0]);
Assert.IsNull(array[0, 1]);
Assert.IsNull(array[1, 1]);
}
public void ChangeSizeOfLastDimension()
{
//we don't use interface because want to check stride
var array = new MultiDimensionalArray();
array.Resize(2, 1);
array[0, 0] = 1; // 0 + 0
array[1, 0] = 2; // 2 + 0
// 1 1 <= stride
Assert.AreEqual(new[] { 1, 1 }, array.Stride);
log.InfoFormat("Before resize: {0}", array.ToString());
array.Resize(new[] { 2, 2 });
log.InfoFormat("After resize: {0}", array.ToString());
Assert.AreEqual(2, array.Rank);
Assert.AreEqual(4, array.Count);
Assert.AreEqual(1, array[0, 0]);
Assert.AreEqual(2, array[1, 0]);
Assert.IsNull(array[0, 1]);
Assert.IsNull(array[1, 1]);
}
public void IncreaseNumberOfDimensions()
{
IMultiDimensionalArray array = new MultiDimensionalArray();
array.Resize(2, 2);
array[0, 0] = 5;
array[1, 1] = 2;
//add an extra dimension
array.Resize(new[] { 2, 2, 4 });
//now we expect the values to be set for the index 0 of this 3rd dimension
Assert.AreEqual(5, array[0, 0, 0]);
Assert.AreEqual(null, array[0, 0, 1]);
Assert.AreEqual(2, array[1, 1, 0]);
Assert.AreEqual(null, array[1, 1, 1]);
}
public void DecreaseNumberOfDimensions()
{
IMultiDimensionalArray array = new MultiDimensionalArray();
array.Resize(2, 2);
array[0, 0] = 5;
array[1, 1] = 2;
//drop one dimensions
array.Resize(new[] { 2 });
//now we expect the values to be taken from dimidx 0 of the removed dimension
Assert.AreEqual(5, array[0]);
Assert.AreEqual(null, array[1]);
}
public void StrideCalculation()
{
IMultiDimensionalArray array = new MultiDimensionalArray();
array.Resize(1, 2);
Assert.AreEqual(new[] { 2, 1 }, array.Stride);
}
public void PerformanceChangeSizeOfFirstDimensions_WithoutEvents()
{
DateTime t = DateTime.Now;
// increasing the 1st dimension should be fast.
// For example when we add a new measurement for a 3x3 grid
IMultiDimensionalArray array = new MultiDimensionalArray <int>(0, 5, 5);
array.FireEvents = false;
//add more data throught and increase the 1st dimenion-size
const int valuesToAdd = 100000;
for (int i = 0; i < valuesToAdd; i++)
{
array.Resize(new[] { i + 1, 5, 5 });
array[i, 1, 1] = 5; //everywhere a five.
}
double dt = DateTime.Now.Subtract(t).TotalMilliseconds;
Assert.Less(dt, 300);
log.DebugFormat("Added {0} values in {1} ms", valuesToAdd, dt);
for (int i = 0; i < valuesToAdd - 1; i++)
{
Assert.AreEqual(5, array[i, 1, 1]);
}
}
public void CollectionChangedEventArgsIndexes()
{
IMultiDimensionalArray array = new MultiDimensionalArray(1, 2, 2);
int callCount = 0;
array.CollectionChanged += delegate(object sender, NotifyCollectionChangedEventArgs e)
{
var args = (MultiDimensionalArrayChangedEventArgs)e;
switch (callCount++)
{
case 0: Assert.IsTrue(new[] { 1, 0, 0 }.SequenceEqual(args.MultiDimensionalIndex));
break;
case 1: Assert.IsTrue(new[] { 1, 0, 1 }.SequenceEqual(args.MultiDimensionalIndex));
break;
case 2: Assert.IsTrue(new[] { 1, 1, 0 }.SequenceEqual(args.MultiDimensionalIndex));
break;
case 3: Assert.IsTrue(new[] { 1, 1, 1 }.SequenceEqual(args.MultiDimensionalIndex));
break;
}
};
array.Resize(new[] { 2, 2, 2 });
}
public void AddEmptyDimensionToArray()
{
IMultiDimensionalArray <double> array = new MultiDimensionalArray <double>(2, 2);
array.Resize(2, 2, 0);
Assert.AreEqual(0, array.Count);
}
public void StrideCalculation2()
{
IMultiDimensionalArray array = new MultiDimensionalArray();
// create grid 2 rows and 6 colums
array.Resize(2, 6);
// cost to move 1 column, 1 row
Assert.AreEqual(new[] { 6, 1 }, array.Stride);
}
public void DefaultValueForValueTypes()
{
IMultiDimensionalArray <int> array = new MultiDimensionalArray <int> {
DefaultValue = 99
};
array.Resize(2, 2);
Assert.AreEqual(99, array[1, 1]);
}
public void DefaultValueForReferenceTypes()
{
IMultiDimensionalArray <string> array = new MultiDimensionalArray <string> {
DefaultValue = "dummy"
};
array.Resize(2, 2);
Assert.AreEqual("dummy", array[1, 1]);
}
public void ResizeParentAndUpdateShapeOfSubArray()
{
//create a 2D grid of 3x3
IMultiDimensionalArray array = new MultiDimensionalArray(3, 3);
//select rows [1, 2). So skip the first row
IMultiDimensionalArray subArray = array.Select(0, 1, int.MaxValue);
Assert.IsTrue(subArray.Shape.SequenceEqual(new[] { 2, 3 }));
//resize the parent. Add one row and one column. Check the shape of the subArray changes
array.Resize(new[] { 4, 4 });
Assert.IsTrue(subArray.Shape.SequenceEqual(new[] { 3, 4 }));
}
public void CollectionChangeEvents_Enlarge2()
{
IMultiDimensionalArray array = new MultiDimensionalArray(2, 2);
int collectionChangingEventCount = 0;
int collectionChangedEventCount = 0;
array.CollectionChanging += delegate { collectionChangingEventCount++; };
array.CollectionChanged += delegate { collectionChangedEventCount++; };
array.Resize(2, 3);
Assert.AreEqual(2, collectionChangingEventCount);
Assert.AreEqual(2, collectionChangedEventCount);
}
public void ChangeSizeOfFirstDimension()
{
IMultiDimensionalArray array = new MultiDimensionalArray();
array.Resize(1, 2);
array[0, 0] = 1; // 0 + 0
array[0, 1] = 2; // 0 + 1
// 2 1 <= stride
log.InfoFormat("Before resize: {0}", array.ToString());
array.Resize(new[] { 2, 2 });
log.InfoFormat("After resize: {0}", array.ToString());
Assert.AreEqual(2, array.Rank);
Assert.AreEqual(4, array.Count);
Assert.AreEqual(1, array[0, 0]);
Assert.AreEqual(2, array[0, 1]);
Assert.IsNull(array[1, 0]);
Assert.IsNull(array[1, 1]);
}
public void ChangeSizeOfFirstDimension()
{
IMultiDimensionalArray array = new MultiDimensionalArray();
array.Resize(1, 2);
array[0, 0] = 1; // 0 + 0
array[0, 1] = 2; // 0 + 1
// 2 1 <= stride
log.InfoFormat("Before resize: {0}", array.ToString());
array.Resize(new[] { 2, 2 });
log.InfoFormat("After resize: {0}", array.ToString());
Assert.AreEqual(2, array.Rank);
Assert.AreEqual(4, array.Count);
Assert.AreEqual(1, array[0, 0]);
Assert.AreEqual(2, array[0, 1]);
Assert.IsNull(array[1, 0]);
Assert.IsNull(array[1, 1]);
}
public void InsertAtRemoveAt()
{
IMultiDimensionalArray array = new MultiDimensionalArray();
array.Resize(2, 2);
array[0, 0] = 5;
array[1, 1] = 2;
array.InsertAt(0, 2);
log.Info(array.ToString());
array.RemoveAt(0, 2);
log.Info(array.ToString());
array.InsertAt(0, 2);
log.Info(array.ToString());
array.RemoveAt(0, 2);
log.Info(array.ToString());
}
public void Bind2D()
{
IMultiDimensionalArray array = new MultiDimensionalArray();
array.Resize(2, 2);
array[0, 0] = 5;
array[1, 1] = 2;
DataGridView gridView = new DataGridView();
MultiDimensionalArrayBindingList multiDimensionalArrayBindingList = new MultiDimensionalArrayBindingList(array);
gridView.DataSource = multiDimensionalArrayBindingList;
Form form = new Form();
gridView.Dock = DockStyle.Fill;
form.Controls.Add(gridView);
WindowsFormsTestHelper.ShowModal(form);
}
public void ResizeArrayResizesInternalValues()
{
//reduce size by 1
IMultiDimensionalArray <int> array = new MultiDimensionalArray <int>(2);
array[0] = 2;
array[1] = 3;
array.Resize(1);
var values = TypeUtils.GetField <MultiDimensionalArray, IList>(array, "values");
Assert.AreEqual(1, values.Count);
//clear the whole thing
array = new MultiDimensionalArray <int>(2);
array[0] = 2;
array[1] = 3;
array.Resize(0);
values = TypeUtils.GetField <MultiDimensionalArray, IList>(array, "values");
Assert.AreEqual(0, values.Count);
}
public void ShapeCalculationWithStartAndEndOffset()
{
IMultiDimensionalArray array = new MultiDimensionalArray(3, 3);
//skip first element in both dimensions
IMultiDimensionalArrayView subArray = new MultiDimensionalArrayView(array);
subArray.OffsetStart[0] = 1;
subArray.OffsetStart[1] = 1;
Assert.IsTrue(subArray.Shape.SequenceEqual(new int[2] {
2, 2
}));
//skip last element for both dimensions
subArray = new MultiDimensionalArrayView(array);
subArray.OffsetEnd[0] = 1;
subArray.OffsetEnd[1] = 1;
Assert.IsTrue(subArray.Shape.SequenceEqual(new int[2] {
2, 2
}));
//skip last and first element for both dimensions
subArray = new MultiDimensionalArrayView(array);
subArray.OffsetEnd[0] = 1;
subArray.OffsetEnd[1] = 1;
subArray.OffsetStart[0] = 1;
subArray.OffsetStart[1] = 1;
Assert.IsTrue(subArray.Shape.SequenceEqual(new int[2] {
1, 1
}));
//skip first element in both dimensions and resize parent
subArray = new MultiDimensionalArrayView(array);
subArray.OffsetStart[0] = 1;
subArray.OffsetStart[1] = 1;
//resize the parent array
array.Resize(new[] { 4, 4 });
Assert.IsTrue(subArray.Shape.SequenceEqual(new int[2] {
3, 3
}));
}
public void Bind2D()
{
IMultiDimensionalArray array = new MultiDimensionalArray();
array.Resize(2, 2);
array[0, 0] = 5;
array[1, 1] = 2;
DataGridView gridView = new DataGridView();
MultiDimensionalArrayBindingList multiDimensionalArrayBindingList = new MultiDimensionalArrayBindingList(array);
gridView.DataSource = multiDimensionalArrayBindingList;
Form form = new Form();
gridView.Dock = DockStyle.Fill;
form.Controls.Add(gridView);
WindowsFormsTestHelper.ShowModal(form);
}
public void ResizeFirstDimensionValuesChanged()
{
IMultiDimensionalArray <int> multiDimensionalArray = new MultiDimensionalArray <int>(1);
int callCount = 0;
multiDimensionalArray.CollectionChanged +=
delegate { callCount++; };
multiDimensionalArray.Resize(2);
Assert.AreEqual(1, callCount);
//resize a more dimensional array
multiDimensionalArray = new MultiDimensionalArray <int>(new List <int> {
1, 2, 3, 4
}, new[] { 2, 2 });
multiDimensionalArray.CollectionChanged +=
delegate { callCount++; };
callCount = 0;
//generate two change events
multiDimensionalArray.Resize(3, 2);
Assert.AreEqual(2, callCount);
}
public void ResizeArrayResizesInternalValues()
{
//reduce size by 1
IMultiDimensionalArray<int> array = new MultiDimensionalArray<int>(2);
array[0] = 2;
array[1] = 3;
array.Resize(1);
var values = TypeUtils.GetField<MultiDimensionalArray, IList>(array, "values");
Assert.AreEqual(1, values.Count);
//clear the whole thing
array = new MultiDimensionalArray<int>(2);
array[0] = 2;
array[1] = 3;
array.Resize(0);
values = TypeUtils.GetField<MultiDimensionalArray, IList>(array, "values");
Assert.AreEqual(0, values.Count);
}
public void PerformanceChangeSizeOfFirstDimensions_WithoutEvents()
{
DateTime t = DateTime.Now;
// increasing the 1st dimension should be fast.
// For example when we add a new measurement for a 3x3 grid
IMultiDimensionalArray array = new MultiDimensionalArray<int>(0, 5, 5);
array.FireEvents = false;
//add more data throught and increase the 1st dimenion-size
const int valuesToAdd = 100000;
for (int i = 0; i < valuesToAdd; i++)
{
array.Resize(new[] { i + 1, 5, 5 });
array[i, 1, 1] = 5; //everywhere a five.
}
double dt = DateTime.Now.Subtract(t).TotalMilliseconds;
Assert.Less(dt, 300);
log.DebugFormat("Added {0} values in {1} ms", valuesToAdd, dt);
for (int i = 0; i < valuesToAdd - 1; i++)
{
Assert.AreEqual(5, array[i, 1, 1]);
}
}
public void PerformanceChangeSizeOfFirstDimensions_WithoutEvents()
{
// increasing the 1st dimension should be fast.
// For example when we add a new measurement for a 3x3 grid
IMultiDimensionalArray array = new MultiDimensionalArray<int>(0, 5, 5);
array.FireEvents = false;
//add more data throught and increase the 1st dimenion-size
const int valuesToAdd = 100000;
Action action = delegate
{
for (int i = 0; i < valuesToAdd; i++)
{
array.Resize(new[] {i + 1, 5, 5});
array[i, 1, 1] = 5; //everywhere a five.
}
};
TestHelper.AssertIsFasterThan(325, action);
for (int i = 0; i < valuesToAdd - 1; i++)
{
Assert.AreEqual(5, array[i, 1, 1]);
}
}
public void StrideCalculation2()
{
IMultiDimensionalArray array = new MultiDimensionalArray();
// create grid 2 rows and 6 colums
array.Resize(2, 6);
// cost to move 1 column, 1 row
Assert.AreEqual(new[] { 6, 1 }, array.Stride);
}
public void ResizeParentAndUpdateShapeOfSubArray()
{
//create a 2D grid of 3x3
IMultiDimensionalArray array = new MultiDimensionalArray(3, 3);
//select rows [1, 2). So skip the first row
IMultiDimensionalArray subArray = array.Select(0, 1, int.MaxValue);
Assert.IsTrue(subArray.Shape.SequenceEqual(new[] {2, 3}));
//resize the parent. Add one row and one column. Check the shape of the subArray changes
array.Resize(new[] {4, 4});
Assert.IsTrue(subArray.Shape.SequenceEqual(new[] {3, 4}));
}
public void DefaultValueForReferenceTypes()
{
IMultiDimensionalArray<string> array = new MultiDimensionalArray<string> { DefaultValue = "dummy" };
array.Resize(2, 2);
Assert.AreEqual("dummy", array[1, 1]);
}
public void DefaultValueForValueTypes()
{
IMultiDimensionalArray<int> array = new MultiDimensionalArray<int> { DefaultValue = 99 };
array.Resize(2, 2);
Assert.AreEqual(99, array[1, 1]);
}
public void CollectionChangeEvents_Shrink()
{
IMultiDimensionalArray array = new MultiDimensionalArray(2, 2);
int collectionChangingEventCount = 0;
int collectionChangedEventCount = 0;
array.CollectionChanging += delegate { collectionChangingEventCount++; };
array.CollectionChanged += delegate { collectionChangedEventCount++; };
array.Resize(1);
Assert.AreEqual(3, collectionChangingEventCount);
Assert.AreEqual(3, collectionChangedEventCount);
}
public void DecreaseNumberOfDimensions()
{
IMultiDimensionalArray array = new MultiDimensionalArray();
array.Resize(2, 2);
array[0, 0] = 5;
array[1, 1] = 2;
//drop one dimensions
array.Resize(new[] { 2 });
//now we expect the values to be taken from dimidx 0 of the removed dimension
Assert.AreEqual(5, array[0]);
Assert.AreEqual(null, array[1]);
}
public void CollectionChangedEventArgsIndexes()
{
IMultiDimensionalArray array = new MultiDimensionalArray(1, 2, 2);
int callCount = 0;
array.CollectionChanged += delegate(object sender, NotifyCollectionChangedEventArgs e)
{
var args = (MultiDimensionalArrayChangedEventArgs)e;
switch (callCount++)
{
case 0: Assert.IsTrue(new[] { 1, 0, 0 }.SequenceEqual(args.MultiDimensionalIndex));
break;
case 1: Assert.IsTrue(new[] { 1, 0, 1 }.SequenceEqual(args.MultiDimensionalIndex));
break;
case 2: Assert.IsTrue(new[] { 1, 1, 0 }.SequenceEqual(args.MultiDimensionalIndex));
break;
case 3: Assert.IsTrue(new[] { 1, 1, 1 }.SequenceEqual(args.MultiDimensionalIndex));
break;
}
};
array.Resize(new[] { 2, 2, 2 });
}
[NUnit.Framework.Category(TestCategory.WorkInProgress)] //not required yet?
public void InsertOneRowInEmptyMatrix()
{
IMultiDimensionalArray array = new MultiDimensionalArray(2,2);
array.Clear();
array.Resize(2,2);
array.InsertAt(0, 0, 2, new List<double> { 1.0, 2.0 });
Assert.AreEqual(array[0, 0], 1.0);
Assert.AreEqual(array[1, 0], 2.0);
}
public void ResizeFirstDimensionValuesChanged()
{
IMultiDimensionalArray<int> multiDimensionalArray = new MultiDimensionalArray<int>(1);
int callCount = 0;
multiDimensionalArray.CollectionChanged +=
delegate { callCount++; };
multiDimensionalArray.Resize(2);
Assert.AreEqual(1, callCount);
//resize a more dimensional array
multiDimensionalArray = new MultiDimensionalArray<int>(new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }, new[] { 2, 5 });
multiDimensionalArray.CollectionChanged +=
delegate (object sender, MultiDimensionalArrayChangingEventArgs args)
{
callCount++;
Assert.AreEqual(5, args.Items.Count);
};
callCount = 0;
//generate two change events
multiDimensionalArray.Resize(3, 5);
Assert.AreEqual(1, callCount);
}
public void ResizeFirstDimensionValuesChanged()
{
IMultiDimensionalArray<int> multiDimensionalArray = new MultiDimensionalArray<int>(1);
int callCount = 0;
multiDimensionalArray.CollectionChanged +=
delegate { callCount++; };
multiDimensionalArray.Resize(2);
Assert.AreEqual(1, callCount);
//resize a more dimensional array
multiDimensionalArray = new MultiDimensionalArray<int>(new List<int> { 1, 2, 3, 4 }, new[] { 2, 2 });
multiDimensionalArray.CollectionChanged +=
delegate { callCount++; };
callCount = 0;
//generate two change events
multiDimensionalArray.Resize(3, 2);
Assert.AreEqual(2, callCount);
}
public void IncreaseNumberOfDimensions()
{
IMultiDimensionalArray array = new MultiDimensionalArray();
array.Resize(2, 2);
array[0, 0] = 5;
array[1, 1] = 2;
//add an extra dimension
array.Resize(new[] { 2, 2, 4 });
//now we expect the values to be set for the index 0 of this 3rd dimension
Assert.AreEqual(5, array[0, 0, 0]);
Assert.AreEqual(null, array[0, 0, 1]);
Assert.AreEqual(2, array[1, 1, 0]);
Assert.AreEqual(null, array[1, 1, 1]);
}
public void StrideCalculation()
{
IMultiDimensionalArray array = new MultiDimensionalArray();
array.Resize(1, 2);
Assert.AreEqual(new[] { 2, 1 }, array.Stride);
}
public void UnsubscribePropertyChangesAfterResize()
{
var testNotifyPropertyChangedObject = new TestNotifyPropertyChangedObject();
IMultiDimensionalArray<TestNotifyPropertyChangedObject> array = new MultiDimensionalArray<TestNotifyPropertyChangedObject>
{
IsAutoSorted = false
};
array.Add(testNotifyPropertyChangedObject);
array.Resize(new[] {2, 2});
Assert.AreEqual(1, testNotifyPropertyChangedObject.GetNumPropertyChangedSubscriptions(), "num property subscriptions");
}
public void Resize()
{
IMultiDimensionalArray<int> array = new MultiDimensionalArray<int>();
array.Resize(new[] { 3 });
}
public void InsertAtRemoveAt()
{
IMultiDimensionalArray array = new MultiDimensionalArray();
array.Resize(2, 2);
array[0, 0] = 5;
array[1, 1] = 2;
array.InsertAt(0, 2);
log.Info(array.ToString());
array.RemoveAt(0, 2);
log.Info(array.ToString());
array.InsertAt(0, 2);
log.Info(array.ToString());
array.RemoveAt(0, 2);
log.Info(array.ToString());
}
public void ShapeCalculationWithStartAndEndOffset()
{
IMultiDimensionalArray array = new MultiDimensionalArray(3, 3);
//skip first element in both dimensions
IMultiDimensionalArrayView subArray = new MultiDimensionalArrayView(array);
subArray.OffsetStart[0] = 1;
subArray.OffsetStart[1] = 1;
Assert.IsTrue(subArray.Shape.SequenceEqual(new int[2] {2, 2}));
//skip last element for both dimensions
subArray = new MultiDimensionalArrayView(array);
subArray.OffsetEnd[0] = 1;
subArray.OffsetEnd[1] = 1;
Assert.IsTrue(subArray.Shape.SequenceEqual(new int[2] {2, 2}));
//skip last and first element for both dimensions
subArray = new MultiDimensionalArrayView(array);
subArray.OffsetEnd[0] = 1;
subArray.OffsetEnd[1] = 1;
subArray.OffsetStart[0] = 1;
subArray.OffsetStart[1] = 1;
Assert.IsTrue(subArray.Shape.SequenceEqual(new int[2] {1, 1}));
//skip first element in both dimensions and resize parent
subArray = new MultiDimensionalArrayView(array);
subArray.OffsetStart[0] = 1;
subArray.OffsetStart[1] = 1;
//resize the parent array
array.Resize(new[] {4, 4});
Assert.IsTrue(subArray.Shape.SequenceEqual(new int[2] {3, 3}));
}
public void AddEmptyDimensionToArray()
{
IMultiDimensionalArray<double> array = new MultiDimensionalArray<double>(2, 2);
array.Resize(2, 2, 0);
Assert.AreEqual(0, array.Count);
}
public void Resize()
{
IMultiDimensionalArray <int> array = new MultiDimensionalArray <int>();
array.Resize(new[] { 3 });
}
public void ReadOnlyResize()
{
var array = new MultiDimensionalArray(true, false, 1, new[] { 1 }, new[] { 1 });
array.Resize(new[]{2,2});
}
public void ResizeFirstDimension()
{
IMultiDimensionalArray<int> array = new MultiDimensionalArray<int>();
array.Resize(1);
}
public void PerformanceChangeSizeOfFirstDimensions_WithEvents()
{
const int valuesToAdd = 100000;
// increasing the 1st dimension should be fast.
// For example when we add a new measurement for a 3x3 grid
IMultiDimensionalArray array = new MultiDimensionalArray(0, 5, 5);
array.CollectionChanged += delegate { };
Action action = delegate
{
//add more data throught and increase the 1st dimenion-size
for (int i = 0; i < valuesToAdd; i++)
{
array.Resize(new[] {i + 1, 5, 5});
array[i, 1, 1] = 5; //everywhere a five.
}
};
TestHelper.AssertIsFasterThan(550, "Added" + valuesToAdd + " values", action);
}
