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