Simplification: value tuple swaps

cdrnet · cdrnet · commit baab796c4c0f · 2022-04-03T13:30:08.000+02:00
diff --git a/src/Numerics/LinearAlgebra/Complex/Factorization/UserLU.cs b/src/Numerics/LinearAlgebra/Complex/Factorization/UserLU.cs
@@ -261,9 +261,7 @@ public override void Solve(Vector<Complex> input, Vector<Complex> result)
                 }
 
                 var p = Pivots[i];
-                var temp = result[p];
-                result[p] = result[i];
-                result[i] = temp;
+                (result[p], result[i]) = (result[i], result[p]);
             }
 
             var order = Factors.RowCount;
diff --git a/src/Numerics/LinearAlgebra/Complex/Solvers/ILUTPPreconditioner.cs b/src/Numerics/LinearAlgebra/Complex/Solvers/ILUTPPreconditioner.cs
@@ -499,9 +499,7 @@ public void Initialize(Matrix<Complex> matrix)
                         SwapColumns(_upper, i, indexSorting[0]);
 
                         // Update P
-                        var temp = _pivots[i];
-                        _pivots[i] = _pivots[indexSorting[0]];
-                        _pivots[indexSorting[0]] = temp;
+                        (_pivots[i], _pivots[indexSorting[0]]) = (_pivots[indexSorting[0]], _pivots[i]);
                     }
                 }
 
@@ -531,9 +529,7 @@ void PivotRow(Vector<Complex> row)
                     // store the pivots in the hashtable
                     knownPivots.Add(_pivots[i], i);
 
-                    var t = row[i];
-                    row[i] = row[_pivots[i]];
-                    row[_pivots[i]] = t;
+                    (row[i], row[_pivots[i]]) = (row[_pivots[i]], row[i]);
                 }
             }
         }
@@ -569,9 +565,7 @@ static void SwapColumns(Matrix<Complex> matrix, int firstColumn, int secondColum
         {
             for (var i = 0; i < matrix.RowCount; i++)
             {
-                var temp = matrix[i, firstColumn];
-                matrix[i, firstColumn] = matrix[i, secondColumn];
-                matrix[i, secondColumn] = temp;
+                (matrix[i, firstColumn], matrix[i, secondColumn]) = (matrix[i, secondColumn], matrix[i, firstColumn]);
             }
         }
 
@@ -856,9 +850,7 @@ static void Sift(int[] values, int start, int count)
         /// <param name="second">Second value to exchange</param>
         static void Exchange(int[] values, int first, int second)
         {
-            var t = values[first];
-            values[first] = values[second];
-            values[second] = t;
+            (values[first], values[second]) = (values[second], values[first]);
         }
     }
 }
diff --git a/src/Numerics/LinearAlgebra/Complex32/Factorization/UserLU.cs b/src/Numerics/LinearAlgebra/Complex32/Factorization/UserLU.cs
@@ -261,9 +261,7 @@ public override void Solve(Vector<Complex32> input, Vector<Complex32> result)
                 }
 
                 var p = Pivots[i];
-                var temp = result[p];
-                result[p] = result[i];
-                result[i] = temp;
+                (result[p], result[i]) = (result[i], result[p]);
             }
 
             var order = Factors.RowCount;
diff --git a/src/Numerics/LinearAlgebra/Complex32/Solvers/ILUTPPreconditioner.cs b/src/Numerics/LinearAlgebra/Complex32/Solvers/ILUTPPreconditioner.cs
@@ -499,9 +499,7 @@ public void Initialize(Matrix<Complex32> matrix)
                         SwapColumns(_upper, i, indexSorting[0]);
 
                         // Update P
-                        var temp = _pivots[i];
-                        _pivots[i] = _pivots[indexSorting[0]];
-                        _pivots[indexSorting[0]] = temp;
+                        (_pivots[i], _pivots[indexSorting[0]]) = (_pivots[indexSorting[0]], _pivots[i]);
                     }
                 }
 
@@ -531,9 +529,7 @@ void PivotRow(Vector<Complex32> row)
                     // store the pivots in the hashtable
                     knownPivots.Add(_pivots[i], i);
 
-                    var t = row[i];
-                    row[i] = row[_pivots[i]];
-                    row[_pivots[i]] = t;
+                    (row[i], row[_pivots[i]]) = (row[_pivots[i]], row[i]);
                 }
             }
         }
@@ -575,9 +571,7 @@ static void SwapColumns(Matrix<Complex32> matrix, int firstColumn, int secondCol
         {
             for (var i = 0; i < matrix.RowCount; i++)
             {
-                var temp = matrix[i, firstColumn];
-                matrix[i, firstColumn] = matrix[i, secondColumn];
-                matrix[i, secondColumn] = temp;
+                (matrix[i, firstColumn], matrix[i, secondColumn]) = (matrix[i, secondColumn], matrix[i, firstColumn]);
             }
         }
 
@@ -862,9 +856,7 @@ static void Sift(int[] values, int start, int count)
         /// <param name="second">Second value to exchange</param>
         static void Exchange(int[] values, int first, int second)
         {
-            var t = values[first];
-            values[first] = values[second];
-            values[second] = t;
+            (values[first], values[second]) = (values[second], values[first]);
         }
     }
 }
diff --git a/src/Numerics/LinearAlgebra/Double/Factorization/UserLU.cs b/src/Numerics/LinearAlgebra/Double/Factorization/UserLU.cs
@@ -259,9 +259,7 @@ public override void Solve(Vector<double> input, Vector<double> result)
                 }
 
                 var p = Pivots[i];
-                var temp = result[p];
-                result[p] = result[i];
-                result[i] = temp;
+                (result[p], result[i]) = (result[i], result[p]);
             }
 
             var order = Factors.RowCount;
diff --git a/src/Numerics/LinearAlgebra/Double/Solvers/ILUTPPreconditioner.cs b/src/Numerics/LinearAlgebra/Double/Solvers/ILUTPPreconditioner.cs
@@ -497,9 +497,7 @@ public void Initialize(Matrix<double> matrix)
                         SwapColumns(_upper, i, indexSorting[0]);
 
                         // Update P
-                        var temp = _pivots[i];
-                        _pivots[i] = _pivots[indexSorting[0]];
-                        _pivots[indexSorting[0]] = temp;
+                        (_pivots[i], _pivots[indexSorting[0]]) = (_pivots[indexSorting[0]], _pivots[i]);
                     }
                 }
 
@@ -529,9 +527,7 @@ void PivotRow(Vector<double> row)
                     // store the pivots in the hashtable
                     knownPivots.Add(_pivots[i], i);
 
-                    var t = row[i];
-                    row[i] = row[_pivots[i]];
-                    row[_pivots[i]] = t;
+                    (row[i], row[_pivots[i]]) = (row[_pivots[i]], row[i]);
                 }
             }
         }
@@ -573,9 +569,7 @@ static void SwapColumns(Matrix<double> matrix, int firstColumn, int secondColumn
         {
             for (var i = 0; i < matrix.RowCount; i++)
             {
-                var temp = matrix[i, firstColumn];
-                matrix[i, firstColumn] = matrix[i, secondColumn];
-                matrix[i, secondColumn] = temp;
+                (matrix[i, firstColumn], matrix[i, secondColumn]) = (matrix[i, secondColumn], matrix[i, firstColumn]);
             }
         }
 
@@ -860,9 +854,7 @@ static void Sift(int[] values, int start, int count)
         /// <param name="second">Second value to exchange</param>
         static void Exchange(int[] values, int first, int second)
         {
-            var t = values[first];
-            values[first] = values[second];
-            values[second] = t;
+            (values[first], values[second]) = (values[second], values[first]);
         }
     }
 }
diff --git a/src/Numerics/LinearAlgebra/Single/Factorization/UserLU.cs b/src/Numerics/LinearAlgebra/Single/Factorization/UserLU.cs
@@ -259,9 +259,7 @@ public override void Solve(Vector<float> input, Vector<float> result)
                 }
 
                 var p = Pivots[i];
-                var temp = result[p];
-                result[p] = result[i];
-                result[i] = temp;
+                (result[p], result[i]) = (result[i], result[p]);
             }
 
             var order = Factors.RowCount;
diff --git a/src/Numerics/LinearAlgebra/Single/Solvers/ILUTPPreconditioner.cs b/src/Numerics/LinearAlgebra/Single/Solvers/ILUTPPreconditioner.cs
@@ -497,9 +497,7 @@ public void Initialize(Matrix<float> matrix)
                         SwapColumns(_upper, i, indexSorting[0]);
 
                         // Update P
-                        var temp = _pivots[i];
-                        _pivots[i] = _pivots[indexSorting[0]];
-                        _pivots[indexSorting[0]] = temp;
+                        (_pivots[i], _pivots[indexSorting[0]]) = (_pivots[indexSorting[0]], _pivots[i]);
                     }
                 }
 
@@ -529,9 +527,7 @@ void PivotRow(Vector<float> row)
                     // store the pivots in the hashtable
                     knownPivots.Add(_pivots[i], i);
 
-                    var t = row[i];
-                    row[i] = row[_pivots[i]];
-                    row[_pivots[i]] = t;
+                    (row[i], row[_pivots[i]]) = (row[_pivots[i]], row[i]);
                 }
             }
         }
@@ -573,9 +569,7 @@ static void SwapColumns(Matrix<float> matrix, int firstColumn, int secondColumn)
         {
             for (var i = 0; i < matrix.RowCount; i++)
             {
-                var temp = matrix[i, firstColumn];
-                matrix[i, firstColumn] = matrix[i, secondColumn];
-                matrix[i, secondColumn] = temp;
+                (matrix[i, firstColumn], matrix[i, secondColumn]) = (matrix[i, secondColumn], matrix[i, firstColumn]);
             }
         }
 
@@ -860,9 +854,7 @@ static void Sift(int[] values, int start, int count)
         /// <param name="second">Second value to exchange</param>
         static void Exchange(int[] values, int first, int second)
         {
-            var t = values[first];
-            values[first] = values[second];
-            values[second] = t;
+            (values[first], values[second]) = (values[second], values[first]);
         }
     }
 }
diff --git a/src/Numerics/LinearAlgebra/Storage/SparseCompressedRowMatrixStorage.cs b/src/Numerics/LinearAlgebra/Storage/SparseCompressedRowMatrixStorage.cs
@@ -1137,9 +1137,7 @@ public static SparseCompressedRowMatrixStorage<T> OfCoordinateFormat(int rows, i
 
             for (int i = 0, last = 0; i <= rows; i++)
             {
-                var temp = csrRowPointers[i];
-                csrRowPointers[i] = last;
-                last = temp;
+                (csrRowPointers[i], last) = (last, csrRowPointers[i]);
             }
 
             storage.ColumnIndices = csrColumnIndices;
diff --git a/src/Numerics/Permutation.cs b/src/Numerics/Permutation.cs
@@ -113,9 +113,7 @@ public static Permutation FromInversions(int[] inv)
             {
                 if (idx[i] != inv[i])
                 {
-                    int t = idx[i];
-                    idx[i] = idx[inv[i]];
-                    idx[inv[i]] = t;
+                    (idx[i], idx[inv[i]]) = (idx[inv[i]], idx[i]);
                 }
             }
 
diff --git a/src/Numerics/Providers/FourierTransform/ManagedFourierTransformProvider.Radix2.cs b/src/Numerics/Providers/FourierTransform/ManagedFourierTransformProvider.Radix2.cs
@@ -47,9 +47,7 @@ static void Radix2Reorder<T>(T[] samples)
             {
                 if (i < j)
                 {
-                    var temp = samples[i];
-                    samples[i] = samples[j];
-                    samples[j] = temp;
+                    (samples[i], samples[j]) = (samples[j], samples[i]);
                 }
 
                 var m = samples.Length;
diff --git a/src/Numerics/Providers/FourierTransform/ManagedFourierTransformProvider.Scaling.cs b/src/Numerics/Providers/FourierTransform/ManagedFourierTransformProvider.Scaling.cs
@@ -33,8 +33,6 @@ namespace MathNet.Numerics.Providers.FourierTransform
 {
     public partial class ManagedFourierTransformProvider
     {
-
-
         /// <summary>
         /// Fully rescale the FFT result.
         /// </summary>
diff --git a/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Complex.cs b/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Complex.cs
@@ -570,16 +570,12 @@ public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB,
 
             if (transposeA != Transpose.DontTranspose)
             {
-                var swap = rowsA;
-                rowsA = columnsA;
-                columnsA = swap;
+                (rowsA, columnsA) = (columnsA, rowsA);
             }
 
             if (transposeB != Transpose.DontTranspose)
             {
-                var swap = rowsB;
-                rowsB = columnsB;
-                columnsB = swap;
+                (rowsB, columnsB) = (columnsB, rowsB);
             }
 
             if (columnsA != rowsB)
@@ -752,9 +748,7 @@ public void LUFactor(Complex[] data, int order, int[] ipiv)
                         var indexk = k*order;
                         var indexkp = indexk + p;
                         var indexkj = indexk + j;
-                        var temp = data[indexkp];
-                        data[indexkp] = data[indexkj];
-                        data[indexkj] = temp;
+                        (data[indexkp], data[indexkj]) = (data[indexkj], data[indexkp]);
                     }
 
                     ipiv[j] = p;
@@ -935,9 +929,7 @@ public void LUSolveFactored(int columnsOfB, Complex[] a, int order, int[] ipiv,
                     var indexk = j*order;
                     var indexkp = indexk + p;
                     var indexkj = indexk + i;
-                    var temp = b[indexkp];
-                    b[indexkp] = b[indexkj];
-                    b[indexkj] = temp;
+                    (b[indexkp], b[indexkj]) = (b[indexkj], b[indexkp]);
                 }
             }
 
@@ -2241,9 +2233,7 @@ public void SingularValueDecomposition(bool computeVectors, Complex[] a, int row
                                 // Swap columns l, l + 1
                                 for (i = 0; i < columnsA; i++)
                                 {
-                                    var z = v[(l*columnsA) + i];
-                                    v[(l*columnsA) + i] = v[((l + 1)*columnsA) + i];
-                                    v[((l + 1)*columnsA) + i] = z;
+                                    (v[(l*columnsA) + i], v[((l + 1)*columnsA) + i]) = (v[((l + 1)*columnsA) + i], v[(l*columnsA) + i]);
                                 }
                             }
 
@@ -2252,9 +2242,7 @@ public void SingularValueDecomposition(bool computeVectors, Complex[] a, int row
                                 // Swap columns l, l + 1
                                 for (i = 0; i < rowsA; i++)
                                 {
-                                    var z = u[(l*rowsA) + i];
-                                    u[(l*rowsA) + i] = u[((l + 1)*rowsA) + i];
-                                    u[((l + 1)*rowsA) + i] = z;
+                                    (u[(l*rowsA) + i], u[((l + 1)*rowsA) + i]) = (u[((l + 1)*rowsA) + i], u[(l*rowsA) + i]);
                                 }
                             }
 
diff --git a/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Complex32.cs b/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Complex32.cs
@@ -570,16 +570,12 @@ public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB,
 
             if (transposeA != Transpose.DontTranspose)
             {
-                var swap = rowsA;
-                rowsA = columnsA;
-                columnsA = swap;
+                (rowsA, columnsA) = (columnsA, rowsA);
             }
 
             if (transposeB != Transpose.DontTranspose)
             {
-                var swap = rowsB;
-                rowsB = columnsB;
-                columnsB = swap;
+                (rowsB, columnsB) = (columnsB, rowsB);
             }
 
             if (columnsA != rowsB)
@@ -752,9 +748,7 @@ public void LUFactor(Complex32[] data, int order, int[] ipiv)
                         var indexk = k*order;
                         var indexkp = indexk + p;
                         var indexkj = indexk + j;
-                        var temp = data[indexkp];
-                        data[indexkp] = data[indexkj];
-                        data[indexkj] = temp;
+                        (data[indexkp], data[indexkj]) = (data[indexkj], data[indexkp]);
                     }
 
                     ipiv[j] = p;
@@ -935,9 +929,7 @@ public void LUSolveFactored(int columnsOfB, Complex32[] a, int order, int[] ipiv
                     var indexk = j*order;
                     var indexkp = indexk + p;
                     var indexkj = indexk + i;
-                    var temp = b[indexkp];
-                    b[indexkp] = b[indexkj];
-                    b[indexkj] = temp;
+                    (b[indexkp], b[indexkj]) = (b[indexkj], b[indexkp]);
                 }
             }
 
@@ -2239,9 +2231,7 @@ public void SingularValueDecomposition(bool computeVectors, Complex32[] a, int r
                                 // Swap columns l, l + 1
                                 for (i = 0; i < columnsA; i++)
                                 {
-                                    var z = v[(l*columnsA) + i];
-                                    v[(l*columnsA) + i] = v[((l + 1)*columnsA) + i];
-                                    v[((l + 1)*columnsA) + i] = z;
+                                    (v[(l*columnsA) + i], v[((l + 1)*columnsA) + i]) = (v[((l + 1)*columnsA) + i], v[(l*columnsA) + i]);
                                 }
                             }
 
@@ -2250,9 +2240,7 @@ public void SingularValueDecomposition(bool computeVectors, Complex32[] a, int r
                                 // Swap columns l, l + 1
                                 for (i = 0; i < rowsA; i++)
                                 {
-                                    var z = u[(l*rowsA) + i];
-                                    u[(l*rowsA) + i] = u[((l + 1)*rowsA) + i];
-                                    u[((l + 1)*rowsA) + i] = z;
+                                    (u[(l*rowsA) + i], u[((l + 1)*rowsA) + i]) = (u[((l + 1)*rowsA) + i], u[(l*rowsA) + i]);
                                 }
                             }
 
diff --git a/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Double.cs b/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Double.cs
diff --git a/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Single.cs b/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Single.cs
diff --git a/src/Numerics/RootFinding/Bisection.cs b/src/Numerics/RootFinding/Bisection.cs
diff --git a/src/Numerics/Sorting.cs b/src/Numerics/Sorting.cs
diff --git a/src/Numerics/SpecialFunctions/Beta.cs b/src/Numerics/SpecialFunctions/Beta.cs
diff --git a/src/Numerics/Statistics/ArrayStatistics.Single.cs b/src/Numerics/Statistics/ArrayStatistics.Single.cs
diff --git a/src/Numerics/Statistics/ArrayStatistics.cs b/src/Numerics/Statistics/ArrayStatistics.cs

Original file line number	Diff line number	Diff line change
`@@ -261,9 +261,7 @@ public override void Solve(Vector<Complex> input, Vector<Complex> result)`
`261`	`261`	`}`
`262`	`262`
`263`	`263`	`var p = Pivots[i];`
`264`		`- var temp = result[p];`
`265`		`- result[p] = result[i];`
`266`		`- result[i] = temp;`
	`264`	`+ (result[p], result[i]) = (result[i], result[p]);`
`267`	`265`	`}`
`268`	`266`
`269`	`267`	`var order = Factors.RowCount;`
Original file line number	Diff line number	Diff line change
`@@ -499,9 +499,7 @@ public void Initialize(Matrix<Complex> matrix)`
`499`	`499`	`SwapColumns(_upper, i, indexSorting[0]);`
`500`	`500`
`501`	`501`	`// Update P`
`502`		`- var temp = _pivots[i];`
`503`		`- _pivots[i] = _pivots[indexSorting[0]];`
`504`		`- _pivots[indexSorting[0]] = temp;`
	`502`	`+ (_pivots[i], _pivots[indexSorting[0]]) = (_pivots[indexSorting[0]], _pivots[i]);`
`505`	`503`	`}`
`506`	`504`	`}`
`507`	`505`
`@@ -531,9 +529,7 @@ void PivotRow(Vector<Complex> row)`
`531`	`529`	`// store the pivots in the hashtable`
`532`	`530`	`knownPivots.Add(_pivots[i], i);`
`533`	`531`
`534`		`- var t = row[i];`
`535`		`- row[i] = row[_pivots[i]];`
`536`		`- row[_pivots[i]] = t;`
	`532`	`+ (row[i], row[_pivots[i]]) = (row[_pivots[i]], row[i]);`
`537`	`533`	`}`
`538`	`534`	`}`
`539`	`535`	`}`
`@@ -569,9 +565,7 @@ static void SwapColumns(Matrix<Complex> matrix, int firstColumn, int secondColum`
`569`	`565`	`{`
`570`	`566`	`for (var i = 0; i < matrix.RowCount; i++)`
`571`	`567`	`{`
`572`		`- var temp = matrix[i, firstColumn];`
`573`		`- matrix[i, firstColumn] = matrix[i, secondColumn];`
`574`		`- matrix[i, secondColumn] = temp;`
	`568`	`+ (matrix[i, firstColumn], matrix[i, secondColumn]) = (matrix[i, secondColumn], matrix[i, firstColumn]);`
`575`	`569`	`}`
`576`	`570`	`}`
`577`	`571`
`@@ -856,9 +850,7 @@ static void Sift(int[] values, int start, int count)`
`856`	`850`	`/// <param name="second">Second value to exchange</param>`
`857`	`851`	`static void Exchange(int[] values, int first, int second)`
`858`	`852`	`{`
`859`		`- var t = values[first];`
`860`		`- values[first] = values[second];`
`861`		`- values[second] = t;`
	`853`	`+ (values[first], values[second]) = (values[second], values[first]);`
`862`	`854`	`}`
`863`	`855`	`}`
`864`	`856`	`}`
Original file line number	Diff line number	Diff line change
`@@ -259,9 +259,7 @@ public override void Solve(Vector<double> input, Vector<double> result)`
`259`	`259`	`}`
`260`	`260`
`261`	`261`	`var p = Pivots[i];`
`262`		`- var temp = result[p];`
`263`		`- result[p] = result[i];`
`264`		`- result[i] = temp;`
	`262`	`+ (result[p], result[i]) = (result[i], result[p]);`
`265`	`263`	`}`
`266`	`264`
`267`	`265`	`var order = Factors.RowCount;`
Original file line number	Diff line number	Diff line change
`@@ -497,9 +497,7 @@ public void Initialize(Matrix<double> matrix)`
`497`	`497`	`SwapColumns(_upper, i, indexSorting[0]);`
`498`	`498`
`499`	`499`	`// Update P`
`500`		`- var temp = _pivots[i];`
`501`		`- _pivots[i] = _pivots[indexSorting[0]];`
`502`		`- _pivots[indexSorting[0]] = temp;`
	`500`	`+ (_pivots[i], _pivots[indexSorting[0]]) = (_pivots[indexSorting[0]], _pivots[i]);`
`503`	`501`	`}`
`504`	`502`	`}`
`505`	`503`
`@@ -529,9 +527,7 @@ void PivotRow(Vector<double> row)`
`529`	`527`	`// store the pivots in the hashtable`
`530`	`528`	`knownPivots.Add(_pivots[i], i);`
`531`	`529`
`532`		`- var t = row[i];`
`533`		`- row[i] = row[_pivots[i]];`
`534`		`- row[_pivots[i]] = t;`
	`530`	`+ (row[i], row[_pivots[i]]) = (row[_pivots[i]], row[i]);`
`535`	`531`	`}`
`536`	`532`	`}`
`537`	`533`	`}`
`@@ -573,9 +569,7 @@ static void SwapColumns(Matrix<double> matrix, int firstColumn, int secondColumn`
`573`	`569`	`{`
`574`	`570`	`for (var i = 0; i < matrix.RowCount; i++)`
`575`	`571`	`{`
`576`		`- var temp = matrix[i, firstColumn];`
`577`		`- matrix[i, firstColumn] = matrix[i, secondColumn];`
`578`		`- matrix[i, secondColumn] = temp;`
	`572`	`+ (matrix[i, firstColumn], matrix[i, secondColumn]) = (matrix[i, secondColumn], matrix[i, firstColumn]);`
`579`	`573`	`}`
`580`	`574`	`}`
`581`	`575`
`@@ -860,9 +854,7 @@ static void Sift(int[] values, int start, int count)`
`860`	`854`	`/// <param name="second">Second value to exchange</param>`
`861`	`855`	`static void Exchange(int[] values, int first, int second)`
`862`	`856`	`{`
`863`		`- var t = values[first];`
`864`		`- values[first] = values[second];`
`865`		`- values[second] = t;`
	`857`	`+ (values[first], values[second]) = (values[second], values[first]);`
`866`	`858`	`}`
`867`	`859`	`}`
`868`	`860`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1137,9 +1137,7 @@ public static SparseCompressedRowMatrixStorage<T> OfCoordinateFormat(int rows, i`
`1137`	`1137`
`1138`	`1138`	`for (int i = 0, last = 0; i <= rows; i++)`
`1139`	`1139`	`{`
`1140`		`- var temp = csrRowPointers[i];`
`1141`		`- csrRowPointers[i] = last;`
`1142`		`- last = temp;`
	`1140`	`+ (csrRowPointers[i], last) = (last, csrRowPointers[i]);`
`1143`	`1141`	`}`
`1144`	`1142`
`1145`	`1143`	`storage.ColumnIndices = csrColumnIndices;`
Original file line number	Diff line number	Diff line change
`@@ -113,9 +113,7 @@ public static Permutation FromInversions(int[] inv)`
`113`	`113`	`{`
`114`	`114`	`if (idx[i] != inv[i])`
`115`	`115`	`{`
`116`		`- int t = idx[i];`
`117`		`- idx[i] = idx[inv[i]];`
`118`		`- idx[inv[i]] = t;`
	`116`	`+ (idx[i], idx[inv[i]]) = (idx[inv[i]], idx[i]);`
`119`	`117`	`}`
`120`	`118`	`}`
`121`	`119`