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 SelectOnMultipleIndexes()
{
// more complex example (isn't it another test?)
var array = new MultiDimensionalArray(3, 3);
// 1 9 2 1 2
// 9 9 9 ==>
// 3 9 4 3 4
array[0, 0] = 1;
array[0, 1] = 9;
array[0, 2] = 2;
array[1, 0] = 9;
array[1, 1] = 9;
array[1, 2] = 9;
array[2, 0] = 3;
array[2, 1] = 9;
array[2, 2] = 4;
IMultiDimensionalArrayView view = array.Select(0, new[] { 0, 2 }).Select(1, new[] { 0, 2 });
Assert.IsTrue(new[] { 2, 2 }.SequenceEqual(view.Shape));
Assert.AreEqual(4, view.Count);
Assert.AreEqual(1, view[0, 0]);
Assert.AreEqual(2, view[0, 1]);
Assert.AreEqual(3, view[1, 0]);
Assert.AreEqual(4, view[1, 1]);
}
public void MoveValuesToStart()
{
var values = new List <int> {
1, 2, 3, 4, 5
};
var array = new MultiDimensionalArray <int>(values, new[] { 5 });
// move 2nd dimension index
var dimension = 0;
var startIndex = 3;
var length = 2;
var newIndex = 0;
int callCount = 0;
array.CollectionChanged += delegate
{
callCount++;
};
array.Move(dimension, startIndex, length, newIndex);
Assert.AreEqual(new[] { 4, 5, 1, 2, 3 }, array);
//every value changed
Assert.AreEqual(5, callCount);
}
public void ReduceBeforeAddingValuesAndGetValuesAfterwards()
{
var array = new MultiDimensionalArray(3, 3);
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
array[i, j] = i * 3 + j;
}
}
var subArray = new MultiDimensionalArrayView(array);
subArray.SelectedIndexes[0] = new int[] { 3 }; //set non-existent index
subArray.Reduce[0] = true; //try to reduce the first dimension
//we can't get any values
subArray.Count.Should("Count should be 0").Be.EqualTo(0);
foreach (var value in subArray)
{
throw new ExpectationViolationException("Shouldn't return any values");
}
//add the index the view is looking for
array.InsertAt(0, 3);
array[3, 0] = 9;
array[3, 1] = 10;
array[3, 2] = 11;
//and now we can get values
subArray.Count.Should("Count should be 3").Be.EqualTo(3);
int actualCount = subArray.Cast <object>().Count();
actualCount.Should("Actual count should be 3").Be.EqualTo(3);
}
public void ToString()
{
var source = new MultiDimensionalArray<int>(new List<int> { 1, 2, 3, 4, 5, 6 }, new[] { 2, 3 });
var target = new ConvertedArray<string, int>(source, Convert.ToInt32, Convert.ToString);
Assert.AreEqual("{{1, 2, 3}, {4, 5, 6}}", target.ToString());
}
public void ReduceOnWrongDimensionThrowsAnException()
{
var array = new MultiDimensionalArray(3, 3);
var subArray = array.Select(0, 0, 1);
subArray.Reduce[0] = true; //try to reduce the first dimension
}
public void ValuesConstructor()
{
IList <int> values = new List <int> {
1, 2, 3, 4
};
//first dimension has 1 element 2nd has 4
IMultiDimensionalArray <int> array = new MultiDimensionalArray <int>(values, new[] { 1, 4 });
Assert.AreEqual(4, array[0, 3]);
//first dimension has 4 elements 2nd has 1
array = new MultiDimensionalArray <int>(values, new[] { 4, 1 });
Assert.AreEqual(4, array[3, 0]);
//2x2
array = new MultiDimensionalArray <int>(values, new[] { 2, 2 });
Assert.AreEqual(4, array[1, 1]);
//3x2
values = new List <int> {
1, 2, 3, 4, 5, 6
};
array = new MultiDimensionalArray <int>(values, new[] { 2, 3 });
Assert.AreEqual(4, array[1, 0]);
}
public void StrideCalculation()
{
IMultiDimensionalArray array = new MultiDimensionalArray();
array.Resize(1, 2);
Assert.AreEqual(new[] { 2, 1 }, array.Stride);
}
public void ReduceArray()
{
// create a 2D grid and slice rows and columns
// 1 2 3
// 4 5 6
// 7 8 9
IMultiDimensionalArray array = new MultiDimensionalArray(3, 3);
array[0, 0] = 1;
array[0, 1] = 2;
array[0, 2] = 3;
array[1, 0] = 4;
array[1, 1] = 5;
array[1, 2] = 6;
array[2, 0] = 7;
array[2, 1] = 8;
array[2, 2] = 9;
//create a reduced array containing the first row
var view = array.Select(0, 0, 0);
view.Reduce[0] = true; //reduce the x dimension
Assert.AreEqual(1, view.Rank);
Assert.AreEqual(new[] { 3 }, view.Shape);
Assert.AreEqual(2, view[1]);
}
public void Create()
{
IMultiDimensionalArray array = new MultiDimensionalArray(new[] { 2, 2 });
array[0, 0] = 1;
array[0, 1] = 2;
array[1, 0] = 3;
array[1, 1] = 4;
IMultiDimensionalArrayView view = new MultiDimensionalArrayView();
view.Parent = array;
//why not same?? If i resize parent i do expect the subarray to be resize as well.
//the values should be the same but not the reference
Assert.AreNotSame(array.Shape, view.Shape);
Assert.IsTrue(view.Shape.SequenceEqual(array.Shape));
Assert.AreEqual(array.Count, view.Count);
Assert.AreEqual(array.Rank, view.Rank);
Assert.AreEqual(array.DefaultValue, view.DefaultValue);
//subArray should have offsetStarts of MinValue and offsetEnds as MaxValue
//so it will resize along with the parent
Assert.IsTrue(view.OffsetStart.SequenceEqual(new[] { int.MinValue, int.MinValue }));
Assert.IsTrue(view.OffsetEnd.SequenceEqual(new[] { int.MaxValue, int.MaxValue }));
//assert values are equal
Assert.AreEqual(array[0, 0], view[0, 0]);
Assert.AreEqual(array[0, 1], view[0, 1]);
Assert.AreEqual(array[1, 0], view[1, 0]);
Assert.AreEqual(array[1, 1], view[1, 1]);
}
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 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 SetValuesOfAWrongTypeGivesException()
{
IMultiDimensionalArray <DateTime> array = new MultiDimensionalArray <DateTime>();
array.Add(DateTime.Now);
((IList)array)[0] = 1; // <-- exception
}
public void AddEmptyDimensionToArray()
{
IMultiDimensionalArray <double> array = new MultiDimensionalArray <double>(2, 2);
array.Resize(2, 2, 0);
Assert.AreEqual(0, array.Count);
}
public void InvalidNumberOfIndexesException()
{
IMultiDimensionalArray array = new MultiDimensionalArray(3, 3);
//try to use wrong index for accessing
array[0, 0, 0] = 5;
}
public void TestNotifyCollectionChanged()
{
var sourceArray = new MultiDimensionalArray <int>(2, 2);
IMultiDimensionalArray <int> array =
new LazyMultiDimensionalArray <int>(() =>
sourceArray, () => sourceArray.Count);
bool called = false;
EventHandler <MultiDimensionalArrayChangingEventArgs> arrayOnCollectionChanged = delegate { called = true; };
array.CollectionChanged += arrayOnCollectionChanged;
array[0, 0] = 0;
array[0, 1] = 1;
array[1, 0] = 2;
array[1, 1] = 3;
//called when values added
Assert.IsTrue(called);
//called when we replace a value
called = false;
array[0, 0] = 5;
Assert.IsTrue(called);
//unsubscribe
called = false;
array.CollectionChanged -= arrayOnCollectionChanged;
array[0, 0] = 3;
Assert.IsFalse(called);
}
public void TestNotifyCollectionChanged()
{
var sourceArray = new MultiDimensionalArray<int>(2, 2);
IMultiDimensionalArray<int> array =
new LazyMultiDimensionalArray<int>(()=>
sourceArray,()=>sourceArray.Count);
bool called = false;
EventHandler<MultiDimensionalArrayChangingEventArgs> arrayOnCollectionChanged = delegate { called = true; };
array.CollectionChanged += arrayOnCollectionChanged;
array[0, 0] = 0;
array[0, 1] = 1;
array[1, 0] = 2;
array[1, 1] = 3;
//called when values added
Assert.IsTrue(called);
//called when we replace a value
called = false;
array[0, 0] = 5;
Assert.IsTrue(called);
//unsubscribe
called = false;
array.CollectionChanged -= arrayOnCollectionChanged;
array[0, 0] = 3;
Assert.IsFalse(called);
}
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 Count()
{
//array = 1,2,3,4,5
IMultiDimensionalArray<int> array = new MultiDimensionalArray<int> {1, 2, 3, 4, 5};
//view = 2,3
IMultiDimensionalArrayView<int> view = new MultiDimensionalArrayView<int>(array, 0, 1, 2);
Assert.AreEqual(2, view.Count);
}
public void EnumerateEmptyArray()
{
IMultiDimensionalArray<int> array = new MultiDimensionalArray<int>();
foreach (int o in array)
{
Assert.Fail("No objects in the array. Should not come here");
}
}
public void Add()
{
IMultiDimensionalArray<int> array = new MultiDimensionalArray<int>();
IMultiDimensionalArrayView view = new MultiDimensionalArrayView(array, 0, int.MinValue, int.MaxValue);
view.Add(4);
Assert.AreEqual(1, view.Count);
Assert.AreEqual(1, array.Count);
}
public void LastValue()
{
//last does not work because the single dimensional indexing does not work see test above
IMultiDimensionalArray <double> array = new MultiDimensionalArray <double>();
array.Add(3.0);
Assert.AreEqual(1, array.Count);
Assert.AreEqual(3.0, array.Last());
}
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 UserOneDimensionalListInterfaceOnMultiDimensionalArray()
{
IMultiDimensionalArray <double> array = new MultiDimensionalArray <double>(2, 2);
array[0, 0] = 5;
IList <double> list = array;
Assert.AreEqual(5, list[0]);
}
public void Add()
{
IMultiDimensionalArray <int> array = new MultiDimensionalArray <int>();
IMultiDimensionalArrayView view = new MultiDimensionalArrayView(array, 0, int.MinValue, int.MaxValue);
view.Add(4);
Assert.AreEqual(1, view.Count);
Assert.AreEqual(1, array.Count);
}
public void ToString()
{
var source = new MultiDimensionalArray <int>(new List <int> {
1, 2, 3, 4, 5, 6
}, new[] { 2, 3 });
var target = new ConvertedArray <string, int>(source, Convert.ToInt32, Convert.ToString);
Assert.AreEqual("{{1, 2, 3}, {4, 5, 6}}", target.ToString());
}
public void ClearView()
{
IMultiDimensionalArray<int> array = new MultiDimensionalArray<int> {1, 2, 3, 4, 5};
IMultiDimensionalArrayView view = new MultiDimensionalArrayView(array, 0, 1, 2);
view.Clear();
Assert.AreEqual(0, view.Count);
Assert.AreEqual(3, array.Count);
Assert.IsTrue(new[] {1, 4, 5}.SequenceEqual(array));
}
public void Contains()
{
IMultiDimensionalArray <int> array = new MultiDimensionalArray <int>();
array.Add(22);
//array.SetValues(new[] {1,2,22});
Assert.IsTrue(array.Contains(22));
Assert.IsFalse(array.Contains(23));
}
public void DefaultValueForReferenceTypes()
{
IMultiDimensionalArray <string> array = new MultiDimensionalArray <string> {
DefaultValue = "dummy"
};
array.Resize(2, 2);
Assert.AreEqual("dummy", array[1, 1]);
}
public void TestGetInsertionIndex()
{
IMultiDimensionalArray<int> ints = new MultiDimensionalArray<int>{1, 2, 40, 50};
Assert.AreEqual(2, MultiDimensionalArrayHelper.GetInsertionIndex(3, ints));
Assert.AreEqual(0, MultiDimensionalArrayHelper.GetInsertionIndex(0, ints));
Assert.AreEqual(4, MultiDimensionalArrayHelper.GetInsertionIndex(60, ints));
Assert.AreEqual(1, MultiDimensionalArrayHelper.GetInsertionIndex(2, ints));
Assert.AreEqual(0, MultiDimensionalArrayHelper.GetInsertionIndex(2, new MultiDimensionalArray<int>()));
}
public void EnumerateEmptyArray()
{
IMultiDimensionalArray <int> array = new MultiDimensionalArray <int>();
foreach (int o in array)
{
Assert.Fail("No objects in the array. Should not come here");
}
}
public void DefaultValueForValueTypes()
{
IMultiDimensionalArray <int> array = new MultiDimensionalArray <int> {
DefaultValue = 99
};
array.Resize(2, 2);
Assert.AreEqual(99, array[1, 1]);
}
public void StrideCalculation()
{
IMultiDimensionalArray array = new MultiDimensionalArray(new[] { 6, 1 });
IMultiDimensionalArray array2 = new MultiDimensionalArray(new[] { 6, 3 });
//reduce the 2nd dimension to only the 1st element. So it resembles the array
IMultiDimensionalArray view = new MultiDimensionalArrayView(array2, 1, 0, 0);
Assert.AreEqual(array.Stride, view.Stride);
}
public void ConvertToListUsingCopyConstructor()
{
MultiDimensionalArray array = new MultiDimensionalArray<double>(2);
IMultiDimensionalArray<double> view = new MultiDimensionalArrayView<double>(array);
view[0] = 10;
view[1] = 5;
var arrayList = new ArrayList(view);
Assert.AreEqual(10, arrayList[0]);
Assert.AreEqual(5, arrayList[1]);
}
private static IMultiDimensionalArray GetValuesArray(double delta, int size, double offset)
{
IMultiDimensionalArray result = new MultiDimensionalArray <double>(size);
for (var j = 0; j < size; j++)
{
result[j] = j * delta + offset;
}
return(result);
}
public void InitializeElementsFromMultiDimensionalArray()
{
var values = new[, ]
{
{ 1, 2, 3 },
{ 4, 5, 6 }
};
var array = new MultiDimensionalArray <int>(values, new[] { 2, 3 });
Assert.IsTrue(array.SequenceEqual(new[] { 1, 2, 3, 4, 5, 6 }));
}
public void Count()
{
//array = 1,2,3,4,5
IMultiDimensionalArray <int> array = new MultiDimensionalArray <int> {
1, 2, 3, 4, 5
};
//view = 2,3
IMultiDimensionalArrayView <int> view = new MultiDimensionalArrayView <int>(array, 0, 1, 2);
Assert.AreEqual(2, view.Count);
}
public void InBetweenTest()
{
IMultiDimensionalArray<int> ints = new MultiDimensionalArray<int> { 1, 2, 40, 50 };
int prev = ints[0];
int next = ints[ints.Count - 1];
Assert.IsTrue(Comparer.IsBetween(prev, 3, next));
Assert.IsFalse(Comparer.IsBetween(prev, 0, next));
Assert.IsFalse(Comparer.IsBetween(prev, 1, next));
Assert.IsFalse(Comparer.IsBetween(prev, 50, next));
Assert.IsTrue(Comparer.IsBetween(prev, 40, next));
}
public void TestVariableOwnerForSubArray()
{
//test on class because our MDA interface does not have owner.
//test here and not in MDA because owner is a variable
IMultiDimensionalArray array = new MultiDimensionalArray(3, 3);
array[1, 1] = 5;
((MultiDimensionalArray)array).Owner = new Variable <double>("x");
array = array.Select(0, 0, 2).Select(1, 0, 2);
Assert.AreEqual(5, array[1, 1]);
}
public void GetLastValueSmallerThan()
{
var array = new MultiDimensionalArray { 1.0, 2.0 };
Assert.IsNull(FunctionHelper.GetLastValueSmallerThan(1.0, array));
Assert.AreEqual(1.0, FunctionHelper.GetLastValueSmallerThan(1.5, array));
Assert.AreEqual(2.0, FunctionHelper.GetLastValueSmallerThan(2.5, array));
array = new MultiDimensionalArray { 1.0 };
Assert.IsNull(FunctionHelper.GetLastValueSmallerThan(1.0, array));
Assert.AreEqual(1.0, FunctionHelper.GetLastValueSmallerThan(55.0, array));
}
public void ConvertToListUsingCopyConstructor()
{
MultiDimensionalArray array = new MultiDimensionalArray <double>(2);
IMultiDimensionalArray <double> view = new MultiDimensionalArrayView <double>(array);
view[0] = 10;
view[1] = 5;
var arrayList = new ArrayList(view);
Assert.AreEqual(10, arrayList[0]);
Assert.AreEqual(5, arrayList[1]);
}
public void EnumerateRowMajor()
{
IMultiDimensionalArray<int> array = new MultiDimensionalArray<int>(2, 2);
array[0, 0] = 0;
array[0, 1] = 1;
array[1, 0] = 2;
array[1, 1] = 3;
//verify we traverse in row major order
int i = 0;
foreach (int j in array)
{
Assert.AreEqual(j, i++);
}
}
public void ConvertToListUsingCopyConstructorGeneric()
{
IList<int> values = new List<int> {1, 2, 3, 4};
MultiDimensionalArray array = new MultiDimensionalArray<int>(values, new[] {1, 4});
IMultiDimensionalArray<int> view = new MultiDimensionalArrayView<int>(array);
IList array1D = new List<int>(view);
Assert.AreEqual(4, array1D.Count);
Assert.AreEqual(4, array1D[3]);
Assert.AreEqual(2, array1D[1]);
}
public void TestConvertedArray()
{
IMultiDimensionalArray<int> intArray = new MultiDimensionalArray<int>(new List<int> { 1, 2, 3, 4, 5 }, new[] { 5 });
IMultiDimensionalArray<string> stringArray = new ConvertedArray<string, int>(intArray, Convert.ToInt32, Convert.ToString);
Assert.AreEqual(intArray.Shape, stringArray.Shape);
Assert.AreEqual("1", stringArray[0]);
//assignment on the converted array are passed to the source
stringArray.Add("30");
Assert.AreEqual(30, intArray[5]);
intArray.Add(31);
Assert.AreEqual("31", stringArray[6]);
}
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 Bind3DArrayUsing2DView()
{
IMultiDimensionalArray array = new MultiDimensionalArray(3, 3, 3);
array[0, 0, 0] = 1;
array[1, 1, 1] = 2;
IMultiDimensionalArrayView view = array.Select(0, 0, 0);
view.Reduce[0] = true; // reduce 1st dimension
DataGridView gridView = new DataGridView();
MultiDimensionalArrayBindingList multiDimensionalArrayBindingList = new MultiDimensionalArrayBindingList(view);
gridView.DataSource = multiDimensionalArrayBindingList;
Form form = new Form();
gridView.Dock = DockStyle.Fill;
form.Controls.Add(gridView);
WindowsFormsTestHelper.ShowModal(form);
}
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 ToString()
{
IMultiDimensionalArray<int> array = new MultiDimensionalArray<int> {1, 2, 3, 4, 5};
IMultiDimensionalArrayView view = new MultiDimensionalArrayView(array, 0, 1, 2);
string s = view.ToString();
Assert.IsTrue(s.Contains(2.ToString()));
Assert.IsTrue(s.Contains(3.ToString()));
Assert.IsFalse(s.Contains(1.ToString()));
Assert.IsFalse(s.Contains(4.ToString()));
Assert.IsFalse(s.Contains(5.ToString()));
}
public void SelectARow()
{
var array = new MultiDimensionalArray(2, 3);
// 1 2 3 1 2 3
// 4 5 6 ==>
array[0, 0] = 1;
array[0, 1] = 2;
array[0, 2] = 3;
array[1, 0] = 4;
array[1, 1] = 5;
array[1, 2] = 6;
// select the first index of the first dimension (e.g. the row)
var row = array.Select(0,new[]{0});
row.Reduce[0] = true;
Assert.AreEqual(new[]{1,2,3},row);
}
public void SelectOnMultipleIndexes()
{
// more complex example (isn't it another test?)
var array = new MultiDimensionalArray(3, 3);
// 1 9 2 1 2
// 9 9 9 ==>
// 3 9 4 3 4
array[0, 0] = 1;
array[0, 1] = 9;
array[0, 2] = 2;
array[1, 0] = 9;
array[1, 1] = 9;
array[1, 2] = 9;
array[2, 0] = 3;
array[2, 1] = 9;
array[2, 2] = 4;
IMultiDimensionalArrayView view = array.Select(0, new[] {0, 2}).Select(1, new[] {0, 2});
Assert.IsTrue(new[] {2, 2}.SequenceEqual(view.Shape));
Assert.AreEqual(4, view.Count);
Assert.AreEqual(1, view[0, 0]);
Assert.AreEqual(2, view[0, 1]);
Assert.AreEqual(3, view[1, 0]);
Assert.AreEqual(4, view[1, 1]);
}
public void SelectUsingIndexes()
{
IMultiDimensionalArray array = new MultiDimensionalArray(3);
array[0] = 1;
array[1] = 2;
array[2] = 3;
IMultiDimensionalArrayView view = array.Select(0, new[] {0, 2});
// Select first and last element
Assert.AreEqual(2, view.Count);
Assert.AreEqual(1, view[0]);
Assert.AreEqual(3, view[1]);
Assert.AreEqual(3,view.MaxValue);
Assert.AreEqual(1,view.MinValue);
}
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 MoveDimensionAtGivenIndexAndLength()
{
var values = new List<int> { 1, 2, 3, 4 };
IMultiDimensionalArray<int> array = new MultiDimensionalArray<int>(values, new[] { 1, 4 });
var view = array.Select(1, 2, 3); // select { 1, 2, [3, 4] }
// move 2nd dimension index
var dimension = 1;
var startIndex = 1;
var length = 2;
var newIndex = 0;
array.Move(dimension, startIndex, length, newIndex); // 1, 2, 3, 4 => 2, 3, 1, 4
// 2, 3, [1, 4]
Assert.IsTrue(view.SequenceEqual(new[] { 1, 4 }));
}
public void Clone()
{
IMultiDimensionalArray<double> array = new MultiDimensionalArray<double>(3);
array[0] = 1;
array[1] = 2;
array[2] = 3;
var view = array.Select(0, 1, 1);
var clonedView = (IMultiDimensionalArrayView)view.Clone();
Assert.IsTrue(view.OffsetStart.SequenceEqual(clonedView.OffsetStart));
Assert.IsTrue(view.OffsetEnd.SequenceEqual(clonedView.OffsetEnd));
}
public void PerformanceAddValuesToArgument_WithEvents_JustAnArray()
{
var t = DateTime.Now;
IMultiDimensionalArray<double> array = new MultiDimensionalArray<double>();
const int valuesToAdd = 10000;
for (var i = 0; i < valuesToAdd; i++)
{
array.Add(i);
}
var dt = DateTime.Now.Subtract(t).TotalMilliseconds;
Assert.Less(dt, 20);
log.DebugFormat("Added {0} values in {1} ms", valuesToAdd, dt);
}
public void TestVariableOwnerForSubArray()
{
//test on class because our MDA interface does not have owner.
//test here and not in MDA because owner is a variable
IMultiDimensionalArray array = new MultiDimensionalArray(3, 3);
array[1, 1] = 5;
((MultiDimensionalArray)array).Owner = new Variable<double>("x");
array = array.Select(0, 0, 2).Select(1, 0, 2);
Assert.AreEqual(5, array[1,1]);
}
public void StrideCalculation()
{
IMultiDimensionalArray array = new MultiDimensionalArray(new[] {6, 1});
IMultiDimensionalArray array2 = new MultiDimensionalArray(new[] {6, 3});
//reduce the 2nd dimension to only the 1st element. So it resembles the array
IMultiDimensionalArray view = new MultiDimensionalArrayView(array2, 1, 0, 0);
Assert.AreEqual(array.Stride, view.Stride);
}
public void RemoveRow()
{
int[] lengths = new[] { 2, 3 };
IMultiDimensionalArray array = new MultiDimensionalArray(lengths);
array[0, 0] = 1;
array[0, 1] = 2;
array[0, 2] = 3;
array[1, 0] = 4;
array[1, 1] = 5;
array[1, 2] = 6;
IMultiDimensionalArrayBindingList bindingList = new MultiDimensionalArrayBindingList(array);
bindingList.RemoveAt(1);
int expectedRowsCount = 2;
Assert.AreEqual(expectedRowsCount, array.Shape[bindingList.RowDimension]);
}
public void UseEnumeratorOnMultiDimensionalArrayView()
{
// Setup an array
// 1 2 -
// 3 4 -
// - - -
IMultiDimensionalArray<double> array = new MultiDimensionalArray<double>(3, 3);
array[0, 0] = 1;
array[0, 1] = 2;
array[1, 0] = 3;
array[1, 1] = 4;
// make a selection of the top right corner
IMultiDimensionalArray<double> view = array.Select(0, 0, 1).Select(1, 0, 1);
Assert.IsTrue(new[] {2, 2}.SequenceEqual(view.Shape));
// since array supports enumerator - we can enumerate throuth all values as 1D array
Assert.IsTrue(new double[] {1, 2, 3, 4}.SequenceEqual(view));
}
public void Create()
{
IMultiDimensionalArray array = new MultiDimensionalArray(new[] {2, 2});
array[0, 0] = 1;
array[0, 1] = 2;
array[1, 0] = 3;
array[1, 1] = 4;
IMultiDimensionalArrayView view = new MultiDimensionalArrayView();
view.Parent = array;
//why not same?? If i resize parent i do expect the subarray to be resize as well.
//the values should be the same but not the reference
Assert.AreNotSame(array.Shape, view.Shape);
Assert.IsTrue(view.Shape.SequenceEqual(array.Shape));
Assert.AreEqual(array.Count, view.Count);
Assert.AreEqual(array.Rank, view.Rank);
Assert.AreEqual(array.DefaultValue, view.DefaultValue);
//subArray should have offsetStarts of MinValue and offsetEnds as MaxValue
//so it will resize along with the parent
Assert.IsTrue(view.OffsetStart.SequenceEqual(new[] {int.MinValue, int.MinValue}));
Assert.IsTrue(view.OffsetEnd.SequenceEqual(new[] {int.MaxValue, int.MaxValue}));
//assert values are equal
Assert.AreEqual(array[0, 0], view[0, 0]);
Assert.AreEqual(array[0, 1], view[0, 1]);
Assert.AreEqual(array[1, 0], view[1, 0]);
Assert.AreEqual(array[1, 1], view[1, 1]);
}
