/// <summary> /// Append a row to the matrix /// </summary> /// <param name="row"></param> protected int AddRow(SparseByteArray row) { int added = _backingArray.AppendRow(row); _dimensions = _backingArray.GetDimensions(); dimensionMultiples = InitDimensionMultiples( isColumnMajor ? Reverse(_dimensions) : _dimensions); return(added); }
/** * Called during mutation operations to simultaneously set the value * on the backing array dynamically. * @param val * @param coordinates */ private void Back(byte val, params int[] coordinates) { //ArrayUtils.SetValue(_backingArray, val, coordinates); _backingArray[coordinates] = val; //update true counts var backingArrayLocal = _backingArray; SparseByteArray coordArray = (SparseByteArray)backingArrayLocal.GetDimensionData(coordinates[0]); //SetTrueCount(coordinates[0], ArrayUtils.AggregateArray(coordArray)); SetTrueCount(coordinates[0], coordArray.AggregateSum()); }
//public virtual AbstractSparseBinaryMatrix Set(int index, object value) //{ // Set(index, (int)(value)); // return this; //} /** * Clears the true counts prior to a cycle where they're * being set */ public override void ClearStatistics(int row) { SetTrueCount(row, 0); SparseByteArray slice = _backingArray.GetRow(row); if (slice != null) { slice.Fill(0); } //Arrays.Fill(slice, 0); }
/// <summary> /// Create sparseArray from given int array /// </summary> /// <param name="array"></param> /// <returns></returns> public static SparseByteArray FromArray(byte[] array) { if (array == null || array.Length == 0) { throw new ArgumentOutOfRangeException("array"); } var indices = ArrayUtils.Where(array, b => b == 1); var indexMap = new ConcurrentDictionary <int, object>(indices.ToDictionary(k => k, v => (object)1)); var spArray = new SparseByteArray(indexMap, new[] { array.Length }, new[] { indices.Length }); return(spArray); }
public void SetRow(int row, SparseByteArray srow) { if (Rank != 2) { throw new InvalidOperationException("This operation only works on 2D matrices"); } _concreteArray[row] = srow._concreteArray; if (row >= _dimensions[0]) { _dimensions[0] = row + 1; Length = _dimensions.Aggregate(1, (i, i1) => i * i1); _dimensionSums[1] = srow._concreteArray.Select(i => (int)i.Value).Sum(); } }
public int AppendRow(SparseByteArray row) { if (Rank != 2) { throw new InvalidOperationException("This operation only works on 2D matrices"); } int nextId = _concreteArray.Keys.Any() ? _concreteArray.Keys.Max() + 1 : 0; _concreteArray.TryAdd(nextId, row._concreteArray); if (nextId >= _dimensions[0]) { _dimensions[0] = nextId + 1; Length = _dimensions.Aggregate(1, (i, i1) => i * i1); _dimensionSums[1] = row._concreteArray.Select(i => (int)i.Value).Sum(); } return(nextId); }
/** * Fills the specified results array with the result of the * matrix vector multiplication. * * @param inputVector the right side vector * @param results the results array */ //public override void RightVecSumAtNZ(int[] inputVector, int[] results) //{ // for (int i = 0; i < _dimensions[0]; i++) // { // SparseArray<byte> slice = (SparseArray<byte>)(_dimensions.Length > 1 ? GetSlice(i) : _backingArray); // for (int j = 0; j < slice.Length; j++) // { // results[i] += (inputVector[j] * slice[j]); // } // } //} public override void RightVecSumAtNZ(int[] inputVector, int[] results) { //////// var mainMatrixPositions = _backingArray.GetSparseIndices(); foreach (int matrixRowIndex in mainMatrixPositions) { SparseByteArray slice = (SparseByteArray)(_dimensions.Length > 1 ? GetSlice(matrixRowIndex) : _backingArray); var sliceIndices = slice.GetSparseIndices(); foreach (int index in sliceIndices) { results[matrixRowIndex] += (inputVector[index] * slice[index]); } } //////// }
/** * Fills the specified results array with the result of the * matrix vector multiplication. * * @param inputVector the right side vector * @param results the results array */ public override void RightVecSumAtNZ(int[] inputVector, int[] results, double stimulusThreshold) { //////// var mainMatrixPositions = _backingArray.GetSparseIndices(); foreach (int matrixRowIndex in mainMatrixPositions) { SparseByteArray slice = (SparseByteArray)(_dimensions.Length > 1 ? GetSlice(matrixRowIndex) : _backingArray); var sliceIndices = slice.GetSparseIndices(); foreach (int index in sliceIndices) { results[matrixRowIndex] += (inputVector[index] * slice[index]); } results[matrixRowIndex] -= results[matrixRowIndex] < stimulusThreshold ? results[matrixRowIndex] : 0; } //////// /// //int dimension = _dimensions[0]; //int[] inputVectorIndices = ArrayUtils.Where(inputVector, ArrayUtils.WHERE_1); ////for (int i = 0; i < dimension; i++) ////{ //Parallel.For(0, dimension, i => //{ // SparseArray<byte> slice = (SparseArray<byte>)(_dimensions.Length > 1 ? GetSlice(i) : _backingArray); // var sliceIndices = slice.GetSparseIndices(); // int j = 0; // foreach (int index in inputVectorIndices.Union(sliceIndices)) // { // results[i] += inputVector[index] * slice[index]; // if (j == slice.Length - 1) // { // results[i] -= results[i] < stimulusThreshold ? results[i] : 0; // } // j++; // } //}); }
/** * Constructs a new {@code SparseBinaryMatrix} with the specified dimensions, * allowing the specification of column major ordering if desired. * (defaults to row major ordering) * * @param dimensions each indexed value is a dimension size * @param useColumnMajorOrdering if true, indicates column first iteration, otherwise * row first iteration is the default (if false). */ public SparseBinaryMatrix(int[] dimensions, bool useColumnMajorOrdering) : base(dimensions, useColumnMajorOrdering) { _backingArray = SparseByteArray.CreateInstance(dimensions); }
public object GetDimensionData(params int[] indices) { if (indices == null || indices.Length == 0) { throw new ArgumentOutOfRangeException("indices", "Cannot get a dimension-date of nothing (too few indices given)"); } if (indices.Length > Rank) { throw new ArgumentOutOfRangeException("indices", "Cannot get a dimension-date of dimensions who are not there! (too many indices given)"); } int outputArrayRank = Rank - indices.Length; if (outputArrayRank == 0) { // Just return the value return(GetValue(indices)); } int[] newArrayDimensions = new int[outputArrayRank]; int startRankOffset = Rank - outputArrayRank; for (int i = 0, j = startRankOffset; i < outputArrayRank; i++) { newArrayDimensions[i] = GetLength(j++); } // Create new destination array SparseByteArray newArray = CreateInstance(newArrayDimensions); // Fillup the new array List <int> origIndices = new List <int>(indices); if (newArray.Rank == 1) // to 1D { //var destArray = newArray; int index1 = origIndices[0]; if (Rank == 2) // from 2D { //Buffer.BlockCopy(givenArray, (index1 * newArray.Length) * Marshal.SizeOf<T>(), // newArray, 0, Marshal.SizeOf<T>() * newArray.Length); newArray = GetRow(index1); } else if (Rank == 3) { //T[,,] srcArray = (T[,,])givenArray; int index2 = origIndices[1]; for (int i = 0; i < newArray.GetLength(0); i++) { byte origValue = this[index1, index2, i]; newArray[i] = origValue; } } else { throw new NotSupportedException("Not yet supported"); } } else if (newArray.Rank == 2) { var destArray = newArray; int index1 = origIndices[0]; if (Rank == 3) { //T[,,] srcArray = (T[,,])givenArray; for (int r0 = 0; r0 < newArray.GetLength(0); r0++) { for (int r1 = 0; r1 < newArray.GetLength(1); r1++) { byte origValue = this[index1, r0, r1]; destArray[r0, r1] = origValue; } } } else { throw new NotSupportedException("Not yet supported (Rank " + newArray.Rank + ")"); } //for (int r0 = 0; r0 < newArray.GetLength(0); r0++) //{ // for (int r1 = 0; r1 < newArray.GetLength(1); r1++) // { // int[] rankList = { r0, r1 }; // int[] rankListGet = new int[0]; // if (origIndices.Count == 1) // { // rankListGet = new[] { origIndices[0], r0, r1 }; // } // else if (origIndices.Count == 2) // { // rankListGet = new[] { origIndices[0], origIndices[1], r0, r1 }; // } // T origValue = (T)givenArray.GetValue(rankListGet); // newArray.SetValue(origValue, rankList); // } //} } return(newArray); }