LA: vector.OfArray (copy) #136

src/FSharp/LinearAlgebra.Vector.fs

@@ -240,7 +240,7 @@ module DenseVector =
     let inline init (n: int) (f: int -> 'T) = Vector<'T>.Build.Dense(n, f)
 
     /// Create a vector from a float array (by copying - use raw instead if no copy is needed).
-    let inline ofArray (fl: 'T array) = Vector<'T>.Build.Dense(Array.copy fl)
+    let inline ofArray (fa: 'T array) = Vector<'T>.Build.Dense(Array.copy fa)
 
     /// Create a vector from a float list.
     let inline ofList (fl: 'T list) = Vector<'T>.Build.Dense(Array.ofList fl)
@@ -278,7 +278,7 @@ module SparseVector =
     let inline init (n: int) (f: int -> 'T) = Vector<'T>.Build.Sparse(n, f)
 
     /// Create a sparse vector from a float array.
-    let inline ofArray (fl: 'T array) = Vector<'T>.Build.SparseOfEnumerable(fl :> seq<'T>)
+    let inline ofArray (fa: 'T array) = Vector<'T>.Build.SparseOfArray(fa)
 
     /// Create a sparse vector from a float list.
     let inline ofList (fl: 'T list) = Vector<'T>.Build.SparseOfEnumerable(Seq.ofList fl)

src/Numerics/LinearAlgebra/Builder.cs

@@ -1127,6 +1127,16 @@ namespace MathNet.Numerics.LinearAlgebra
             return Dense(DenseVectorStorage<T>.OfVector(vector.Storage));
         }
 
+        /// <summary>
+        /// Create a new dense vector as a copy of the given array.
+        /// This new vector will be independent from the array.
+        /// A new memory block will be allocated for storing the vector.
+        /// </summary>
+        public Vector<T> DenseOfArray(T[] array)
+        {
+            return Dense(DenseVectorStorage<T>.OfVector(new DenseVectorStorage<T>(array.Length, array)));
+        }
+
         /// <summary>
         /// Create a new dense vector as a copy of the given enumerable.
         /// This new vector will be independent from the enumerable.
@@ -1192,6 +1202,16 @@ namespace MathNet.Numerics.LinearAlgebra
             return Sparse(SparseVectorStorage<T>.OfVector(vector.Storage));
         }
 
+        /// <summary>
+        /// Create a new sparse vector as a copy of the given array.
+        /// This new vector will be independent from the array.
+        /// A new memory block will be allocated for storing the vector.
+        /// </summary>
+        public Vector<T> SparseOfArray(T[] array)
+        {
+            return Sparse(SparseVectorStorage<T>.OfEnumerable(array));
+        }
+
         /// <summary>
         /// Create a new sparse vector as a copy of the given enumerable.
         /// This new vector will be independent from the enumerable.

src/Numerics/LinearAlgebra/Complex/DenseVector.cs

@@ -106,6 +106,16 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
             return new DenseVector(DenseVectorStorage<Complex>.OfVector(vector.Storage));
         }
 
+        /// <summary>
+        /// Create a new dense vector as a copy of the given array.
+        /// This new vector will be independent from the array.
+        /// A new memory block will be allocated for storing the vector.
+        /// </summary>
+        public static DenseVector OfArray(Complex[] array)
+        {
+            return new DenseVector(DenseVectorStorage<Complex>.OfVector(new DenseVectorStorage<Complex>(array.Length, array)));
+        }
+
         /// <summary>
         /// Create a new dense vector as a copy of the given enumerable.
         /// This new vector will be independent from the enumerable.

src/Numerics/LinearAlgebra/Complex32/DenseVector.cs

@@ -101,6 +101,16 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
             return new DenseVector(DenseVectorStorage<Complex32>.OfVector(vector.Storage));
         }
 
+        /// <summary>
+        /// Create a new dense vector as a copy of the given array.
+        /// This new vector will be independent from the array.
+        /// A new memory block will be allocated for storing the vector.
+        /// </summary>
+        public static DenseVector OfArray(Complex32[] array)
+        {
+            return new DenseVector(DenseVectorStorage<Complex32>.OfVector(new DenseVectorStorage<Complex32>(array.Length, array)));
+        }
+
         /// <summary>
         /// Create a new dense vector as a copy of the given enumerable.
         /// This new vector will be independent from the enumerable.

src/Numerics/LinearAlgebra/Double/DenseVector.cs

@@ -101,6 +101,16 @@ namespace MathNet.Numerics.LinearAlgebra.Double
             return new DenseVector(DenseVectorStorage<double>.OfVector(vector.Storage));
         }
 
+        /// <summary>
+        /// Create a new dense vector as a copy of the given array.
+        /// This new vector will be independent from the array.
+        /// A new memory block will be allocated for storing the vector.
+        /// </summary>
+        public static DenseVector OfArray(double[] array)
+        {
+            return new DenseVector(DenseVectorStorage<double>.OfVector(new DenseVectorStorage<double>(array.Length, array)));
+        }
+
         /// <summary>
         /// Create a new dense vector as a copy of the given enumerable.
         /// This new vector will be independent from the enumerable.

src/Numerics/LinearAlgebra/Single/DenseVector.cs

@@ -100,6 +100,16 @@ namespace MathNet.Numerics.LinearAlgebra.Single
             return new DenseVector(DenseVectorStorage<float>.OfVector(vector.Storage));
         }
 
+        /// <summary>
+        /// Create a new dense vector as a copy of the given array.
+        /// This new vector will be independent from the array.
+        /// A new memory block will be allocated for storing the vector.
+        /// </summary>
+        public static DenseVector OfArray(float[] array)
+        {
+            return new DenseVector(DenseVectorStorage<float>.OfVector(new DenseVectorStorage<float>(array.Length, array)));
+        }
+
         /// <summary>
         /// Create a new dense vector as a copy of the given enumerable.
         /// This new vector will be independent from the enumerable.