Build: add explicit .NET 6.0 target

cdrnet · cdrnet · commit 97a905c65245 · 2022-03-06T09:06:50.000+01:00
diff --git a/src/Data.Matlab/Data.Matlab.csproj b/src/Data.Matlab/Data.Matlab.csproj
@@ -2,7 +2,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
     <PropertyGroup>
         <OutputType>Library</OutputType>
-        <TargetFrameworks>net5.0;net461;net48;netstandard2.0</TargetFrameworks>
+        <TargetFrameworks>net6.0;net5.0;net461;net48;netstandard2.0</TargetFrameworks>
         <AssemblyName>MathNet.Numerics.Data.Matlab</AssemblyName>
         <RootNamespace>MathNet.Numerics.Data.Matlab</RootNamespace>
         <IsPackable>true</IsPackable>
diff --git a/src/Data.Text/Data.Text.csproj b/src/Data.Text/Data.Text.csproj
@@ -2,7 +2,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
     <PropertyGroup>
         <OutputType>Library</OutputType>
-        <TargetFrameworks>net5.0;net461;net48;netstandard2.0</TargetFrameworks>
+        <TargetFrameworks>net6.0;net5.0;net461;net48;netstandard2.0</TargetFrameworks>
         <AssemblyName>MathNet.Numerics.Data.Text</AssemblyName>
         <RootNamespace>MathNet.Numerics.Data.Text</RootNamespace>
         <IsPackable>true</IsPackable>
diff --git a/src/FSharp/FSharp.fsproj b/src/FSharp/FSharp.fsproj
@@ -2,7 +2,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
     <PropertyGroup>
         <OutputType>Library</OutputType>
-        <TargetFrameworks>net5.0;net461;net48;netstandard2.0</TargetFrameworks>
+        <TargetFrameworks>net6.0;net5.0;net461;net48;netstandard2.0</TargetFrameworks>
         <AssemblyName>MathNet.Numerics.FSharp</AssemblyName>
         <RootNamespace>MathNet.Numerics</RootNamespace>
         <IsPackable>true</IsPackable>
diff --git a/src/Numerics.Tests/GenericMath.cs b/src/Numerics.Tests/GenericMath.cs
@@ -589,7 +589,7 @@ static Operator()
             }
             else
             {
-                zero = default(T);
+                zero = default;
                 if (typeT.IsValueType)
                 {
                     nullOp = (INullOp<T>)Activator.CreateInstance(
diff --git a/src/Numerics.Tests/LinearAlgebraTests/MatrixStructureTheory.Access.cs b/src/Numerics.Tests/LinearAlgebraTests/MatrixStructureTheory.Access.cs
@@ -700,7 +700,7 @@ public void CanSetSubmatrix(TestMatrix testMatrix)
 
             // Invalid
             m = matrix.Clone();
-            Assert.That(() => m.SetSubMatrix(0, 1, 0, 1, default(Matrix<T>)), Throws.InstanceOf<NullReferenceException>());
+            Assert.That(() => m.SetSubMatrix(0, 1, 0, 1, default), Throws.InstanceOf<NullReferenceException>());
             Assert.That(() => m.SetSubMatrix(-1, 1, 0, 1, Matrix<T>.Build.Dense(1, 1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
             Assert.That(() => m.SetSubMatrix(matrix.RowCount, 1, 0, 1, Matrix<T>.Build.Dense(1, 1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
             Assert.That(() => m.SetSubMatrix(0, 1, -1, 1, Matrix<T>.Build.Dense(1, 1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
diff --git a/src/Numerics.Tests/LinearAlgebraTests/MatrixStructureTheory.Reform.cs b/src/Numerics.Tests/LinearAlgebraTests/MatrixStructureTheory.Reform.cs
@@ -116,7 +116,7 @@ public void CanInsertRow(TestMatrix testMatrix)
             }
 
             // Invalid
-            Assert.That(() => matrix.InsertRow(0, default(Vector<T>)), Throws.Exception);
+            Assert.That(() => matrix.InsertRow(0, default), Throws.Exception);
             Assert.That(() => matrix.InsertRow(-1, Vector<T>.Build.Dense(matrix.ColumnCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
             Assert.That(() => matrix.InsertRow(matrix.RowCount + 1, Vector<T>.Build.Dense(matrix.ColumnCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
             Assert.That(() => matrix.InsertRow(0, Vector<T>.Build.Dense(matrix.ColumnCount - 1)), Throws.ArgumentException);
@@ -178,7 +178,7 @@ public void CanInsertColumn(TestMatrix testMatrix)
             }
 
             // Invalid
-            Assert.That(() => matrix.InsertColumn(0, default(Vector<T>)), Throws.Exception);
+            Assert.That(() => matrix.InsertColumn(0, default), Throws.Exception);
             Assert.That(() => matrix.InsertColumn(-1, Vector<T>.Build.Dense(matrix.RowCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
             Assert.That(() => matrix.InsertColumn(matrix.ColumnCount + 1, Vector<T>.Build.Dense(matrix.RowCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
             Assert.That(() => matrix.InsertColumn(0, Vector<T>.Build.Dense(matrix.RowCount - 1)), Throws.ArgumentException);
@@ -231,7 +231,7 @@ public void CanAppend(TestMatrix leftTestMatrix, TestMatrix rightTestMatrix)
             }
 
             // Invalid
-            Assert.That(() => left.Append(default(Matrix<T>)), Throws.InstanceOf<ArgumentNullException>());
+            Assert.That(() => left.Append(default), Throws.InstanceOf<ArgumentNullException>());
         }
 
         [Theory]
@@ -255,7 +255,7 @@ public void CanAppendIntoResult(TestMatrix leftTestMatrix, TestMatrix rightTestM
             }
 
             // Invalid
-            Assert.That(() => left.Append(right, default(Matrix<T>)), Throws.InstanceOf<ArgumentNullException>());
+            Assert.That(() => left.Append(right, default), Throws.InstanceOf<ArgumentNullException>());
             Assert.That(() => left.Append(right, Matrix<T>.Build.Dense(left.RowCount + 1, left.ColumnCount + right.ColumnCount)), Throws.ArgumentException);
             Assert.That(() => left.Append(right, Matrix<T>.Build.Dense(left.RowCount - 1, left.ColumnCount + right.ColumnCount)), Throws.ArgumentException);
             Assert.That(() => left.Append(right, Matrix<T>.Build.Dense(left.RowCount, left.ColumnCount + right.ColumnCount + 1)), Throws.ArgumentException);
@@ -284,7 +284,7 @@ public void CanStack(TestMatrix topTestMatrix, TestMatrix bottomTestMatrix)
             }
 
             // Invalid
-            Assert.That(() => top.Stack(default(Matrix<T>)), Throws.InstanceOf<ArgumentNullException>());
+            Assert.That(() => top.Stack(default), Throws.InstanceOf<ArgumentNullException>());
         }
 
         [Theory]
@@ -308,7 +308,7 @@ public void CanStackIntoResult(TestMatrix topTestMatrix, TestMatrix bottomTestMa
             }
 
             // Invalid
-            Assert.That(() => top.Stack(bottom, default(Matrix<T>)), Throws.InstanceOf<ArgumentNullException>());
+            Assert.That(() => top.Stack(bottom, default), Throws.InstanceOf<ArgumentNullException>());
             Assert.That(() => top.Stack(bottom, Matrix<T>.Build.Dense(top.RowCount + bottom.RowCount + 1, top.ColumnCount)), Throws.ArgumentException);
             Assert.That(() => top.Stack(bottom, Matrix<T>.Build.Dense(top.RowCount + bottom.RowCount - 1, top.ColumnCount)), Throws.ArgumentException);
             Assert.That(() => top.Stack(bottom, Matrix<T>.Build.Dense(top.RowCount + bottom.RowCount, top.ColumnCount + 1)), Throws.ArgumentException);
@@ -341,7 +341,7 @@ public void CanDiagonalStack(TestMatrix leftTestMatrix, TestMatrix rightTestMatr
             }
 
             // Invalid
-            Assert.That(() => left.DiagonalStack(default(Matrix<T>)), Throws.InstanceOf<ArgumentNullException>(), "{0}+{1}->{2}", left.GetType(), right.GetType(), result.GetType());
+            Assert.That<Matrix<T>>(() => left.DiagonalStack(default), Throws.InstanceOf<ArgumentNullException>(), "{0}+{1}->{2}", left.GetType(), right.GetType(), result.GetType());
         }
 
         [Theory]
@@ -371,7 +371,7 @@ public void CanDiagonalStackIntoResult(TestMatrix leftTestMatrix, TestMatrix rig
             }
 
             // Invalid
-            Assert.That(() => left.DiagonalStack(right, default(Matrix<T>)), Throws.InstanceOf<ArgumentNullException>());
+            Assert.That(() => left.DiagonalStack(right, default), Throws.InstanceOf<ArgumentNullException>());
             Assert.That(() => left.DiagonalStack(right, Matrix<T>.Build.Dense(left.RowCount + right.RowCount + 1, left.ColumnCount + right.ColumnCount)), Throws.ArgumentException);
             Assert.That(() => left.DiagonalStack(right, Matrix<T>.Build.Dense(left.RowCount + right.RowCount - 1, left.ColumnCount + right.ColumnCount)), Throws.ArgumentException);
             Assert.That(() => left.DiagonalStack(right, Matrix<T>.Build.Dense(left.RowCount + right.RowCount, left.ColumnCount + right.ColumnCount + 1)), Throws.ArgumentException);
diff --git a/src/Numerics/Numerics.csproj b/src/Numerics/Numerics.csproj
@@ -2,7 +2,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <OutputType>Library</OutputType>
-    <TargetFrameworks>net5.0;net461;net48;netstandard2.0</TargetFrameworks>
+    <TargetFrameworks>net6.0;net5.0;net461;net48;netstandard2.0</TargetFrameworks>
     <AssemblyName>MathNet.Numerics</AssemblyName>
     <RootNamespace>MathNet.Numerics</RootNamespace>
     <IsPackable>true</IsPackable>
diff --git a/src/Providers.CUDA/Providers.CUDA.csproj b/src/Providers.CUDA/Providers.CUDA.csproj
@@ -2,7 +2,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <OutputType>Library</OutputType>
-    <TargetFrameworks>net5.0;net461;net48;netstandard2.0</TargetFrameworks>
+    <TargetFrameworks>net6.0;net5.0;net461;net48;netstandard2.0</TargetFrameworks>
     <AssemblyName>MathNet.Numerics.Providers.CUDA</AssemblyName>
     <RootNamespace>MathNet.Numerics.Providers.CUDA</RootNamespace>
     <IsPackable>true</IsPackable>
diff --git a/src/Providers.MKL/Providers.MKL.csproj b/src/Providers.MKL/Providers.MKL.csproj
@@ -2,7 +2,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <OutputType>Library</OutputType>
-    <TargetFrameworks>net5.0;net461;net48;netstandard2.0</TargetFrameworks>
+    <TargetFrameworks>net6.0;net5.0;net461;net48;netstandard2.0</TargetFrameworks>
     <AssemblyName>MathNet.Numerics.Providers.MKL</AssemblyName>
     <RootNamespace>MathNet.Numerics.Providers.MKL</RootNamespace>
     <IsPackable>true</IsPackable>
diff --git a/src/Providers.OpenBLAS/Providers.OpenBLAS.csproj b/src/Providers.OpenBLAS/Providers.OpenBLAS.csproj
@@ -2,7 +2,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <OutputType>Library</OutputType>
-    <TargetFrameworks>net5.0;net461;net48;netstandard2.0</TargetFrameworks>
+    <TargetFrameworks>net6.0;net5.0;net461;net48;netstandard2.0</TargetFrameworks>
     <AssemblyName>MathNet.Numerics.Providers.OpenBLAS</AssemblyName>
     <RootNamespace>MathNet.Numerics.Providers.OpenBLAS</RootNamespace>
     <IsPackable>true</IsPackable>

Original file line number	Diff line number	Diff line change
`@@ -589,7 +589,7 @@ static Operator()`
`589`	`589`	`}`
`590`	`590`	`else`
`591`	`591`	`{`
`592`		`- zero = default(T);`
	`592`	`+ zero = default;`
`593`	`593`	`if (typeT.IsValueType)`
`594`	`594`	`{`
`595`	`595`	`nullOp = (INullOp<T>)Activator.CreateInstance(`
Original file line number	Diff line number	Diff line change
`@@ -116,7 +116,7 @@ public void CanInsertRow(TestMatrix testMatrix)`
`116`	`116`	`}`
`117`	`117`
`118`	`118`	`// Invalid`
`119`		`- Assert.That(() => matrix.InsertRow(0, default(Vector<T>)), Throws.Exception);`
	`119`	`+ Assert.That(() => matrix.InsertRow(0, default), Throws.Exception);`
`120`	`120`	`Assert.That(() => matrix.InsertRow(-1, Vector<T>.Build.Dense(matrix.ColumnCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());`
`121`	`121`	`Assert.That(() => matrix.InsertRow(matrix.RowCount + 1, Vector<T>.Build.Dense(matrix.ColumnCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());`
`122`	`122`	`Assert.That(() => matrix.InsertRow(0, Vector<T>.Build.Dense(matrix.ColumnCount - 1)), Throws.ArgumentException);`
`@@ -178,7 +178,7 @@ public void CanInsertColumn(TestMatrix testMatrix)`
`178`	`178`	`}`
`179`	`179`
`180`	`180`	`// Invalid`
`181`		`- Assert.That(() => matrix.InsertColumn(0, default(Vector<T>)), Throws.Exception);`
	`181`	`+ Assert.That(() => matrix.InsertColumn(0, default), Throws.Exception);`
`182`	`182`	`Assert.That(() => matrix.InsertColumn(-1, Vector<T>.Build.Dense(matrix.RowCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());`
`183`	`183`	`Assert.That(() => matrix.InsertColumn(matrix.ColumnCount + 1, Vector<T>.Build.Dense(matrix.RowCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());`
`184`	`184`	`Assert.That(() => matrix.InsertColumn(0, Vector<T>.Build.Dense(matrix.RowCount - 1)), Throws.ArgumentException);`
`@@ -231,7 +231,7 @@ public void CanAppend(TestMatrix leftTestMatrix, TestMatrix rightTestMatrix)`
`231`	`231`	`}`
`232`	`232`
`233`	`233`	`// Invalid`
`234`		`- Assert.That(() => left.Append(default(Matrix<T>)), Throws.InstanceOf<ArgumentNullException>());`
	`234`	`+ Assert.That(() => left.Append(default), Throws.InstanceOf<ArgumentNullException>());`
`235`	`235`	`}`
`236`	`236`
`237`	`237`	`[Theory]`
`@@ -255,7 +255,7 @@ public void CanAppendIntoResult(TestMatrix leftTestMatrix, TestMatrix rightTestM`
`255`	`255`	`}`
`256`	`256`
`257`	`257`	`// Invalid`
`258`		`- Assert.That(() => left.Append(right, default(Matrix<T>)), Throws.InstanceOf<ArgumentNullException>());`
	`258`	`+ Assert.That(() => left.Append(right, default), Throws.InstanceOf<ArgumentNullException>());`
`259`	`259`	`Assert.That(() => left.Append(right, Matrix<T>.Build.Dense(left.RowCount + 1, left.ColumnCount + right.ColumnCount)), Throws.ArgumentException);`
`260`	`260`	`Assert.That(() => left.Append(right, Matrix<T>.Build.Dense(left.RowCount - 1, left.ColumnCount + right.ColumnCount)), Throws.ArgumentException);`
`261`	`261`	`Assert.That(() => left.Append(right, Matrix<T>.Build.Dense(left.RowCount, left.ColumnCount + right.ColumnCount + 1)), Throws.ArgumentException);`
`@@ -284,7 +284,7 @@ public void CanStack(TestMatrix topTestMatrix, TestMatrix bottomTestMatrix)`
`284`	`284`	`}`
`285`	`285`
`286`	`286`	`// Invalid`
`287`		`- Assert.That(() => top.Stack(default(Matrix<T>)), Throws.InstanceOf<ArgumentNullException>());`
	`287`	`+ Assert.That(() => top.Stack(default), Throws.InstanceOf<ArgumentNullException>());`
`288`	`288`	`}`
`289`	`289`
`290`	`290`	`[Theory]`
`@@ -308,7 +308,7 @@ public void CanStackIntoResult(TestMatrix topTestMatrix, TestMatrix bottomTestMa`
`308`	`308`	`}`
`309`	`309`
`310`	`310`	`// Invalid`
`311`		`- Assert.That(() => top.Stack(bottom, default(Matrix<T>)), Throws.InstanceOf<ArgumentNullException>());`
	`311`	`+ Assert.That(() => top.Stack(bottom, default), Throws.InstanceOf<ArgumentNullException>());`
`312`	`312`	`Assert.That(() => top.Stack(bottom, Matrix<T>.Build.Dense(top.RowCount + bottom.RowCount + 1, top.ColumnCount)), Throws.ArgumentException);`
`313`	`313`	`Assert.That(() => top.Stack(bottom, Matrix<T>.Build.Dense(top.RowCount + bottom.RowCount - 1, top.ColumnCount)), Throws.ArgumentException);`
`314`	`314`	`Assert.That(() => top.Stack(bottom, Matrix<T>.Build.Dense(top.RowCount + bottom.RowCount, top.ColumnCount + 1)), Throws.ArgumentException);`
`@@ -341,7 +341,7 @@ public void CanDiagonalStack(TestMatrix leftTestMatrix, TestMatrix rightTestMatr`
`341`	`341`	`}`
`342`	`342`
`343`	`343`	`// Invalid`
`344`		`- Assert.That(() => left.DiagonalStack(default(Matrix<T>)), Throws.InstanceOf<ArgumentNullException>(), "{0}+{1}->{2}", left.GetType(), right.GetType(), result.GetType());`
	`344`	`+ Assert.That<Matrix<T>>(() => left.DiagonalStack(default), Throws.InstanceOf<ArgumentNullException>(), "{0}+{1}->{2}", left.GetType(), right.GetType(), result.GetType());`
`345`	`345`	`}`
`346`	`346`
`347`	`347`	`[Theory]`
`@@ -371,7 +371,7 @@ public void CanDiagonalStackIntoResult(TestMatrix leftTestMatrix, TestMatrix rig`
`371`	`371`	`}`
`372`	`372`
`373`	`373`	`// Invalid`
`374`		`- Assert.That(() => left.DiagonalStack(right, default(Matrix<T>)), Throws.InstanceOf<ArgumentNullException>());`
	`374`	`+ Assert.That(() => left.DiagonalStack(right, default), Throws.InstanceOf<ArgumentNullException>());`
`375`	`375`	`Assert.That(() => left.DiagonalStack(right, Matrix<T>.Build.Dense(left.RowCount + right.RowCount + 1, left.ColumnCount + right.ColumnCount)), Throws.ArgumentException);`
`376`	`376`	`Assert.That(() => left.DiagonalStack(right, Matrix<T>.Build.Dense(left.RowCount + right.RowCount - 1, left.ColumnCount + right.ColumnCount)), Throws.ArgumentException);`
`377`	`377`	`Assert.That(() => left.DiagonalStack(right, Matrix<T>.Build.Dense(left.RowCount + right.RowCount, left.ColumnCount + right.ColumnCount + 1)), Throws.ArgumentException);`