More value tuples

Author: cdrnet

.paket/Paket.Restore.targets

@@ -359,7 +359,8 @@
               NuspecProperties="$(NuspecProperties)"
               PackageLicenseFile="$(PackageLicenseFile)"
               PackageLicenseExpression="$(PackageLicenseExpression)"
-              PackageLicenseExpressionVersion="$(PackageLicenseExpressionVersion)" />
+              PackageLicenseExpressionVersion="$(PackageLicenseExpressionVersion)"
+              NoDefaultExcludes="$(NoDefaultExcludes)" />
 
     <PackTask Condition="$(UseMSBuild15_9_Pack)"
               PackItem="$(PackProjectInputFile)"

src/Data.Text/MatrixMarketReader.cs

@@ -133,7 +133,7 @@ public static Matrix<T> ReadMatrix<T>(TextReader reader) where T : struct, IEqua
 
             if (sparse)
             {
-                var indexed = ReadTokenLines(reader).Select(tokens => new Tuple<int, int, T>(int.Parse(tokens[0]) - 1, int.Parse(tokens[1]) - 1, parse(2, tokens)));
+                var indexed = ReadTokenLines(reader).Select(tokens => (int.Parse(tokens[0]) - 1, int.Parse(tokens[1]) - 1, parse(2, tokens)));
                 return Matrix<T>.Build.SparseOfIndexed(rows, cols, symmetry == MatrixMarketSymmetry.General ? indexed : ExpandSparse(symmetry, indexed));
             }
 
@@ -207,7 +207,7 @@ public static Vector<T> ReadVector<T>(TextReader reader)
 
             if (sparse)
             {
-                var indexedSeq = ReadTokenLines(reader).Select(tokens => new Tuple<int, T>(int.Parse(tokens[0]) - 1, parse(1, tokens)));
+                var indexedSeq = ReadTokenLines(reader).Select(tokens => (int.Parse(tokens[0]) - 1, parse(1, tokens)));
                 return Vector<T>.Build.SparseOfIndexed(length, indexedSeq);
             }
 
@@ -326,15 +326,15 @@ static IEnumerable<string[]> ReadTokenLines(TextReader reader)
             }
         }
 
-        static IEnumerable<Tuple<int, int, T>> ExpandSparse<T>(MatrixMarketSymmetry symmetry, IEnumerable<Tuple<int, int, T>> indexedValues)
+        static IEnumerable<(int, int, T)> ExpandSparse<T>(MatrixMarketSymmetry symmetry, IEnumerable<(int, int, T)> indexedValues)
         {
             var map = CreateSymmetryMap<T>(symmetry);
             foreach (var x in indexedValues)
             {
                 yield return x;
                 if (x.Item1 != x.Item2)
                 {
-                    yield return new Tuple<int, int, T>(x.Item2, x.Item1, map(x.Item3));
+                    yield return (x.Item2, x.Item1, map(x.Item3));
                 }
             }
         }

src/FSharp/LinearAlgebra.Matrix.fs

@@ -52,25 +52,25 @@ module Matrix =
     let inline toSeq (m: #Matrix<_>) = m.Enumerate(Zeros.Include)
 
     /// Transform a matrix into an indexed sequence.
-    let inline toSeqi (m: #Matrix<_>) = m.EnumerateIndexed(Zeros.Include)
+    let inline toSeqi (m: #Matrix<_>) = m.EnumerateIndexed(Zeros.Include) |> Seq.map (fun t -> t.ToTuple())
 
     /// Transform a matrix into a sequence where zero-values are skipped. Skipping zeros is efficient on sparse data.
     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.EnumerateIndexed(Zeros.AllowSkip)
+    let inline toSeqiSkipZeros (m: #Matrix<_>) = m.EnumerateIndexed(Zeros.AllowSkip) |> Seq.map (fun t -> t.ToTuple())
 
     /// Transform a matrix into a column sequence.
     let inline toColSeq (m: #Matrix<_>) = m.EnumerateColumns()
 
     /// Transform a matrix into an indexed column sequence.
-    let inline toColSeqi (m: #Matrix<_>) = m.EnumerateColumnsIndexed()
+    let inline toColSeqi (m: #Matrix<_>) = m.EnumerateColumnsIndexed() |> Seq.map (fun t -> t.ToTuple())
 
     /// Transform a matrix into a row sequence.
     let inline toRowSeq (m: #Matrix<_>) = m.EnumerateRows()
 
     /// Transform a matrix into an indexed row sequence.
-    let inline toRowSeqi (m: #Matrix<_>) = m.EnumerateRowsIndexed()
+    let inline toRowSeqi (m: #Matrix<_>) = m.EnumerateRowsIndexed() |> Seq.map (fun t -> t.ToTuple())
 
 
     /// Applies a function to all elements of the matrix.

src/FSharp/LinearAlgebra.Vector.fs

@@ -49,13 +49,13 @@ module Vector =
     let inline toSeq (v: #Vector<_>) = v.Enumerate(Zeros.Include)
 
     /// Transform a vector into an indexed sequence.
-    let inline toSeqi (v: #Vector<_>) = v.EnumerateIndexed(Zeros.Include)
+    let inline toSeqi (v: #Vector<_>) = v.EnumerateIndexed(Zeros.Include) |> Seq.map (fun t -> t.ToTuple())
 
     /// Transform a vector into a sequence where zero-values are skipped. Skipping zeros is efficient on sparse data.
     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.EnumerateIndexed(Zeros.AllowSkip)
+    let inline toSeqiSkipZeros (v: #Vector<_>) = v.EnumerateIndexed(Zeros.AllowSkip) |> Seq.map (fun t -> t.ToTuple())
 
 
     /// Applies a function to all elements of the vector.

src/Numerics.Tests/GenerateTests.cs

@@ -222,8 +222,8 @@ public void ImpulseConsistentWithSequence()
         public void UnfoldConsistentWithSequence()
         {
             Assert.That(
-                Generate.UnfoldSequence((s => new Tuple<int, int>(s + 1, s + 1)), 0).Take(250).ToArray(),
-                Is.EqualTo(Generate.Unfold(250, (s => new Tuple<int, int>(s + 1, s + 1)), 0)).AsCollection);
+                Generate.UnfoldSequence((s => (s + 1, s + 1)), 0).Take(250).ToArray(),
+                Is.EqualTo(Generate.Unfold(250, (s => (s + 1, s + 1)), 0)).AsCollection);
         }
 
         [Test]
@@ -239,11 +239,11 @@ public void FibonacciConsistentWithUnfold()
         {
             Assert.That(
                 Generate.FibonacciSequence().Take(250).ToArray(),
-                Is.EqualTo(new[] { BigInteger.Zero, BigInteger.One }.Concat(Generate.Unfold(248, (s =>
+                Is.EqualTo(new[] { BigInteger.Zero, BigInteger.One }.Concat(Generate.Unfold(248, s =>
                 {
                     var z = s.Item1 + s.Item2;
-                    return new Tuple<BigInteger, Tuple<BigInteger, BigInteger>>(z, new Tuple<BigInteger, BigInteger>(s.Item2, z));
-                }), new Tuple<BigInteger, BigInteger>(BigInteger.Zero, BigInteger.One)))).AsCollection);
+                    return (z, (s.Item2, z));
+                }, (BigInteger.Zero, BigInteger.One)))).AsCollection);
         }
     }
 }

src/Numerics/Generate.cs

@@ -774,9 +774,25 @@ public static T[] Unfold<T, TState>(int length, Func<TState, Tuple<T, TState>> f
             var data = new T[length];
             for (int i = 0; i < data.Length; i++)
             {
-                Tuple<T, TState> next = f(state);
-                data[i] = next.Item1;
-                state = next.Item2;
+                (data[i], state) = f(state);
+            }
+            return data;
+        }
+
+        /// <summary>
+        /// Generate samples generated by the given computation.
+        /// </summary>
+        public static T[] Unfold<T, TState>(int length, Func<TState, (T, TState)> f, TState state)
+        {
+            if (length < 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(length));
+            }
+
+            var data = new T[length];
+            for (int i = 0; i < data.Length; i++)
+            {
+                (data[i], state) = f(state);
             }
             return data;
         }
@@ -788,9 +804,22 @@ public static IEnumerable<T> UnfoldSequence<T, TState>(Func<TState, Tuple<T, TSt
         {
             while (true)
             {
-                Tuple<T, TState> next = f(state);
-                state = next.Item2;
-                yield return next.Item1;
+                var (item, nextState) = f(state);
+                state = nextState;
+                yield return item;
+            }
+        }
+
+        /// <summary>
+        /// Generate an infinite sequence generated by the given computation.
+        /// </summary>
+        public static IEnumerable<T> UnfoldSequence<T, TState>(Func<TState, (T, TState)> f, TState state)
+        {
+            while (true)
+            {
+                var (item, nextState) = f(state);
+                state = nextState;
+                yield return item;
             }
         }
 

src/Numerics/LinearAlgebra/Builder.cs

@@ -565,6 +565,17 @@ public Matrix<T> DenseOfIndexed(int rows, int columns, IEnumerable<Tuple<int, in
             return Dense(DenseColumnMajorMatrixStorage<T>.OfIndexedEnumerable(rows, columns, enumerable));
         }
 
+        /// <summary>
+        /// Create a new dense matrix as a copy of the given indexed enumerable.
+        /// Keys must be provided at most once, zero is assumed if a key is omitted.
+        /// This new matrix will be independent from the enumerable.
+        /// A new memory block will be allocated for storing the matrix.
+        /// </summary>
+        public Matrix<T> DenseOfIndexed(int rows, int columns, IEnumerable<(int, int, T)> enumerable)
+        {
+            return Dense(DenseColumnMajorMatrixStorage<T>.OfIndexedEnumerable(rows, columns, enumerable));
+        }
+
         /// <summary>
         /// Create a new dense matrix as a copy of the given enumerable.
         /// The enumerable is assumed to be in column-major order (column by column).
@@ -911,6 +922,17 @@ public Matrix<T> SparseOfIndexed(int rows, int columns, IEnumerable<Tuple<int, i
             return Sparse(SparseCompressedRowMatrixStorage<T>.OfIndexedEnumerable(rows, columns, enumerable));
         }
 
+        /// <summary>
+        /// Create a new sparse matrix as a copy of the given indexed enumerable.
+        /// Keys must be provided at most once, zero is assumed if a key is omitted.
+        /// This new matrix will be independent from the enumerable.
+        /// A new memory block will be allocated for storing the matrix.
+        /// </summary>
+        public Matrix<T> SparseOfIndexed(int rows, int columns, IEnumerable<(int, int, T)> enumerable)
+        {
+            return Sparse(SparseCompressedRowMatrixStorage<T>.OfIndexedEnumerable(rows, columns, enumerable));
+        }
+
         /// <summary>
         /// Create a new sparse matrix as a copy of the given enumerable.
         /// The enumerable is assumed to be in row-major order (row by row).
@@ -1537,6 +1559,17 @@ public Vector<T> DenseOfIndexed(int length, IEnumerable<Tuple<int, T>> enumerabl
             return Dense(DenseVectorStorage<T>.OfIndexedEnumerable(length, enumerable));
         }
 
+        /// <summary>
+        /// Create a new dense vector as a copy of the given indexed enumerable.
+        /// Keys must be provided at most once, zero is assumed if a key is omitted.
+        /// This new vector will be independent from the enumerable.
+        /// A new memory block will be allocated for storing the vector.
+        /// </summary>
+        public Vector<T> DenseOfIndexed(int length, IEnumerable<(int, T)> enumerable)
+        {
+            return Dense(DenseVectorStorage<T>.OfIndexedEnumerable(length, enumerable));
+        }
+
         /// <summary>
         /// Create a new sparse vector straight from an initialized vector storage instance.
         /// The storage is used directly without copying.
@@ -1611,6 +1644,17 @@ public Vector<T> SparseOfIndexed(int length, IEnumerable<Tuple<int, T>> enumerab
         {
             return Sparse(SparseVectorStorage<T>.OfIndexedEnumerable(length, enumerable));
         }
+
+        /// <summary>
+        /// Create a new sparse vector as a copy of the given indexed enumerable.
+        /// Keys must be provided at most once, zero is assumed if a key is omitted.
+        /// This new vector will be independent from the enumerable.
+        /// A new memory block will be allocated for storing the vector.
+        /// </summary>
+        public Vector<T> SparseOfIndexed(int length, IEnumerable<(int, T)> enumerable)
+        {
+            return Sparse(SparseVectorStorage<T>.OfIndexedEnumerable(length, enumerable));
+        }
     }
 
     internal static class BuilderInstance<T> where T : struct, IEquatable<T>, IFormattable

src/Numerics/LinearAlgebra/Complex/DenseMatrix.cs

@@ -145,6 +145,17 @@ public static DenseMatrix OfIndexed(int rows, int columns, IEnumerable<Tuple<int
             return new DenseMatrix(DenseColumnMajorMatrixStorage<Complex>.OfIndexedEnumerable(rows, columns, enumerable));
         }
 
+        /// <summary>
+        /// Create a new dense matrix as a copy of the given indexed enumerable.
+        /// Keys must be provided at most once, zero is assumed if a key is omitted.
+        /// This new matrix will be independent from the enumerable.
+        /// A new memory block will be allocated for storing the matrix.
+        /// </summary>
+        public static DenseMatrix OfIndexed(int rows, int columns, IEnumerable<(int, int, Complex)> enumerable)
+        {
+            return new DenseMatrix(DenseColumnMajorMatrixStorage<Complex>.OfIndexedEnumerable(rows, columns, enumerable));
+        }
+
         /// <summary>
         /// Create a new dense matrix as a copy of the given enumerable.
         /// The enumerable is assumed to be in column-major order (column by column).

src/Numerics/LinearAlgebra/Complex/DenseVector.cs

@@ -131,6 +131,17 @@ public static DenseVector OfIndexedEnumerable(int length, IEnumerable<Tuple<int,
             return new DenseVector(DenseVectorStorage<Complex>.OfIndexedEnumerable(length, enumerable));
         }
 
+        /// <summary>
+        /// Create a new dense vector as a copy of the given indexed enumerable.
+        /// Keys must be provided at most once, zero is assumed if a key is omitted.
+        /// This new vector will be independent from the enumerable.
+        /// A new memory block will be allocated for storing the vector.
+        /// </summary>
+        public static DenseVector OfIndexedEnumerable(int length, IEnumerable<(int, Complex)> enumerable)
+        {
+            return new DenseVector(DenseVectorStorage<Complex>.OfIndexedEnumerable(length, enumerable));
+        }
+
         /// <summary>
         /// Create a new dense vector and initialize each value using the provided value.
         /// </summary>

src/Numerics/LinearAlgebra/Complex/DiagonalMatrix.cs

@@ -148,6 +148,17 @@ public static DiagonalMatrix OfIndexedDiagonal(int rows, int columns, IEnumerabl
             return new DiagonalMatrix(DiagonalMatrixStorage<Complex>.OfIndexedEnumerable(rows, columns, diagonal));
         }
 
+        /// <summary>
+        /// Create a new diagonal matrix and initialize each diagonal value from the provided indexed enumerable.
+        /// Keys must be provided at most once, zero is assumed if a key is omitted.
+        /// This new matrix will be independent from the enumerable.
+        /// A new memory block will be allocated for storing the matrix.
+        /// </summary>
+        public static DiagonalMatrix OfIndexedDiagonal(int rows, int columns, IEnumerable<(int, Complex)> diagonal)
+        {
+            return new DiagonalMatrix(DiagonalMatrixStorage<Complex>.OfIndexedEnumerable(rows, columns, diagonal));
+        }
+
         /// <summary>
         /// Create a new diagonal matrix and initialize each diagonal value from the provided enumerable.
         /// This new matrix will be independent from the enumerable.