LA: Result should be called 'result' not 'target'

src/Numerics/LinearAlgebra/Complex/DenseVector.cs

@@ -369,15 +369,15 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
         }
 
         /// <summary>
-        /// Negates vector and saves result to <paramref name="target"/>
+        /// Negates vector and saves result to <paramref name="result"/>
         /// </summary>
-        /// <param name="target">Target vector</param>
-        protected override void DoNegate(Vector<Complex> target)
+        /// <param name="result">Target vector</param>
+        protected override void DoNegate(Vector<Complex> result)
         {
-            var denseResult = target as DenseVector;
+            var denseResult = result as DenseVector;
             if (denseResult == null)
             {
-                base.DoNegate(target);
+                base.DoNegate(result);
             }
             else
             {
@@ -863,24 +863,22 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
         #endregion
 
         /// <summary>
-        /// Conjugates vector and save result to <paramref name="target"/>
+        /// Conjugates vector and save result to <paramref name="result"/>
         /// </summary>
-        /// <param name="target">Target vector</param>
-        protected override void DoConjugate(Vector<Complex> target)
+        /// <param name="result">Target vector</param>
+        protected override void DoConjugate(Vector<Complex> result)
         {
-            var denseTarget = target as DenseVector;
-
-            if (denseTarget == null)
+            var resultDense = result as DenseVector;
+            if (resultDense == null)
             {
-                base.DoConjugate(target);
-            }
-            else
-            {
-                CommonParallel.For(
-                    0,
-                    _length,
-                    index => denseTarget._values[index] = _values[index].Conjugate());
+                base.DoConjugate(result);
+                return;
             }
+
+            CommonParallel.For(
+                0,
+                _length,
+                index => resultDense._values[index] = _values[index].Conjugate());
         }
     }
 }

src/Numerics/LinearAlgebra/Complex/SparseVector.cs

@@ -174,22 +174,22 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
         }
 
         /// <summary>
-        /// Conjugates vector and save result to <paramref name="target"/>
+        /// Conjugates vector and save result to <paramref name="result"/>
         /// </summary>
-        /// <param name="target">Target vector</param>
-        protected override void DoConjugate(Vector<Complex> target)
+        /// <param name="result">Target vector</param>
+        protected override void DoConjugate(Vector<Complex> result)
         {
-            if (ReferenceEquals(this, target))
+            if (ReferenceEquals(this, result))
             {
                 var tmp = CreateVector(Count);
                 DoConjugate(tmp);
-                tmp.CopyTo(target);
+                tmp.CopyTo(result);
             }
 
-            var targetSparse = target as SparseVector;
+            var targetSparse = result as SparseVector;
             if (targetSparse == null)
             {
-                base.DoConjugate(target);
+                base.DoConjugate(result);
                 return;
             }
 
@@ -448,23 +448,23 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
         }
 
         /// <summary>
-        /// Negates vector and saves result to <paramref name="target"/>
+        /// Negates vector and saves result to <paramref name="result"/>
         /// </summary>
-        /// <param name="target">Target vector</param>
-        protected override void DoNegate(Vector<Complex> target)
+        /// <param name="result">Target vector</param>
+        protected override void DoNegate(Vector<Complex> result)
         {
-            var sparseResult = target as SparseVector;
+            var sparseResult = result as SparseVector;
             if (sparseResult == null)
             {
-                target.Clear();
+                result.Clear();
                 for (var index = 0; index < _storage.ValueCount; index++)
                 {
-                    target.At(_storage.Indices[index], -_storage.Values[index]);
+                    result.At(_storage.Indices[index], -_storage.Values[index]);
                 }
             }
             else
             {
-                if (!ReferenceEquals(this, target))
+                if (!ReferenceEquals(this, result))
                 {
                     sparseResult._storage.ValueCount = _storage.ValueCount;
                     sparseResult._storage.Indices = new int[_storage.ValueCount];

src/Numerics/LinearAlgebra/Complex/Vector.cs

@@ -327,26 +327,26 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
         }
 
         /// <summary>
-        /// Conjugates vector and save result to <paramref name="target"/>
+        /// Conjugates vector and save result to <paramref name="result"/>
         /// </summary>
-        /// <param name="target">Target vector</param>
-        protected override void DoConjugate(Vector<Complex> target)
+        /// <param name="result">Target vector</param>
+        protected override void DoConjugate(Vector<Complex> result)
         {
             for (var index = 0; index < Count; index++)
             {
-                target.At(index, At(index).Conjugate());
+                result.At(index, At(index).Conjugate());
             }
         }
 
         /// <summary>
-        /// Negates vector and saves result to <paramref name="target"/>
+        /// Negates vector and saves result to <paramref name="result"/>
         /// </summary>
-        /// <param name="target">Target vector</param>
-        protected override void DoNegate(Vector<Complex> target)
+        /// <param name="result">Target vector</param>
+        protected override void DoNegate(Vector<Complex> result)
         {
             for (var index = 0; index < Count; index++)
             {
-                target.At(index, -At(index));
+                result.At(index, -At(index));
             }
         }
 

src/Numerics/LinearAlgebra/Complex32/DenseVector.cs

@@ -369,15 +369,15 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
         }
 
         /// <summary>
-        /// Negates vector and saves result to <paramref name="target"/>
+        /// Negates vector and saves result to <paramref name="result"/>
         /// </summary>
-        /// <param name="target">Target vector</param>
-        protected override void DoNegate(Vector<Complex32> target)
+        /// <param name="result">Target vector</param>
+        protected override void DoNegate(Vector<Complex32> result)
         {
-            var denseResult = target as DenseVector;
+            var denseResult = result as DenseVector;
             if (denseResult == null)
             {
-                base.DoNegate(target);
+                base.DoNegate(result);
             }
             else
             {
@@ -863,24 +863,22 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
         #endregion
 
         /// <summary>
-        /// Conjugates vector and save result to <paramref name="target"/>
+        /// Conjugates vector and save result to <paramref name="result"/>
         /// </summary>
-        /// <param name="target">Target vector</param>
-        protected override void DoConjugate(Vector<Complex32> target)
+        /// <param name="result">Target vector</param>
+        protected override void DoConjugate(Vector<Complex32> result)
         {
-            var denseTarget = target as DenseVector;
-
-            if (denseTarget == null)
+            var resultDense = result as DenseVector;
+            if (resultDense == null)
             {
-                base.DoConjugate(target);
-            }
-            else
-            {
-                CommonParallel.For(
-                    0,
-                    _length,
-                    index => denseTarget._values[index] = _values[index].Conjugate());
+                base.DoConjugate(result);
+                return;
             }
+
+            CommonParallel.For(
+                0,
+                _length,
+                index => resultDense._values[index] = _values[index].Conjugate());
         }
     }
 }

src/Numerics/LinearAlgebra/Complex32/SparseVector.cs

@@ -174,22 +174,22 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
         }
 
         /// <summary>
-        /// Conjugates vector and save result to <paramref name="target"/>
+        /// Conjugates vector and save result to <paramref name="result"/>
         /// </summary>
-        /// <param name="target">Target vector</param>
-        protected override void DoConjugate(Vector<Complex32> target)
+        /// <param name="result">Target vector</param>
+        protected override void DoConjugate(Vector<Complex32> result)
         {
-            if (ReferenceEquals(this, target))
+            if (ReferenceEquals(this, result))
             {
                 var tmp = CreateVector(Count);
                 DoConjugate(tmp);
-                tmp.CopyTo(target);
+                tmp.CopyTo(result);
             }
 
-            var targetSparse = target as SparseVector;
+            var targetSparse = result as SparseVector;
             if (targetSparse == null)
             {
-                base.DoConjugate(target);
+                base.DoConjugate(result);
                 return;
             }
 
@@ -448,23 +448,23 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
         }
 
         /// <summary>
-        /// Negates vector and saves result to <paramref name="target"/>
+        /// Negates vector and saves result to <paramref name="result"/>
         /// </summary>
-        /// <param name="target">Target vector</param>
-        protected override void DoNegate(Vector<Complex32> target)
+        /// <param name="result">Target vector</param>
+        protected override void DoNegate(Vector<Complex32> result)
         {
-            var sparseResult = target as SparseVector;
+            var sparseResult = result as SparseVector;
             if (sparseResult == null)
             {
-                target.Clear();
+                result.Clear();
                 for (var index = 0; index < _storage.ValueCount; index++)
                 {
-                    target.At(_storage.Indices[index], -_storage.Values[index]);
+                    result.At(_storage.Indices[index], -_storage.Values[index]);
                 }
             }
             else
             {
-                if (!ReferenceEquals(this, target))
+                if (!ReferenceEquals(this, result))
                 {
                     sparseResult._storage.ValueCount = _storage.ValueCount;
                     sparseResult._storage.Indices = new int[_storage.ValueCount];

src/Numerics/LinearAlgebra/Complex32/Vector.cs

@@ -327,26 +327,26 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
         }
 
         /// <summary>
-        /// Conjugates vector and save result to <paramref name="target"/>
+        /// Conjugates vector and save result to <paramref name="result"/>
         /// </summary>
-        /// <param name="target">Target vector</param>
-        protected override void DoConjugate(Vector<Complex32> target)
+        /// <param name="result">Target vector</param>
+        protected override void DoConjugate(Vector<Complex32> result)
         {
             for (var index = 0; index < Count; index++)
             {
-                target.At(index, At(index).Conjugate());
+                result.At(index, At(index).Conjugate());
             }
         }
 
         /// <summary>
-        /// Negates vector and saves result to <paramref name="target"/>
+        /// Negates vector and saves result to <paramref name="result"/>
         /// </summary>
-        /// <param name="target">Target vector</param>
-        protected override void DoNegate(Vector<Complex32> target)
+        /// <param name="result">Target vector</param>
+        protected override void DoNegate(Vector<Complex32> result)
         {
             for (var index = 0; index < Count; index++)
             {
-                target.At(index, -At(index));
+                result.At(index, -At(index));
             }
         }
 

src/Numerics/LinearAlgebra/Double/DenseVector.cs

@@ -379,15 +379,15 @@ namespace MathNet.Numerics.LinearAlgebra.Double
         }
 
         /// <summary>
-        /// Negates vector and saves result to <paramref name="target"/>
+        /// Negates vector and saves result to <paramref name="result"/>
         /// </summary>
-        /// <param name="target">Target vector</param>
-        protected override void DoNegate(Vector<double> target)
+        /// <param name="result">Target vector</param>
+        protected override void DoNegate(Vector<double> result)
         {
-            var denseResult = target as DenseVector;
+            var denseResult = result as DenseVector;
             if (denseResult == null)
             {
-                base.DoNegate(target);
+                base.DoNegate(result);
             }
             else
             {

src/Numerics/LinearAlgebra/Double/SparseVector.cs

@@ -416,23 +416,23 @@ namespace MathNet.Numerics.LinearAlgebra.Double
         }
 
         /// <summary>
-        /// Negates vector and saves result to <paramref name="target"/>
+        /// Negates vector and saves result to <paramref name="result"/>
         /// </summary>
-        /// <param name="target">Target vector</param>
-        protected override void DoNegate(Vector<double> target)
+        /// <param name="result">Target vector</param>
+        protected override void DoNegate(Vector<double> result)
         {
-            var sparseResult = target as SparseVector;
+            var sparseResult = result as SparseVector;
             if (sparseResult == null)
             {
-                target.Clear();
+                result.Clear();
                 for (var index = 0; index < _storage.ValueCount; index++)
                 {
-                    target.At(_storage.Indices[index], -_storage.Values[index]);
+                    result.At(_storage.Indices[index], -_storage.Values[index]);
                 }
             }
             else
             {
-                if (!ReferenceEquals(this, target))
+                if (!ReferenceEquals(this, result))
                 {
                     sparseResult._storage.ValueCount = _storage.ValueCount;
                     sparseResult._storage.Indices = new int[_storage.ValueCount];

src/Numerics/LinearAlgebra/Double/Vector.cs

@@ -329,28 +329,28 @@ namespace MathNet.Numerics.LinearAlgebra.Double
         }
 
         /// <summary>
-        /// Conjugates vector and save result to <paramref name="target"/>
+        /// Conjugates vector and save result to <paramref name="result"/>
         /// </summary>
-        /// <param name="target">Target vector</param>
-        protected override void DoConjugate(Vector<double> target)
+        /// <param name="result">Target vector</param>
+        protected override void DoConjugate(Vector<double> result)
         {
-            if (ReferenceEquals(this, target))
+            if (ReferenceEquals(this, result))
             {
                 return;
             }
 
-            CopyTo(target);
+            CopyTo(result);
         }
 
         /// <summary>
-        /// Negates vector and saves result to <paramref name="target"/>
+        /// Negates vector and saves result to <paramref name="result"/>
         /// </summary>
-        /// <param name="target">Target vector</param>
-        protected override void DoNegate(Vector<double> target)
+        /// <param name="result">Target vector</param>
+        protected override void DoNegate(Vector<double> result)
         {
             for (var index = 0; index < Count; index++)
             {
-                target.At(index, -At(index));
+                result.At(index, -At(index));
             }
         }
 

src/Numerics/LinearAlgebra/Generic/Vector.cs

@@ -161,16 +161,16 @@ namespace MathNet.Numerics.LinearAlgebra.Generic
 
 
         /// <summary>
-        /// Negates vector and save result to <paramref name="target"/>
+        /// Negates vector and save result to <paramref name="result"/>
         /// </summary>
-        /// <param name="target">Target vector</param>
-        protected abstract void DoNegate(Vector<T> target);
+        /// <param name="result">Target vector</param>
+        protected abstract void DoNegate(Vector<T> result);
 
         /// <summary>
-        /// Complex conjugates vector and save result to <paramref name="target"/>
+        /// Complex conjugates vector and save result to <paramref name="result"/>
         /// </summary>
-        /// <param name="target">Target vector</param>
-        protected abstract void DoConjugate(Vector<T> target);
+        /// <param name="result">Target vector</param>
+        protected abstract void DoConjugate(Vector<T> result);
 
         /// <summary>
         /// Adds a scalar to each element of the vector and stores the result in the result vector.
@@ -405,22 +405,22 @@ namespace MathNet.Numerics.LinearAlgebra.Generic
         }
 
         /// <summary>
-        /// Negates vector and save result to <paramref name="target"/>
+        /// Negates vector and save result to <paramref name="result"/>
         /// </summary>
-        /// <param name="target">Target vector</param>
-        public void Negate(Vector<T> target)
+        /// <param name="result">Target vector</param>
+        public void Negate(Vector<T> result)
         {
-            if (target == null)
+            if (result == null)
             {
-                throw new ArgumentNullException("target");
+                throw new ArgumentNullException("result");
             }
 
-            if (Count != target.Count)
+            if (Count != result.Count)
             {
-                throw new ArgumentException(Resources.ArgumentVectorsSameLength, "target");
+                throw new ArgumentException(Resources.ArgumentVectorsSameLength, "result");
             }
 
-            DoNegate(target);
+            DoNegate(result);
         }
 
         /// <summary>
@@ -483,22 +483,22 @@ namespace MathNet.Numerics.LinearAlgebra.Generic
         }
 
         /// <summary>
-        /// Complex conjugates vector and save result to <paramref name="target"/>
+        /// Complex conjugates vector and save result to <paramref name="result"/>
         /// </summary>
-        /// <param name="target">Target vector</param>
-        public void Conjugate(Vector<T> target)
+        /// <param name="result">Target vector</param>
+        public void Conjugate(Vector<T> result)
         {
-            if (target == null)
+            if (result == null)
             {
-                throw new ArgumentNullException("target");
+                throw new ArgumentNullException("result");
             }
 
-            if (Count != target.Count)
+            if (Count != result.Count)
             {
-                throw new ArgumentException(Resources.ArgumentVectorsSameLength, "target");
+                throw new ArgumentException(Resources.ArgumentVectorsSameLength, "result");
             }
 
-            DoConjugate(target);
+            DoConjugate(result);
         }
 
         /// <summary>

src/Numerics/LinearAlgebra/Single/DenseVector.cs

@@ -369,15 +369,15 @@ namespace MathNet.Numerics.LinearAlgebra.Single
         }
 
         /// <summary>
-        /// Negates vector and saves result to <paramref name="target"/>
+        /// Negates vector and saves result to <paramref name="result"/>
         /// </summary>
-        /// <param name="target">Target vector</param>
-        protected override void DoNegate(Vector<float> target)
+        /// <param name="result">Target vector</param>
+        protected override void DoNegate(Vector<float> result)
         {
-            var denseResult = target as DenseVector;
+            var denseResult = result as DenseVector;
             if (denseResult == null)
             {
-                base.DoNegate(target);
+                base.DoNegate(result);
             }
             else
             {

src/Numerics/LinearAlgebra/Single/SparseVector.cs

@@ -417,23 +417,23 @@ namespace MathNet.Numerics.LinearAlgebra.Single
         }
 
         /// <summary>
-        /// Negates vector and saves result to <paramref name="target"/>
+        /// Negates vector and saves result to <paramref name="result"/>
         /// </summary>
-        /// <param name="target">Target vector</param>
-        protected override void DoNegate(Vector<float> target)
+        /// <param name="result">Target vector</param>
+        protected override void DoNegate(Vector<float> result)
         {
-            var sparseResult = target as SparseVector;
+            var sparseResult = result as SparseVector;
             if (sparseResult == null)
             {
-                target.Clear();
+                result.Clear();
                 for (var index = 0; index < _storage.ValueCount; index++)
                 {
-                    target.At(_storage.Indices[index], -_storage.Values[index]);
+                    result.At(_storage.Indices[index], -_storage.Values[index]);
                 }
             }
             else
             {
-                if (!ReferenceEquals(this, target))
+                if (!ReferenceEquals(this, result))
                 {
                     sparseResult._storage.ValueCount = _storage.ValueCount;
                     sparseResult._storage.Indices = new int[_storage.ValueCount];

src/Numerics/LinearAlgebra/Single/Vector.cs

@@ -329,28 +329,28 @@ namespace MathNet.Numerics.LinearAlgebra.Single
         }
 
         /// <summary>
-        /// Conjugates vector and save result to <paramref name="target"/>
+        /// Conjugates vector and save result to <paramref name="result"/>
         /// </summary>
-        /// <param name="target">Target vector</param>
-        protected override void DoConjugate(Vector<float> target)
+        /// <param name="result">Target vector</param>
+        protected override void DoConjugate(Vector<float> result)
         {
-            if (ReferenceEquals(this, target))
+            if (ReferenceEquals(this, result))
             {
                 return;
             }
 
-            CopyTo(target);
+            CopyTo(result);
         }
 
         /// <summary>
-        /// Negates vector and saves result to <paramref name="target"/>
+        /// Negates vector and saves result to <paramref name="result"/>
         /// </summary>
-        /// <param name="target">Target vector</param>
-        protected override void DoNegate(Vector<float> target)
+        /// <param name="result">Target vector</param>
+        protected override void DoNegate(Vector<float> result)
         {
             for (var index = 0; index < Count; index++)
             {
-                target.At(index, -At(index));
+                result.At(index, -At(index));
             }
         }