public static TScalar ArrayGet <[AnyPrimitive] TScalar>(
MFullArray <TScalar> array, double rowIndex, double columnIndex, double sliceIndex)
{
var index = LinearizeIndex(array.shape, ToInt(rowIndex), ToInt(columnIndex), ToInt(sliceIndex));
return(array.elements[index - 1]);
}
public static void ArraySet <[AnyPrimitive] TScalar>(
MFullArray <TScalar> array, int rowIndex, int columnIndex, TScalar value)
{
// Performance critical method!
Contract.Requires(array != null);
if (rowIndex < 1)
{
throw new ArgumentOutOfRangeException("rowIndex");
}
if (columnIndex < 1)
{
throw new ArgumentOutOfRangeException("columnIndex");
}
int rowCount = array.shape.RowCount;
if (rowIndex > array.RowCount || columnIndex > array.ColumnCount)
{
// Array needs resizing
// TODO: zeros(2, 2, 2) (3, 3) = 5 should work and produce a 3x2x2 matrix
if (array.IsHigherDimensional)
{
throw new ArgumentOutOfRangeException();
}
if (rowIndex > rowCount)
{
rowCount = rowIndex;
}
int columnCount = Math.Max(array.shape.ColumnCount, columnIndex);
array.Resize(new MArrayShape(rowCount, columnCount));
}
array.elements[(columnIndex - 1) * rowCount + (rowIndex - 1)] = value;
}
public static MFullArray <TResult> CollapseDimension <TSource, TResult>(
this MFullArray <TSource> array, int dimensionIndex,
Func <TSource, TResult> map, Func <TResult, TResult, TResult> reduce)
{
Contract.Requires(array != null);
Contract.Requires(map != null);
Contract.Requires(reduce != null);
if (array.IsEmpty)
{
throw new MArrayShapeException();
}
var shape = array.Shape;
int sliceStep, sliceSize;
shape.GetDimensionStepAndSize(dimensionIndex, out sliceStep, out sliceSize);
var result = new MFullArray <TResult>(MArrayShape.CollapseDimension(shape, dimensionIndex));
var resultArray = result.BackingArray;
for (int sliceIndex = 0; sliceIndex < resultArray.Length; ++sliceIndex)
{
TResult aggregator = map(array[sliceIndex * sliceSize]);
for (int sliceElementIndex = 1; sliceElementIndex < sliceSize; ++sliceElementIndex)
{
aggregator = reduce(aggregator, map(array[sliceIndex * sliceSize + sliceElementIndex * sliceStep]));
}
resultArray[sliceIndex] = aggregator;
}
return(result);
}
public static void ArraySet <[AnyPrimitive] TScalar>(
MFullArray <TScalar> array, double rowIndex, double columnIndex, double sliceIndex, TScalar value)
{
var index = LinearizeIndex(array.shape, ToInt(rowIndex), ToInt(columnIndex), ToInt(sliceIndex));
array[index - 1] = value;
}
public static MFullArray <TScalar> ArrayGet <[AnyPrimitive] TScalar>(
MFullArray <TScalar> array, MFullArray <int> rowIndices, MFullArray <int> columnIndices)
{
Contract.Requires(array != null);
Contract.Requires(rowIndices != null);
Contract.Requires(columnIndices != null);
var indexedShape = new MArrayShape(rowIndices.Count, columnIndices.Count);
var result = new MFullArray <TScalar>(indexedShape);
for (int j = 0; j < columnIndices.Count; ++j)
{
int columnIndex = columnIndices[j];
if (columnIndex < 1 || columnIndex > array.ColumnCount)
{
throw new IndexOutOfRangeException();
}
for (int i = 0; i < rowIndices.Count; ++i)
{
int rowIndex = rowIndices[i];
if (rowIndex < 1 || rowIndex > array.RowCount)
{
throw new IndexOutOfRangeException();
}
result[j * indexedShape.RowCount + i] = array[(columnIndex - 1) * array.RowCount + (rowIndex - 1)];
}
}
return(result);
}
public static void ArraySet <[AnyPrimitive] TScalar>(
MFullArray <TScalar> array, int index, TScalar value)
{
Contract.Requires(array != null);
if (index < 1)
{
throw new ArgumentOutOfRangeException("index");
}
if (index > array.Count)
{
// Must resize, only works if the array is empty, a scalar or a vector
// - Empty, scalar or row vector: grows in columns
// - Column vector: grows in rows
// - Otherwise: throws
if (array.IsHigherDimensional)
{
throw new ArgumentOutOfRangeException("index");
}
else if (array.RowCount <= 1)
{
array.Resize(new MArrayShape(1, index));
}
else if (array.ColumnCount == 1)
{
array.Resize(new MArrayShape(index, 1));
}
else
{
throw new ArgumentOutOfRangeException("index");
}
}
array[index - 1] = value;
}
public void TestArrayLoad_ColonLinearization()
{
// function value = arrayload(array)
// value = array(:)
var arrayInput = Declare <MFullArray <double> >("array");
var valueOutput = Declare <MFullArray <double> >("value");
var function = CompileFunction <Func <MFullArray <double>, MFullArray <double> > >(
arrayInput, valueOutput,
new LoadParenthesized(valueOutput, arrayInput, IndexArgument.Colon));
var arg = new MFullArray <double>(2, 2);
arg[0] = 1;
arg[1] = 2;
arg[2] = 3;
arg[3] = 4;
var result = function(arg);
Assert.AreEqual(arg.Count, result.Count);
Assert.AreEqual(arg.Count, result.RowCount);
Assert.AreEqual(1, result.ColumnCount);
for (int i = 0; i < arg.Count; ++i)
{
Assert.AreEqual(arg[i], result[i]);
}
}
public static void ArraySet <[AnyPrimitive] TScalar>(
MFullArray <TScalar> array, double rowIndex, double columnIndex, TScalar value)
{
// Performance critical method!
Contract.Requires(array != null);
int rowIndexInt = ToInt(rowIndex);
if (rowIndexInt < 1)
{
throw new ArgumentOutOfRangeException("rowIndex");
}
int rowCount = array.shape.RowCount;
int columnIndexInt = ToInt(columnIndex);
if (rowIndexInt > rowCount || columnIndexInt > array.shape.ColumnCount)
{
if (array.shape.IsHigherDimensional)
{
throw new ArgumentOutOfRangeException();
}
if (rowIndexInt > rowCount)
{
rowCount = rowIndexInt;
}
int columnCount = Math.Max(array.shape.ColumnCount, columnIndexInt);
array.Resize(new MArrayShape(rowCount, columnCount));
}
array.elements[(columnIndexInt - 1) * rowCount + (rowIndexInt - 1)] = value;
}
public MCellArray(MArrayShape shape) : base(shape)
{
elements = new MCell[shape.Count];
for (int i = 0; i < elements.Length; ++i)
{
elements[i] = new MFullArray <double>(MArrayShape.Empty);
}
}
public MCell Initialize()
{
if (value == null)
{
value = MFullArray <double> .CreateEmpty();
}
return(this);
}
public static TScalar ArrayGet <[AnyPrimitive] TScalar>(MFullArray <TScalar> array, int index)
{
// Performance critical method!
if (index > array.shape.Count) // We'll get an IndexOutOfRangeException if it's < 1
{
throw new ArgumentOutOfRangeException("index");
}
return(array.elements[index - 1]);
}
public static int ToIntScalar(MFullArray <double> value)
{
Contract.Requires(value != null);
if (!value.IsScalar)
{
throw new MArrayShapeException();
}
return(ToInt(value[0]));
}
public static TScalar ToScalar <[AnyPrimitive] TScalar>(MFullArray <TScalar> array)
{
Contract.Requires(array != null);
if (!array.IsScalar)
{
throw new MArrayShapeException();
}
return(array[0]);
}
public static MFullArray <long> ToArray(MIntegralRange <long> range)
{
var result = new MFullArray <long>(1, range.Count);
for (int i = 0; i < range.Count; ++i)
{
result[i] = range.First + i;
}
return(result);
}
public static MFullArray <double> ToArray(MIntegralRange <double> range)
{
var result = new MFullArray <double>(1, range.Count);
for (int i = 0; i < range.Count; ++i)
{
result[i] = (double)(range.First + i);
}
return(result);
}
public static MFullArray <TScalar> Linearize <[AnyPrimitive] TScalar>(MFullArray <TScalar> array)
{
Contract.Requires(array != null);
int count = array.Count;
var result = new MFullArray <TScalar>(count, 1);
Array.Copy(array.BackingArray, result.BackingArray, count);
return(result);
}
public static void ArraySet <[AnyPrimitive] TScalar>(
MFullArray <TScalar> array, TScalar value)
{
Contract.Requires(array != null);
int count = array.Count;
for (int i = 0; i < count; ++i)
{
array[i] = value;
}
}
public static MFullArray <TOut> Map <TIn, TOut>(this MFullArray <TIn> array, Func <TIn, TOut> map)
{
Contract.Requires(array != null);
Contract.Requires(map != null);
var result = new MFullArray <TOut>(array.Shape);
for (int i = 0; i < array.Count; ++i)
{
result[i] = map(array[i]);
}
return(result);
}
public static MFullArray <TScalar> ArrayGet <[AnyPrimitive] TScalar>(MFullArray <TScalar> array, MIntegralRange <double> indices)
{
Contract.Requires(array != null);
if (indices.First < 1 || indices.Last > array.Count)
{
throw new ArgumentOutOfRangeException("indices");
}
var result = new MFullArray <TScalar>(1, indices.Count);
Array.Copy(array.BackingArray, indices.First - 1, result.BackingArray, 0, indices.Count);
return(result);
}
public static string ToString(MFullArray <char> array)
{
Contract.Requires(array != null);
var shape = array.Shape;
if (!shape.IsRowVector)
{
throw new MArrayShapeException();
}
// TODO: Don't assume a full array
return(new string(array.BackingArray, 0, shape.ColumnCount));
}
public static MFullArray <TScalar> GetForSlice <[AnyPrimitive] TScalar>(MFullArray <TScalar> array, int index)
{
Contract.Requires(array != null);
var arrayShape = array.shape;
Contract.Assert(!arrayShape.IsHigherDimensional);
int baseArrayIndex = arrayShape.RowCount * index;
var slice = new MFullArray <TScalar>(new MArrayShape(arrayShape.RowCount, 1));
for (int i = 0; i < arrayShape.RowCount; ++i)
{
slice[i] = array[baseArrayIndex + i];
}
return(slice);
}
public static TScalar ArrayGet <[AnyPrimitive] TScalar>(
MFullArray <TScalar> array, int rowIndex, int columnIndex)
{
// Performance critical method!
int rowCount = array.shape.RowCount;
if (rowIndex < 1 || rowIndex > rowCount)
{
throw new ArgumentOutOfRangeException("rowIndex");
}
if (columnIndex > array.shape.ColumnCount) // We'll get an IndexOutOfRangeException if it's < 1
{
throw new ArgumentOutOfRangeException("columnIndex");
}
return(array.elements[(columnIndex - 1) * rowCount + (rowIndex - 1)]);
}
public void TestCopyAssignmentWithMFullArray()
{
// function result = copy(x)
// result = x;
var input = Declare <MFullArray <double> >("input");
var output = Declare <MFullArray <double> >("output");
var function = CompileFunction <Func <MFullArray <double>, MFullArray <double> > >(
input, output,
new Copy(output, input));
var argument = MFullArray <double> .CreateScalar(42);
var result = function(argument);
Assert.AreEqual(argument.Shape, result.Shape);
Assert.AreEqual(argument[0], result[0]);
Assert.AreNotSame(argument, result);
}
public void TestIf()
{
// There is no such thing as a logical literal
const double trueDouble = 42;
const double falseDouble = 666;
var input = Declare <MValue>("input");
var output = Declare <double>("output");
var function = CompileFunction <Func <MValue, double> >(
input, output,
new If(input,
new Literal(output, trueDouble),
new Literal(output, falseDouble)));
Assert.AreEqual(trueDouble, function(MFullArray <double> .CreateScalar(1)));
Assert.AreEqual(falseDouble, function(MFullArray <double> .CreateScalar(0)));
Assert.AreEqual(falseDouble, function(MFullArray <double> .CreateRowVector(0, 0, 1, 0)));
Assert.AreEqual(trueDouble, function(MFullArray <double> .CreateRowVector(1, 1, 1, 1)));
}
public void TestArrayLoad()
{
// function value = arrayload(array, index)
// value = array(index)
var arrayInput = Declare <MFullArray <double> >("array");
var indexInput = Declare <MFullArray <double> >("index");
var valueOutput = Declare <MFullArray <double> >("value");
var function = CompileFunction <Func <MFullArray <double>, MFullArray <double>, MFullArray <double> > >(
new[] { arrayInput, indexInput }, valueOutput,
new LoadParenthesized(valueOutput, arrayInput, (IndexArgument)indexInput));
var arg1 = new MFullArray <double>(2, 1);
arg1[0] = 42;
arg1[1] = 666;
Assert.AreEqual(arg1[0], ToScalar(function(arg1, 1.0)));
Assert.AreEqual(arg1[1], ToScalar(function(arg1, 2.0)));
}
public static void ArraySet <[AnyPrimitive] TScalar>(
MFullArray <TScalar> array, MFullArray <double> indices, TScalar value)
{
Contract.Requires(array != null);
Contract.Requires(indices != null);
var indicesShape = indices.shape;
if (!indicesShape.IsVector)
{
throw MArrayShapeException.CreateFormatted("Array index must be a vector but has shape {0}.", indicesShape);
}
int indexCount = indices.Count;
for (int i = 0; i < indexCount; i++)
{
array[ToInt(indices[i]) - 1] = value;
}
}
public static void ArraySet <[AnyPrimitive] TScalar>(
MFullArray <TScalar> array, MIntegralRange <double> rowIndices, MIntegralRange <double> columnIndices, MFullArray <TScalar> values)
{
if (array.IsHigherDimensional)
{
throw new MArrayShapeException();
}
int destRowCount = array.shape.RowCount;
if (rowIndices.First < 1 || rowIndices.Last > destRowCount)
{
throw new ArgumentOutOfRangeException("rowIndices");
}
int destColumnCount = array.shape.ColumnCount;
if (columnIndices.First < 1 || columnIndices.Last > destColumnCount)
{
throw new ArgumentOutOfRangeException("columnIndices");
}
int valueRowCount = rowIndices.Count;
int valueColumnCount = columnIndices.Count;
if (values.shape.RowCount != valueRowCount || values.shape.ColumnCount != valueColumnCount || values.IsHigherDimensional)
{
throw new MArrayShapeException();
}
for (int j = 0; j < valueColumnCount; ++j)
{
int destColumnIndex = columnIndices.First + j - 1;
for (int i = 0; i < valueRowCount; ++i)
{
int destRowIndex = rowIndices.First + i - 1;
var value = values.elements[j * valueRowCount + i];
array.elements[destColumnIndex * destRowCount + destRowIndex] = value;
}
}
}
public static MFullArray <TOut> Map <TIn1, TIn2, TOut>(MFullArray <TIn1> array1, MFullArray <TIn2> array2, Func <TIn1, TIn2, TOut> map)
{
Contract.Requires(array1 != null);
Contract.Requires(array2 != null);
Contract.Requires(map != null);
var shape = array1.Shape;
if (array2.Shape != array1.Shape)
{
throw new MArrayShapeException();
}
var result = new MFullArray <TOut>(shape);
for (int i = 0; i < shape.Count; ++i)
{
result[i] = map(array1[i], array2[i]);
}
return(result);
}
public static MFullArray <TOut> Zip <TIn1, TIn2, TOut>(
MFullArray <TIn1> lhs, MFullArray <TIn2> rhs, Func <TIn1, TIn2, TOut> zipper, bool allowScalarArgument)
{
Contract.Requires(lhs != null);
Contract.Requires(rhs != null);
if (lhs.Shape == rhs.Shape)
{
var result = new MFullArray <TOut>(lhs.Shape);
for (int i = 0; i < result.Count; ++i)
{
result[i] = zipper(lhs[i], rhs[i]);
}
return(result);
}
else if (lhs.IsScalar)
{
var lhsScalar = lhs[0];
var result = new MFullArray <TOut>(lhs.Shape);
for (int i = 0; i < result.Count; ++i)
{
result[i] = zipper(lhsScalar, rhs[i]);
}
return(result);
}
else if (rhs.IsScalar)
{
var rhsScalar = rhs[0];
var result = new MFullArray <TOut>(lhs.Shape);
for (int i = 0; i < result.Count; ++i)
{
result[i] = zipper(lhs[i], rhsScalar);
}
return(result);
}
else
{
throw new MArrayShapeException();
}
}
public static MFullArray <TScalar> ArrayGet <[AnyPrimitive] TScalar>(
MFullArray <TScalar> array, MIntegralRange <double> rowIndices, MIntegralRange <double> columnIndices)
{
if (array.IsHigherDimensional)
{
throw new MArrayShapeException();
}
int sourceRowCount = array.shape.RowCount;
if (rowIndices.First < 1 || rowIndices.Last > sourceRowCount)
{
throw new ArgumentOutOfRangeException("rowIndices");
}
int sourceColumnCount = array.shape.ColumnCount;
if (columnIndices.First < 1 || columnIndices.Last > sourceColumnCount)
{
throw new ArgumentOutOfRangeException("columnIndices");
}
int resultRowCount = rowIndices.Count;
int resultColumnCount = columnIndices.Count;
var result = new MFullArray <TScalar>(resultRowCount, resultColumnCount);
for (int j = 0; j < resultColumnCount; ++j)
{
int sourceColumnIndex = columnIndices.First + j - 1;
for (int i = 0; i < resultRowCount; ++i)
{
int sourceRowIndex = rowIndices.First + i - 1;
var sourceValue = array.elements[sourceColumnIndex * sourceRowCount + sourceRowIndex];
result.elements[j * resultRowCount + i] = sourceValue;
}
}
return(result);
}
