diff --git a/src/Numerics/Compatibility.cs b/src/Numerics/Compatibility.cs
index 4499bde4..c36e8bac 100644
--- a/src/Numerics/Compatibility.cs
+++ b/src/Numerics/Compatibility.cs
@@ -21,7 +21,7 @@ namespace MathNet.Numerics
     {
         public static IEnumerable<Tuple<int, int>> Create(int fromInclusive, int toExclusive)
         {
-            var rangeSize = Math.Max(1, (toExclusive - fromInclusive) / Control.NumberOfParallelWorkerThreads);
+            var rangeSize = Math.Max(1, (toExclusive - fromInclusive) / Control.MaxDegreeOfParallelism);
             return Create(fromInclusive, toExclusive, rangeSize);
         }
 
@@ -260,7 +260,7 @@ namespace MathNet.Numerics
     {
         public static OrderablePartitioner<Tuple<int, int>> Create(int fromInclusive, int toExclusive)
         {
-            var rangeSize = Math.Max(1, (toExclusive - fromInclusive) / Control.NumberOfParallelWorkerThreads);
+            var rangeSize = Math.Max(1, (toExclusive - fromInclusive) / Control.MaxDegreeOfParallelism);
             return Create(fromInclusive, toExclusive, rangeSize);
         }
 
diff --git a/src/Numerics/Control.cs b/src/Numerics/Control.cs
index 21bb583b..290681d9 100644
--- a/src/Numerics/Control.cs
+++ b/src/Numerics/Control.cs
@@ -39,7 +39,7 @@ namespace MathNet.Numerics
     /// </summary>
     public static class Control
     {
-        static int _numberOfThreads;
+        static int _maxDegreeOfParallelism;
         static int _blockSize;
         static int _parallelizeOrder;
         static int _parallelizeElements;
@@ -61,7 +61,7 @@ namespace MathNet.Numerics
             MaxToStringRows = 8;
 
             // Parallelization & Threading
-            _numberOfThreads = Environment.ProcessorCount;
+            _maxDegreeOfParallelism = Environment.ProcessorCount;
             _blockSize = 512;
             _parallelizeOrder = 64;
             _parallelizeElements = 300;
@@ -93,7 +93,7 @@ namespace MathNet.Numerics
 
         public static void UseSingleThread()
         {
-            _numberOfThreads = 1;
+            _maxDegreeOfParallelism = 1;
             ThreadSafeRandomNumberGenerators = false;
         }
 
@@ -146,10 +146,10 @@ namespace MathNet.Numerics
         /// when parallelization is applicable.
         /// </summary>
         /// <remarks>Default to the number of processor cores, must be between 1 and 1024 (inclusive).</remarks>
-        public static int NumberOfParallelWorkerThreads
+        public static int MaxDegreeOfParallelism
         {
-            get { return _numberOfThreads; }
-            set { _numberOfThreads = Math.Max(1, Math.Min(1024, value)); }
+            get { return _maxDegreeOfParallelism; }
+            set { _maxDegreeOfParallelism = Math.Max(1, Math.Min(1024, value)); }
         }
 
         /// <summary>
diff --git a/src/Numerics/LinearAlgebra/Complex/Factorization/UserCholesky.cs b/src/Numerics/LinearAlgebra/Complex/Factorization/UserCholesky.cs
index d66fad2b..501e2c5b 100644
--- a/src/Numerics/LinearAlgebra/Complex/Factorization/UserCholesky.cs
+++ b/src/Numerics/LinearAlgebra/Complex/Factorization/UserCholesky.cs
@@ -92,7 +92,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
                     }
 
                     // Remaining columns, below the diagonal
-                    DoCholeskyStep(factor, factor.RowCount, ij + 1, factor.RowCount, tmpColumn, Control.NumberOfParallelWorkerThreads);
+                    DoCholeskyStep(factor, factor.RowCount, ij + 1, factor.RowCount, tmpColumn, Control.MaxDegreeOfParallelism);
                 }
                 else
                 {
diff --git a/src/Numerics/LinearAlgebra/Complex/Factorization/UserQR.cs b/src/Numerics/LinearAlgebra/Complex/Factorization/UserQR.cs
index 5726ebf1..163e20d9 100644
--- a/src/Numerics/LinearAlgebra/Complex/Factorization/UserQR.cs
+++ b/src/Numerics/LinearAlgebra/Complex/Factorization/UserQR.cs
@@ -87,12 +87,12 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
                 for (var i = 0; i < minmn; i++)
                 {
                     u[i] = GenerateColumn(r, i, i);
-                    ComputeQR(u[i], r, i, matrix.RowCount, i + 1, matrix.ColumnCount, Control.NumberOfParallelWorkerThreads);
+                    ComputeQR(u[i], r, i, matrix.RowCount, i + 1, matrix.ColumnCount, Control.MaxDegreeOfParallelism);
                 }
 
                 for (var i = minmn - 1; i >= 0; i--)
                 {
-                    ComputeQR(u[i], q, i, matrix.RowCount, i, matrix.RowCount, Control.NumberOfParallelWorkerThreads);
+                    ComputeQR(u[i], q, i, matrix.RowCount, i, matrix.RowCount, Control.MaxDegreeOfParallelism);
                 }
             }
             else
@@ -102,7 +102,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
                 for (var i = 0; i < minmn; i++)
                 {
                     u[i] = GenerateColumn(q, i, i);
-                    ComputeQR(u[i], q, i, matrix.RowCount, i + 1, matrix.ColumnCount, Control.NumberOfParallelWorkerThreads);
+                    ComputeQR(u[i], q, i, matrix.RowCount, i + 1, matrix.ColumnCount, Control.MaxDegreeOfParallelism);
                 }
 
                 r = q.SubMatrix(0, matrix.ColumnCount, 0, matrix.ColumnCount);
@@ -115,7 +115,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
 
                 for (var i = minmn - 1; i >= 0; i--)
                 {
-                    ComputeQR(u[i], q, i, matrix.RowCount, i, matrix.ColumnCount, Control.NumberOfParallelWorkerThreads);
+                    ComputeQR(u[i], q, i, matrix.RowCount, i, matrix.ColumnCount, Control.MaxDegreeOfParallelism);
                 }
             }
 
diff --git a/src/Numerics/LinearAlgebra/Complex32/Factorization/UserCholesky.cs b/src/Numerics/LinearAlgebra/Complex32/Factorization/UserCholesky.cs
index c5ccddb4..042fa1c8 100644
--- a/src/Numerics/LinearAlgebra/Complex32/Factorization/UserCholesky.cs
+++ b/src/Numerics/LinearAlgebra/Complex32/Factorization/UserCholesky.cs
@@ -87,7 +87,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
                     }
 
                     // Remaining columns, below the diagonal
-                    DoCholeskyStep(factor, factor.RowCount, ij + 1, factor.RowCount, tmpColumn, Control.NumberOfParallelWorkerThreads);
+                    DoCholeskyStep(factor, factor.RowCount, ij + 1, factor.RowCount, tmpColumn, Control.MaxDegreeOfParallelism);
                 }
                 else
                 {
diff --git a/src/Numerics/LinearAlgebra/Complex32/Factorization/UserQR.cs b/src/Numerics/LinearAlgebra/Complex32/Factorization/UserQR.cs
index 6fab031d..64f6fb6b 100644
--- a/src/Numerics/LinearAlgebra/Complex32/Factorization/UserQR.cs
+++ b/src/Numerics/LinearAlgebra/Complex32/Factorization/UserQR.cs
@@ -82,12 +82,12 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
                 for (var i = 0; i < minmn; i++)
                 {
                     u[i] = GenerateColumn(r, i, i);
-                    ComputeQR(u[i], r, i, matrix.RowCount, i + 1, matrix.ColumnCount, Control.NumberOfParallelWorkerThreads);
+                    ComputeQR(u[i], r, i, matrix.RowCount, i + 1, matrix.ColumnCount, Control.MaxDegreeOfParallelism);
                 }
 
                 for (var i = minmn - 1; i >= 0; i--)
                 {
-                    ComputeQR(u[i], q, i, matrix.RowCount, i, matrix.RowCount, Control.NumberOfParallelWorkerThreads);
+                    ComputeQR(u[i], q, i, matrix.RowCount, i, matrix.RowCount, Control.MaxDegreeOfParallelism);
                 }
             }
             else
@@ -97,7 +97,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
                 for (var i = 0; i < minmn; i++)
                 {
                     u[i] = GenerateColumn(q, i, i);
-                    ComputeQR(u[i], q, i, matrix.RowCount, i + 1, matrix.ColumnCount, Control.NumberOfParallelWorkerThreads);
+                    ComputeQR(u[i], q, i, matrix.RowCount, i + 1, matrix.ColumnCount, Control.MaxDegreeOfParallelism);
                 }
 
                 r = q.SubMatrix(0, matrix.ColumnCount, 0, matrix.ColumnCount);
@@ -110,7 +110,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
 
                 for (var i = minmn - 1; i >= 0; i--)
                 {
-                    ComputeQR(u[i], q, i, matrix.RowCount, i, matrix.ColumnCount, Control.NumberOfParallelWorkerThreads);
+                    ComputeQR(u[i], q, i, matrix.RowCount, i, matrix.ColumnCount, Control.MaxDegreeOfParallelism);
                 }
             }
 
diff --git a/src/Numerics/LinearAlgebra/Double/Factorization/UserCholesky.cs b/src/Numerics/LinearAlgebra/Double/Factorization/UserCholesky.cs
index 58f3e122..6ee943fe 100644
--- a/src/Numerics/LinearAlgebra/Double/Factorization/UserCholesky.cs
+++ b/src/Numerics/LinearAlgebra/Double/Factorization/UserCholesky.cs
@@ -85,7 +85,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
                     }
 
                     // Remaining columns, below the diagonal
-                    DoCholeskyStep(factor, factor.RowCount, ij + 1, factor.RowCount, tmpColumn, Control.NumberOfParallelWorkerThreads);
+                    DoCholeskyStep(factor, factor.RowCount, ij + 1, factor.RowCount, tmpColumn, Control.MaxDegreeOfParallelism);
                 }
                 else
                 {
diff --git a/src/Numerics/LinearAlgebra/Double/Factorization/UserQR.cs b/src/Numerics/LinearAlgebra/Double/Factorization/UserQR.cs
index 47459ccb..69cb286c 100644
--- a/src/Numerics/LinearAlgebra/Double/Factorization/UserQR.cs
+++ b/src/Numerics/LinearAlgebra/Double/Factorization/UserQR.cs
@@ -80,12 +80,12 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
                 for (var i = 0; i < minmn; i++)
                 {
                     u[i] = GenerateColumn(r, i, i);
-                    ComputeQR(u[i], r, i, matrix.RowCount, i + 1, matrix.ColumnCount, Control.NumberOfParallelWorkerThreads);
+                    ComputeQR(u[i], r, i, matrix.RowCount, i + 1, matrix.ColumnCount, Control.MaxDegreeOfParallelism);
                 }
 
                 for (var i = minmn - 1; i >= 0; i--)
                 {
-                    ComputeQR(u[i], q, i, matrix.RowCount, i, matrix.RowCount, Control.NumberOfParallelWorkerThreads);
+                    ComputeQR(u[i], q, i, matrix.RowCount, i, matrix.RowCount, Control.MaxDegreeOfParallelism);
                 }
             }
             else
@@ -95,7 +95,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
                 for (var i = 0; i < minmn; i++)
                 {
                     u[i] = GenerateColumn(q, i, i);
-                    ComputeQR(u[i], q, i, matrix.RowCount, i + 1, matrix.ColumnCount, Control.NumberOfParallelWorkerThreads);
+                    ComputeQR(u[i], q, i, matrix.RowCount, i + 1, matrix.ColumnCount, Control.MaxDegreeOfParallelism);
                 }
 
                 r = q.SubMatrix(0, matrix.ColumnCount, 0, matrix.ColumnCount);
@@ -108,7 +108,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
 
                 for (var i = minmn - 1; i >= 0; i--)
                 {
-                    ComputeQR(u[i], q, i, matrix.RowCount, i, matrix.ColumnCount, Control.NumberOfParallelWorkerThreads);
+                    ComputeQR(u[i], q, i, matrix.RowCount, i, matrix.ColumnCount, Control.MaxDegreeOfParallelism);
                 }
             }
 
diff --git a/src/Numerics/LinearAlgebra/Single/Factorization/UserCholesky.cs b/src/Numerics/LinearAlgebra/Single/Factorization/UserCholesky.cs
index 2ca816dc..3419ba0d 100644
--- a/src/Numerics/LinearAlgebra/Single/Factorization/UserCholesky.cs
+++ b/src/Numerics/LinearAlgebra/Single/Factorization/UserCholesky.cs
@@ -85,7 +85,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
                     }
 
                     // Remaining columns, below the diagonal
-                    DoCholeskyStep(factor, factor.RowCount, ij + 1, factor.RowCount, tmpColumn, Control.NumberOfParallelWorkerThreads);
+                    DoCholeskyStep(factor, factor.RowCount, ij + 1, factor.RowCount, tmpColumn, Control.MaxDegreeOfParallelism);
                 }
                 else
                 {
diff --git a/src/Numerics/LinearAlgebra/Single/Factorization/UserQR.cs b/src/Numerics/LinearAlgebra/Single/Factorization/UserQR.cs
index 21a2d4df..a6e0fe79 100644
--- a/src/Numerics/LinearAlgebra/Single/Factorization/UserQR.cs
+++ b/src/Numerics/LinearAlgebra/Single/Factorization/UserQR.cs
@@ -80,12 +80,12 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
                 for (var i = 0; i < minmn; i++)
                 {
                     u[i] = GenerateColumn(r, i, i);
-                    ComputeQR(u[i], r, i, matrix.RowCount, i + 1, matrix.ColumnCount, Control.NumberOfParallelWorkerThreads);
+                    ComputeQR(u[i], r, i, matrix.RowCount, i + 1, matrix.ColumnCount, Control.MaxDegreeOfParallelism);
                 }
 
                 for (var i = minmn - 1; i >= 0; i--)
                 {
-                    ComputeQR(u[i], q, i, matrix.RowCount, i, matrix.RowCount, Control.NumberOfParallelWorkerThreads);
+                    ComputeQR(u[i], q, i, matrix.RowCount, i, matrix.RowCount, Control.MaxDegreeOfParallelism);
                 }
             }
             else
@@ -95,7 +95,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
                 for (var i = 0; i < minmn; i++)
                 {
                     u[i] = GenerateColumn(q, i, i);
-                    ComputeQR(u[i], q, i, matrix.RowCount, i + 1, matrix.ColumnCount, Control.NumberOfParallelWorkerThreads);
+                    ComputeQR(u[i], q, i, matrix.RowCount, i + 1, matrix.ColumnCount, Control.MaxDegreeOfParallelism);
                 }
 
                 r = q.SubMatrix(0, matrix.ColumnCount, 0, matrix.ColumnCount);
@@ -108,7 +108,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
 
                 for (var i = minmn - 1; i >= 0; i--)
                 {
-                    ComputeQR(u[i], q, i, matrix.RowCount, i, matrix.ColumnCount, Control.NumberOfParallelWorkerThreads);
+                    ComputeQR(u[i], q, i, matrix.RowCount, i, matrix.ColumnCount, Control.MaxDegreeOfParallelism);
                 }
             }
 
diff --git a/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Complex.cs b/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Complex.cs
index 7afcebea..8bd0b943 100644
--- a/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Complex.cs
+++ b/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Complex.cs
@@ -1265,7 +1265,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra
                     }
 
                     // Remaining columns, below the diagonal
-                    DoCholeskyStep(a, order, ij + 1, order, tmpColumn, Control.NumberOfParallelWorkerThreads);
+                    DoCholeskyStep(a, order, ij + 1, order, tmpColumn, Control.MaxDegreeOfParallelism);
                 }
                 else
                 {
@@ -1546,12 +1546,12 @@ namespace MathNet.Numerics.Providers.LinearAlgebra
             for (var i = 0; i < minmn; i++)
             {
                 GenerateColumn(work, r, rowsR, i, i);
-                ComputeQR(work, i, r, i, rowsR, i + 1, columnsR, Control.NumberOfParallelWorkerThreads);
+                ComputeQR(work, i, r, i, rowsR, i + 1, columnsR, Control.MaxDegreeOfParallelism);
             }
 
             for (var i = minmn - 1; i >= 0; i--)
             {
-                ComputeQR(work, i, q, i, rowsR, i, rowsR, Control.NumberOfParallelWorkerThreads);
+                ComputeQR(work, i, q, i, rowsR, i, rowsR, Control.MaxDegreeOfParallelism);
             }
 
             work[0] = columnsR > rowsR ? rowsR*rowsR : rowsR*columnsR;
@@ -1657,7 +1657,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra
             for (var i = 0; i < minmn; i++)
             {
                 GenerateColumn(work, a, rowsA, i, i);
-                ComputeQR(work, i, a, i, rowsA, i + 1, columnsA, Control.NumberOfParallelWorkerThreads);
+                ComputeQR(work, i, a, i, rowsA, i + 1, columnsA, Control.MaxDegreeOfParallelism);
             }
 
             //copy R
@@ -1680,7 +1680,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra
 
             for (var i = minmn - 1; i >= 0; i--)
             {
-                ComputeQR(work, i, a, i, rowsA, i, columnsA, Control.NumberOfParallelWorkerThreads);
+                ComputeQR(work, i, a, i, rowsA, i, columnsA, Control.MaxDegreeOfParallelism);
             }
 
             work[0] = rowsA*columnsA;
diff --git a/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Complex32.cs b/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Complex32.cs
index 003054bf..ae36ff99 100644
--- a/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Complex32.cs
+++ b/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Complex32.cs
@@ -1262,7 +1262,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra
                     }
 
                     // Remaining columns, below the diagonal
-                    DoCholeskyStep(a, order, ij + 1, order, tmpColumn, Control.NumberOfParallelWorkerThreads);
+                    DoCholeskyStep(a, order, ij + 1, order, tmpColumn, Control.MaxDegreeOfParallelism);
                 }
                 else
                 {
@@ -1543,12 +1543,12 @@ namespace MathNet.Numerics.Providers.LinearAlgebra
             for (var i = 0; i < minmn; i++)
             {
                 GenerateColumn(work, r, rowsR, i, i);
-                ComputeQR(work, i, r, i, rowsR, i + 1, columnsR, Control.NumberOfParallelWorkerThreads);
+                ComputeQR(work, i, r, i, rowsR, i + 1, columnsR, Control.MaxDegreeOfParallelism);
             }
 
             for (var i = minmn - 1; i >= 0; i--)
             {
-                ComputeQR(work, i, q, i, rowsR, i, rowsR, Control.NumberOfParallelWorkerThreads);
+                ComputeQR(work, i, q, i, rowsR, i, rowsR, Control.MaxDegreeOfParallelism);
             }
 
             work[0] = columnsR > rowsR ? rowsR*rowsR : rowsR*columnsR;
@@ -1654,7 +1654,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra
             for (var i = 0; i < minmn; i++)
             {
                 GenerateColumn(work, a, rowsA, i, i);
-                ComputeQR(work, i, a, i, rowsA, i + 1, columnsA, Control.NumberOfParallelWorkerThreads);
+                ComputeQR(work, i, a, i, rowsA, i + 1, columnsA, Control.MaxDegreeOfParallelism);
             }
 
             //copy R
@@ -1677,7 +1677,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra
 
             for (var i = minmn - 1; i >= 0; i--)
             {
-                ComputeQR(work, i, a, i, rowsA, i, columnsA, Control.NumberOfParallelWorkerThreads);
+                ComputeQR(work, i, a, i, rowsA, i, columnsA, Control.MaxDegreeOfParallelism);
             }
 
             work[0] = rowsA*columnsA;
diff --git a/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Double.cs b/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Double.cs
index 4d19b341..b73df945 100644
--- a/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Double.cs
+++ b/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Double.cs
@@ -1148,7 +1148,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra
                     }
 
                     // Remaining columns, below the diagonal
-                    DoCholeskyStep(a, order, ij + 1, order, tmpColumn, Control.NumberOfParallelWorkerThreads);
+                    DoCholeskyStep(a, order, ij + 1, order, tmpColumn, Control.MaxDegreeOfParallelism);
                 }
                 else
                 {
@@ -1430,12 +1430,12 @@ namespace MathNet.Numerics.Providers.LinearAlgebra
             for (var i = 0; i < minmn; i++)
             {
                 GenerateColumn(work, r, rowsR, i, i);
-                ComputeQR(work, i, r, i, rowsR, i + 1, columnsR, Control.NumberOfParallelWorkerThreads);
+                ComputeQR(work, i, r, i, rowsR, i + 1, columnsR, Control.MaxDegreeOfParallelism);
             }
 
             for (var i = minmn - 1; i >= 0; i--)
             {
-                ComputeQR(work, i, q, i, rowsR, i, rowsR, Control.NumberOfParallelWorkerThreads);
+                ComputeQR(work, i, q, i, rowsR, i, rowsR, Control.MaxDegreeOfParallelism);
             }
 
             work[0] = columnsR > rowsR ? rowsR*rowsR : rowsR*columnsR;
@@ -1541,7 +1541,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra
             for (var i = 0; i < minmn; i++)
             {
                 GenerateColumn(work, a, rowsA, i, i);
-                ComputeQR(work, i, a, i, rowsA, i + 1, columnsA, Control.NumberOfParallelWorkerThreads);
+                ComputeQR(work, i, a, i, rowsA, i + 1, columnsA, Control.MaxDegreeOfParallelism);
             }
 
             //copy R
@@ -1564,7 +1564,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra
 
             for (var i = minmn - 1; i >= 0; i--)
             {
-                ComputeQR(work, i, a, i, rowsA, i, columnsA, Control.NumberOfParallelWorkerThreads);
+                ComputeQR(work, i, a, i, rowsA, i, columnsA, Control.MaxDegreeOfParallelism);
             }
 
             work[0] = rowsA*columnsA;
diff --git a/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Single.cs b/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Single.cs
index 024cca70..e47b174e 100644
--- a/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Single.cs
+++ b/src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Single.cs
@@ -1148,7 +1148,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra
                     }
 
                     // Remaining columns, below the diagonal
-                    DoCholeskyStep(a, order, ij + 1, order, tmpColumn, Control.NumberOfParallelWorkerThreads);
+                    DoCholeskyStep(a, order, ij + 1, order, tmpColumn, Control.MaxDegreeOfParallelism);
                 }
                 else
                 {
@@ -1429,12 +1429,12 @@ namespace MathNet.Numerics.Providers.LinearAlgebra
             for (var i = 0; i < minmn; i++)
             {
                 GenerateColumn(work, r, rowsR, i, i);
-                ComputeQR(work, i, r, i, rowsR, i + 1, columnsR, Control.NumberOfParallelWorkerThreads);
+                ComputeQR(work, i, r, i, rowsR, i + 1, columnsR, Control.MaxDegreeOfParallelism);
             }
 
             for (var i = minmn - 1; i >= 0; i--)
             {
-                ComputeQR(work, i, q, i, rowsR, i, rowsR, Control.NumberOfParallelWorkerThreads);
+                ComputeQR(work, i, q, i, rowsR, i, rowsR, Control.MaxDegreeOfParallelism);
             }
 
             work[0] = columnsR > rowsR ? rowsR*rowsR : rowsR*columnsR;
@@ -1540,7 +1540,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra
             for (var i = 0; i < minmn; i++)
             {
                 GenerateColumn(work, a, rowsA, i, i);
-                ComputeQR(work, i, a, i, rowsA, i + 1, columnsA, Control.NumberOfParallelWorkerThreads);
+                ComputeQR(work, i, a, i, rowsA, i + 1, columnsA, Control.MaxDegreeOfParallelism);
             }
 
             //copy R
@@ -1563,7 +1563,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra
 
             for (var i = minmn - 1; i >= 0; i--)
             {
-                ComputeQR(work, i, a, i, rowsA, i, columnsA, Control.NumberOfParallelWorkerThreads);
+                ComputeQR(work, i, a, i, rowsA, i, columnsA, Control.MaxDegreeOfParallelism);
             }
 
             work[0] = rowsA*columnsA;
diff --git a/src/Numerics/Random/Palf.cs b/src/Numerics/Random/Palf.cs
index 635d98f1..aa5c4d77 100644
--- a/src/Numerics/Random/Palf.cs
+++ b/src/Numerics/Random/Palf.cs
@@ -124,7 +124,7 @@ namespace MathNet.Numerics.Random
                 seed = 1;
             }
 
-            _threads = Control.NumberOfParallelWorkerThreads;
+            _threads = Control.MaxDegreeOfParallelism;
             ShortLag = shortLag;
 
             // Align LongLag to number of worker threads.
@@ -234,7 +234,7 @@ namespace MathNet.Numerics.Random
                 seed = 1;
             }
 
-            int threads = Control.NumberOfParallelWorkerThreads;
+            int threads = Control.MaxDegreeOfParallelism;
             const int shortLag = DefaultShortLag;
             var longLag = DefaultLongLag;
 
@@ -284,7 +284,7 @@ namespace MathNet.Numerics.Random
                 seed = 1;
             }
 
-            int threads = Control.NumberOfParallelWorkerThreads;
+            int threads = Control.MaxDegreeOfParallelism;
             const int shortLag = DefaultShortLag;
             var longLag = DefaultLongLag;
 
diff --git a/src/Numerics/Threading/CommonParallel.cs b/src/Numerics/Threading/CommonParallel.cs
index 6e93d465..1b777120 100644
--- a/src/Numerics/Threading/CommonParallel.cs
+++ b/src/Numerics/Threading/CommonParallel.cs
@@ -51,7 +51,7 @@ namespace MathNet.Numerics.Threading
         {
             return new ParallelOptions
                 {
-                    MaxDegreeOfParallelism = Control.NumberOfParallelWorkerThreads,
+                    MaxDegreeOfParallelism = Control.MaxDegreeOfParallelism,
                     TaskScheduler = Control.TaskScheduler,
                 };
         }
@@ -64,7 +64,7 @@ namespace MathNet.Numerics.Threading
         /// <param name="body">The body to be invoked for each iteration range.</param>
         public static void For(int fromInclusive, int toExclusive, Action<int, int> body)
         {
-            For(fromInclusive, toExclusive, Math.Max(1, (toExclusive - fromInclusive)/Control.NumberOfParallelWorkerThreads), body);
+            For(fromInclusive, toExclusive, Math.Max(1, (toExclusive - fromInclusive)/Control.MaxDegreeOfParallelism), body);
         }
 
         /// <summary>
@@ -90,7 +90,7 @@ namespace MathNet.Numerics.Threading
             }
 
             // Special case: not worth to parallelize, inline
-            if (Control.NumberOfParallelWorkerThreads < 2 || (rangeSize * 2) > length)
+            if (Control.MaxDegreeOfParallelism < 2 || (rangeSize * 2) > length)
             {
                 body(fromInclusive, toExclusive);
                 return;
@@ -125,7 +125,7 @@ namespace MathNet.Numerics.Threading
             }
 
             // Special case: straight execution without parallelism
-            if (Control.NumberOfParallelWorkerThreads < 2)
+            if (Control.MaxDegreeOfParallelism < 2)
             {
                 for (int i = 0; i < actions.Length; i++)
                 {
@@ -166,7 +166,7 @@ namespace MathNet.Numerics.Threading
             }
 
             // Special case: straight execution without parallelism
-            if (Control.NumberOfParallelWorkerThreads < 2)
+            if (Control.MaxDegreeOfParallelism < 2)
             {
                 var mapped = new T[toExclusive - fromInclusive];
                 for (int k = 0; k < mapped.Length; k++)
@@ -228,7 +228,7 @@ namespace MathNet.Numerics.Threading
             }
 
             // Special case: straight execution without parallelism
-            if (Control.NumberOfParallelWorkerThreads < 2)
+            if (Control.MaxDegreeOfParallelism < 2)
             {
                 var mapped = new TOut[array.Length];
                 for (int k = 0; k < mapped.Length; k++)