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 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 override IFunction GetTimeSeries(ICoordinate coordinate)
{
var face = GetFaceAtCoordinate(coordinate);
if (face != null)
{
var timeSeries = new TimeSeries {
Parent = this
};
var component = new Variable <double>
{
Name = Name + string.Format(" ({0}, {1})", face.I, face.J)
};
timeSeries.Components.Add(component);
var times = (IMultiDimensionalArray <DateTime>)Time.Values.Clone();
var values = new MultiDimensionalArrayView <double>(Components[0].Values);
values.SelectedIndexes[1] = new[] { face.I };
values.SelectedIndexes[2] = new[] { face.J };
timeSeries.SetValues(values, new VariableValueFilter <DateTime>(timeSeries.Time, times));
return(timeSeries);
}
return(null);
}
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 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 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 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 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]);
}
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 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 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 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 ReduceWithEmptyIndex()
{
var array = new MultiDimensionalArray(3, 3);
var subArray = new MultiDimensionalArrayView(array);
//set empty index
subArray.SelectedIndexes[0] = new int[] {};
subArray.Reduce[0] = true; //try to reduce the first dimension
subArray.Count.Should("Count should be 0").Be.EqualTo(0);
foreach (var value in subArray) //should be empty list
{
throw new ExpectationViolationException("Shouldn't return any values");
}
}
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 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 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 ReduceWithNonExistentIndex()
{
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
subArray.Count.Should("Count should be 0").Be.EqualTo(0);
foreach (var value in subArray) //should be empty list
{
throw new ExpectationViolationException("Shouldn't return any values");
}
}
public void RemoveAt()
{
//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.IsTrue(new[] { 2, 3 }.SequenceEqual(view));
view.RemoveAt(0);
//array = 1,3,4,5
//view = 3
Assert.AreEqual(1, view.Count);
Assert.AreEqual(4, array.Count);
Assert.IsTrue(new[] { 3 }.SequenceEqual(view));
Assert.IsTrue(new[] { 1, 3, 4, 5 }.SequenceEqual(array));
view.RemoveAt(0);
Assert.AreEqual(0, view.Count);
Assert.AreEqual(3, array.Count);
Assert.IsTrue(new[] { 1, 4, 5 }.SequenceEqual(array));
}
public void ReduceWithNonExistentIndex()
{
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
subArray.Count.Should("Count should be 0").Be.EqualTo(0);
foreach(var value in subArray) //should be empty list
throw new ExpectationViolationException("Shouldn't return any values");
}
public void ReduceWithEmptyIndex()
{
var array = new MultiDimensionalArray(3,3);
var subArray = new MultiDimensionalArrayView(array);
//set empty index
subArray.SelectedIndexes[0] = new int[]{};
subArray.Reduce[0] = true; //try to reduce the first dimension
subArray.Count.Should("Count should be 0").Be.EqualTo(0);
foreach (var value in subArray) //should be empty list
throw new ExpectationViolationException("Shouldn't return any values");
}
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 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()
{
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 RemoveAt()
{
//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.IsTrue(new[] {2, 3}.SequenceEqual(view));
view.RemoveAt(0);
//array = 1,3,4,5
//view = 3
Assert.AreEqual(1, view.Count);
Assert.AreEqual(4, array.Count);
Assert.IsTrue(new[] {3}.SequenceEqual(view));
Assert.IsTrue(new[] {1, 3, 4, 5}.SequenceEqual(array));
view.RemoveAt(0);
Assert.AreEqual(0, view.Count);
Assert.AreEqual(3, array.Count);
Assert.IsTrue(new[] {1, 4, 5}.SequenceEqual(array));
}
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 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);
}
