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