public void StrideCalculation()
{
//Stride is a vector by which we multiply the indices of the MD-array to get the index in a single dimensional array
int[] stride = MultiDimensionalArrayHelper.GetStride(new[] { 1, 2 });
Assert.AreEqual(new[] { 2, 1 }, stride);
//is this correct??? works out OK. Last dimension should always have stride 1.
stride = MultiDimensionalArrayHelper.GetStride(new[] { 1, 1 });
Assert.AreEqual(new[] { 1, 1 }, stride);
//go from 2,1 (2 dimensional) to 4,3,2 (3 dimensional)
stride = MultiDimensionalArrayHelper.GetStride(new[] { 4, 3, 2 });
Assert.AreEqual(new[] { 6, 2, 1 }, stride);
stride = MultiDimensionalArrayHelper.GetStride(new[] { 2, 3, 4 });
Assert.AreEqual(new[] { 12, 4, 1 }, stride);
stride = MultiDimensionalArrayHelper.GetStride(new[] { 2, 3 });
Assert.AreEqual(new[] { 3, 1 }, stride);
//Notice stride does not change when the first dimension changes size
stride = MultiDimensionalArrayHelper.GetStride(new[] { 3, 2 });
Assert.AreEqual(new[] { 2, 1 }, stride);
stride = MultiDimensionalArrayHelper.GetStride(new[] { 4, 2 });
Assert.AreEqual(new[] { 2, 1 }, stride);
}
internal object GetColumnValue(int columnIndex)
{
if (!owner.Contains(this) || !owner.Functions.Any())
{
return(null);
}
object value = null;
var variable = owner.GetVariableForColumnIndex(columnIndex);
var values = variable.Values;
if (columnIndex < owner.Function.Arguments.Count)
{
var argumentIndex = Index[columnIndex];
if (values.Count > argumentIndex)
{
value = values[argumentIndex];
}
}
else
{
var index = Index;
if (MultiDimensionalArrayHelper.IsIndexWithinShape(index, values.Shape))
{
value = values[Index];
}
}
return(value);
}
protected virtual void OnFunctionValuesAdd(FunctionValuesChangingEventArgs e)
{
if (function == null || function.IsEditing)
{
return;
}
if (!function.Arguments.Contains((IVariable)e.Function))
{
return;
}
// do nothing if at least 1 of arguments is empty
if (function.Arguments.Any(a => a.Values.Count == 0))
{
return;
}
var shape = function.Components[0].Values.Shape;
var valuesPerRow = MultiDimensionalArrayHelper.GetTotalLength(shape.Skip(1).ToArray());
var numRowsAdded = e.Items.Count;
var rowsToAdd = numRowsAdded * valuesPerRow;
if (rowsToAdd > 0)
{
InsertRows(shape, rowsToAdd, e.Index);
}
}
private void OnFunctionValuesAdded(FunctionValuesChangingEventArgs e)
{
var function = e.Function;
if (!function.Arguments.Contains((IVariable)e.Function))
{
return;
}
// do nothing if at least 1 of arguments is empty
if (function.Arguments.Any(a => a.Values.Count == 0))
{
return;
}
// get number of rows to insert
var shape = function.Components[0].Values.Shape;
var valuesPerRow = MultiDimensionalArrayHelper.GetTotalLength(shape.Skip(1).ToArray());
var numRowsAdded = e.Items.Count;
var rowsToAdd = numRowsAdded * valuesPerRow;
var index = new int[shape.Length];
for (var i = 0; i < rowsToAdd; i++)
{
Insert(e.Index, new MultipleFunctionBindingListRow(this));
//rowIndices.Insert(e.Index, index);
MultiDimensionalArrayHelper.IncrementIndex(index, shape, 0);
}
}
public void DecrementMultiDimensionalIndexOnZeroIndexThrowsException()
{
var shape = new[] { 3, 3, 3 };
var index = new[] { 0, 0, 0 };
MultiDimensionalArrayHelper.DecrementIndexForShape(index, shape);
index.Should().Be.Equals(new[] { 0, 0, 0 });
}
public void DetectShapeFromString()
{
const string str = "{{1, 2.5, 3}, {2, 3, 4}}";
var shape = MultiDimensionalArrayHelper.DetectShapeFromString(str);
Assert.IsTrue(shape.SequenceEqual(new [] { 2, 3 }));
}
private void InsertRows(int[] shape, int rowsToAdd, int listIndex)
{
var index = new int[shape.Length];
for (var i = 0; i < rowsToAdd; i++)
{
Insert(listIndex, CreateEmptyBindingListRow());
MultiDimensionalArrayHelper.IncrementIndex(index, shape, 0);
}
}
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 new static IMultiDimensionalArray <T> Parse(string text)
{
if (string.IsNullOrEmpty(text) || text.Trim() == "")
{
throw new ArgumentException("Cant parse string: " + text, "text");
}
var values = text
.Replace(" ", string.Empty).Replace("{", string.Empty).Replace("}", string.Empty)
.Split(',')
.Select(s => s.Parse <T>(CultureInfo.InvariantCulture));
var shape = MultiDimensionalArrayHelper.DetectShapeFromString(text);
return(new MultiDimensionalArray <T>(values.ToArray(), shape));
}
public void DecrementMultiDimensionalIndex()
{
var shape = new[] { 3, 3, 3 };
var index = new[] { 2, 2, 2 };
MultiDimensionalArrayHelper.DecrementIndexForShape(index, shape);
index.Should().Be.Equals(new[] { 2, 2, 1 });
MultiDimensionalArrayHelper.DecrementIndexForShape(index, shape);
index.Should().Be.Equals(new[] { 2, 2, 0 });
MultiDimensionalArrayHelper.DecrementIndexForShape(index, shape);
index.Should().Be.Equals(new[] { 2, 0, 2 });
MultiDimensionalArrayHelper.DecrementIndexForShape(index, shape);
index.Should().Be.Equals(new[] { 2, 0, 1 });
MultiDimensionalArrayHelper.DecrementIndexForShape(index, shape);
index.Should().Be.Equals(new[] { 2, 0, 0 });
}
public void IncrementMultiDimensionalIndex()
{
var shape = new[] { 3, 3, 3 };
bool result;
var index = new[] { 0, 0, 0 };
var dimension = 0;
result = MultiDimensionalArrayHelper.IncrementIndex(index, shape, dimension);
Assert.IsTrue(result);
Assert.IsTrue(index.SequenceEqual(new[] { 1, 0, 0 }));
result = MultiDimensionalArrayHelper.IncrementIndex(index, shape, dimension);
Assert.IsTrue(index.SequenceEqual(new[] { 2, 0, 0 }));
Assert.IsTrue(result);
result = MultiDimensionalArrayHelper.IncrementIndex(index, shape, dimension);
Assert.IsFalse(result);
index = new[] { 0, 0, 0 };
dimension = 1;
result = MultiDimensionalArrayHelper.IncrementIndex(index, shape, dimension);
Assert.IsTrue(index.SequenceEqual(new[] { 0, 1, 0 }));
Assert.IsTrue(result);
result = MultiDimensionalArrayHelper.IncrementIndex(index, shape, dimension);
Assert.IsTrue(index.SequenceEqual(new[] { 0, 2, 0 }));
Assert.IsTrue(result);
result = MultiDimensionalArrayHelper.IncrementIndex(index, shape, dimension);
Assert.IsTrue(index.SequenceEqual(new[] { 1, 0, 0 }));
Assert.IsTrue(result);
result = MultiDimensionalArrayHelper.IncrementIndex(index, shape, dimension);
Assert.IsTrue(index.SequenceEqual(new[] { 1, 1, 0 }));
Assert.IsTrue(result);
result = MultiDimensionalArrayHelper.IncrementIndex(index, shape, dimension);
Assert.IsTrue(index.SequenceEqual(new[] { 1, 2, 0 }));
Assert.IsTrue(result);
result = MultiDimensionalArrayHelper.IncrementIndex(index, shape, dimension);
Assert.IsTrue(index.SequenceEqual(new[] { 2, 0, 0 }));
Assert.IsTrue(result);
result = MultiDimensionalArrayHelper.IncrementIndex(index, shape, dimension);
Assert.IsTrue(index.SequenceEqual(new[] { 2, 1, 0 }));
Assert.IsTrue(result);
result = MultiDimensionalArrayHelper.IncrementIndex(index, shape, dimension);
Assert.IsTrue(index.SequenceEqual(new[] { 2, 2, 0 }));
Assert.IsTrue(result);
result = MultiDimensionalArrayHelper.IncrementIndex(index, shape, dimension);
Assert.IsFalse(result);
}
protected override object OnGetColumnValue(int columnIndex)
{
if (owner.GetIndexOfRow(this) == -1 || owner.Function == null)
{
return(null);
}
object value = null;
if (columnIndex < owner.Function.Arguments.Count)
{
if (columnIndex >= Index.Count())
{
return(null);
}
var values = owner.GetVariableForColumnIndex(columnIndex).Values;
var argumentIndex = Index[columnIndex];
if (values.Count > argumentIndex)
{
value = values[argumentIndex];
}
}
else
{
var componentIndex = columnIndex - owner.Function.Arguments.Count;
if (componentIndex >= owner.Function.Components.Count)
{
return(value);
}
var values = owner.GetVariableForColumnIndex(columnIndex).Values;
// component column
var index = Index;
if (MultiDimensionalArrayHelper.IsIndexWithinShape(index, values.Shape))
{
value = values[index];
}
}
return(value);
}
public override object Evaluate(ICoordinate coordinate, DateTime?time)
{
// check value directly at the point
var xValues = x.Values;
var yValues = y.Values;
for (int i = 0; i < xValues.Count; i++)
{
if (xValues[i] == coordinate.X && yValues[i] == coordinate.Y)
{
var index = MultiDimensionalArrayHelper.GetIndex(i, xValues.Stride);
if (time != null)
{
var timeIndex = Time.Values.IndexOf(time);
return(Components[0].Values[timeIndex, index[0], index[1]]);
}
else
{
return(Components[0].Values[i]);
}
}
}
// otherwise face
var face = GetFaceAtCoordinate(coordinate);
// does not work?
// var face = facesIndex.Query(point.EnvelopeInternal).Cast<Face>().FirstOrDefault();
if (face != null)
{
if (time != null)
{
var timeIndex = Time.Values.IndexOf(time);
return(Components[0].Values[timeIndex, face.I, face.J]);
}
else
{
return(Components[0].Values[face.Index]);
}
}
return(null);
}
private void UpdateInsertionIndex(FunctionValuesChangedEventArgs e, IList <T> values)
{
if ((typeof(T) == typeof(string)))
{
return; // doesn't matter, it is always unique + we don't care about objects
}
var oldIndex = e.Index;
e.Index = MultiDimensionalArrayHelper.GetInsertionIndex((T)e.Item, values);
if (e.Action == NotifyCollectionChangedAction.Replace)
{
if (e.Index > oldIndex) // !@#@#??????
{
e.Index--;
}
}
}
protected override object OnGetColumnValue(int columnIndex)
{
if (owner.GetIndexOfRow(this) == -1 || owner.Function == null)
{
return(null);
}
object value = null;
if (columnIndex < owner.Function.Arguments.Count)
{
var argumentIndex = Index[columnIndex];
//log.DebugFormat("GetColumnValue: {0}, {1}", columnIndex, argumentIndex);
var values = owner.Function.Arguments[columnIndex].Values;
if (values.Count > argumentIndex)
{
value = values[argumentIndex];
}
}
else
{
var componentIndex = columnIndex - owner.Function.Arguments.Count;
if (componentIndex >= owner.Function.Components.Count)
{
return(value);
}
// component column
var component = owner.Function.Components[componentIndex];
var values = component.Values;
var index = Index;
if (MultiDimensionalArrayHelper.IsIndexWithinShape(index, values.Shape))
{
value = values[index];
}
}
return(value);
}
public override object Evaluate(ICoordinate coordinate)
{
// TODO: add spatial indexing
var xValues = x.Values;
var yValues = y.Values;
for (var i = 0; i < xValues.Count; i++)
{
if (xValues[i] != coordinate.X || yValues[i] != coordinate.Y)
{
continue;
}
var index = MultiDimensionalArrayHelper.GetIndex(i, X.Values.Stride);
return(Components[0].Values[index]);
}
return(null);
}
internal object GetColumnValue(int columnIndex)
{
if (!owner.Contains(this))
{
return(null);
}
lock (owner.Function.Store)
{
object value = null;
if (columnIndex < owner.Function.Arguments.Count)
{
var argumentIndex = Index[columnIndex];
//log.DebugFormat("GetColumnValue: {0}, {1}", columnIndex, argumentIndex);
var values = owner.Function.Arguments[columnIndex].Values;
if (values.Count > argumentIndex)
{
value = values[argumentIndex];
}
}
else
{
// component column
var component = owner.Function.Components[columnIndex - owner.Function.Arguments.Count];
var values = component.Values;
var index = Index;
if (MultiDimensionalArrayHelper.IsIndexWithinShape(index, values.Shape))
{
value = values[Index];
}
}
return(value);
}
}
protected override int GetInsertionStartIndex(IList valuesToInsert)
{
return(MultiDimensionalArrayHelper.GetInsertionIndex(valuesToInsert[0], (IList)values2));
}
private void GenerateFaces()
{
var xValues = x.Values;
var yValues = y.Values;
faces = new MultiDimensionalArray <IGridFace>(new [] { Size1 - 1, Size2 - 1 });
// build quad tree
facesIndex = new Quadtree();
for (var i = 0; i < Size1 - 1; i++)
{
for (var j = 0; j < Size2 - 1; j++)
{
var points = new Coordinate[5];
points[0] = new Coordinate(xValues[i, j], yValues[i, j]);
points[1] = new Coordinate(xValues[i, j + 1], yValues[i, j + 1]);
points[2] = new Coordinate(xValues[i + 1, j + 1], yValues[i + 1, j + 1]);
points[3] = new Coordinate(xValues[i + 1, j], yValues[i + 1, j]);
points[4] = points[0];
var face = new Face {
Geometry = new Polygon(new LinearRing(points)), I = i, J = j, Index = MultiDimensionalArrayHelper.GetIndex1d(new[] { i, j }, xValues.Stride), Grid = this
};
Faces[i, j] = face;
facesIndex.Insert(face.Geometry.EnvelopeInternal, face);
}
}
}
private void FunctionValuesChanged(object sender, FunctionValuesChangingEventArgs e)
{
//should not a delayedEventHandler be used?
if (!DelayedEventHandlerController.FireEvents)
{
return;
}
if (changingFromGui)
{
return;
}
while (changing)
{
Thread.Sleep(0); // wait until other change has been processed
}
changing = true;
var argumentIndex = function.Arguments.IndexOf((IVariable)e.Function);;
//find out the property descriptor for this function and raise event.
switch (e.Action)
{
case NotifyCollectionChangeAction.Reset:
//SetFunction(function);
Clear();
ResetBindings();
changing = false;
Fill();
changing = true;
break;
case NotifyCollectionChangeAction.Replace:
OnListChanged(new ListChangedEventArgs(ListChangedType.ItemChanged, e.Index));
// log.DebugFormat("Function[{0}] value replaced {1}, number of rows: {2}", args.Function, e.Index, Count);
break;
case NotifyCollectionChangeAction.Add:
// react only on chainges in arguments
if (!function.Arguments.Contains((IVariable)e.Function))
{
break;
}
// do nothing if at least 1 of arguments is empty
if (function.Arguments.Any(a => a.Values.Count == 0))
{
break;
}
// get number of rows to insert
var shape = function.Components[0].Values.Shape;
//TODO : this would be wrong if not the dimensions is added.
var countValuesToInsert = MultiDimensionalArrayHelper.GetTotalLength(shape.Skip(1).ToArray());
var index = new int[shape.Length];
for (var i = 0; i < countValuesToInsert; i++)
{
Insert(e.Index, CreateEmptyBindingListRow());
//rowIndices.Insert(e.Index, index);
MultiDimensionalArrayHelper.IncrementIndex(index, shape, 0);
}
// log.DebugFormat("Function[{0}] value added {1}, number of rows: {2}", args.Function, e.Index, Count);
break;
case NotifyCollectionChangeAction.Remove:
// react only on chainges in arguments
if (!function.Arguments.Contains((IVariable)e.Function))
{
break;
}
// 1d case, faster implementation
if (function.Arguments.Count == 1)
{
AllowRemove = true;
RemoveAt(e.Index);
AllowRemove = false;
break;
}
for (var i = Count - 1; i >= 0; i--)
{
if (this[i].Index[argumentIndex] == e.Index)
{
AllowRemove = true;
RemoveAt(i);
AllowRemove = false;
}
}
// log.DebugFormat("Function[{0}] value removed {1}, number of rows: {2}", args.Function, e.Index, Count);
break;
default:
changing = false;
throw new NotImplementedException(e.ToString());
}
changing = false;
}
/// <summary>
/// Returns multi-dimensional row index of the row based on the current sort order, filters, etc.
/// </summary>
/// <param name="row"></param>
/// <returns></returns>
public int[] GetMultiDimensionalRowIndex(FunctionBindingListRow row)
{
return(MultiDimensionalArrayHelper.GetIndex(IndexOf(row), values.Stride));
}
private void function_ValuesChanged(object sender, FunctionValuesChangedEventArgs e)
{
if (changing) // this is dangerous, what if values change during list changes, rare but possible?
{
return;
}
changing = true;
var argumentIndex = function.Arguments.IndexOf((IVariable)e.Function);;
//find out the property descriptor for this function and raise event.
switch (e.Action)
{
case NotifyCollectionChangedAction.Replace:
OnListChanged(new ListChangedEventArgs(ListChangedType.ItemChanged, e.Index));
// log.DebugFormat("Function[{0}] value replaced {1}, number of rows: {2}", args.Function, e.Index, Count);
break;
case NotifyCollectionChangedAction.Add:
// react only on chainges in arguments
if (!function.Arguments.Contains((IVariable)e.Function))
{
break;
}
// do nothing if at least 1 of arguments is empty
if (function.Arguments.Any(a => a.Values.Count == 0))
{
break;
}
// get number of rows to insert
lock (function.Store)
{
var shape = function.Components[0].Values.Shape;
//TODO : this would be wrong if not the dimensions is added.
var countValuesToInsert = MultiDimensionalArrayHelper.GetTotalLength(shape.Skip(1).ToArray());
var index = new int[shape.Length];
for (var i = 0; i < countValuesToInsert; i++)
{
Insert(e.Index, new FunctionBindingListRow(this));
//rowIndices.Insert(e.Index, index);
MultiDimensionalArrayHelper.IncrementIndex(index, shape, 0);
}
}
// log.DebugFormat("Function[{0}] value added {1}, number of rows: {2}", args.Function, e.Index, Count);
break;
case NotifyCollectionChangedAction.Remove:
lock (function.Store)
{
// react only on chainges in arguments
if (!function.Arguments.Contains((IVariable)e.Function))
{
break;
}
// 1d case, faster implementation
if (function.Arguments.Count == 1)
{
RemoveAt(e.Index);
break;
}
for (var i = Count - 1; i >= 0; i--)
{
if (this[i].Index[argumentIndex] == e.Index)
{
AllowRemove = true;
RemoveAt(i);
AllowRemove = false;
}
}
}
// log.DebugFormat("Function[{0}] value removed {1}, number of rows: {2}", args.Function, e.Index, Count);
break;
default:
changing = false;
throw new NotImplementedException(e.ToString());
}
changing = false;
}
public void IsIndexWithinShapeIsFalseForAShapeContaining0()
{
Assert.IsFalse(MultiDimensionalArrayHelper.IsIndexWithinShape(new[] { 0 }, new[] { 0, 2, 2 }));
Assert.IsFalse(MultiDimensionalArrayHelper.IsIndexWithinShape(new[] { 0, 0 }, new[] { 2, 2, 0 }));
}
public void GetLength()
{
Assert.AreEqual(MultiDimensionalArrayHelper.GetTotalLength(new int[] { 5, 4, 6 }), 120);
}
public override string ToString()
{
return(MultiDimensionalArrayHelper.ToString(this));
}
