forked from tsai/mathnet-numerics
Christoph Ruegg
14 years ago
66 changed files with 1805 additions and 2670 deletions
@ -0,0 +1,333 @@ |
|||||
|
using System; |
||||
|
using MathNet.Numerics.Properties; |
||||
|
|
||||
|
namespace MathNet.Numerics.LinearAlgebra.Storage |
||||
|
{ |
||||
|
[Serializable] |
||||
|
public class SparseVectorStorage<T> : VectorStorage<T> |
||||
|
where T : struct, IEquatable<T>, IFormattable |
||||
|
{ |
||||
|
// [ruegg] public fields are OK here
|
||||
|
|
||||
|
readonly T _zero; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Array that contains the indices of the non-zero values.
|
||||
|
/// </summary>
|
||||
|
public int[] Indices; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Array that contains the non-zero elements of the vector.
|
||||
|
/// </summary>
|
||||
|
public T[] Values; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the number of non-zero elements in the vector.
|
||||
|
/// </summary>
|
||||
|
public int ValueCount; |
||||
|
|
||||
|
internal SparseVectorStorage(int length, T zero = default(T)) |
||||
|
: base(length) |
||||
|
{ |
||||
|
_zero = zero; |
||||
|
Indices = new int[0]; |
||||
|
Values = new T[0]; |
||||
|
ValueCount = 0; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Retrieves the requested element without range checking.
|
||||
|
/// </summary>
|
||||
|
public override T At(int index) |
||||
|
{ |
||||
|
// Search if item idex exists in NonZeroIndices array in range "0 - nonzero values count"
|
||||
|
var itemIndex = Array.BinarySearch(Indices, 0, ValueCount, index); |
||||
|
return itemIndex >= 0 ? Values[itemIndex] : _zero; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Sets the element without range checking.
|
||||
|
/// </summary>
|
||||
|
public override void At(int index, T value) |
||||
|
{ |
||||
|
// Search if "index" already exists in range "0 - nonzero values count"
|
||||
|
var itemIndex = Array.BinarySearch(Indices, 0, ValueCount, index); |
||||
|
if (itemIndex >= 0) |
||||
|
{ |
||||
|
// Non-zero item found in matrix
|
||||
|
if (_zero.Equals(value)) |
||||
|
{ |
||||
|
// Delete existing item
|
||||
|
RemoveAtIndexUnchecked(itemIndex); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
// Update item
|
||||
|
Values[itemIndex] = value; |
||||
|
} |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
// Item not found. Add new value
|
||||
|
if (!_zero.Equals(value)) |
||||
|
{ |
||||
|
InsertAtIndexUnchecked(~itemIndex, index, value); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void InsertAtIndexUnchecked(int itemIndex, int index, T value) |
||||
|
{ |
||||
|
// Check if the storage needs to be increased
|
||||
|
if ((ValueCount == Values.Length) && (ValueCount < Length)) |
||||
|
{ |
||||
|
// Value and Indices arrays are completely full so we increase the size
|
||||
|
var size = Math.Min(Values.Length + GrowthSize(), Length); |
||||
|
Array.Resize(ref Values, size); |
||||
|
Array.Resize(ref Indices, size); |
||||
|
} |
||||
|
|
||||
|
// Move all values (with a position larger than index) in the value array to the next position
|
||||
|
// Move all values (with a position larger than index) in the columIndices array to the next position
|
||||
|
Array.Copy(Values, itemIndex, Values, itemIndex + 1, ValueCount - itemIndex); |
||||
|
Array.Copy(Indices, itemIndex, Indices, itemIndex + 1, ValueCount - itemIndex); |
||||
|
|
||||
|
// Add the value and the column index
|
||||
|
Values[itemIndex] = value; |
||||
|
Indices[itemIndex] = index; |
||||
|
|
||||
|
// increase the number of non-zero numbers by one
|
||||
|
ValueCount += 1; |
||||
|
} |
||||
|
|
||||
|
void RemoveAtIndexUnchecked(int itemIndex) |
||||
|
{ |
||||
|
// Value is zero. Let's delete it from Values and Indices array
|
||||
|
Array.Copy(Values, itemIndex + 1, Values, itemIndex, ValueCount - itemIndex - 1); |
||||
|
Array.Copy(Indices, itemIndex + 1, Indices, itemIndex, ValueCount - itemIndex - 1); |
||||
|
|
||||
|
ValueCount -= 1; |
||||
|
|
||||
|
// Check whether we need to shrink the arrays. This is reasonable to do if
|
||||
|
// there are a lot of non-zero elements and storage is two times bigger
|
||||
|
if ((ValueCount > 1024) && (ValueCount < Indices.Length / 2)) |
||||
|
{ |
||||
|
Array.Resize(ref Values, ValueCount); |
||||
|
Array.Resize(ref Indices, ValueCount); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Calculates the amount with which to grow the storage array's if they need to be
|
||||
|
/// increased in size.
|
||||
|
/// </summary>
|
||||
|
/// <returns>The amount grown.</returns>
|
||||
|
int GrowthSize() |
||||
|
{ |
||||
|
int delta; |
||||
|
if (Values.Length > 1024) |
||||
|
{ |
||||
|
delta = Values.Length / 4; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
if (Values.Length > 256) |
||||
|
{ |
||||
|
delta = 512; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
delta = Values.Length > 64 ? 128 : 32; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return delta; |
||||
|
} |
||||
|
|
||||
|
public override void Clear() |
||||
|
{ |
||||
|
ValueCount = 0; |
||||
|
} |
||||
|
|
||||
|
public override void Clear(int index, int count) |
||||
|
{ |
||||
|
if (index == 0 && count == Length) |
||||
|
{ |
||||
|
Clear(); |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
var first = Array.BinarySearch(Indices, 0, ValueCount, index); |
||||
|
var last = Array.BinarySearch(Indices, 0, ValueCount, index + count - 1); |
||||
|
if (first < 0) first = ~first; |
||||
|
if (last < 0) last = ~last - 1; |
||||
|
int itemCount = last - first + 1; |
||||
|
|
||||
|
if (itemCount > 0) |
||||
|
{ |
||||
|
Array.Copy(Values, first + count, Values, first, ValueCount - first - count); |
||||
|
Array.Copy(Indices, first + count, Indices, first, ValueCount - first - count); |
||||
|
|
||||
|
ValueCount -= count; |
||||
|
} |
||||
|
|
||||
|
// Check whether we need to shrink the arrays. This is reasonable to do if
|
||||
|
// there are a lot of non-zero elements and storage is two times bigger
|
||||
|
if ((ValueCount > 1024) && (ValueCount < Indices.Length / 2)) |
||||
|
{ |
||||
|
Array.Resize(ref Values, ValueCount); |
||||
|
Array.Resize(ref Indices, ValueCount); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <remarks>Parameters assumed to be validated already.</remarks>
|
||||
|
public override void CopyTo(VectorStorage<T> target, bool skipClearing = false) |
||||
|
{ |
||||
|
var sparseTarget = target as SparseVectorStorage<T>; |
||||
|
if (sparseTarget != null) |
||||
|
{ |
||||
|
CopyTo(sparseTarget); |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
// FALL BACK
|
||||
|
|
||||
|
if (!skipClearing) |
||||
|
{ |
||||
|
target.Clear(); |
||||
|
} |
||||
|
|
||||
|
if (ValueCount != 0) |
||||
|
{ |
||||
|
for (int i = 0; i < ValueCount; i++) |
||||
|
{ |
||||
|
target.At(Indices[i], Values[i]); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void CopyTo(SparseVectorStorage<T> target) |
||||
|
{ |
||||
|
if (ReferenceEquals(this, target)) |
||||
|
{ |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
if (Length != target.Length) |
||||
|
{ |
||||
|
var message = string.Format(Resources.ArgumentMatrixDimensions2, Length, target.Length); |
||||
|
throw new ArgumentException(message, "target"); |
||||
|
} |
||||
|
|
||||
|
target.ValueCount = ValueCount; |
||||
|
target.Values = new T[ValueCount]; |
||||
|
target.Indices = new int[ValueCount]; |
||||
|
|
||||
|
if (ValueCount != 0) |
||||
|
{ |
||||
|
Array.Copy(Values, target.Values, ValueCount); |
||||
|
Buffer.BlockCopy(Indices, 0, target.Indices, 0, ValueCount * Constants.SizeOfInt); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public override void CopySubVectorTo(VectorStorage<T> target, |
||||
|
int sourceIndex, int targetIndex, int count, |
||||
|
bool skipClearing = false) |
||||
|
{ |
||||
|
ValidateSubVectorRange(target, sourceIndex, targetIndex, count); |
||||
|
|
||||
|
var sparseTarget = target as SparseVectorStorage<T>; |
||||
|
if (sparseTarget != null) |
||||
|
{ |
||||
|
CopySubVectorTo(sparseTarget, sourceIndex, targetIndex, count, skipClearing); |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
// FALL BACK
|
||||
|
|
||||
|
var offset = targetIndex - sourceIndex; |
||||
|
|
||||
|
var sourceFirst = Array.BinarySearch(Indices, 0, ValueCount, sourceIndex); |
||||
|
var sourceLast = Array.BinarySearch(Indices, 0, ValueCount, sourceIndex + count - 1); |
||||
|
if (sourceFirst < 0) sourceFirst = ~sourceFirst; |
||||
|
if (sourceLast < 0) sourceLast = ~sourceLast - 1; |
||||
|
|
||||
|
if (!skipClearing) |
||||
|
{ |
||||
|
target.Clear(targetIndex, count); |
||||
|
} |
||||
|
|
||||
|
for (int i = sourceFirst; i <= sourceLast; i++) |
||||
|
{ |
||||
|
target.At(Indices[i] + offset, Values[i]); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void CopySubVectorTo(SparseVectorStorage<T> target, |
||||
|
int sourceIndex, int targetIndex, int count, |
||||
|
bool skipClearing) |
||||
|
{ |
||||
|
var offset = targetIndex - sourceIndex; |
||||
|
|
||||
|
var sourceFirst = Array.BinarySearch(Indices, 0, ValueCount, sourceIndex); |
||||
|
var sourceLast = Array.BinarySearch(Indices, 0, ValueCount, sourceIndex + count - 1); |
||||
|
if (sourceFirst < 0) sourceFirst = ~sourceFirst; |
||||
|
if (sourceLast < 0) sourceLast = ~sourceLast - 1; |
||||
|
int sourceCount = sourceLast - sourceFirst + 1; |
||||
|
|
||||
|
// special case when copying to itself
|
||||
|
if (ReferenceEquals(this, target)) |
||||
|
{ |
||||
|
var values = new T[sourceCount]; |
||||
|
var indices = new int[sourceCount]; |
||||
|
|
||||
|
Array.Copy(Values, sourceFirst, values, 0, sourceCount); |
||||
|
for (int i = 0; i < indices.Length; i++) |
||||
|
{ |
||||
|
indices[i] = Indices[i + sourceFirst]; |
||||
|
} |
||||
|
|
||||
|
if (!skipClearing) |
||||
|
{ |
||||
|
Clear(targetIndex, count); |
||||
|
} |
||||
|
|
||||
|
for (int i = sourceFirst; i <= sourceLast; i++) |
||||
|
{ |
||||
|
At(indices[i] + offset, values[i]); |
||||
|
} |
||||
|
|
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
// special case for empty target - much faster
|
||||
|
if (target.ValueCount == 0) |
||||
|
{ |
||||
|
var values = new T[sourceCount]; |
||||
|
var indices = new int[sourceCount]; |
||||
|
|
||||
|
Array.Copy(Values, sourceFirst, values, 0, sourceCount); |
||||
|
for (int i = 0; i < indices.Length; i++) |
||||
|
{ |
||||
|
indices[i] = Indices[i + sourceFirst] + offset; |
||||
|
} |
||||
|
|
||||
|
target.ValueCount = sourceCount; |
||||
|
target.Values = values; |
||||
|
target.Indices = indices; |
||||
|
|
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
if (!skipClearing) |
||||
|
{ |
||||
|
target.Clear(targetIndex, count); |
||||
|
} |
||||
|
|
||||
|
for (int i = sourceFirst; i <= sourceLast; i++) |
||||
|
{ |
||||
|
target.At(Indices[i] + offset, Values[i]); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
Loading…
Reference in new issue