ufkc7e3d
/
mathnet-numerics
forked from tsai/mathnet-numerics
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

LA: consistency: enumerators should leverage Zeros-enum, like map/fold already does.

provider
Christoph Ruegg 12 years ago
parent
6edd3ff9e8
commit
0eef2b15b3
9 changed files with 138 additions and 59 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 52
      src/FSharp/LinearAlgebra.Matrix.fs
  2. 52
      src/FSharp/LinearAlgebra.Vector.fs
  3. 2
      src/Numerics/LinearAlgebra/Matrix.Solve.cs
  4. 45
      src/Numerics/LinearAlgebra/Matrix.cs
  5. 38
      src/Numerics/LinearAlgebra/Vector.cs
  6. 2
      src/UnitTests/LinearAlgebraTests/Complex/VectorTests.cs
  7. 2
      src/UnitTests/LinearAlgebraTests/Complex32/VectorTests.cs
  8. 2
      src/UnitTests/LinearAlgebraTests/Double/VectorTests.cs
  9. 2
      src/UnitTests/LinearAlgebraTests/Single/VectorTests.cs

52
src/FSharp/LinearAlgebra.Matrix.fs
View File

@ -43,16 +43,16 @@ module Matrix =
/// Transform a matrix into a sequence.
let inline toSeq (m: #Matrix<_>) = m.Enumerate()
let inline toSeq (m: #Matrix<_>) = m.Enumerate(Zeros.Include)
/// Transform a matrix into an indexed sequence.
let inline toSeqi (m: #Matrix<_>) = m.EnumerateIndexed()
let inline toSeqi (m: #Matrix<_>) = m.EnumerateIndexed(Zeros.Include)
/// Transform a matrix into a sequence where zero-values are skipped. Skipping zeros is efficient on sparse data.
let inline toSeqSkipZeros (m: #Matrix<_>) = m.EnumerateNonZero()
let inline toSeqSkipZeros (m: #Matrix<_>) = m.Enumerate(Zeros.AllowSkip)
/// Transform a matrix into an indexed sequence where zero-values are skipped. Skipping zeros is efficient on sparse data.
let inline toSeqiSkipZeros (m: #Matrix<_>) = m.EnumerateNonZeroIndexed()
let inline toSeqiSkipZeros (m: #Matrix<_>) = m.EnumerateIndexed(Zeros.AllowSkip)
/// Transform a matrix into a column sequence.
let inline toColSeq (m: #Matrix<_>) = m.EnumerateColumns()
@ -68,16 +68,16 @@ module Matrix =
/// Applies a function to all elements of the matrix.
let inline iter f (m: #Matrix<_>) = m.Enumerate() |> Seq.iter f
let inline iter f (m: #Matrix<_>) = m.Enumerate(Zeros.Include) |> Seq.iter f
/// Applies a function to all indexed elements of the matrix.
let inline iteri f (m: #Matrix<_>) = m.EnumerateIndexed() |> Seq.iter (fun (i, j, x) -> f i j x)
let inline iteri f (m: #Matrix<_>) = m.EnumerateIndexed(Zeros.Include) |> Seq.iter (fun (i, j, x) -> f i j x)
/// Applies a function to all non-zero elements of the matrix. Skipping zeros is efficient on sparse data.
let inline iterSkipZerosnz f (m: #Matrix<_>) = m.EnumerateNonZero() |> Seq.iter f
let inline iterSkipZerosnz f (m: #Matrix<_>) = m.Enumerate(Zeros.AllowSkip) |> Seq.iter f
/// Applies a function to all non-zero indexed elements of the matrix. Skipping zeros is efficient on sparse data.
let inline iteriSkipZeros f (m: #Matrix<_>) = m.EnumerateNonZeroIndexed() |> Seq.iter (fun (i, j, x) -> f i j x)
let inline iteriSkipZeros f (m: #Matrix<_>) = m.EnumerateIndexed(Zeros.AllowSkip) |> Seq.iter (fun (i, j, x) -> f i j x)
/// Applies a function to all columns of the matrix.
let inline iterCols f (m: #Matrix<_>) = m.EnumerateColumns() |> Seq.iter f
@ -93,16 +93,16 @@ module Matrix =
/// Fold all entries of a matrix.
let inline fold f state (m: #Matrix<_>) = m.Enumerate() |> Seq.fold f state
let inline fold f state (m: #Matrix<_>) = m.Enumerate(Zeros.Include) |> Seq.fold f state
/// Fold all entries of a matrix with an indexed folding function.
let inline foldi f state (m: #Matrix<_>) = m.EnumerateIndexed() |> Seq.fold (fun s (i,j,x) -> f i j s x) state
let inline foldi f state (m: #Matrix<_>) = m.EnumerateIndexed(Zeros.Include) |> Seq.fold (fun s (i,j,x) -> f i j s x) state
/// Fold all non-zero entries of a matrix. Skipping zeros is efficient on sparse data.
let inline foldSkipZeros f state (m: #Matrix<_>) = m.EnumerateNonZero() |> Seq.fold f state
let inline foldSkipZeros f state (m: #Matrix<_>) = m.Enumerate(Zeros.AllowSkip) |> Seq.fold f state
/// Fold all non-zero entries of a matrix with an indexed folding function. Skipping zeros is efficient on sparse data.
let inline foldiSkipZeros f state (m: #Matrix<_>) = m.EnumerateNonZeroIndexed() |> Seq.fold (fun s (i,j,x) -> f i j s x) state
let inline foldiSkipZeros f state (m: #Matrix<_>) = m.EnumerateIndexed(Zeros.AllowSkip) |> Seq.fold (fun s (i,j,x) -> f i j s x) state
/// Fold all columns of a matrix.
let inline foldCols f state (m: #Matrix<_>) = m.EnumerateColumns() |> Seq.fold f state
@ -118,16 +118,16 @@ module Matrix =
/// Scan all entries of a matrix.
let inline scan f state (m: #Matrix<_>) = m.Enumerate() |> Seq.scan f state
let inline scan f state (m: #Matrix<_>) = m.Enumerate(Zeros.Include) |> Seq.scan f state
/// Scan all entries of a matrix with an indexed folding function.
let inline scani f state (m: #Matrix<_>) = m.EnumerateIndexed() |> Seq.scan (fun s (i,j,x) -> f i j s x) state
let inline scani f state (m: #Matrix<_>) = m.EnumerateIndexed(Zeros.Include) |> Seq.scan (fun s (i,j,x) -> f i j s x) state
/// Scan all non-zero entries of a matrix. Skipping zeros is efficient on sparse data.
let inline scanSkipZeros f state (m: #Matrix<_>) = m.EnumerateNonZero() |> Seq.scan f state
let inline scanSkipZeros f state (m: #Matrix<_>) = m.Enumerate(Zeros.AllowSkip) |> Seq.scan f state
/// Scan all non-zero entries of a matrix with an indexed folding function. Skipping zeros is efficient on sparse data.
let inline scaniSkipZeros f state (m: #Matrix<_>) = m.EnumerateNonZeroIndexed() |> Seq.scan (fun s (i,j,x) -> f i j s x) state
let inline scaniSkipZeros f state (m: #Matrix<_>) = m.EnumerateIndexed(Zeros.AllowSkip) |> Seq.scan (fun s (i,j,x) -> f i j s x) state
/// Scan all columns of a matrix.
let inline scanCols f state (m: #Matrix<_>) = m.EnumerateColumns() |> Seq.scan f state
@ -143,10 +143,10 @@ module Matrix =
/// Reduce all entries of a matrix.
let inline reduce f (m: #Matrix<_>) = m.Enumerate() |> Seq.reduce f
let inline reduce f (m: #Matrix<_>) = m.Enumerate(Zeros.Include) |> Seq.reduce f
/// Reduce all non-zero entries of a matrix. Skipping zeros is efficient on sparse data.
let inline reduceSkipZeros f (m: #Matrix<_>) = m.EnumerateNonZero() |> Seq.reduce f
let inline reduceSkipZeros f (m: #Matrix<_>) = m.Enumerate(Zeros.AllowSkip) |> Seq.reduce f
/// Reduce all columns of a matrix.
let inline reduceCols f (m: #Matrix<_>) = m.EnumerateColumns() |> Seq.reduce f
@ -156,16 +156,16 @@ module Matrix =
/// Checks whether there is an entry in the matrix that satisfies a predicate.
let inline exists p (m: #Matrix<_>) = m.Enumerate() |> Seq.exists p
let inline exists p (m: #Matrix<_>) = m.Enumerate(Zeros.Include) |> Seq.exists p
/// Checks whether there is an entry in the matrix that satisfies a position dependent predicate.
let inline existsi p (m: #Matrix<_>) = m.EnumerateIndexed() |> Seq.exists (fun (i,j,x) -> p i j x)
let inline existsi p (m: #Matrix<_>) = m.EnumerateIndexed(Zeros.Include) |> Seq.exists (fun (i,j,x) -> p i j x)
/// Checks whether there is a non-zero entry in the matrix that satisfies a predicate. Skipping zeros is efficient on sparse data.
let inline existsSkipZeros p (m: #Matrix<_>) = m.EnumerateNonZero() |> Seq.exists p
let inline existsSkipZeros p (m: #Matrix<_>) = m.Enumerate(Zeros.AllowSkip) |> Seq.exists p
/// Checks whether there is a non-zero entry in the matrix that satisfies a position dependent predicate. Skipping zeros is efficient on sparse data.
let inline existsiSkipZeros p (m: #Matrix<_>) = m.EnumerateNonZeroIndexed() |> Seq.exists (fun (i,j,x) -> p i j x)
let inline existsiSkipZeros p (m: #Matrix<_>) = m.EnumerateIndexed(Zeros.AllowSkip) |> Seq.exists (fun (i,j,x) -> p i j x)
/// Checks whether there is a column in the matrix that satisfies a predicate.
let inline existsCol p (m: #Matrix<_>) = m.EnumerateColumns() |> Seq.exists p
@ -181,16 +181,16 @@ module Matrix =
/// Checks whether all entries in the matrix that satisfies a given predicate.
let inline forall p (m: #Matrix<_>) = m.Enumerate() |> Seq.forall p
let inline forall p (m: #Matrix<_>) = m.Enumerate(Zeros.Include) |> Seq.forall p
/// Checks whether all entries in the matrix that satisfies a given position dependent predicate.
let inline foralli p (m: #Matrix<_>) = m.EnumerateIndexed() |> Seq.forall (fun (i,j,x) -> p i j x)
let inline foralli p (m: #Matrix<_>) = m.EnumerateIndexed(Zeros.Include) |> Seq.forall (fun (i,j,x) -> p i j x)
/// Checks whether all non-zero entries in the matrix that satisfies a given predicate. Skipping zeros is efficient on sparse data.
let inline forallSkipZeros p (m: #Matrix<_>) = m.EnumerateNonZero() |> Seq.forall p
let inline forallSkipZeros p (m: #Matrix<_>) = m.Enumerate(Zeros.AllowSkip) |> Seq.forall p
/// Checks whether all non-zero entries in the matrix that satisfies a given position dependent predicate. Skipping zeros is efficient on sparse data.
let inline foralliSkipZeros p (m: #Matrix<_>) = m.EnumerateNonZeroIndexed() |> Seq.forall (fun (i,j,x) -> p i j x)
let inline foralliSkipZeros p (m: #Matrix<_>) = m.EnumerateIndexed(Zeros.AllowSkip) |> Seq.forall (fun (i,j,x) -> p i j x)
/// Checks whether all columns in the matrix that satisfy a predicate.
let inline forallCols p (m: #Matrix<_>) = m.EnumerateColumns() |> Seq.forall p

52
src/FSharp/LinearAlgebra.Vector.fs
View File

@ -46,88 +46,88 @@ module Vector =
/// Transform a vector into a sequence.
let inline toSeq (v: #Vector<_>) = v.Enumerate()
let inline toSeq (v: #Vector<_>) = v.Enumerate(Zeros.Include)
/// Transform a vector into an indexed sequence.
let inline toSeqi (v: #Vector<_>) = v.EnumerateIndexed()
let inline toSeqi (v: #Vector<_>) = v.EnumerateIndexed(Zeros.Include)
/// Transform a vector into a sequence where zero-values are skipped. Skipping zeros is efficient on sparse data.
let inline toSeqSkipZeros (v: #Vector<_>) = v.EnumerateNonZero()
let inline toSeqSkipZeros (v: #Vector<_>) = v.Enumerate(Zeros.AllowSkip)
/// Transform a vector into an indexed sequence where zero-values are skipped. Skipping zeros is efficient on sparse data.
let inline toSeqiSkipZeros (v: #Vector<_>) = v.EnumerateNonZeroIndexed()
let inline toSeqiSkipZeros (v: #Vector<_>) = v.EnumerateIndexed(Zeros.AllowSkip)
/// Applies a function to all elements of the vector.
let inline iter f (v: #Vector<_>) = v.Enumerate() |> Seq.iter f
let inline iter f (v: #Vector<_>) = v.Enumerate(Zeros.Include) |> Seq.iter f
/// Applies a function to all indexed elements of the vector.
let inline iteri f (v: #Vector<_>) = v.Enumerate() |> Seq.iteri f
let inline iteri f (v: #Vector<_>) = v.Enumerate(Zeros.Include) |> Seq.iteri f
/// Applies a function to all non-zero elements of the vector. Skipping zeros is efficient on sparse data.
let inline iterSkipZeros f (v: #Vector<_>) = v.EnumerateNonZero() |> Seq.iter f
let inline iterSkipZeros f (v: #Vector<_>) = v.Enumerate(Zeros.AllowSkip) |> Seq.iter f
/// Applies a function to all non-zero indexed elements of the vector. Skipping zeros is efficient on sparse data.
let inline iteriSkipZeros f (v: #Vector<_>) = v.EnumerateNonZeroIndexed() |> Seq.iter (fun (i,x) -> f i x)
let inline iteriSkipZeros f (v: #Vector<_>) = v.EnumerateIndexed(Zeros.AllowSkip) |> Seq.iter (fun (i,x) -> f i x)
/// Fold all entries of a vector.
let inline fold f state (v: #Vector<_>) = v.Enumerate() |> Seq.fold f state
let inline fold f state (v: #Vector<_>) = v.Enumerate(Zeros.Include) |> Seq.fold f state
/// Fold all entries of a vector using a position dependent folding function.
let inline foldi f state (v: #Vector<_>) = v.EnumerateIndexed() |> Seq.fold (fun s (i,x) -> f i s x) state
let inline foldi f state (v: #Vector<_>) = v.EnumerateIndexed(Zeros.Include) |> Seq.fold (fun s (i,x) -> f i s x) state
/// Fold all non-zero entries of a vector. Skipping zeros is efficient on sparse data.
let inline foldSkipZeros f state (v: #Vector<_>) = v.EnumerateNonZero() |> Seq.fold f state
let inline foldSkipZeros f state (v: #Vector<_>) = v.Enumerate(Zeros.AllowSkip) |> Seq.fold f state
/// Fold all non-zero entries of a vector using a position dependent folding function. Skipping zeros is efficient on sparse data.
let inline foldiSkipZeros f state (v: #Vector<_>) = v.EnumerateNonZeroIndexed() |> Seq.fold (fun s (i,x) -> f i s x) state
let inline foldiSkipZeros f state (v: #Vector<_>) = v.EnumerateIndexed(Zeros.AllowSkip) |> Seq.fold (fun s (i,x) -> f i s x) state
/// Scan all entries of a vector.
let inline scan f state (v: #Vector<_>) = v.Enumerate() |> Seq.scan f state
let inline scan f state (v: #Vector<_>) = v.Enumerate(Zeros.Include) |> Seq.scan f state
/// Scan all entries of a vector using a position dependent folding function.
let inline scani f state (v: #Vector<_>) = v.EnumerateIndexed() |> Seq.scan (fun s (i,x) -> f i s x) state
let inline scani f state (v: #Vector<_>) = v.EnumerateIndexed(Zeros.Include) |> Seq.scan (fun s (i,x) -> f i s x) state
/// Scan all non-zero entries of a vector. Skipping zeros is efficient on sparse data.
let inline scanSkipZeros f state (v: #Vector<_>) = v.EnumerateNonZero() |> Seq.scan f state
let inline scanSkipZeros f state (v: #Vector<_>) = v.Enumerate(Zeros.AllowSkip) |> Seq.scan f state
/// Scan all non-zero entries of a vector using a position dependent folding function. Skipping zeros is efficient on sparse data.
let inline scaniSkipZeros f state (v: #Vector<_>) = v.EnumerateNonZeroIndexed() |> Seq.scan (fun s (i,x) -> f i s x) state
let inline scaniSkipZeros f state (v: #Vector<_>) = v.EnumerateIndexed(Zeros.AllowSkip) |> Seq.scan (fun s (i,x) -> f i s x) state
/// Reduce all entries of a vector.
let inline reduce f (v: #Vector<_>) = v.Enumerate() |> Seq.reduce f
let inline reduce f (v: #Vector<_>) = v.Enumerate(Zeros.Include) |> Seq.reduce f
/// Reduce all non-zero entries of a vector. Skipping zeros is efficient on sparse data.
let inline reduceSkipZeros f (v: #Vector<_>) = v.EnumerateNonZero() |> Seq.reduce f
let inline reduceSkipZeros f (v: #Vector<_>) = v.Enumerate(Zeros.AllowSkip) |> Seq.reduce f
/// Checks whether there is an entry in the vector that satisfies a predicate.
let inline exists p (v: #Vector<_>) = v.Enumerate() |> Seq.exists p
let inline exists p (v: #Vector<_>) = v.Enumerate(Zeros.Include) |> Seq.exists p
/// Checks whether there is an entry in the vector that satisfies a position dependent predicate.
let inline existsi p (v: #Vector<_>) = v.EnumerateIndexed() |> Seq.exists (fun (i,x) -> p i x)
let inline existsi p (v: #Vector<_>) = v.EnumerateIndexed(Zeros.Include) |> Seq.exists (fun (i,x) -> p i x)
/// Checks whether there is a non-zero entry in the vector that satisfies a predicate. Skipping zeros is efficient on sparse data.
let inline existsSkipZeros p (v: #Vector<_>) = v.EnumerateNonZero() |> Seq.exists p
let inline existsSkipZeros p (v: #Vector<_>) = v.Enumerate(Zeros.AllowSkip) |> Seq.exists p
/// Checks whether there is a non-zero entry in the vector that satisfies a position dependent predicate. Skipping zeros is efficient on sparse data.
let inline existsiSkipZeros p (v: #Vector<_>) = v.EnumerateNonZeroIndexed() |> Seq.exists (fun (i,x) -> p i x)
let inline existsiSkipZeros p (v: #Vector<_>) = v.EnumerateIndexed(Zeros.AllowSkip) |> Seq.exists (fun (i,x) -> p i x)
/// Checks whether all entries in the vector that satisfies a given predicate.
let inline forall p (v: #Vector<_>) = v.Enumerate() |> Seq.forall p
let inline forall p (v: #Vector<_>) = v.Enumerate(Zeros.Include) |> Seq.forall p
/// Checks whether all entries in the vector that satisfies a given position dependent predicate.
let inline foralli p (v: #Vector<_>) = v.EnumerateIndexed() |> Seq.forall (fun (i,x) -> p i x)
let inline foralli p (v: #Vector<_>) = v.EnumerateIndexed(Zeros.Include) |> Seq.forall (fun (i,x) -> p i x)
/// Checks whether all non-zero entries in the vector that satisfies a given predicate. Skipping zeros is efficient on sparse data.
let inline forallSkipZeros p (v: #Vector<_>) = v.EnumerateNonZero() |> Seq.forall p
let inline forallSkipZeros p (v: #Vector<_>) = v.Enumerate(Zeros.AllowSkip) |> Seq.forall p
/// Checks whether all non-zero entries in the vector that satisfies a given position dependent predicate. Skipping zeros is efficient on sparse data.
let inline foralliSkipZeros p (v: #Vector<_>) = v.EnumerateNonZeroIndexed() |> Seq.forall (fun (i,x) -> p i x)
let inline foralliSkipZeros p (v: #Vector<_>) = v.EnumerateIndexed(Zeros.AllowSkip) |> Seq.forall (fun (i,x) -> p i x)

2
src/Numerics/LinearAlgebra/Matrix.Solve.cs
View File

@ -205,7 +205,7 @@ namespace MathNet.Numerics.LinearAlgebra
solver.Solve(this, input.Column(column), solution, iterator, preconditioner);
foreach (var element in solution.EnumerateNonZeroIndexed())
foreach (var element in solution.EnumerateIndexed(Zeros.AllowSkip))
{
result.At(element.Item1, column, element.Item2);
}

45
src/Numerics/LinearAlgebra/Matrix.cs
View File

@ -1331,7 +1331,7 @@ namespace MathNet.Numerics.LinearAlgebra
/// </pre></example>
/// <returns>An array containing the matrix's elements.</returns>
/// <seealso cref="ToRowWiseArray"/>
/// <seealso cref="Enumerate"/>
/// <seealso cref="Enumerate(Zeros)"/>
public T[] ToColumnWiseArray()
{
return Storage.ToColumnMajorArray();
@ -1347,7 +1347,7 @@ namespace MathNet.Numerics.LinearAlgebra
/// </pre></example>
/// <returns>An array containing the matrix's elements.</returns>
/// <seealso cref="ToColumnWiseArray"/>
/// <seealso cref="Enumerate"/>
/// <seealso cref="Enumerate(Zeros)"/>
public T[] ToRowWiseArray()
{
return Storage.ToRowMajorArray();
@ -1367,6 +1367,26 @@ namespace MathNet.Numerics.LinearAlgebra
return Storage.Enumerate();
}
/// <summary>
/// Returns an IEnumerable that can be used to iterate through all values of the matrix.
/// </summary>
/// <remarks>
/// The enumerator will include all values, even if they are zero.
/// The ordering of the values is unspecified (not necessarily column-wise or row-wise).
/// </remarks>
/// <seealso cref="ToColumnWiseArray"/>
/// <seealso cref="ToRowWiseArray"/>
public IEnumerable<T> Enumerate(Zeros zeros = Zeros.Include)
{
switch (zeros)
{
case Zeros.AllowSkip:
return Storage.EnumerateNonZero();
default:
return Storage.Enumerate();
}
}
/// <summary>
/// Returns an IEnumerable that can be used to iterate through all values of the matrix and their index.
/// </summary>
@ -1380,12 +1400,32 @@ namespace MathNet.Numerics.LinearAlgebra
return Storage.EnumerateIndexed();
}
/// <summary>
/// Returns an IEnumerable that can be used to iterate through all values of the matrix and their index.
/// </summary>
/// <remarks>
/// The enumerator returns a Tuple with the first two values being the row and column index
/// and the third value being the value of the element at that index.
/// The enumerator will include all values, even if they are zero.
/// </remarks>
public IEnumerable<Tuple<int, int, T>> EnumerateIndexed(Zeros zeros = Zeros.Include)
{
switch (zeros)
{
case Zeros.AllowSkip:
return Storage.EnumerateNonZeroIndexed();
default:
return Storage.EnumerateIndexed();
}
}
/// <summary>
/// Returns an IEnumerable that can be used to iterate through all non-zero values of the matrix.
/// </summary>
/// <remarks>
/// The enumerator will skip all elements with a zero value.
/// </remarks>
[Obsolete("Use Enumerate(Zeros.AllowSkip) instead. Will be removed in v4.")]
public IEnumerable<T> EnumerateNonZero()
{
return Storage.EnumerateNonZero();
@ -1399,6 +1439,7 @@ namespace MathNet.Numerics.LinearAlgebra
/// and the third value being the value of the element at that index.
/// The enumerator will skip all elements with a zero value.
/// </remarks>
[Obsolete("Use EnumerateIndexed(Zeros.AllowSkip) instead. Will be removed in v4.")]
public IEnumerable<Tuple<int, int, T>> EnumerateNonZeroIndexed()
{
return Storage.EnumerateNonZeroIndexed();

38
src/Numerics/LinearAlgebra/Vector.cs
View File

@ -287,6 +287,23 @@ namespace MathNet.Numerics.LinearAlgebra
return Storage.Enumerate();
}
/// <summary>
/// Returns an IEnumerable that can be used to iterate through all values of the vector.
/// </summary>
/// <remarks>
/// The enumerator will include all values, even if they are zero.
/// </remarks>
public IEnumerable<T> Enumerate(Zeros zeros = Zeros.Include)
{
switch (zeros)
{
case Zeros.AllowSkip:
return Storage.EnumerateNonZero();
default:
return Storage.Enumerate();
}
}
/// <summary>
/// Returns an IEnumerable that can be used to iterate through all values of the vector and their index.
/// </summary>
@ -300,12 +317,32 @@ namespace MathNet.Numerics.LinearAlgebra
return Storage.EnumerateIndexed();
}
/// <summary>
/// Returns an IEnumerable that can be used to iterate through all values of the vector and their index.
/// </summary>
/// <remarks>
/// The enumerator returns a Tuple with the first value being the element index
/// and the second value being the value of the element at that index.
/// The enumerator will include all values, even if they are zero.
/// </remarks>
public IEnumerable<Tuple<int, T>> EnumerateIndexed(Zeros zeros = Zeros.Include)
{
switch (zeros)
{
case Zeros.AllowSkip:
return Storage.EnumerateNonZeroIndexed();
default:
return Storage.EnumerateIndexed();
}
}
/// <summary>
/// Returns an IEnumerable that can be used to iterate through all non-zero values of the vector.
/// </summary>
/// <remarks>
/// The enumerator will skip all elements with a zero value.
/// </remarks>
[Obsolete("Use Enumerate(Zeros.AllowSkip) instead. Will be removed in v4.")]
public IEnumerable<T> EnumerateNonZero()
{
return Storage.EnumerateNonZero();
@ -319,6 +356,7 @@ namespace MathNet.Numerics.LinearAlgebra
/// and the second value being the value of the element at that index.
/// The enumerator will skip all elements with a zero value.
/// </remarks>
[Obsolete("Use EnumerateIndexed(Zeros.AllowSkip) instead. Will be removed in v4.")]
public IEnumerable<Tuple<int, T>> EnumerateNonZeroIndexed()
{
return Storage.EnumerateNonZeroIndexed();

2
src/UnitTests/LinearAlgebraTests/Complex/VectorTests.cs
View File

@ -251,7 +251,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
public void CanEnumerateOverVectorUsingNonZeroEnumerator()
{
var vector = CreateVector(Data);
foreach (var pair in vector.EnumerateNonZeroIndexed())
foreach (var pair in vector.EnumerateIndexed(Zeros.AllowSkip))
{
Assert.AreEqual(Data[pair.Item1], pair.Item2);
Assert.AreNotEqual(Complex.Zero, pair.Item2);

2
src/UnitTests/LinearAlgebraTests/Complex32/VectorTests.cs
View File

@ -247,7 +247,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
public void CanEnumerateOverVectorUsingNonZeroEnumerator()
{
var vector = CreateVector(Data);
foreach (var pair in vector.EnumerateNonZeroIndexed())
foreach (var pair in vector.EnumerateIndexed(Zeros.AllowSkip))
{
Assert.AreEqual(Data[pair.Item1], pair.Item2);
Assert.AreNotEqual(Complex32.Zero, pair.Item2);

2
src/UnitTests/LinearAlgebraTests/Double/VectorTests.cs
View File

@ -243,7 +243,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
public void CanEnumerateOverVectorUsingNonZeroEnumerator()
{
var vector = CreateVector(Data);
foreach (var pair in vector.EnumerateNonZeroIndexed())
foreach (var pair in vector.EnumerateIndexed(Zeros.AllowSkip))
{
Assert.AreEqual(Data[pair.Item1], pair.Item2);
Assert.AreNotEqual(0d, pair.Item2);

2
src/UnitTests/LinearAlgebraTests/Single/VectorTests.cs
View File

@ -244,7 +244,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
public void CanEnumerateOverVectorUsingNonZeroEnumerator()
{
var vector = CreateVector(Data);
foreach (var pair in vector.EnumerateNonZeroIndexed())
foreach (var pair in vector.EnumerateIndexed(Zeros.AllowSkip))
{
Assert.AreEqual(Data[pair.Item1], pair.Item2);
Assert.AreNotEqual(0f, pair.Item2);

Write Preview
Loading…
Cancel
Save