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

Sparse Linear Algebra: make unchecked setter privately accessible. gh-20.

pull/36/head
Christoph Ruegg 15 years ago
parent
063e74989a
commit
101864e798
4 changed files with 116 additions and 112 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. 57
      src/Numerics/LinearAlgebra/Complex/SparseVector.cs
  2. 57
      src/Numerics/LinearAlgebra/Complex32/SparseVector.cs
  3. 57
      src/Numerics/LinearAlgebra/Double/SparseVector.cs
  4. 57
      src/Numerics/LinearAlgebra/Single/SparseVector.cs

57
src/Numerics/LinearAlgebra/Complex/SparseVector.cs
View File

@ -1181,7 +1181,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
NonZerosCount -= 1;
// Check if the storage needs to be shrink. This is reasonable to do if
// Check if the storage needs to be shrink. This is reasonable to do if
// there are a lot of non-zero elements and storage is two times bigger
if ((NonZerosCount > 1024) && (NonZerosCount < _nonZeroIndices.Length / 2))
{
@ -1196,39 +1196,40 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
}
else
{
if (value == Complex.Zero)
if (value != Complex.Zero)
{
return;
InsertAtUnchecked(~itemIndex, index, value);
}
}
}
itemIndex = ~itemIndex; // Index where to put new value
// Check if the storage needs to be increased
if ((NonZerosCount == _nonZeroValues.Length) && (NonZerosCount < Count))
{
// Value and Indices arrays are completely full so we increase the size
var size = Math.Min(_nonZeroValues.Length + GrowthSize(), Count);
Array.Resize(ref _nonZeroValues, size);
Array.Resize(ref _nonZeroIndices, size);
}
private void InsertAtUnchecked(int itemIndex, int index, Complex value)
{
// Check if the storage needs to be increased
if ((NonZerosCount == _nonZeroValues.Length) && (NonZerosCount < Count))
{
// Value and Indices arrays are completely full so we increase the size
var size = Math.Min(_nonZeroValues.Length + GrowthSize(), Count);
Array.Resize(ref _nonZeroValues, size);
Array.Resize(ref _nonZeroIndices, size);
}
// Move all values (with an position larger than index) in the value array
// to the next position
// move all values (with an position larger than index) in the columIndices
// array to the next position
for (var i = NonZerosCount - 1; i > itemIndex - 1; i--)
{
_nonZeroValues[i + 1] = _nonZeroValues[i];
_nonZeroIndices[i + 1] = _nonZeroIndices[i];
}
// Move all values (with an position larger than index) in the value array
// to the next position
// Move all values (with an position larger than index) in the columIndices
// array to the next position
for (var i = NonZerosCount - 1; i > itemIndex - 1; i--)
{
_nonZeroValues[i + 1] = _nonZeroValues[i];
_nonZeroIndices[i + 1] = _nonZeroIndices[i];
}
// Add the value and the column index
_nonZeroValues[itemIndex] = value;
_nonZeroIndices[itemIndex] = index;
// Add the value and the column index
_nonZeroValues[itemIndex] = value;
_nonZeroIndices[itemIndex] = index;
// increase the number of non-zero numbers by one
NonZerosCount += 1;
}
// increase the number of non-zero numbers by one
NonZerosCount += 1;
}
/// <summary>

57
src/Numerics/LinearAlgebra/Complex32/SparseVector.cs
View File

@ -1211,7 +1211,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
NonZerosCount -= 1;
// Check if the storage needs to be shrink. This is reasonable to do if
// Check if the storage needs to be shrink. This is reasonable to do if
// there are a lot of non-zero elements and storage is two times bigger
if ((NonZerosCount > 1024) && (NonZerosCount < _nonZeroIndices.Length / 2))
{
@ -1226,39 +1226,40 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
}
else
{
if (value == Complex32.Zero)
if (value != Complex32.Zero)
{
return;
InsertAtUnchecked(~itemIndex, index, value);
}
}
}
itemIndex = ~itemIndex; // Index where to put new value
// Check if the storage needs to be increased
if ((NonZerosCount == _nonZeroValues.Length) && (NonZerosCount < Count))
{
// Value and Indices arrays are completely full so we increase the size
var size = Math.Min(_nonZeroValues.Length + GrowthSize(), Count);
Array.Resize(ref _nonZeroValues, size);
Array.Resize(ref _nonZeroIndices, size);
}
private void InsertAtUnchecked(int itemIndex, int index, Complex32 value)
{
// Check if the storage needs to be increased
if ((NonZerosCount == _nonZeroValues.Length) && (NonZerosCount < Count))
{
// Value and Indices arrays are completely full so we increase the size
var size = Math.Min(_nonZeroValues.Length + GrowthSize(), Count);
Array.Resize(ref _nonZeroValues, size);
Array.Resize(ref _nonZeroIndices, size);
}
// Move all values (with an position larger than index) in the value array
// to the next position
// move all values (with an position larger than index) in the columIndices
// array to the next position
for (var i = NonZerosCount - 1; i > itemIndex - 1; i--)
{
_nonZeroValues[i + 1] = _nonZeroValues[i];
_nonZeroIndices[i + 1] = _nonZeroIndices[i];
}
// Move all values (with an position larger than index) in the value array
// to the next position
// Move all values (with an position larger than index) in the columIndices
// array to the next position
for (var i = NonZerosCount - 1; i > itemIndex - 1; i--)
{
_nonZeroValues[i + 1] = _nonZeroValues[i];
_nonZeroIndices[i + 1] = _nonZeroIndices[i];
}
// Add the value and the column index
_nonZeroValues[itemIndex] = value;
_nonZeroIndices[itemIndex] = index;
// Add the value and the column index
_nonZeroValues[itemIndex] = value;
_nonZeroIndices[itemIndex] = index;
// increase the number of non-zero numbers by one
NonZerosCount += 1;
}
// increase the number of non-zero numbers by one
NonZerosCount += 1;
}
/// <summary>

57
src/Numerics/LinearAlgebra/Double/SparseVector.cs
View File

@ -1241,7 +1241,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double
NonZerosCount -= 1;
// Check if the storage needs to be shrink. This is reasonable to do if
// Check if the storage needs to be shrink. This is reasonable to do if
// there are a lot of non-zero elements and storage is two times bigger
if ((NonZerosCount > 1024) && (NonZerosCount < _nonZeroIndices.Length / 2))
{
@ -1256,39 +1256,40 @@ namespace MathNet.Numerics.LinearAlgebra.Double
}
else
{
if (value == 0.0)
if (value != 0.0)
{
return;
InsertAtUnchecked(~itemIndex, index, value);
}
}
}
itemIndex = ~itemIndex; // Index where to put new value
// Check if the storage needs to be increased
if ((NonZerosCount == _nonZeroValues.Length) && (NonZerosCount < Count))
{
// Value and Indices arrays are completely full so we increase the size
var size = Math.Min(_nonZeroValues.Length + GrowthSize(), Count);
Array.Resize(ref _nonZeroValues, size);
Array.Resize(ref _nonZeroIndices, size);
}
private void InsertAtUnchecked(int itemIndex, int index, double value)
{
// Check if the storage needs to be increased
if ((NonZerosCount == _nonZeroValues.Length) && (NonZerosCount < Count))
{
// Value and Indices arrays are completely full so we increase the size
var size = Math.Min(_nonZeroValues.Length + GrowthSize(), Count);
Array.Resize(ref _nonZeroValues, size);
Array.Resize(ref _nonZeroIndices, size);
}
// Move all values (with an position larger than index) in the value array
// to the next position
// move all values (with an position larger than index) in the columIndices
// array to the next position
for (var i = NonZerosCount - 1; i > itemIndex - 1; i--)
{
_nonZeroValues[i + 1] = _nonZeroValues[i];
_nonZeroIndices[i + 1] = _nonZeroIndices[i];
}
// Move all values (with an position larger than index) in the value array
// to the next position
// Move all values (with an position larger than index) in the columIndices
// array to the next position
for (var i = NonZerosCount - 1; i > itemIndex - 1; i--)
{
_nonZeroValues[i + 1] = _nonZeroValues[i];
_nonZeroIndices[i + 1] = _nonZeroIndices[i];
}
// Add the value and the column index
_nonZeroValues[itemIndex] = value;
_nonZeroIndices[itemIndex] = index;
// Add the value and the column index
_nonZeroValues[itemIndex] = value;
_nonZeroIndices[itemIndex] = index;
// increase the number of non-zero numbers by one
NonZerosCount += 1;
}
// increase the number of non-zero numbers by one
NonZerosCount += 1;
}
/// <summary>

57
src/Numerics/LinearAlgebra/Single/SparseVector.cs
View File

@ -1251,7 +1251,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single
NonZerosCount -= 1;
// Check if the storage needs to be shrink. This is reasonable to do if
// Check if the storage needs to be shrink. This is reasonable to do if
// there are a lot of non-zero elements and storage is two times bigger
if ((NonZerosCount > 1024) && (NonZerosCount < _nonZeroIndices.Length / 2))
{
@ -1266,39 +1266,40 @@ namespace MathNet.Numerics.LinearAlgebra.Single
}
else
{
if (value == 0.0)
if (value != 0.0)
{
return;
InsertAtUnchecked(~itemIndex, index, value);
}
}
}
itemIndex = ~itemIndex; // Index where to put new value
// Check if the storage needs to be increased
if ((NonZerosCount == _nonZeroValues.Length) && (NonZerosCount < Count))
{
// Value and Indices arrays are completely full so we increase the size
var size = Math.Min(_nonZeroValues.Length + GrowthSize(), Count);
Array.Resize(ref _nonZeroValues, size);
Array.Resize(ref _nonZeroIndices, size);
}
private void InsertAtUnchecked(int itemIndex, int index, float value)
{
// Check if the storage needs to be increased
if ((NonZerosCount == _nonZeroValues.Length) && (NonZerosCount < Count))
{
// Value and Indices arrays are completely full so we increase the size
var size = Math.Min(_nonZeroValues.Length + GrowthSize(), Count);
Array.Resize(ref _nonZeroValues, size);
Array.Resize(ref _nonZeroIndices, size);
}
// Move all values (with an position larger than index) in the value array
// to the next position
// move all values (with an position larger than index) in the columIndices
// array to the next position
for (var i = NonZerosCount - 1; i > itemIndex - 1; i--)
{
_nonZeroValues[i + 1] = _nonZeroValues[i];
_nonZeroIndices[i + 1] = _nonZeroIndices[i];
}
// Move all values (with an position larger than index) in the value array
// to the next position
// Move all values (with an position larger than index) in the columIndices
// array to the next position
for (var i = NonZerosCount - 1; i > itemIndex - 1; i--)
{
_nonZeroValues[i + 1] = _nonZeroValues[i];
_nonZeroIndices[i + 1] = _nonZeroIndices[i];
}
// Add the value and the column index
_nonZeroValues[itemIndex] = value;
_nonZeroIndices[itemIndex] = index;
// Add the value and the column index
_nonZeroValues[itemIndex] = value;
_nonZeroIndices[itemIndex] = index;
// increase the number of non-zero numbers by one
NonZerosCount += 1;
}
// increase the number of non-zero numbers by one
NonZerosCount += 1;
}
/// <summary>

Write Preview
Loading…
Cancel
Save