Math.NET Numerics
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 

3190 lines
182 KiB

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
<title>ManagedLinearAlgebraProvider - Math.NET Numerics Documentation</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
<link type="text/css" rel="stylesheet" href="../main.css"/>
<script type="text/javascript" src="../js/jquery-1.3.2.min.js"></script>
<script type="text/javascript" src="../js/jquery.scrollTo-min.js"></script>
<script type="text/javascript" src="../js/navigation.js"></script>
<script type="text/javascript" src="../js/example.js"></script>
</head>
<body><div id="namespaces">
<h2 class="fixed">Namespaces</h2>
<div class="scroll">
<ul>
<li>
<a href="../MathNet.Numerics/index.htm">MathNet.Numerics</a>
</li>
<li>
<a href="../MathNet.Numerics.Differentiation/index.htm">MathNet.Numerics.Differentiation</a>
</li>
<li>
<a href="../MathNet.Numerics.Distributions/index.htm">MathNet.Numerics.Distributions</a>
</li>
<li>
<a href="../MathNet.Numerics.Financial/index.htm">MathNet.Numerics.Financial</a>
</li>
<li>
<a href="../MathNet.Numerics.IntegralTransforms/index.htm">MathNet.Numerics.IntegralTransforms</a>
</li>
<li>
<a href="../MathNet.Numerics.Integration/index.htm">MathNet.Numerics.Integration</a>
</li>
<li>
<a href="../MathNet.Numerics.Interpolation/index.htm">MathNet.Numerics.Interpolation</a>
</li>
<li>
<a href="../MathNet.Numerics.LinearAlgebra/index.htm">MathNet.Numerics.LinearAlgebra</a>
</li>
<li>
<a href="../MathNet.Numerics.LinearAlgebra.Complex/index.htm">MathNet.Numerics.LinearAlgebra.Complex</a>
</li>
<li>
<a href="../MathNet.Numerics.LinearAlgebra.Complex.Solvers/index.htm">MathNet.Numerics.LinearAlgebra.Complex.Solvers</a>
</li>
<li>
<a href="../MathNet.Numerics.LinearAlgebra.Complex32/index.htm">MathNet.Numerics.LinearAlgebra.Complex32</a>
</li>
<li>
<a href="../MathNet.Numerics.LinearAlgebra.Complex32.Solvers/index.htm">MathNet.Numerics.LinearAlgebra.Complex32.Solvers</a>
</li>
<li>
<a href="../MathNet.Numerics.LinearAlgebra.Double/index.htm">MathNet.Numerics.LinearAlgebra.Double</a>
</li>
<li>
<a href="../MathNet.Numerics.LinearAlgebra.Double.Solvers/index.htm">MathNet.Numerics.LinearAlgebra.Double.Solvers</a>
</li>
<li>
<a href="../MathNet.Numerics.LinearAlgebra.Factorization/index.htm">MathNet.Numerics.LinearAlgebra.Factorization</a>
</li>
<li>
<a href="../MathNet.Numerics.LinearAlgebra.Single/index.htm">MathNet.Numerics.LinearAlgebra.Single</a>
</li>
<li>
<a href="../MathNet.Numerics.LinearAlgebra.Single.Solvers/index.htm">MathNet.Numerics.LinearAlgebra.Single.Solvers</a>
</li>
<li>
<a href="../MathNet.Numerics.LinearAlgebra.Solvers/index.htm">MathNet.Numerics.LinearAlgebra.Solvers</a>
</li>
<li>
<a href="../MathNet.Numerics.LinearAlgebra.Storage/index.htm">MathNet.Numerics.LinearAlgebra.Storage</a>
</li>
<li>
<a href="../MathNet.Numerics.LinearRegression/index.htm">MathNet.Numerics.LinearRegression</a>
</li>
<li>
<a href="../MathNet.Numerics.OdeSolvers/index.htm">MathNet.Numerics.OdeSolvers</a>
</li>
<li>
<a href="../MathNet.Numerics.Optimization/index.htm">MathNet.Numerics.Optimization</a>
</li>
<li>
<a href="../MathNet.Numerics.Optimization.LineSearch/index.htm">MathNet.Numerics.Optimization.LineSearch</a>
</li>
<li>
<a href="../MathNet.Numerics.Optimization.ObjectiveFunctions/index.htm">MathNet.Numerics.Optimization.ObjectiveFunctions</a>
</li>
<li>
<a href="../MathNet.Numerics.Optimization.TrustRegion/index.htm">MathNet.Numerics.Optimization.TrustRegion</a>
</li>
<li>
<a href="../MathNet.Numerics.Providers/index.htm">MathNet.Numerics.Providers</a>
</li>
<li>
<a href="../MathNet.Numerics.Providers.FourierTransform/index.htm">MathNet.Numerics.Providers.FourierTransform</a>
</li>
<li>
<a href="../MathNet.Numerics.Providers.LinearAlgebra/index.htm" class="current">MathNet.Numerics.Providers.LinearAlgebra</a>
</li>
<li>
<a href="../MathNet.Numerics.Providers.SparseSolver/index.htm">MathNet.Numerics.Providers.SparseSolver</a>
</li>
<li>
<a href="../MathNet.Numerics.Random/index.htm">MathNet.Numerics.Random</a>
</li>
<li>
<a href="../MathNet.Numerics.RootFinding/index.htm">MathNet.Numerics.RootFinding</a>
</li>
<li>
<a href="../MathNet.Numerics.Statistics/index.htm">MathNet.Numerics.Statistics</a>
</li>
<li>
<a href="../MathNet.Numerics.Statistics.Mcmc/index.htm">MathNet.Numerics.Statistics.Mcmc</a>
</li>
</ul>
</div>
</div><div id="types">
<h2 class="fixed">Types in MathNet.Numerics.Providers.LinearAlgebra</h2>
<div class="scroll">
<ul>
<li>
<a href="../MathNet.Numerics.Providers.LinearAlgebra/ILinearAlgebraProvider.htm">ILinearAlgebraProvider</a>
</li>
<li>
<a href="../MathNet.Numerics.Providers.LinearAlgebra/ILinearAlgebraProvider`1.htm">ILinearAlgebraProvider&lt;T&gt;</a>
</li>
<li>
<a href="../MathNet.Numerics.Providers.LinearAlgebra/LinearAlgebraControl.htm">LinearAlgebraControl</a>
</li>
<li>
<a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm" class="current">ManagedLinearAlgebraProvider</a>
</li>
<li>
<a href="../MathNet.Numerics.Providers.LinearAlgebra/Norm.htm">Norm</a>
</li>
<li>
<a href="../MathNet.Numerics.Providers.LinearAlgebra/Transpose.htm">Transpose</a>
</li>
</ul>
</div>
</div>
<div class="header">
<p class="class"><strong>Type</strong> ManagedLinearAlgebraProvider</p>
<p><strong>Namespace</strong> MathNet.Numerics.Providers.LinearAlgebra</p>
<p><strong>Interfaces</strong> <a href="../MathNet.Numerics.Providers.LinearAlgebra/ILinearAlgebraProvider.htm">ILinearAlgebraProvider</a></p>
</div>
<div class="sub-header">
<div id="summary">The managed linear algebra provider.
</div>
<h3 class="section">Constructors</h3>
<ul>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#.ctor">ManagedLinearAlgebraProvider</a></li>
</ul>
<h3 class="section">Methods</h3>
<ul>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#AddArrays">AddArrays</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#AddArrays">AddArrays</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#AddArrays">AddArrays</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#AddArrays">AddArrays</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#AddVectorToScaledVector">AddVectorToScaledVector</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#AddVectorToScaledVector">AddVectorToScaledVector</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#AddVectorToScaledVector">AddVectorToScaledVector</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#AddVectorToScaledVector">AddVectorToScaledVector</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#CholeskyFactor">CholeskyFactor</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#CholeskyFactor">CholeskyFactor</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#CholeskyFactor">CholeskyFactor</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#CholeskyFactor">CholeskyFactor</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#CholeskySolve">CholeskySolve</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#CholeskySolve">CholeskySolve</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#CholeskySolve">CholeskySolve</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#CholeskySolve">CholeskySolve</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#CholeskySolveFactored">CholeskySolveFactored</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#CholeskySolveFactored">CholeskySolveFactored</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#CholeskySolveFactored">CholeskySolveFactored</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#CholeskySolveFactored">CholeskySolveFactored</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#ConjugateArray">ConjugateArray</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#ConjugateArray">ConjugateArray</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#ConjugateArray">ConjugateArray</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#ConjugateArray">ConjugateArray</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#DotProduct">DotProduct</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#DotProduct">DotProduct</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#DotProduct">DotProduct</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#DotProduct">DotProduct</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#EigenDecomp">EigenDecomp</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#EigenDecomp">EigenDecomp</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#EigenDecomp">EigenDecomp</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#EigenDecomp">EigenDecomp</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#Equals">Equals</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#FreeResources">FreeResources</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#GetHashCode">GetHashCode</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#GetType">GetType</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#InitializeVerify">InitializeVerify</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#IsAvailable">IsAvailable</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#LUFactor">LUFactor</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#LUFactor">LUFactor</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#LUFactor">LUFactor</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#LUFactor">LUFactor</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#LUInverse">LUInverse</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#LUInverse">LUInverse</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#LUInverse">LUInverse</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#LUInverse">LUInverse</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#LUInverseFactored">LUInverseFactored</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#LUInverseFactored">LUInverseFactored</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#LUInverseFactored">LUInverseFactored</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#LUInverseFactored">LUInverseFactored</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#LUSolve">LUSolve</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#LUSolve">LUSolve</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#LUSolve">LUSolve</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#LUSolve">LUSolve</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#LUSolveFactored">LUSolveFactored</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#LUSolveFactored">LUSolveFactored</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#LUSolveFactored">LUSolveFactored</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#LUSolveFactored">LUSolveFactored</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#MatrixMultiply">MatrixMultiply</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#MatrixMultiply">MatrixMultiply</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#MatrixMultiply">MatrixMultiply</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#MatrixMultiply">MatrixMultiply</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#MatrixMultiplyWithUpdate">MatrixMultiplyWithUpdate</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#MatrixMultiplyWithUpdate">MatrixMultiplyWithUpdate</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#MatrixMultiplyWithUpdate">MatrixMultiplyWithUpdate</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#MatrixMultiplyWithUpdate">MatrixMultiplyWithUpdate</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#MatrixNorm">MatrixNorm</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#MatrixNorm">MatrixNorm</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#MatrixNorm">MatrixNorm</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#MatrixNorm">MatrixNorm</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#PointWiseDivideArrays">PointWiseDivideArrays</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#PointWiseDivideArrays">PointWiseDivideArrays</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#PointWiseDivideArrays">PointWiseDivideArrays</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#PointWiseDivideArrays">PointWiseDivideArrays</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#PointWiseMultiplyArrays">PointWiseMultiplyArrays</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#PointWiseMultiplyArrays">PointWiseMultiplyArrays</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#PointWiseMultiplyArrays">PointWiseMultiplyArrays</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#PointWiseMultiplyArrays">PointWiseMultiplyArrays</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#PointWisePowerArrays">PointWisePowerArrays</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#PointWisePowerArrays">PointWisePowerArrays</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#PointWisePowerArrays">PointWisePowerArrays</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#PointWisePowerArrays">PointWisePowerArrays</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#QRFactor">QRFactor</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#QRFactor">QRFactor</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#QRFactor">QRFactor</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#QRFactor">QRFactor</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#QRSolve">QRSolve</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#QRSolve">QRSolve</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#QRSolve">QRSolve</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#QRSolve">QRSolve</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#QRSolveFactored">QRSolveFactored</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#QRSolveFactored">QRSolveFactored</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#QRSolveFactored">QRSolveFactored</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#QRSolveFactored">QRSolveFactored</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#ScaleArray">ScaleArray</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#ScaleArray">ScaleArray</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#ScaleArray">ScaleArray</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#ScaleArray">ScaleArray</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#SingularValueDecomposition">SingularValueDecomposition</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#SingularValueDecomposition">SingularValueDecomposition</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#SingularValueDecomposition">SingularValueDecomposition</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#SingularValueDecomposition">SingularValueDecomposition</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#SubtractArrays">SubtractArrays</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#SubtractArrays">SubtractArrays</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#SubtractArrays">SubtractArrays</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#SubtractArrays">SubtractArrays</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#SvdSolve">SvdSolve</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#SvdSolve">SvdSolve</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#SvdSolve">SvdSolve</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#SvdSolve">SvdSolve</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#SvdSolveFactored">SvdSolveFactored</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#SvdSolveFactored">SvdSolveFactored</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#SvdSolveFactored">SvdSolveFactored</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#SvdSolveFactored">SvdSolveFactored</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#ThinQRFactor">ThinQRFactor</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#ThinQRFactor">ThinQRFactor</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#ThinQRFactor">ThinQRFactor</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#ThinQRFactor">ThinQRFactor</a></li>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#ToString">ToString</a></li>
</ul>
<h3 class="section">Properties</h3>
<ul>
<li><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#Instance">Instance</a></li>
</ul>
</div>
<h3 class="section">Public Constructors</h3>
<div id=".ctor" class="method">
<h4> <strong>ManagedLinearAlgebraProvider</strong>()</h4>
<div class="content">
</div>
</div>
<h3 class="section">Public Methods</h3>
<div id="AddArrays" class="method">
<h4><span title="System.void">void</span> <strong>AddArrays</strong>(<span title="System.Single[]">Single[]</span> x, <span title="System.Single[]">Single[]</span> y, <span title="System.Single[]">Single[]</span> result)</h4>
<div class="content">Does a point wise add of two arrays <code>z = x + y</code>. This can be used
to add vectors or matrices. <blockquote class="remarks">
There is no equivalent BLAS routine, but many libraries
provide optimized (parallel and/or vectorized) versions of this
routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Single[]">Single[]</span></code> x</h6>
<p class="comments">The array x. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> y</h6>
<p class="comments">The array y. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> result</h6>
<p class="comments">The result of the addition. </p>
</div>
</div>
</div>
<div id="AddArrays" class="method">
<h4><span title="System.void">void</span> <strong>AddArrays</strong>(<span title="System.Double[]">Double[]</span> x, <span title="System.Double[]">Double[]</span> y, <span title="System.Double[]">Double[]</span> result)</h4>
<div class="content">Does a point wise add of two arrays <code>z = x + y</code>. This can be used
to add vectors or matrices. <blockquote class="remarks">
There is no equivalent BLAS routine, but many libraries
provide optimized (parallel and/or vectorized) versions of this
routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Double[]">Double[]</span></code> x</h6>
<p class="comments">The array x. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> y</h6>
<p class="comments">The array y. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> result</h6>
<p class="comments">The result of the addition. </p>
</div>
</div>
</div>
<div id="AddArrays" class="method">
<h4><span title="System.void">void</span> <strong>AddArrays</strong>(<span title="System.Numerics.Complex[]">Complex[]</span> x, <span title="System.Numerics.Complex[]">Complex[]</span> y, <span title="System.Numerics.Complex[]">Complex[]</span> result)</h4>
<div class="content">Does a point wise add of two arrays <code>z = x + y</code>. This can be used
to add vectors or matrices. <blockquote class="remarks">
There is no equivalent BLAS routine, but many libraries
provide optimized (parallel and/or vectorized) versions of this
routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> x</h6>
<p class="comments">The array x. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> y</h6>
<p class="comments">The array y. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> result</h6>
<p class="comments">The result of the addition. </p>
</div>
</div>
</div>
<div id="AddArrays" class="method">
<h4><span title="System.void">void</span> <strong>AddArrays</strong>(<span title="MathNet.Numerics.Complex32[]">Complex32[]</span> x, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> y, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> result)</h4>
<div class="content">Does a point wise add of two arrays <code>z = x + y</code>. This can be used
to add vectors or matrices. <blockquote class="remarks">
There is no equivalent BLAS routine, but many libraries
provide optimized (parallel and/or vectorized) versions of this
routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> x</h6>
<p class="comments">The array x. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> y</h6>
<p class="comments">The array y. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> result</h6>
<p class="comments">The result of the addition. </p>
</div>
</div>
</div>
<div id="AddVectorToScaledVector" class="method">
<h4><span title="System.void">void</span> <strong>AddVectorToScaledVector</strong>(<span title="System.Single[]">Single[]</span> y, <span title="System.float">float</span> alpha, <span title="System.Single[]">Single[]</span> x, <span title="System.Single[]">Single[]</span> result)</h4>
<div class="content">Adds a scaled vector to another: <code>result = y + alpha*x</code>. <blockquote class="remarks">
This is similar to the AXPY BLAS routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Single[]">Single[]</span></code> y</h6>
<p class="comments">The vector to update. </p>
<h6><code><span title="System.float">float</span></code> alpha</h6>
<p class="comments">The value to scale <var>x</var> by. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> x</h6>
<p class="comments">The vector to add to <var>y</var>. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> result</h6>
<p class="comments">The result of the addition. </p>
</div>
</div>
</div>
<div id="AddVectorToScaledVector" class="method">
<h4><span title="System.void">void</span> <strong>AddVectorToScaledVector</strong>(<span title="System.Double[]">Double[]</span> y, <span title="System.double">double</span> alpha, <span title="System.Double[]">Double[]</span> x, <span title="System.Double[]">Double[]</span> result)</h4>
<div class="content">Adds a scaled vector to another: <code>result = y + alpha*x</code>. <blockquote class="remarks">
This is similar to the AXPY BLAS routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Double[]">Double[]</span></code> y</h6>
<p class="comments">The vector to update. </p>
<h6><code><span title="System.double">double</span></code> alpha</h6>
<p class="comments">The value to scale <var>x</var> by. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> x</h6>
<p class="comments">The vector to add to <var>y</var>. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> result</h6>
<p class="comments">The result of the addition. </p>
</div>
</div>
</div>
<div id="AddVectorToScaledVector" class="method">
<h4><span title="System.void">void</span> <strong>AddVectorToScaledVector</strong>(<span title="MathNet.Numerics.Complex32[]">Complex32[]</span> y, <a href="../MathNet.Numerics/Complex32.htm">Complex32</a> alpha, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> x, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> result)</h4>
<div class="content">Adds a scaled vector to another: <code>result = y + alpha*x</code>. <blockquote class="remarks">
This is similar to the AXPY BLAS routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> y</h6>
<p class="comments">The vector to update. </p>
<h6><code><a href="../MathNet.Numerics/Complex32.htm">Complex32</a></code> alpha</h6>
<p class="comments">The value to scale <var>x</var> by. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> x</h6>
<p class="comments">The vector to add to <var>y</var>. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> result</h6>
<p class="comments">The result of the addition. </p>
</div>
</div>
</div>
<div id="AddVectorToScaledVector" class="method">
<h4><span title="System.void">void</span> <strong>AddVectorToScaledVector</strong>(<span title="System.Numerics.Complex[]">Complex[]</span> y, <span title="System.Numerics.Complex">Complex</span> alpha, <span title="System.Numerics.Complex[]">Complex[]</span> x, <span title="System.Numerics.Complex[]">Complex[]</span> result)</h4>
<div class="content">Adds a scaled vector to another: <code>result = y + alpha*x</code>. <blockquote class="remarks">
This is similar to the AXPY BLAS routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> y</h6>
<p class="comments">The vector to update. </p>
<h6><code><span title="System.Numerics.Complex">Complex</span></code> alpha</h6>
<p class="comments">The value to scale <var>x</var> by. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> x</h6>
<p class="comments">The vector to add to <var>y</var>. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> result</h6>
<p class="comments">The result of the addition. </p>
</div>
</div>
</div>
<div id="CholeskyFactor" class="method">
<h4><span title="System.void">void</span> <strong>CholeskyFactor</strong>(<span title="MathNet.Numerics.Complex32[]">Complex32[]</span> a, <span title="System.int">int</span> order)</h4>
<div class="content">Computes the Cholesky factorization of A. <blockquote class="remarks">
This is equivalent to the POTRF LAPACK routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> a</h6>
<p class="comments">On entry, a square, positive definite matrix. On exit, the matrix is overwritten with the
the Cholesky factorization. </p>
<h6><code><span title="System.int">int</span></code> order</h6>
<p class="comments">The number of rows or columns in the matrix. </p>
</div>
</div>
</div>
<div id="CholeskyFactor" class="method">
<h4><span title="System.void">void</span> <strong>CholeskyFactor</strong>(<span title="System.Single[]">Single[]</span> a, <span title="System.int">int</span> order)</h4>
<div class="content">Computes the Cholesky factorization of A. <blockquote class="remarks">
This is equivalent to the POTRF LAPACK routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Single[]">Single[]</span></code> a</h6>
<p class="comments">On entry, a square, positive definite matrix. On exit, the matrix is overwritten with the
the Cholesky factorization. </p>
<h6><code><span title="System.int">int</span></code> order</h6>
<p class="comments">The number of rows or columns in the matrix. </p>
</div>
</div>
</div>
<div id="CholeskyFactor" class="method">
<h4><span title="System.void">void</span> <strong>CholeskyFactor</strong>(<span title="System.Double[]">Double[]</span> a, <span title="System.int">int</span> order)</h4>
<div class="content">Computes the Cholesky factorization of A. <blockquote class="remarks">
This is equivalent to the POTRF LAPACK routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Double[]">Double[]</span></code> a</h6>
<p class="comments">On entry, a square, positive definite matrix. On exit, the matrix is overwritten with the
the Cholesky factorization. </p>
<h6><code><span title="System.int">int</span></code> order</h6>
<p class="comments">The number of rows or columns in the matrix. </p>
</div>
</div>
</div>
<div id="CholeskyFactor" class="method">
<h4><span title="System.void">void</span> <strong>CholeskyFactor</strong>(<span title="System.Numerics.Complex[]">Complex[]</span> a, <span title="System.int">int</span> order)</h4>
<div class="content">Computes the Cholesky factorization of A. <blockquote class="remarks">
This is equivalent to the POTRF LAPACK routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> a</h6>
<p class="comments">On entry, a square, positive definite matrix. On exit, the matrix is overwritten with the
the Cholesky factorization. </p>
<h6><code><span title="System.int">int</span></code> order</h6>
<p class="comments">The number of rows or columns in the matrix. </p>
</div>
</div>
</div>
<div id="CholeskySolve" class="method">
<h4><span title="System.void">void</span> <strong>CholeskySolve</strong>(<span title="System.Single[]">Single[]</span> a, <span title="System.int">int</span> orderA, <span title="System.Single[]">Single[]</span> b, <span title="System.int">int</span> columnsB)</h4>
<div class="content">Solves A*X=B for X using Cholesky factorization. <blockquote class="remarks">
This is equivalent to the POTRF add POTRS LAPACK routines.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Single[]">Single[]</span></code> a</h6>
<p class="comments">The square, positive definite matrix A. </p>
<h6><code><span title="System.int">int</span></code> orderA</h6>
<p class="comments">The number of rows and columns in A. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> b</h6>
<p class="comments">On entry the B matrix; on exit the X matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsB</h6>
<p class="comments">The number of columns in the B matrix. </p>
</div>
</div>
</div>
<div id="CholeskySolve" class="method">
<h4><span title="System.void">void</span> <strong>CholeskySolve</strong>(<span title="MathNet.Numerics.Complex32[]">Complex32[]</span> a, <span title="System.int">int</span> orderA, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> b, <span title="System.int">int</span> columnsB)</h4>
<div class="content">Solves A*X=B for X using Cholesky factorization. <blockquote class="remarks">
This is equivalent to the POTRF add POTRS LAPACK routines.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> a</h6>
<p class="comments">The square, positive definite matrix A. </p>
<h6><code><span title="System.int">int</span></code> orderA</h6>
<p class="comments">The number of rows and columns in A. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> b</h6>
<p class="comments">On entry the B matrix; on exit the X matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsB</h6>
<p class="comments">The number of columns in the B matrix. </p>
</div>
</div>
</div>
<div id="CholeskySolve" class="method">
<h4><span title="System.void">void</span> <strong>CholeskySolve</strong>(<span title="System.Numerics.Complex[]">Complex[]</span> a, <span title="System.int">int</span> orderA, <span title="System.Numerics.Complex[]">Complex[]</span> b, <span title="System.int">int</span> columnsB)</h4>
<div class="content">Solves A*X=B for X using Cholesky factorization. <blockquote class="remarks">
This is equivalent to the POTRF add POTRS LAPACK routines.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> a</h6>
<p class="comments">The square, positive definite matrix A. </p>
<h6><code><span title="System.int">int</span></code> orderA</h6>
<p class="comments">The number of rows and columns in A. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> b</h6>
<p class="comments">On entry the B matrix; on exit the X matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsB</h6>
<p class="comments">The number of columns in the B matrix. </p>
</div>
</div>
</div>
<div id="CholeskySolve" class="method">
<h4><span title="System.void">void</span> <strong>CholeskySolve</strong>(<span title="System.Double[]">Double[]</span> a, <span title="System.int">int</span> orderA, <span title="System.Double[]">Double[]</span> b, <span title="System.int">int</span> columnsB)</h4>
<div class="content">Solves A*X=B for X using Cholesky factorization. <blockquote class="remarks">
This is equivalent to the POTRF add POTRS LAPACK routines.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Double[]">Double[]</span></code> a</h6>
<p class="comments">The square, positive definite matrix A. </p>
<h6><code><span title="System.int">int</span></code> orderA</h6>
<p class="comments">The number of rows and columns in A. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> b</h6>
<p class="comments">On entry the B matrix; on exit the X matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsB</h6>
<p class="comments">The number of columns in the B matrix. </p>
</div>
</div>
</div>
<div id="CholeskySolveFactored" class="method">
<h4><span title="System.void">void</span> <strong>CholeskySolveFactored</strong>(<span title="System.Double[]">Double[]</span> a, <span title="System.int">int</span> orderA, <span title="System.Double[]">Double[]</span> b, <span title="System.int">int</span> columnsB)</h4>
<div class="content">Solves A*X=B for X using a previously factored A matrix. <blockquote class="remarks">
This is equivalent to the POTRS LAPACK routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Double[]">Double[]</span></code> a</h6>
<p class="comments">The square, positive definite matrix A. Has to be different than <var>b</var>. </p>
<h6><code><span title="System.int">int</span></code> orderA</h6>
<p class="comments">The number of rows and columns in A. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> b</h6>
<p class="comments">On entry the B matrix; on exit the X matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsB</h6>
<p class="comments">The number of columns in the B matrix. </p>
</div>
</div>
</div>
<div id="CholeskySolveFactored" class="method">
<h4><span title="System.void">void</span> <strong>CholeskySolveFactored</strong>(<span title="System.Numerics.Complex[]">Complex[]</span> a, <span title="System.int">int</span> orderA, <span title="System.Numerics.Complex[]">Complex[]</span> b, <span title="System.int">int</span> columnsB)</h4>
<div class="content">Solves A*X=B for X using a previously factored A matrix. <blockquote class="remarks">
This is equivalent to the POTRS LAPACK routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> a</h6>
<p class="comments">The square, positive definite matrix A. </p>
<h6><code><span title="System.int">int</span></code> orderA</h6>
<p class="comments">The number of rows and columns in A. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> b</h6>
<p class="comments">The B matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsB</h6>
<p class="comments">The number of columns in the B matrix. </p>
</div>
</div>
</div>
<div id="CholeskySolveFactored" class="method">
<h4><span title="System.void">void</span> <strong>CholeskySolveFactored</strong>(<span title="MathNet.Numerics.Complex32[]">Complex32[]</span> a, <span title="System.int">int</span> orderA, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> b, <span title="System.int">int</span> columnsB)</h4>
<div class="content">Solves A*X=B for X using a previously factored A matrix. <blockquote class="remarks">
This is equivalent to the POTRS LAPACK routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> a</h6>
<p class="comments">The square, positive definite matrix A. </p>
<h6><code><span title="System.int">int</span></code> orderA</h6>
<p class="comments">The number of rows and columns in A. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> b</h6>
<p class="comments">On entry the B matrix; on exit the X matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsB</h6>
<p class="comments">The number of columns in the B matrix. </p>
</div>
</div>
</div>
<div id="CholeskySolveFactored" class="method">
<h4><span title="System.void">void</span> <strong>CholeskySolveFactored</strong>(<span title="System.Single[]">Single[]</span> a, <span title="System.int">int</span> orderA, <span title="System.Single[]">Single[]</span> b, <span title="System.int">int</span> columnsB)</h4>
<div class="content">Solves A*X=B for X using a previously factored A matrix. <blockquote class="remarks">
This is equivalent to the POTRS LAPACK routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Single[]">Single[]</span></code> a</h6>
<p class="comments">The square, positive definite matrix A. </p>
<h6><code><span title="System.int">int</span></code> orderA</h6>
<p class="comments">The number of rows and columns in A. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> b</h6>
<p class="comments">On entry the B matrix; on exit the X matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsB</h6>
<p class="comments">The number of columns in the B matrix. </p>
</div>
</div>
</div>
<div id="ConjugateArray" class="method">
<h4><span title="System.void">void</span> <strong>ConjugateArray</strong>(<span title="System.Single[]">Single[]</span> x, <span title="System.Single[]">Single[]</span> result)</h4>
<div class="content">Conjugates an array. Can be used to conjugate a vector and a matrix.
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Single[]">Single[]</span></code> x</h6>
<p class="comments">The values to conjugate. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> result</h6>
<p class="comments">This result of the conjugation. </p>
</div>
</div>
</div>
<div id="ConjugateArray" class="method">
<h4><span title="System.void">void</span> <strong>ConjugateArray</strong>(<span title="MathNet.Numerics.Complex32[]">Complex32[]</span> x, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> result)</h4>
<div class="content">Conjugates an array. Can be used to conjugate a vector and a matrix.
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> x</h6>
<p class="comments">The values to conjugate. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> result</h6>
<p class="comments">This result of the conjugation. </p>
</div>
</div>
</div>
<div id="ConjugateArray" class="method">
<h4><span title="System.void">void</span> <strong>ConjugateArray</strong>(<span title="System.Double[]">Double[]</span> x, <span title="System.Double[]">Double[]</span> result)</h4>
<div class="content">Conjugates an array. Can be used to conjugate a vector and a matrix.
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Double[]">Double[]</span></code> x</h6>
<p class="comments">The values to conjugate. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> result</h6>
<p class="comments">This result of the conjugation. </p>
</div>
</div>
</div>
<div id="ConjugateArray" class="method">
<h4><span title="System.void">void</span> <strong>ConjugateArray</strong>(<span title="System.Numerics.Complex[]">Complex[]</span> x, <span title="System.Numerics.Complex[]">Complex[]</span> result)</h4>
<div class="content">Conjugates an array. Can be used to conjugate a vector and a matrix.
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> x</h6>
<p class="comments">The values to conjugate. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> result</h6>
<p class="comments">This result of the conjugation. </p>
</div>
</div>
</div>
<div id="DotProduct" class="method">
<h4><span title="System.float">float</span> <strong>DotProduct</strong>(<span title="System.Single[]">Single[]</span> x, <span title="System.Single[]">Single[]</span> y)</h4>
<div class="content">Computes the dot product of x and y. <blockquote class="remarks">
This is equivalent to the DOT BLAS routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Single[]">Single[]</span></code> x</h6>
<p class="comments">The vector x. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> y</h6>
<p class="comments">The vector y. </p>
</div>
<div class="return">
<h5>Return</h5>
<h6><code><span title="System.float">float</span></code></h6>
<p>The dot product of x and y. </p>
</div>
</div>
</div>
<div id="DotProduct" class="method">
<h4><a href="../MathNet.Numerics/Complex32.htm">Complex32</a> <strong>DotProduct</strong>(<span title="MathNet.Numerics.Complex32[]">Complex32[]</span> x, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> y)</h4>
<div class="content">Computes the dot product of x and y. <blockquote class="remarks">
This is equivalent to the DOT BLAS routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> x</h6>
<p class="comments">The vector x. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> y</h6>
<p class="comments">The vector y. </p>
</div>
<div class="return">
<h5>Return</h5>
<h6><code><a href="../MathNet.Numerics/Complex32.htm">Complex32</a></code></h6>
<p>The dot product of x and y. </p>
</div>
</div>
</div>
<div id="DotProduct" class="method">
<h4><span title="System.Numerics.Complex">Complex</span> <strong>DotProduct</strong>(<span title="System.Numerics.Complex[]">Complex[]</span> x, <span title="System.Numerics.Complex[]">Complex[]</span> y)</h4>
<div class="content">Computes the dot product of x and y. <blockquote class="remarks">
This is equivalent to the DOT BLAS routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> x</h6>
<p class="comments">The vector x. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> y</h6>
<p class="comments">The vector y. </p>
</div>
<div class="return">
<h5>Return</h5>
<h6><code><span title="System.Numerics.Complex">Complex</span></code></h6>
<p>The dot product of x and y. </p>
</div>
</div>
</div>
<div id="DotProduct" class="method">
<h4><span title="System.double">double</span> <strong>DotProduct</strong>(<span title="System.Double[]">Double[]</span> x, <span title="System.Double[]">Double[]</span> y)</h4>
<div class="content">Computes the dot product of x and y. <blockquote class="remarks">
This is equivalent to the DOT BLAS routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Double[]">Double[]</span></code> x</h6>
<p class="comments">The vector x. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> y</h6>
<p class="comments">The vector y. </p>
</div>
<div class="return">
<h5>Return</h5>
<h6><code><span title="System.double">double</span></code></h6>
<p>The dot product of x and y. </p>
</div>
</div>
</div>
<div id="EigenDecomp" class="method">
<h4><span title="System.void">void</span> <strong>EigenDecomp</strong>(<span title="System.bool">bool</span> isSymmetric, <span title="System.int">int</span> order, <span title="System.Single[]">Single[]</span> matrix, <span title="System.Single[]">Single[]</span> matrixEv, <span title="System.Numerics.Complex[]">Complex[]</span> vectorEv, <span title="System.Single[]">Single[]</span> matrixD)</h4>
<div class="content">Computes the eigenvalues and eigenvectors of a matrix.
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.bool">bool</span></code> isSymmetric</h6>
<p class="comments">Whether the matrix is symmetric or not. </p>
<h6><code><span title="System.int">int</span></code> order</h6>
<p class="comments">The order of the matrix. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> matrix</h6>
<p class="comments">The matrix to decompose. The length of the array must be order * order. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> matrixEv</h6>
<p class="comments">On output, the matrix contains the eigen vectors. The length of the array must be order * order. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> vectorEv</h6>
<p class="comments">On output, the eigen values (λ) of matrix in ascending value. The length of the array must <var>order</var>. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> matrixD</h6>
<p class="comments">On output, the block diagonal eigenvalue matrix. The length of the array must be order * order. </p>
</div>
</div>
</div>
<div id="EigenDecomp" class="method">
<h4><span title="System.void">void</span> <strong>EigenDecomp</strong>(<span title="System.bool">bool</span> isSymmetric, <span title="System.int">int</span> order, <span title="System.Double[]">Double[]</span> matrix, <span title="System.Double[]">Double[]</span> matrixEv, <span title="System.Numerics.Complex[]">Complex[]</span> vectorEv, <span title="System.Double[]">Double[]</span> matrixD)</h4>
<div class="content">Computes the eigenvalues and eigenvectors of a matrix.
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.bool">bool</span></code> isSymmetric</h6>
<p class="comments">Whether the matrix is symmetric or not. </p>
<h6><code><span title="System.int">int</span></code> order</h6>
<p class="comments">The order of the matrix. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> matrix</h6>
<p class="comments">The matrix to decompose. The length of the array must be order * order. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> matrixEv</h6>
<p class="comments">On output, the matrix contains the eigen vectors. The length of the array must be order * order. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> vectorEv</h6>
<p class="comments">On output, the eigen values (λ) of matrix in ascending value. The length of the array must <var>order</var>. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> matrixD</h6>
<p class="comments">On output, the block diagonal eigenvalue matrix. The length of the array must be order * order. </p>
</div>
</div>
</div>
<div id="EigenDecomp" class="method">
<h4><span title="System.void">void</span> <strong>EigenDecomp</strong>(<span title="System.bool">bool</span> isSymmetric, <span title="System.int">int</span> order, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> matrix, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> matrixEv, <span title="System.Numerics.Complex[]">Complex[]</span> vectorEv, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> matrixD)</h4>
<div class="content">Computes the eigenvalues and eigenvectors of a matrix.
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.bool">bool</span></code> isSymmetric</h6>
<p class="comments">Whether the matrix is symmetric or not. </p>
<h6><code><span title="System.int">int</span></code> order</h6>
<p class="comments">The order of the matrix. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> matrix</h6>
<p class="comments">The matrix to decompose. The length of the array must be order * order. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> matrixEv</h6>
<p class="comments">On output, the matrix contains the eigen vectors. The length of the array must be order * order. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> vectorEv</h6>
<p class="comments">On output, the eigen values (λ) of matrix in ascending value. The length of the array must <var>order</var>. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> matrixD</h6>
<p class="comments">On output, the block diagonal eigenvalue matrix. The length of the array must be order * order. </p>
</div>
</div>
</div>
<div id="EigenDecomp" class="method">
<h4><span title="System.void">void</span> <strong>EigenDecomp</strong>(<span title="System.bool">bool</span> isSymmetric, <span title="System.int">int</span> order, <span title="System.Numerics.Complex[]">Complex[]</span> matrix, <span title="System.Numerics.Complex[]">Complex[]</span> matrixEv, <span title="System.Numerics.Complex[]">Complex[]</span> vectorEv, <span title="System.Numerics.Complex[]">Complex[]</span> matrixD)</h4>
<div class="content">Computes the eigenvalues and eigenvectors of a matrix.
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.bool">bool</span></code> isSymmetric</h6>
<p class="comments">Whether the matrix is symmetric or not. </p>
<h6><code><span title="System.int">int</span></code> order</h6>
<p class="comments">The order of the matrix. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> matrix</h6>
<p class="comments">The matrix to decompose. The length of the array must be order * order. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> matrixEv</h6>
<p class="comments">On output, the matrix contains the eigen vectors. The length of the array must be order * order. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> vectorEv</h6>
<p class="comments">On output, the eigen values (λ) of matrix in ascending value. The length of the array must <var>order</var>. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> matrixD</h6>
<p class="comments">On output, the block diagonal eigenvalue matrix. The length of the array must be order * order. </p>
</div>
</div>
</div>
<div id="Equals" class="method">
<h4><span title="System.bool">bool</span> <strong>Equals</strong>(<span title="System.object">object</span> obj)</h4>
<div class="content">
</div>
</div>
<div id="FreeResources" class="method">
<h4><span title="System.void">void</span> <strong>FreeResources</strong>()</h4>
<div class="content">Frees memory buffers, caches and handles allocated in or to the provider.
Does not unload the provider itself, it is still usable afterwards.
</div>
</div>
<div id="GetHashCode" class="method">
<h4><span title="System.int">int</span> <strong>GetHashCode</strong>()</h4>
<div class="content">
</div>
</div>
<div id="GetType" class="method">
<h4><span title="System.Type">Type</span> <strong>GetType</strong>()</h4>
<div class="content">
</div>
</div>
<div id="InitializeVerify" class="method">
<h4><span title="System.void">void</span> <strong>InitializeVerify</strong>()</h4>
<div class="content">Initialize and verify that the provided is indeed available. If not, fall back to alternatives like the managed provider
</div>
</div>
<div id="IsAvailable" class="method">
<h4><span title="System.bool">bool</span> <strong>IsAvailable</strong>()</h4>
<div class="content">Try to find out whether the provider is available, at least in principle.
Verification may still fail if available, but it will certainly fail if unavailable.
</div>
</div>
<div id="LUFactor" class="method">
<h4><span title="System.void">void</span> <strong>LUFactor</strong>(<span title="System.Single[]">Single[]</span> data, <span title="System.int">int</span> order, <span title="System.Int32[]">Int32[]</span> ipiv)</h4>
<div class="content">Computes the LUP factorization of A. P*A = L*U. <blockquote class="remarks">
This is equivalent to the GETRF LAPACK routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Single[]">Single[]</span></code> data</h6>
<p class="comments">An <var>order</var> by <var>order</var> matrix. The matrix is overwritten with the
the LU factorization on exit. The lower triangular factor L is stored in under the diagonal of <var>data</var> (the diagonal is always 1.0
for the L factor). The upper triangular factor U is stored on and above the diagonal of <var>data</var>. </p>
<h6><code><span title="System.int">int</span></code> order</h6>
<p class="comments">The order of the square matrix <var>data</var>. </p>
<h6><code><span title="System.Int32[]">Int32[]</span></code> ipiv</h6>
<p class="comments">On exit, it contains the pivot indices. The size of the array must be <var>order</var>. </p>
</div>
</div>
</div>
<div id="LUFactor" class="method">
<h4><span title="System.void">void</span> <strong>LUFactor</strong>(<span title="System.Double[]">Double[]</span> data, <span title="System.int">int</span> order, <span title="System.Int32[]">Int32[]</span> ipiv)</h4>
<div class="content">Computes the LUP factorization of A. P*A = L*U. <blockquote class="remarks">
This is equivalent to the GETRF LAPACK routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Double[]">Double[]</span></code> data</h6>
<p class="comments">An <var>order</var> by <var>order</var> matrix. The matrix is overwritten with the
the LU factorization on exit. The lower triangular factor L is stored in under the diagonal of <var>data</var> (the diagonal is always 1.0
for the L factor). The upper triangular factor U is stored on and above the diagonal of <var>data</var>. </p>
<h6><code><span title="System.int">int</span></code> order</h6>
<p class="comments">The order of the square matrix <var>data</var>. </p>
<h6><code><span title="System.Int32[]">Int32[]</span></code> ipiv</h6>
<p class="comments">On exit, it contains the pivot indices. The size of the array must be <var>order</var>. </p>
</div>
</div>
</div>
<div id="LUFactor" class="method">
<h4><span title="System.void">void</span> <strong>LUFactor</strong>(<span title="MathNet.Numerics.Complex32[]">Complex32[]</span> data, <span title="System.int">int</span> order, <span title="System.Int32[]">Int32[]</span> ipiv)</h4>
<div class="content">Computes the LUP factorization of A. P*A = L*U. <blockquote class="remarks">
This is equivalent to the GETRF LAPACK routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> data</h6>
<p class="comments">An <var>order</var> by <var>order</var> matrix. The matrix is overwritten with the
the LU factorization on exit. The lower triangular factor L is stored in under the diagonal of <var>data</var> (the diagonal is always 1.0
for the L factor). The upper triangular factor U is stored on and above the diagonal of <var>data</var>. </p>
<h6><code><span title="System.int">int</span></code> order</h6>
<p class="comments">The order of the square matrix <var>data</var>. </p>
<h6><code><span title="System.Int32[]">Int32[]</span></code> ipiv</h6>
<p class="comments">On exit, it contains the pivot indices. The size of the array must be <var>order</var>. </p>
</div>
</div>
</div>
<div id="LUFactor" class="method">
<h4><span title="System.void">void</span> <strong>LUFactor</strong>(<span title="System.Numerics.Complex[]">Complex[]</span> data, <span title="System.int">int</span> order, <span title="System.Int32[]">Int32[]</span> ipiv)</h4>
<div class="content">Computes the LUP factorization of A. P*A = L*U. <blockquote class="remarks">
This is equivalent to the GETRF LAPACK routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> data</h6>
<p class="comments">An <var>order</var> by <var>order</var> matrix. The matrix is overwritten with the
the LU factorization on exit. The lower triangular factor L is stored in under the diagonal of <var>data</var> (the diagonal is always 1.0
for the L factor). The upper triangular factor U is stored on and above the diagonal of <var>data</var>. </p>
<h6><code><span title="System.int">int</span></code> order</h6>
<p class="comments">The order of the square matrix <var>data</var>. </p>
<h6><code><span title="System.Int32[]">Int32[]</span></code> ipiv</h6>
<p class="comments">On exit, it contains the pivot indices. The size of the array must be <var>order</var>. </p>
</div>
</div>
</div>
<div id="LUInverse" class="method">
<h4><span title="System.void">void</span> <strong>LUInverse</strong>(<span title="System.Double[]">Double[]</span> a, <span title="System.int">int</span> order)</h4>
<div class="content">Computes the inverse of matrix using LU factorization. <blockquote class="remarks">
This is equivalent to the GETRF and GETRI LAPACK routines.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Double[]">Double[]</span></code> a</h6>
<p class="comments">The N by N matrix to invert. Contains the inverse On exit. </p>
<h6><code><span title="System.int">int</span></code> order</h6>
<p class="comments">The order of the square matrix <var>a</var>. </p>
</div>
</div>
</div>
<div id="LUInverse" class="method">
<h4><span title="System.void">void</span> <strong>LUInverse</strong>(<span title="System.Numerics.Complex[]">Complex[]</span> a, <span title="System.int">int</span> order)</h4>
<div class="content">Computes the inverse of matrix using LU factorization. <blockquote class="remarks">
This is equivalent to the GETRF and GETRI LAPACK routines.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> a</h6>
<p class="comments">The N by N matrix to invert. Contains the inverse On exit. </p>
<h6><code><span title="System.int">int</span></code> order</h6>
<p class="comments">The order of the square matrix <var>a</var>. </p>
</div>
</div>
</div>
<div id="LUInverse" class="method">
<h4><span title="System.void">void</span> <strong>LUInverse</strong>(<span title="System.Single[]">Single[]</span> a, <span title="System.int">int</span> order)</h4>
<div class="content">Computes the inverse of matrix using LU factorization. <blockquote class="remarks">
This is equivalent to the GETRF and GETRI LAPACK routines.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Single[]">Single[]</span></code> a</h6>
<p class="comments">The N by N matrix to invert. Contains the inverse On exit. </p>
<h6><code><span title="System.int">int</span></code> order</h6>
<p class="comments">The order of the square matrix <var>a</var>. </p>
</div>
</div>
</div>
<div id="LUInverse" class="method">
<h4><span title="System.void">void</span> <strong>LUInverse</strong>(<span title="MathNet.Numerics.Complex32[]">Complex32[]</span> a, <span title="System.int">int</span> order)</h4>
<div class="content">Computes the inverse of matrix using LU factorization. <blockquote class="remarks">
This is equivalent to the GETRF and GETRI LAPACK routines.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> a</h6>
<p class="comments">The N by N matrix to invert. Contains the inverse On exit. </p>
<h6><code><span title="System.int">int</span></code> order</h6>
<p class="comments">The order of the square matrix <var>a</var>. </p>
</div>
</div>
</div>
<div id="LUInverseFactored" class="method">
<h4><span title="System.void">void</span> <strong>LUInverseFactored</strong>(<span title="System.Numerics.Complex[]">Complex[]</span> a, <span title="System.int">int</span> order, <span title="System.Int32[]">Int32[]</span> ipiv)</h4>
<div class="content">Computes the inverse of a previously factored matrix. <blockquote class="remarks">
This is equivalent to the GETRI LAPACK routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> a</h6>
<p class="comments">The LU factored N by N matrix. Contains the inverse On exit. </p>
<h6><code><span title="System.int">int</span></code> order</h6>
<p class="comments">The order of the square matrix <var>a</var>. </p>
<h6><code><span title="System.Int32[]">Int32[]</span></code> ipiv</h6>
<p class="comments">The pivot indices of <var>a</var>. </p>
</div>
</div>
</div>
<div id="LUInverseFactored" class="method">
<h4><span title="System.void">void</span> <strong>LUInverseFactored</strong>(<span title="MathNet.Numerics.Complex32[]">Complex32[]</span> a, <span title="System.int">int</span> order, <span title="System.Int32[]">Int32[]</span> ipiv)</h4>
<div class="content">Computes the inverse of a previously factored matrix. <blockquote class="remarks">
This is equivalent to the GETRI LAPACK routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> a</h6>
<p class="comments">The LU factored N by N matrix. Contains the inverse On exit. </p>
<h6><code><span title="System.int">int</span></code> order</h6>
<p class="comments">The order of the square matrix <var>a</var>. </p>
<h6><code><span title="System.Int32[]">Int32[]</span></code> ipiv</h6>
<p class="comments">The pivot indices of <var>a</var>. </p>
</div>
</div>
</div>
<div id="LUInverseFactored" class="method">
<h4><span title="System.void">void</span> <strong>LUInverseFactored</strong>(<span title="System.Single[]">Single[]</span> a, <span title="System.int">int</span> order, <span title="System.Int32[]">Int32[]</span> ipiv)</h4>
<div class="content">Computes the inverse of a previously factored matrix. <blockquote class="remarks">
This is equivalent to the GETRI LAPACK routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Single[]">Single[]</span></code> a</h6>
<p class="comments">The LU factored N by N matrix. Contains the inverse On exit. </p>
<h6><code><span title="System.int">int</span></code> order</h6>
<p class="comments">The order of the square matrix <var>a</var>. </p>
<h6><code><span title="System.Int32[]">Int32[]</span></code> ipiv</h6>
<p class="comments">The pivot indices of <var>a</var>. </p>
</div>
</div>
</div>
<div id="LUInverseFactored" class="method">
<h4><span title="System.void">void</span> <strong>LUInverseFactored</strong>(<span title="System.Double[]">Double[]</span> a, <span title="System.int">int</span> order, <span title="System.Int32[]">Int32[]</span> ipiv)</h4>
<div class="content">Computes the inverse of a previously factored matrix. <blockquote class="remarks">
This is equivalent to the GETRI LAPACK routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Double[]">Double[]</span></code> a</h6>
<p class="comments">The LU factored N by N matrix. Contains the inverse On exit. </p>
<h6><code><span title="System.int">int</span></code> order</h6>
<p class="comments">The order of the square matrix <var>a</var>. </p>
<h6><code><span title="System.Int32[]">Int32[]</span></code> ipiv</h6>
<p class="comments">The pivot indices of <var>a</var>. </p>
</div>
</div>
</div>
<div id="LUSolve" class="method">
<h4><span title="System.void">void</span> <strong>LUSolve</strong>(<span title="System.int">int</span> columnsOfB, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> a, <span title="System.int">int</span> order, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> b)</h4>
<div class="content">Solves A*X=B for X using LU factorization. <blockquote class="remarks">
This is equivalent to the GETRF and GETRS LAPACK routines.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.int">int</span></code> columnsOfB</h6>
<p class="comments">The number of columns of B. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> a</h6>
<p class="comments">The square matrix A. </p>
<h6><code><span title="System.int">int</span></code> order</h6>
<p class="comments">The order of the square matrix <var>a</var>. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> b</h6>
<p class="comments">On entry the B matrix; on exit the X matrix. </p>
</div>
</div>
</div>
<div id="LUSolve" class="method">
<h4><span title="System.void">void</span> <strong>LUSolve</strong>(<span title="System.int">int</span> columnsOfB, <span title="System.Numerics.Complex[]">Complex[]</span> a, <span title="System.int">int</span> order, <span title="System.Numerics.Complex[]">Complex[]</span> b)</h4>
<div class="content">Solves A*X=B for X using LU factorization. <blockquote class="remarks">
This is equivalent to the GETRF and GETRS LAPACK routines.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.int">int</span></code> columnsOfB</h6>
<p class="comments">The number of columns of B. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> a</h6>
<p class="comments">The square matrix A. </p>
<h6><code><span title="System.int">int</span></code> order</h6>
<p class="comments">The order of the square matrix <var>a</var>. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> b</h6>
<p class="comments">On entry the B matrix; on exit the X matrix. </p>
</div>
</div>
</div>
<div id="LUSolve" class="method">
<h4><span title="System.void">void</span> <strong>LUSolve</strong>(<span title="System.int">int</span> columnsOfB, <span title="System.Double[]">Double[]</span> a, <span title="System.int">int</span> order, <span title="System.Double[]">Double[]</span> b)</h4>
<div class="content">Solves A*X=B for X using LU factorization. <blockquote class="remarks">
This is equivalent to the GETRF and GETRS LAPACK routines.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.int">int</span></code> columnsOfB</h6>
<p class="comments">The number of columns of B. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> a</h6>
<p class="comments">The square matrix A. </p>
<h6><code><span title="System.int">int</span></code> order</h6>
<p class="comments">The order of the square matrix <var>a</var>. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> b</h6>
<p class="comments">On entry the B matrix; on exit the X matrix. </p>
</div>
</div>
</div>
<div id="LUSolve" class="method">
<h4><span title="System.void">void</span> <strong>LUSolve</strong>(<span title="System.int">int</span> columnsOfB, <span title="System.Single[]">Single[]</span> a, <span title="System.int">int</span> order, <span title="System.Single[]">Single[]</span> b)</h4>
<div class="content">Solves A*X=B for X using LU factorization. <blockquote class="remarks">
This is equivalent to the GETRF and GETRS LAPACK routines.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.int">int</span></code> columnsOfB</h6>
<p class="comments">The number of columns of B. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> a</h6>
<p class="comments">The square matrix A. </p>
<h6><code><span title="System.int">int</span></code> order</h6>
<p class="comments">The order of the square matrix <var>a</var>. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> b</h6>
<p class="comments">On entry the B matrix; on exit the X matrix. </p>
</div>
</div>
</div>
<div id="LUSolveFactored" class="method">
<h4><span title="System.void">void</span> <strong>LUSolveFactored</strong>(<span title="System.int">int</span> columnsOfB, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> a, <span title="System.int">int</span> order, <span title="System.Int32[]">Int32[]</span> ipiv, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> b)</h4>
<div class="content">Solves A*X=B for X using a previously factored A matrix. <blockquote class="remarks">
This is equivalent to the GETRS LAPACK routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.int">int</span></code> columnsOfB</h6>
<p class="comments">The number of columns of B. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> a</h6>
<p class="comments">The factored A matrix. </p>
<h6><code><span title="System.int">int</span></code> order</h6>
<p class="comments">The order of the square matrix <var>a</var>. </p>
<h6><code><span title="System.Int32[]">Int32[]</span></code> ipiv</h6>
<p class="comments">The pivot indices of <var>a</var>. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> b</h6>
<p class="comments">On entry the B matrix; on exit the X matrix. </p>
</div>
</div>
</div>
<div id="LUSolveFactored" class="method">
<h4><span title="System.void">void</span> <strong>LUSolveFactored</strong>(<span title="System.int">int</span> columnsOfB, <span title="System.Numerics.Complex[]">Complex[]</span> a, <span title="System.int">int</span> order, <span title="System.Int32[]">Int32[]</span> ipiv, <span title="System.Numerics.Complex[]">Complex[]</span> b)</h4>
<div class="content">Solves A*X=B for X using a previously factored A matrix. <blockquote class="remarks">
This is equivalent to the GETRS LAPACK routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.int">int</span></code> columnsOfB</h6>
<p class="comments">The number of columns of B. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> a</h6>
<p class="comments">The factored A matrix. </p>
<h6><code><span title="System.int">int</span></code> order</h6>
<p class="comments">The order of the square matrix <var>a</var>. </p>
<h6><code><span title="System.Int32[]">Int32[]</span></code> ipiv</h6>
<p class="comments">The pivot indices of <var>a</var>. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> b</h6>
<p class="comments">On entry the B matrix; on exit the X matrix. </p>
</div>
</div>
</div>
<div id="LUSolveFactored" class="method">
<h4><span title="System.void">void</span> <strong>LUSolveFactored</strong>(<span title="System.int">int</span> columnsOfB, <span title="System.Double[]">Double[]</span> a, <span title="System.int">int</span> order, <span title="System.Int32[]">Int32[]</span> ipiv, <span title="System.Double[]">Double[]</span> b)</h4>
<div class="content">Solves A*X=B for X using a previously factored A matrix. <blockquote class="remarks">
This is equivalent to the GETRS LAPACK routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.int">int</span></code> columnsOfB</h6>
<p class="comments">The number of columns of B. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> a</h6>
<p class="comments">The factored A matrix. </p>
<h6><code><span title="System.int">int</span></code> order</h6>
<p class="comments">The order of the square matrix <var>a</var>. </p>
<h6><code><span title="System.Int32[]">Int32[]</span></code> ipiv</h6>
<p class="comments">The pivot indices of <var>a</var>. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> b</h6>
<p class="comments">On entry the B matrix; on exit the X matrix. </p>
</div>
</div>
</div>
<div id="LUSolveFactored" class="method">
<h4><span title="System.void">void</span> <strong>LUSolveFactored</strong>(<span title="System.int">int</span> columnsOfB, <span title="System.Single[]">Single[]</span> a, <span title="System.int">int</span> order, <span title="System.Int32[]">Int32[]</span> ipiv, <span title="System.Single[]">Single[]</span> b)</h4>
<div class="content">Solves A*X=B for X using a previously factored A matrix. <blockquote class="remarks">
This is equivalent to the GETRS LAPACK routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.int">int</span></code> columnsOfB</h6>
<p class="comments">The number of columns of B. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> a</h6>
<p class="comments">The factored A matrix. </p>
<h6><code><span title="System.int">int</span></code> order</h6>
<p class="comments">The order of the square matrix <var>a</var>. </p>
<h6><code><span title="System.Int32[]">Int32[]</span></code> ipiv</h6>
<p class="comments">The pivot indices of <var>a</var>. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> b</h6>
<p class="comments">On entry the B matrix; on exit the X matrix. </p>
</div>
</div>
</div>
<div id="MatrixMultiply" class="method">
<h4><span title="System.void">void</span> <strong>MatrixMultiply</strong>(<span title="MathNet.Numerics.Complex32[]">Complex32[]</span> x, <span title="System.int">int</span> rowsX, <span title="System.int">int</span> columnsX, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> y, <span title="System.int">int</span> rowsY, <span title="System.int">int</span> columnsY, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> result)</h4>
<div class="content">Multiples two matrices. <code>result = x * y</code> <blockquote class="remarks">
This is a simplified version of the BLAS GEMM routine with alpha
set to 1.0 and beta set to 0.0, and x and y are not transposed.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> x</h6>
<p class="comments">The x matrix. </p>
<h6><code><span title="System.int">int</span></code> rowsX</h6>
<p class="comments">The number of rows in the x matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsX</h6>
<p class="comments">The number of columns in the x matrix. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> y</h6>
<p class="comments">The y matrix. </p>
<h6><code><span title="System.int">int</span></code> rowsY</h6>
<p class="comments">The number of rows in the y matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsY</h6>
<p class="comments">The number of columns in the y matrix. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> result</h6>
<p class="comments">Where to store the result of the multiplication. </p>
</div>
</div>
</div>
<div id="MatrixMultiply" class="method">
<h4><span title="System.void">void</span> <strong>MatrixMultiply</strong>(<span title="System.Double[]">Double[]</span> x, <span title="System.int">int</span> rowsX, <span title="System.int">int</span> columnsX, <span title="System.Double[]">Double[]</span> y, <span title="System.int">int</span> rowsY, <span title="System.int">int</span> columnsY, <span title="System.Double[]">Double[]</span> result)</h4>
<div class="content">Multiples two matrices. <code>result = x * y</code> <blockquote class="remarks">
This is a simplified version of the BLAS GEMM routine with alpha
set to 1.0 and beta set to 0.0, and x and y are not transposed.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Double[]">Double[]</span></code> x</h6>
<p class="comments">The x matrix. </p>
<h6><code><span title="System.int">int</span></code> rowsX</h6>
<p class="comments">The number of rows in the x matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsX</h6>
<p class="comments">The number of columns in the x matrix. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> y</h6>
<p class="comments">The y matrix. </p>
<h6><code><span title="System.int">int</span></code> rowsY</h6>
<p class="comments">The number of rows in the y matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsY</h6>
<p class="comments">The number of columns in the y matrix. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> result</h6>
<p class="comments">Where to store the result of the multiplication. </p>
</div>
</div>
</div>
<div id="MatrixMultiply" class="method">
<h4><span title="System.void">void</span> <strong>MatrixMultiply</strong>(<span title="System.Single[]">Single[]</span> x, <span title="System.int">int</span> rowsX, <span title="System.int">int</span> columnsX, <span title="System.Single[]">Single[]</span> y, <span title="System.int">int</span> rowsY, <span title="System.int">int</span> columnsY, <span title="System.Single[]">Single[]</span> result)</h4>
<div class="content">Multiples two matrices. <code>result = x * y</code> <blockquote class="remarks">
This is a simplified version of the BLAS GEMM routine with alpha
set to 1.0 and beta set to 0.0, and x and y are not transposed.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Single[]">Single[]</span></code> x</h6>
<p class="comments">The x matrix. </p>
<h6><code><span title="System.int">int</span></code> rowsX</h6>
<p class="comments">The number of rows in the x matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsX</h6>
<p class="comments">The number of columns in the x matrix. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> y</h6>
<p class="comments">The y matrix. </p>
<h6><code><span title="System.int">int</span></code> rowsY</h6>
<p class="comments">The number of rows in the y matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsY</h6>
<p class="comments">The number of columns in the y matrix. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> result</h6>
<p class="comments">Where to store the result of the multiplication. </p>
</div>
</div>
</div>
<div id="MatrixMultiply" class="method">
<h4><span title="System.void">void</span> <strong>MatrixMultiply</strong>(<span title="System.Numerics.Complex[]">Complex[]</span> x, <span title="System.int">int</span> rowsX, <span title="System.int">int</span> columnsX, <span title="System.Numerics.Complex[]">Complex[]</span> y, <span title="System.int">int</span> rowsY, <span title="System.int">int</span> columnsY, <span title="System.Numerics.Complex[]">Complex[]</span> result)</h4>
<div class="content">Multiples two matrices. <code>result = x * y</code> <blockquote class="remarks">
This is a simplified version of the BLAS GEMM routine with alpha
set to 1.0 and beta set to 0.0, and x and y are not transposed.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> x</h6>
<p class="comments">The x matrix. </p>
<h6><code><span title="System.int">int</span></code> rowsX</h6>
<p class="comments">The number of rows in the x matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsX</h6>
<p class="comments">The number of columns in the x matrix. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> y</h6>
<p class="comments">The y matrix. </p>
<h6><code><span title="System.int">int</span></code> rowsY</h6>
<p class="comments">The number of rows in the y matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsY</h6>
<p class="comments">The number of columns in the y matrix. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> result</h6>
<p class="comments">Where to store the result of the multiplication. </p>
</div>
</div>
</div>
<div id="MatrixMultiplyWithUpdate" class="method">
<h4><span title="System.void">void</span> <strong>MatrixMultiplyWithUpdate</strong>(<a href="../MathNet.Numerics.Providers.LinearAlgebra/Transpose.htm">Transpose</a> transposeA, <a href="../MathNet.Numerics.Providers.LinearAlgebra/Transpose.htm">Transpose</a> transposeB, <span title="System.float">float</span> alpha, <span title="System.Single[]">Single[]</span> a, <span title="System.int">int</span> rowsA, <span title="System.int">int</span> columnsA, <span title="System.Single[]">Single[]</span> b, <span title="System.int">int</span> rowsB, <span title="System.int">int</span> columnsB, <span title="System.float">float</span> beta, <span title="System.Single[]">Single[]</span> c)</h4>
<div class="content">Multiplies two matrices and updates another with the result. <code>c = alpha*op(a)*op(b) + beta*c</code>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><a href="../MathNet.Numerics.Providers.LinearAlgebra/Transpose.htm">Transpose</a></code> transposeA</h6>
<p class="comments">How to transpose the <var>a</var> matrix. </p>
<h6><code><a href="../MathNet.Numerics.Providers.LinearAlgebra/Transpose.htm">Transpose</a></code> transposeB</h6>
<p class="comments">How to transpose the <var>b</var> matrix. </p>
<h6><code><span title="System.float">float</span></code> alpha</h6>
<p class="comments">The value to scale <var>a</var> matrix. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> a</h6>
<p class="comments">The a matrix. </p>
<h6><code><span title="System.int">int</span></code> rowsA</h6>
<p class="comments">The number of rows in the <var>a</var> matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsA</h6>
<p class="comments">The number of columns in the <var>a</var> matrix. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> b</h6>
<p class="comments">The b matrix </p>
<h6><code><span title="System.int">int</span></code> rowsB</h6>
<p class="comments">The number of rows in the <var>b</var> matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsB</h6>
<p class="comments">The number of columns in the <var>b</var> matrix. </p>
<h6><code><span title="System.float">float</span></code> beta</h6>
<p class="comments">The value to scale the <var>c</var> matrix. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> c</h6>
<p class="comments">The c matrix. </p>
</div>
</div>
</div>
<div id="MatrixMultiplyWithUpdate" class="method">
<h4><span title="System.void">void</span> <strong>MatrixMultiplyWithUpdate</strong>(<a href="../MathNet.Numerics.Providers.LinearAlgebra/Transpose.htm">Transpose</a> transposeA, <a href="../MathNet.Numerics.Providers.LinearAlgebra/Transpose.htm">Transpose</a> transposeB, <span title="System.Numerics.Complex">Complex</span> alpha, <span title="System.Numerics.Complex[]">Complex[]</span> a, <span title="System.int">int</span> rowsA, <span title="System.int">int</span> columnsA, <span title="System.Numerics.Complex[]">Complex[]</span> b, <span title="System.int">int</span> rowsB, <span title="System.int">int</span> columnsB, <span title="System.Numerics.Complex">Complex</span> beta, <span title="System.Numerics.Complex[]">Complex[]</span> c)</h4>
<div class="content">Multiplies two matrices and updates another with the result. <code>c = alpha*op(a)*op(b) + beta*c</code>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><a href="../MathNet.Numerics.Providers.LinearAlgebra/Transpose.htm">Transpose</a></code> transposeA</h6>
<p class="comments">How to transpose the <var>a</var> matrix. </p>
<h6><code><a href="../MathNet.Numerics.Providers.LinearAlgebra/Transpose.htm">Transpose</a></code> transposeB</h6>
<p class="comments">How to transpose the <var>b</var> matrix. </p>
<h6><code><span title="System.Numerics.Complex">Complex</span></code> alpha</h6>
<p class="comments">The value to scale <var>a</var> matrix. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> a</h6>
<p class="comments">The a matrix. </p>
<h6><code><span title="System.int">int</span></code> rowsA</h6>
<p class="comments">The number of rows in the <var>a</var> matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsA</h6>
<p class="comments">The number of columns in the <var>a</var> matrix. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> b</h6>
<p class="comments">The b matrix </p>
<h6><code><span title="System.int">int</span></code> rowsB</h6>
<p class="comments">The number of rows in the <var>b</var> matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsB</h6>
<p class="comments">The number of columns in the <var>b</var> matrix. </p>
<h6><code><span title="System.Numerics.Complex">Complex</span></code> beta</h6>
<p class="comments">The value to scale the <var>c</var> matrix. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> c</h6>
<p class="comments">The c matrix. </p>
</div>
</div>
</div>
<div id="MatrixMultiplyWithUpdate" class="method">
<h4><span title="System.void">void</span> <strong>MatrixMultiplyWithUpdate</strong>(<a href="../MathNet.Numerics.Providers.LinearAlgebra/Transpose.htm">Transpose</a> transposeA, <a href="../MathNet.Numerics.Providers.LinearAlgebra/Transpose.htm">Transpose</a> transposeB, <span title="System.double">double</span> alpha, <span title="System.Double[]">Double[]</span> a, <span title="System.int">int</span> rowsA, <span title="System.int">int</span> columnsA, <span title="System.Double[]">Double[]</span> b, <span title="System.int">int</span> rowsB, <span title="System.int">int</span> columnsB, <span title="System.double">double</span> beta, <span title="System.Double[]">Double[]</span> c)</h4>
<div class="content">Multiplies two matrices and updates another with the result. <code>c = alpha*op(a)*op(b) + beta*c</code>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><a href="../MathNet.Numerics.Providers.LinearAlgebra/Transpose.htm">Transpose</a></code> transposeA</h6>
<p class="comments">How to transpose the <var>a</var> matrix. </p>
<h6><code><a href="../MathNet.Numerics.Providers.LinearAlgebra/Transpose.htm">Transpose</a></code> transposeB</h6>
<p class="comments">How to transpose the <var>b</var> matrix. </p>
<h6><code><span title="System.double">double</span></code> alpha</h6>
<p class="comments">The value to scale <var>a</var> matrix. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> a</h6>
<p class="comments">The a matrix. </p>
<h6><code><span title="System.int">int</span></code> rowsA</h6>
<p class="comments">The number of rows in the <var>a</var> matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsA</h6>
<p class="comments">The number of columns in the <var>a</var> matrix. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> b</h6>
<p class="comments">The b matrix </p>
<h6><code><span title="System.int">int</span></code> rowsB</h6>
<p class="comments">The number of rows in the <var>b</var> matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsB</h6>
<p class="comments">The number of columns in the <var>b</var> matrix. </p>
<h6><code><span title="System.double">double</span></code> beta</h6>
<p class="comments">The value to scale the <var>c</var> matrix. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> c</h6>
<p class="comments">The c matrix. </p>
</div>
</div>
</div>
<div id="MatrixMultiplyWithUpdate" class="method">
<h4><span title="System.void">void</span> <strong>MatrixMultiplyWithUpdate</strong>(<a href="../MathNet.Numerics.Providers.LinearAlgebra/Transpose.htm">Transpose</a> transposeA, <a href="../MathNet.Numerics.Providers.LinearAlgebra/Transpose.htm">Transpose</a> transposeB, <a href="../MathNet.Numerics/Complex32.htm">Complex32</a> alpha, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> a, <span title="System.int">int</span> rowsA, <span title="System.int">int</span> columnsA, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> b, <span title="System.int">int</span> rowsB, <span title="System.int">int</span> columnsB, <a href="../MathNet.Numerics/Complex32.htm">Complex32</a> beta, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> c)</h4>
<div class="content">Multiplies two matrices and updates another with the result. <code>c = alpha*op(a)*op(b) + beta*c</code>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><a href="../MathNet.Numerics.Providers.LinearAlgebra/Transpose.htm">Transpose</a></code> transposeA</h6>
<p class="comments">How to transpose the <var>a</var> matrix. </p>
<h6><code><a href="../MathNet.Numerics.Providers.LinearAlgebra/Transpose.htm">Transpose</a></code> transposeB</h6>
<p class="comments">How to transpose the <var>b</var> matrix. </p>
<h6><code><a href="../MathNet.Numerics/Complex32.htm">Complex32</a></code> alpha</h6>
<p class="comments">The value to scale <var>a</var> matrix. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> a</h6>
<p class="comments">The a matrix. </p>
<h6><code><span title="System.int">int</span></code> rowsA</h6>
<p class="comments">The number of rows in the <var>a</var> matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsA</h6>
<p class="comments">The number of columns in the <var>a</var> matrix. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> b</h6>
<p class="comments">The b matrix </p>
<h6><code><span title="System.int">int</span></code> rowsB</h6>
<p class="comments">The number of rows in the <var>b</var> matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsB</h6>
<p class="comments">The number of columns in the <var>b</var> matrix. </p>
<h6><code><a href="../MathNet.Numerics/Complex32.htm">Complex32</a></code> beta</h6>
<p class="comments">The value to scale the <var>c</var> matrix. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> c</h6>
<p class="comments">The c matrix. </p>
</div>
</div>
</div>
<div id="MatrixNorm" class="method">
<h4><span title="System.double">double</span> <strong>MatrixNorm</strong>(<a href="../MathNet.Numerics.Providers.LinearAlgebra/Norm.htm">Norm</a> norm, <span title="System.int">int</span> rows, <span title="System.int">int</span> columns, <span title="System.Single[]">Single[]</span> matrix)</h4>
<div class="content">Computes the requested <a href="../MathNet.Numerics.Providers.LinearAlgebra/Norm.htm">Norm</a> of the matrix.
<div class="parameters">
<h5>Parameters</h5>
<h6><code><a href="../MathNet.Numerics.Providers.LinearAlgebra/Norm.htm">Norm</a></code> norm</h6>
<p class="comments">The type of norm to compute. </p>
<h6><code><span title="System.int">int</span></code> rows</h6>
<p class="comments">The number of rows. </p>
<h6><code><span title="System.int">int</span></code> columns</h6>
<p class="comments">The number of columns. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> matrix</h6>
<p class="comments">The matrix to compute the norm from. </p>
</div>
<div class="return">
<h5>Return</h5>
<h6><code><span title="System.double">double</span></code></h6>
<p>The requested <a href="../MathNet.Numerics.Providers.LinearAlgebra/Norm.htm">Norm</a> of the matrix. </p>
</div>
</div>
</div>
<div id="MatrixNorm" class="method">
<h4><span title="System.double">double</span> <strong>MatrixNorm</strong>(<a href="../MathNet.Numerics.Providers.LinearAlgebra/Norm.htm">Norm</a> norm, <span title="System.int">int</span> rows, <span title="System.int">int</span> columns, <span title="System.Double[]">Double[]</span> matrix)</h4>
<div class="content">Computes the requested <a href="../MathNet.Numerics.Providers.LinearAlgebra/Norm.htm">Norm</a> of the matrix.
<div class="parameters">
<h5>Parameters</h5>
<h6><code><a href="../MathNet.Numerics.Providers.LinearAlgebra/Norm.htm">Norm</a></code> norm</h6>
<p class="comments">The type of norm to compute. </p>
<h6><code><span title="System.int">int</span></code> rows</h6>
<p class="comments">The number of rows. </p>
<h6><code><span title="System.int">int</span></code> columns</h6>
<p class="comments">The number of columns. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> matrix</h6>
<p class="comments">The matrix to compute the norm from. </p>
</div>
<div class="return">
<h5>Return</h5>
<h6><code><span title="System.double">double</span></code></h6>
<p>The requested <a href="../MathNet.Numerics.Providers.LinearAlgebra/Norm.htm">Norm</a> of the matrix. </p>
</div>
</div>
</div>
<div id="MatrixNorm" class="method">
<h4><span title="System.double">double</span> <strong>MatrixNorm</strong>(<a href="../MathNet.Numerics.Providers.LinearAlgebra/Norm.htm">Norm</a> norm, <span title="System.int">int</span> rows, <span title="System.int">int</span> columns, <span title="System.Numerics.Complex[]">Complex[]</span> matrix)</h4>
<div class="content">Computes the requested <a href="../MathNet.Numerics.Providers.LinearAlgebra/Norm.htm">Norm</a> of the matrix.
<div class="parameters">
<h5>Parameters</h5>
<h6><code><a href="../MathNet.Numerics.Providers.LinearAlgebra/Norm.htm">Norm</a></code> norm</h6>
<p class="comments">The type of norm to compute. </p>
<h6><code><span title="System.int">int</span></code> rows</h6>
<p class="comments">The number of rows. </p>
<h6><code><span title="System.int">int</span></code> columns</h6>
<p class="comments">The number of columns. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> matrix</h6>
<p class="comments">The matrix to compute the norm from. </p>
</div>
<div class="return">
<h5>Return</h5>
<h6><code><span title="System.double">double</span></code></h6>
<p>The requested <a href="../MathNet.Numerics.Providers.LinearAlgebra/Norm.htm">Norm</a> of the matrix. </p>
</div>
</div>
</div>
<div id="MatrixNorm" class="method">
<h4><span title="System.double">double</span> <strong>MatrixNorm</strong>(<a href="../MathNet.Numerics.Providers.LinearAlgebra/Norm.htm">Norm</a> norm, <span title="System.int">int</span> rows, <span title="System.int">int</span> columns, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> matrix)</h4>
<div class="content">Computes the requested <a href="../MathNet.Numerics.Providers.LinearAlgebra/Norm.htm">Norm</a> of the matrix.
<div class="parameters">
<h5>Parameters</h5>
<h6><code><a href="../MathNet.Numerics.Providers.LinearAlgebra/Norm.htm">Norm</a></code> norm</h6>
<p class="comments">The type of norm to compute. </p>
<h6><code><span title="System.int">int</span></code> rows</h6>
<p class="comments">The number of rows. </p>
<h6><code><span title="System.int">int</span></code> columns</h6>
<p class="comments">The number of columns. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> matrix</h6>
<p class="comments">The matrix to compute the norm from. </p>
</div>
<div class="return">
<h5>Return</h5>
<h6><code><span title="System.double">double</span></code></h6>
<p>The requested <a href="../MathNet.Numerics.Providers.LinearAlgebra/Norm.htm">Norm</a> of the matrix. </p>
</div>
</div>
</div>
<div id="PointWiseDivideArrays" class="method">
<h4><span title="System.void">void</span> <strong>PointWiseDivideArrays</strong>(<span title="System.Double[]">Double[]</span> x, <span title="System.Double[]">Double[]</span> y, <span title="System.Double[]">Double[]</span> result)</h4>
<div class="content">Does a point wise division of two arrays <code>z = x / y</code>. This can be used
to divide elements of vectors or matrices. <blockquote class="remarks">
There is no equivalent BLAS routine, but many libraries
provide optimized (parallel and/or vectorized) versions of this
routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Double[]">Double[]</span></code> x</h6>
<p class="comments">The array x. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> y</h6>
<p class="comments">The array y. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> result</h6>
<p class="comments">The result of the point wise division. </p>
</div>
</div>
</div>
<div id="PointWiseDivideArrays" class="method">
<h4><span title="System.void">void</span> <strong>PointWiseDivideArrays</strong>(<span title="System.Numerics.Complex[]">Complex[]</span> x, <span title="System.Numerics.Complex[]">Complex[]</span> y, <span title="System.Numerics.Complex[]">Complex[]</span> result)</h4>
<div class="content">Does a point wise division of two arrays <code>z = x / y</code>. This can be used
to divide elements of vectors or matrices. <blockquote class="remarks">
There is no equivalent BLAS routine, but many libraries
provide optimized (parallel and/or vectorized) versions of this
routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> x</h6>
<p class="comments">The array x. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> y</h6>
<p class="comments">The array y. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> result</h6>
<p class="comments">The result of the point wise division. </p>
</div>
</div>
</div>
<div id="PointWiseDivideArrays" class="method">
<h4><span title="System.void">void</span> <strong>PointWiseDivideArrays</strong>(<span title="MathNet.Numerics.Complex32[]">Complex32[]</span> x, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> y, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> result)</h4>
<div class="content">Does a point wise division of two arrays <code>z = x / y</code>. This can be used
to divide elements of vectors or matrices. <blockquote class="remarks">
There is no equivalent BLAS routine, but many libraries
provide optimized (parallel and/or vectorized) versions of this
routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> x</h6>
<p class="comments">The array x. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> y</h6>
<p class="comments">The array y. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> result</h6>
<p class="comments">The result of the point wise division. </p>
</div>
</div>
</div>
<div id="PointWiseDivideArrays" class="method">
<h4><span title="System.void">void</span> <strong>PointWiseDivideArrays</strong>(<span title="System.Single[]">Single[]</span> x, <span title="System.Single[]">Single[]</span> y, <span title="System.Single[]">Single[]</span> result)</h4>
<div class="content">Does a point wise division of two arrays <code>z = x / y</code>. This can be used
to divide elements of vectors or matrices. <blockquote class="remarks">
There is no equivalent BLAS routine, but many libraries
provide optimized (parallel and/or vectorized) versions of this
routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Single[]">Single[]</span></code> x</h6>
<p class="comments">The array x. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> y</h6>
<p class="comments">The array y. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> result</h6>
<p class="comments">The result of the point wise division. </p>
</div>
</div>
</div>
<div id="PointWiseMultiplyArrays" class="method">
<h4><span title="System.void">void</span> <strong>PointWiseMultiplyArrays</strong>(<span title="System.Numerics.Complex[]">Complex[]</span> x, <span title="System.Numerics.Complex[]">Complex[]</span> y, <span title="System.Numerics.Complex[]">Complex[]</span> result)</h4>
<div class="content">Does a point wise multiplication of two arrays <code>z = x * y</code>. This can be used
to multiple elements of vectors or matrices. <blockquote class="remarks">
There is no equivalent BLAS routine, but many libraries
provide optimized (parallel and/or vectorized) versions of this
routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> x</h6>
<p class="comments">The array x. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> y</h6>
<p class="comments">The array y. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> result</h6>
<p class="comments">The result of the point wise multiplication. </p>
</div>
</div>
</div>
<div id="PointWiseMultiplyArrays" class="method">
<h4><span title="System.void">void</span> <strong>PointWiseMultiplyArrays</strong>(<span title="MathNet.Numerics.Complex32[]">Complex32[]</span> x, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> y, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> result)</h4>
<div class="content">Does a point wise multiplication of two arrays <code>z = x * y</code>. This can be used
to multiple elements of vectors or matrices. <blockquote class="remarks">
There is no equivalent BLAS routine, but many libraries
provide optimized (parallel and/or vectorized) versions of this
routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> x</h6>
<p class="comments">The array x. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> y</h6>
<p class="comments">The array y. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> result</h6>
<p class="comments">The result of the point wise multiplication. </p>
</div>
</div>
</div>
<div id="PointWiseMultiplyArrays" class="method">
<h4><span title="System.void">void</span> <strong>PointWiseMultiplyArrays</strong>(<span title="System.Single[]">Single[]</span> x, <span title="System.Single[]">Single[]</span> y, <span title="System.Single[]">Single[]</span> result)</h4>
<div class="content">Does a point wise multiplication of two arrays <code>z = x * y</code>. This can be used
to multiple elements of vectors or matrices. <blockquote class="remarks">
There is no equivalent BLAS routine, but many libraries
provide optimized (parallel and/or vectorized) versions of this
routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Single[]">Single[]</span></code> x</h6>
<p class="comments">The array x. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> y</h6>
<p class="comments">The array y. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> result</h6>
<p class="comments">The result of the point wise multiplication. </p>
</div>
</div>
</div>
<div id="PointWiseMultiplyArrays" class="method">
<h4><span title="System.void">void</span> <strong>PointWiseMultiplyArrays</strong>(<span title="System.Double[]">Double[]</span> x, <span title="System.Double[]">Double[]</span> y, <span title="System.Double[]">Double[]</span> result)</h4>
<div class="content">Does a point wise multiplication of two arrays <code>z = x * y</code>. This can be used
to multiple elements of vectors or matrices. <blockquote class="remarks">
There is no equivalent BLAS routine, but many libraries
provide optimized (parallel and/or vectorized) versions of this
routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Double[]">Double[]</span></code> x</h6>
<p class="comments">The array x. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> y</h6>
<p class="comments">The array y. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> result</h6>
<p class="comments">The result of the point wise multiplication. </p>
</div>
</div>
</div>
<div id="PointWisePowerArrays" class="method">
<h4><span title="System.void">void</span> <strong>PointWisePowerArrays</strong>(<span title="System.Single[]">Single[]</span> x, <span title="System.Single[]">Single[]</span> y, <span title="System.Single[]">Single[]</span> result)</h4>
<div class="content">Does a point wise power of two arrays <code>z = x ^ y</code>. This can be used
to raise elements of vectors or matrices to the powers of another vector or matrix. <blockquote class="remarks">
There is no equivalent BLAS routine, but many libraries
provide optimized (parallel and/or vectorized) versions of this
routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Single[]">Single[]</span></code> x</h6>
<p class="comments">The array x. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> y</h6>
<p class="comments">The array y. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> result</h6>
<p class="comments">The result of the point wise power. </p>
</div>
</div>
</div>
<div id="PointWisePowerArrays" class="method">
<h4><span title="System.void">void</span> <strong>PointWisePowerArrays</strong>(<span title="MathNet.Numerics.Complex32[]">Complex32[]</span> x, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> y, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> result)</h4>
<div class="content">Does a point wise power of two arrays <code>z = x ^ y</code>. This can be used
to raise elements of vectors or matrices to the powers of another vector or matrix. <blockquote class="remarks">
There is no equivalent BLAS routine, but many libraries
provide optimized (parallel and/or vectorized) versions of this
routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> x</h6>
<p class="comments">The array x. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> y</h6>
<p class="comments">The array y. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> result</h6>
<p class="comments">The result of the point wise power. </p>
</div>
</div>
</div>
<div id="PointWisePowerArrays" class="method">
<h4><span title="System.void">void</span> <strong>PointWisePowerArrays</strong>(<span title="System.Double[]">Double[]</span> x, <span title="System.Double[]">Double[]</span> y, <span title="System.Double[]">Double[]</span> result)</h4>
<div class="content">Does a point wise power of two arrays <code>z = x ^ y</code>. This can be used
to raise elements of vectors or matrices to the powers of another vector or matrix. <blockquote class="remarks">
There is no equivalent BLAS routine, but many libraries
provide optimized (parallel and/or vectorized) versions of this
routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Double[]">Double[]</span></code> x</h6>
<p class="comments">The array x. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> y</h6>
<p class="comments">The array y. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> result</h6>
<p class="comments">The result of the point wise power. </p>
</div>
</div>
</div>
<div id="PointWisePowerArrays" class="method">
<h4><span title="System.void">void</span> <strong>PointWisePowerArrays</strong>(<span title="System.Numerics.Complex[]">Complex[]</span> x, <span title="System.Numerics.Complex[]">Complex[]</span> y, <span title="System.Numerics.Complex[]">Complex[]</span> result)</h4>
<div class="content">Does a point wise power of two arrays <code>z = x ^ y</code>. This can be used
to raise elements of vectors or matrices to the powers of another vector or matrix. <blockquote class="remarks">
There is no equivalent BLAS routine, but many libraries
provide optimized (parallel and/or vectorized) versions of this
routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> x</h6>
<p class="comments">The array x. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> y</h6>
<p class="comments">The array y. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> result</h6>
<p class="comments">The result of the point wise power. </p>
</div>
</div>
</div>
<div id="QRFactor" class="method">
<h4><span title="System.void">void</span> <strong>QRFactor</strong>(<span title="System.Double[]">Double[]</span> r, <span title="System.int">int</span> rowsR, <span title="System.int">int</span> columnsR, <span title="System.Double[]">Double[]</span> q, <span title="System.Double[]">Double[]</span> tau)</h4>
<div class="content">Computes the QR factorization of A. <blockquote class="remarks">
This is similar to the GEQRF and ORGQR LAPACK routines.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Double[]">Double[]</span></code> r</h6>
<p class="comments">On entry, it is the M by N A matrix to factor. On exit,
it is overwritten with the R matrix of the QR factorization. </p>
<h6><code><span title="System.int">int</span></code> rowsR</h6>
<p class="comments">The number of rows in the A matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsR</h6>
<p class="comments">The number of columns in the A matrix. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> q</h6>
<p class="comments">On exit, A M by M matrix that holds the Q matrix of the
QR factorization. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> tau</h6>
<p class="comments">A min(m,n) vector. On exit, contains additional information
to be used by the QR solve routine. </p>
</div>
</div>
</div>
<div id="QRFactor" class="method">
<h4><span title="System.void">void</span> <strong>QRFactor</strong>(<span title="System.Numerics.Complex[]">Complex[]</span> r, <span title="System.int">int</span> rowsR, <span title="System.int">int</span> columnsR, <span title="System.Numerics.Complex[]">Complex[]</span> q, <span title="System.Numerics.Complex[]">Complex[]</span> tau)</h4>
<div class="content">Computes the QR factorization of A. <blockquote class="remarks">
This is similar to the GEQRF and ORGQR LAPACK routines.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> r</h6>
<p class="comments">On entry, it is the M by N A matrix to factor. On exit,
it is overwritten with the R matrix of the QR factorization. </p>
<h6><code><span title="System.int">int</span></code> rowsR</h6>
<p class="comments">The number of rows in the A matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsR</h6>
<p class="comments">The number of columns in the A matrix. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> q</h6>
<p class="comments">On exit, A M by M matrix that holds the Q matrix of the
QR factorization. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> tau</h6>
<p class="comments">A min(m,n) vector. On exit, contains additional information
to be used by the QR solve routine. </p>
</div>
</div>
</div>
<div id="QRFactor" class="method">
<h4><span title="System.void">void</span> <strong>QRFactor</strong>(<span title="MathNet.Numerics.Complex32[]">Complex32[]</span> r, <span title="System.int">int</span> rowsR, <span title="System.int">int</span> columnsR, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> q, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> tau)</h4>
<div class="content">Computes the QR factorization of A. <blockquote class="remarks">
This is similar to the GEQRF and ORGQR LAPACK routines.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> r</h6>
<p class="comments">On entry, it is the M by N A matrix to factor. On exit,
it is overwritten with the R matrix of the QR factorization. </p>
<h6><code><span title="System.int">int</span></code> rowsR</h6>
<p class="comments">The number of rows in the A matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsR</h6>
<p class="comments">The number of columns in the A matrix. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> q</h6>
<p class="comments">On exit, A M by M matrix that holds the Q matrix of the
QR factorization. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> tau</h6>
<p class="comments">A min(m,n) vector. On exit, contains additional information
to be used by the QR solve routine. </p>
</div>
</div>
</div>
<div id="QRFactor" class="method">
<h4><span title="System.void">void</span> <strong>QRFactor</strong>(<span title="System.Single[]">Single[]</span> r, <span title="System.int">int</span> rowsR, <span title="System.int">int</span> columnsR, <span title="System.Single[]">Single[]</span> q, <span title="System.Single[]">Single[]</span> tau)</h4>
<div class="content">Computes the QR factorization of A. <blockquote class="remarks">
This is similar to the GEQRF and ORGQR LAPACK routines.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Single[]">Single[]</span></code> r</h6>
<p class="comments">On entry, it is the M by N A matrix to factor. On exit,
it is overwritten with the R matrix of the QR factorization. </p>
<h6><code><span title="System.int">int</span></code> rowsR</h6>
<p class="comments">The number of rows in the A matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsR</h6>
<p class="comments">The number of columns in the A matrix. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> q</h6>
<p class="comments">On exit, A M by M matrix that holds the Q matrix of the
QR factorization. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> tau</h6>
<p class="comments">A min(m,n) vector. On exit, contains additional information
to be used by the QR solve routine. </p>
</div>
</div>
</div>
<div id="QRSolve" class="method">
<h4><span title="System.void">void</span> <strong>QRSolve</strong>(<span title="System.Double[]">Double[]</span> a, <span title="System.int">int</span> rows, <span title="System.int">int</span> columns, <span title="System.Double[]">Double[]</span> b, <span title="System.int">int</span> columnsB, <span title="System.Double[]">Double[]</span> x, <a href="../MathNet.Numerics.LinearAlgebra.Factorization/QRMethod.htm">QRMethod</a> method)</h4>
<div class="content">Solves A*X=B for X using QR factorization of A. <blockquote class="remarks">
Rows must be greater or equal to columns.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Double[]">Double[]</span></code> a</h6>
<p class="comments">The A matrix. </p>
<h6><code><span title="System.int">int</span></code> rows</h6>
<p class="comments">The number of rows in the A matrix. </p>
<h6><code><span title="System.int">int</span></code> columns</h6>
<p class="comments">The number of columns in the A matrix. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> b</h6>
<p class="comments">The B matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsB</h6>
<p class="comments">The number of columns of B. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> x</h6>
<p class="comments">On exit, the solution matrix. </p>
<h6><code><a href="../MathNet.Numerics.LinearAlgebra.Factorization/QRMethod.htm">QRMethod</a></code> method</h6>
<p class="comments">The type of QR factorization to perform. </p>
</div>
</div>
</div>
<div id="QRSolve" class="method">
<h4><span title="System.void">void</span> <strong>QRSolve</strong>(<span title="System.Numerics.Complex[]">Complex[]</span> a, <span title="System.int">int</span> rows, <span title="System.int">int</span> columns, <span title="System.Numerics.Complex[]">Complex[]</span> b, <span title="System.int">int</span> columnsB, <span title="System.Numerics.Complex[]">Complex[]</span> x, <a href="../MathNet.Numerics.LinearAlgebra.Factorization/QRMethod.htm">QRMethod</a> method)</h4>
<div class="content">Solves A*X=B for X using QR factorization of A. <blockquote class="remarks">
Rows must be greater or equal to columns.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> a</h6>
<p class="comments">The A matrix. </p>
<h6><code><span title="System.int">int</span></code> rows</h6>
<p class="comments">The number of rows in the A matrix. </p>
<h6><code><span title="System.int">int</span></code> columns</h6>
<p class="comments">The number of columns in the A matrix. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> b</h6>
<p class="comments">The B matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsB</h6>
<p class="comments">The number of columns of B. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> x</h6>
<p class="comments">On exit, the solution matrix. </p>
<h6><code><a href="../MathNet.Numerics.LinearAlgebra.Factorization/QRMethod.htm">QRMethod</a></code> method</h6>
<p class="comments">The type of QR factorization to perform. </p>
</div>
</div>
</div>
<div id="QRSolve" class="method">
<h4><span title="System.void">void</span> <strong>QRSolve</strong>(<span title="MathNet.Numerics.Complex32[]">Complex32[]</span> a, <span title="System.int">int</span> rows, <span title="System.int">int</span> columns, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> b, <span title="System.int">int</span> columnsB, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> x, <a href="../MathNet.Numerics.LinearAlgebra.Factorization/QRMethod.htm">QRMethod</a> method)</h4>
<div class="content">Solves A*X=B for X using QR factorization of A. <blockquote class="remarks">
Rows must be greater or equal to columns.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> a</h6>
<p class="comments">The A matrix. </p>
<h6><code><span title="System.int">int</span></code> rows</h6>
<p class="comments">The number of rows in the A matrix. </p>
<h6><code><span title="System.int">int</span></code> columns</h6>
<p class="comments">The number of columns in the A matrix. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> b</h6>
<p class="comments">The B matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsB</h6>
<p class="comments">The number of columns of B. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> x</h6>
<p class="comments">On exit, the solution matrix. </p>
<h6><code><a href="../MathNet.Numerics.LinearAlgebra.Factorization/QRMethod.htm">QRMethod</a></code> method</h6>
<p class="comments">The type of QR factorization to perform. </p>
</div>
</div>
</div>
<div id="QRSolve" class="method">
<h4><span title="System.void">void</span> <strong>QRSolve</strong>(<span title="System.Single[]">Single[]</span> a, <span title="System.int">int</span> rows, <span title="System.int">int</span> columns, <span title="System.Single[]">Single[]</span> b, <span title="System.int">int</span> columnsB, <span title="System.Single[]">Single[]</span> x, <a href="../MathNet.Numerics.LinearAlgebra.Factorization/QRMethod.htm">QRMethod</a> method)</h4>
<div class="content">Solves A*X=B for X using QR factorization of A. <blockquote class="remarks">
Rows must be greater or equal to columns.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Single[]">Single[]</span></code> a</h6>
<p class="comments">The A matrix. </p>
<h6><code><span title="System.int">int</span></code> rows</h6>
<p class="comments">The number of rows in the A matrix. </p>
<h6><code><span title="System.int">int</span></code> columns</h6>
<p class="comments">The number of columns in the A matrix. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> b</h6>
<p class="comments">The B matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsB</h6>
<p class="comments">The number of columns of B. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> x</h6>
<p class="comments">On exit, the solution matrix. </p>
<h6><code><a href="../MathNet.Numerics.LinearAlgebra.Factorization/QRMethod.htm">QRMethod</a></code> method</h6>
<p class="comments">The type of QR factorization to perform. </p>
</div>
</div>
</div>
<div id="QRSolveFactored" class="method">
<h4><span title="System.void">void</span> <strong>QRSolveFactored</strong>(<span title="System.Numerics.Complex[]">Complex[]</span> q, <span title="System.Numerics.Complex[]">Complex[]</span> r, <span title="System.int">int</span> rowsA, <span title="System.int">int</span> columnsA, <span title="System.Numerics.Complex[]">Complex[]</span> tau, <span title="System.Numerics.Complex[]">Complex[]</span> b, <span title="System.int">int</span> columnsB, <span title="System.Numerics.Complex[]">Complex[]</span> x, <a href="../MathNet.Numerics.LinearAlgebra.Factorization/QRMethod.htm">QRMethod</a> method)</h4>
<div class="content">Solves A*X=B for X using a previously QR factored matrix. <blockquote class="remarks">
Rows must be greater or equal to columns.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> q</h6>
<p class="comments">The Q matrix obtained by calling <a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#QRFactor">QRFactor</a>. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> r</h6>
<p class="comments">The R matrix obtained by calling <a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#QRFactor">QRFactor</a>. </p>
<h6><code><span title="System.int">int</span></code> rowsA</h6>
<p class="comments">The number of rows in the A matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsA</h6>
<p class="comments">The number of columns in the A matrix. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> tau</h6>
<p class="comments">Contains additional information on Q. Only used for the native solver
and can be <code>null</code> for the managed provider. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> b</h6>
<p class="comments">The B matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsB</h6>
<p class="comments">The number of columns of B. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> x</h6>
<p class="comments">On exit, the solution matrix. </p>
<h6><code><a href="../MathNet.Numerics.LinearAlgebra.Factorization/QRMethod.htm">QRMethod</a></code> method</h6>
<p class="comments">The type of QR factorization to perform. </p>
</div>
</div>
</div>
<div id="QRSolveFactored" class="method">
<h4><span title="System.void">void</span> <strong>QRSolveFactored</strong>(<span title="System.Single[]">Single[]</span> q, <span title="System.Single[]">Single[]</span> r, <span title="System.int">int</span> rowsA, <span title="System.int">int</span> columnsA, <span title="System.Single[]">Single[]</span> tau, <span title="System.Single[]">Single[]</span> b, <span title="System.int">int</span> columnsB, <span title="System.Single[]">Single[]</span> x, <a href="../MathNet.Numerics.LinearAlgebra.Factorization/QRMethod.htm">QRMethod</a> method)</h4>
<div class="content">Solves A*X=B for X using a previously QR factored matrix. <blockquote class="remarks">
Rows must be greater or equal to columns.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Single[]">Single[]</span></code> q</h6>
<p class="comments">The Q matrix obtained by calling <a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#QRFactor">QRFactor</a>. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> r</h6>
<p class="comments">The R matrix obtained by calling <a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#QRFactor">QRFactor</a>. </p>
<h6><code><span title="System.int">int</span></code> rowsA</h6>
<p class="comments">The number of rows in the A matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsA</h6>
<p class="comments">The number of columns in the A matrix. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> tau</h6>
<p class="comments">Contains additional information on Q. Only used for the native solver
and can be <code>null</code> for the managed provider. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> b</h6>
<p class="comments">The B matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsB</h6>
<p class="comments">The number of columns of B. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> x</h6>
<p class="comments">On exit, the solution matrix. </p>
<h6><code><a href="../MathNet.Numerics.LinearAlgebra.Factorization/QRMethod.htm">QRMethod</a></code> method</h6>
<p class="comments">The type of QR factorization to perform. </p>
</div>
</div>
</div>
<div id="QRSolveFactored" class="method">
<h4><span title="System.void">void</span> <strong>QRSolveFactored</strong>(<span title="MathNet.Numerics.Complex32[]">Complex32[]</span> q, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> r, <span title="System.int">int</span> rowsA, <span title="System.int">int</span> columnsA, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> tau, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> b, <span title="System.int">int</span> columnsB, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> x, <a href="../MathNet.Numerics.LinearAlgebra.Factorization/QRMethod.htm">QRMethod</a> method)</h4>
<div class="content">Solves A*X=B for X using a previously QR factored matrix. <blockquote class="remarks">
Rows must be greater or equal to columns.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> q</h6>
<p class="comments">The Q matrix obtained by calling <a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#QRFactor">QRFactor</a>. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> r</h6>
<p class="comments">The R matrix obtained by calling <a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#QRFactor">QRFactor</a>. </p>
<h6><code><span title="System.int">int</span></code> rowsA</h6>
<p class="comments">The number of rows in the A matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsA</h6>
<p class="comments">The number of columns in the A matrix. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> tau</h6>
<p class="comments">Contains additional information on Q. Only used for the native solver
and can be <code>null</code> for the managed provider. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> b</h6>
<p class="comments">The B matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsB</h6>
<p class="comments">The number of columns of B. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> x</h6>
<p class="comments">On exit, the solution matrix. </p>
<h6><code><a href="../MathNet.Numerics.LinearAlgebra.Factorization/QRMethod.htm">QRMethod</a></code> method</h6>
<p class="comments">The type of QR factorization to perform. </p>
</div>
</div>
</div>
<div id="QRSolveFactored" class="method">
<h4><span title="System.void">void</span> <strong>QRSolveFactored</strong>(<span title="System.Double[]">Double[]</span> q, <span title="System.Double[]">Double[]</span> r, <span title="System.int">int</span> rowsA, <span title="System.int">int</span> columnsA, <span title="System.Double[]">Double[]</span> tau, <span title="System.Double[]">Double[]</span> b, <span title="System.int">int</span> columnsB, <span title="System.Double[]">Double[]</span> x, <a href="../MathNet.Numerics.LinearAlgebra.Factorization/QRMethod.htm">QRMethod</a> method)</h4>
<div class="content">Solves A*X=B for X using a previously QR factored matrix. <blockquote class="remarks">
Rows must be greater or equal to columns.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Double[]">Double[]</span></code> q</h6>
<p class="comments">The Q matrix obtained by calling <a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#QRFactor">QRFactor</a>. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> r</h6>
<p class="comments">The R matrix obtained by calling <a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#QRFactor">QRFactor</a>. </p>
<h6><code><span title="System.int">int</span></code> rowsA</h6>
<p class="comments">The number of rows in the A matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsA</h6>
<p class="comments">The number of columns in the A matrix. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> tau</h6>
<p class="comments">Contains additional information on Q. Only used for the native solver
and can be <code>null</code> for the managed provider. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> b</h6>
<p class="comments">The B matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsB</h6>
<p class="comments">The number of columns of B. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> x</h6>
<p class="comments">On exit, the solution matrix. </p>
<h6><code><a href="../MathNet.Numerics.LinearAlgebra.Factorization/QRMethod.htm">QRMethod</a></code> method</h6>
<p class="comments">The type of QR factorization to perform. </p>
</div>
</div>
</div>
<div id="ScaleArray" class="method">
<h4><span title="System.void">void</span> <strong>ScaleArray</strong>(<span title="System.double">double</span> alpha, <span title="System.Double[]">Double[]</span> x, <span title="System.Double[]">Double[]</span> result)</h4>
<div class="content">Scales an array. Can be used to scale a vector and a matrix. <blockquote class="remarks">
This is similar to the SCAL BLAS routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.double">double</span></code> alpha</h6>
<p class="comments">The scalar. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> x</h6>
<p class="comments">The values to scale. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> result</h6>
<p class="comments">This result of the scaling. </p>
</div>
</div>
</div>
<div id="ScaleArray" class="method">
<h4><span title="System.void">void</span> <strong>ScaleArray</strong>(<span title="System.float">float</span> alpha, <span title="System.Single[]">Single[]</span> x, <span title="System.Single[]">Single[]</span> result)</h4>
<div class="content">Scales an array. Can be used to scale a vector and a matrix. <blockquote class="remarks">
This is similar to the SCAL BLAS routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.float">float</span></code> alpha</h6>
<p class="comments">The scalar. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> x</h6>
<p class="comments">The values to scale. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> result</h6>
<p class="comments">This result of the scaling. </p>
</div>
</div>
</div>
<div id="ScaleArray" class="method">
<h4><span title="System.void">void</span> <strong>ScaleArray</strong>(<span title="System.Numerics.Complex">Complex</span> alpha, <span title="System.Numerics.Complex[]">Complex[]</span> x, <span title="System.Numerics.Complex[]">Complex[]</span> result)</h4>
<div class="content">Scales an array. Can be used to scale a vector and a matrix. <blockquote class="remarks">
This is similar to the SCAL BLAS routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Numerics.Complex">Complex</span></code> alpha</h6>
<p class="comments">The scalar. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> x</h6>
<p class="comments">The values to scale. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> result</h6>
<p class="comments">This result of the scaling. </p>
</div>
</div>
</div>
<div id="ScaleArray" class="method">
<h4><span title="System.void">void</span> <strong>ScaleArray</strong>(<a href="../MathNet.Numerics/Complex32.htm">Complex32</a> alpha, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> x, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> result)</h4>
<div class="content">Scales an array. Can be used to scale a vector and a matrix. <blockquote class="remarks">
This is similar to the SCAL BLAS routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><a href="../MathNet.Numerics/Complex32.htm">Complex32</a></code> alpha</h6>
<p class="comments">The scalar. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> x</h6>
<p class="comments">The values to scale. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> result</h6>
<p class="comments">This result of the scaling. </p>
</div>
</div>
</div>
<div id="SingularValueDecomposition" class="method">
<h4><span title="System.void">void</span> <strong>SingularValueDecomposition</strong>(<span title="System.bool">bool</span> computeVectors, <span title="System.Single[]">Single[]</span> a, <span title="System.int">int</span> rowsA, <span title="System.int">int</span> columnsA, <span title="System.Single[]">Single[]</span> s, <span title="System.Single[]">Single[]</span> u, <span title="System.Single[]">Single[]</span> vt)</h4>
<div class="content">Computes the singular value decomposition of A. <blockquote class="remarks">
This is equivalent to the GESVD LAPACK routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.bool">bool</span></code> computeVectors</h6>
<p class="comments">Compute the singular U and VT vectors or not. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> a</h6>
<p class="comments">On entry, the M by N matrix to decompose. On exit, A may be overwritten. </p>
<h6><code><span title="System.int">int</span></code> rowsA</h6>
<p class="comments">The number of rows in the A matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsA</h6>
<p class="comments">The number of columns in the A matrix. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> s</h6>
<p class="comments">The singular values of A in ascending value. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> u</h6>
<p class="comments">If <var>computeVectors</var> is <code>true</code> , on exit U contains the left
singular vectors. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> vt</h6>
<p class="comments">If <var>computeVectors</var> is <code>true</code> , on exit VT contains the transposed
right singular vectors. </p>
</div>
</div>
</div>
<div id="SingularValueDecomposition" class="method">
<h4><span title="System.void">void</span> <strong>SingularValueDecomposition</strong>(<span title="System.bool">bool</span> computeVectors, <span title="System.Numerics.Complex[]">Complex[]</span> a, <span title="System.int">int</span> rowsA, <span title="System.int">int</span> columnsA, <span title="System.Numerics.Complex[]">Complex[]</span> s, <span title="System.Numerics.Complex[]">Complex[]</span> u, <span title="System.Numerics.Complex[]">Complex[]</span> vt)</h4>
<div class="content">Computes the singular value decomposition of A. <blockquote class="remarks">
This is equivalent to the GESVD LAPACK routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.bool">bool</span></code> computeVectors</h6>
<p class="comments">Compute the singular U and VT vectors or not. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> a</h6>
<p class="comments">On entry, the M by N matrix to decompose. On exit, A may be overwritten. </p>
<h6><code><span title="System.int">int</span></code> rowsA</h6>
<p class="comments">The number of rows in the A matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsA</h6>
<p class="comments">The number of columns in the A matrix. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> s</h6>
<p class="comments">The singular values of A in ascending value. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> u</h6>
<p class="comments">If <var>computeVectors</var> is <code>true</code> , on exit U contains the left
singular vectors. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> vt</h6>
<p class="comments">If <var>computeVectors</var> is <code>true</code> , on exit VT contains the transposed
right singular vectors. </p>
</div>
</div>
</div>
<div id="SingularValueDecomposition" class="method">
<h4><span title="System.void">void</span> <strong>SingularValueDecomposition</strong>(<span title="System.bool">bool</span> computeVectors, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> a, <span title="System.int">int</span> rowsA, <span title="System.int">int</span> columnsA, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> s, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> u, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> vt)</h4>
<div class="content">Computes the singular value decomposition of A. <blockquote class="remarks">
This is equivalent to the GESVD LAPACK routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.bool">bool</span></code> computeVectors</h6>
<p class="comments">Compute the singular U and VT vectors or not. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> a</h6>
<p class="comments">On entry, the M by N matrix to decompose. On exit, A may be overwritten. </p>
<h6><code><span title="System.int">int</span></code> rowsA</h6>
<p class="comments">The number of rows in the A matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsA</h6>
<p class="comments">The number of columns in the A matrix. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> s</h6>
<p class="comments">The singular values of A in ascending value. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> u</h6>
<p class="comments">If <var>computeVectors</var> is <code>true</code> , on exit U contains the left
singular vectors. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> vt</h6>
<p class="comments">If <var>computeVectors</var> is <code>true</code> , on exit VT contains the transposed
right singular vectors. </p>
</div>
</div>
</div>
<div id="SingularValueDecomposition" class="method">
<h4><span title="System.void">void</span> <strong>SingularValueDecomposition</strong>(<span title="System.bool">bool</span> computeVectors, <span title="System.Double[]">Double[]</span> a, <span title="System.int">int</span> rowsA, <span title="System.int">int</span> columnsA, <span title="System.Double[]">Double[]</span> s, <span title="System.Double[]">Double[]</span> u, <span title="System.Double[]">Double[]</span> vt)</h4>
<div class="content">Computes the singular value decomposition of A. <blockquote class="remarks">
This is equivalent to the GESVD LAPACK routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.bool">bool</span></code> computeVectors</h6>
<p class="comments">Compute the singular U and VT vectors or not. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> a</h6>
<p class="comments">On entry, the M by N matrix to decompose. On exit, A may be overwritten. </p>
<h6><code><span title="System.int">int</span></code> rowsA</h6>
<p class="comments">The number of rows in the A matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsA</h6>
<p class="comments">The number of columns in the A matrix. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> s</h6>
<p class="comments">The singular values of A in ascending value. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> u</h6>
<p class="comments">If <var>computeVectors</var> is <code>true</code> , on exit U contains the left
singular vectors. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> vt</h6>
<p class="comments">If <var>computeVectors</var> is <code>true</code> , on exit VT contains the transposed
right singular vectors. </p>
</div>
</div>
</div>
<div id="SubtractArrays" class="method">
<h4><span title="System.void">void</span> <strong>SubtractArrays</strong>(<span title="MathNet.Numerics.Complex32[]">Complex32[]</span> x, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> y, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> result)</h4>
<div class="content">Does a point wise subtraction of two arrays <code>z = x - y</code>. This can be used
to subtract vectors or matrices. <blockquote class="remarks">
There is no equivalent BLAS routine, but many libraries
provide optimized (parallel and/or vectorized) versions of this
routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> x</h6>
<p class="comments">The array x. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> y</h6>
<p class="comments">The array y. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> result</h6>
<p class="comments">The result of the subtraction. </p>
</div>
</div>
</div>
<div id="SubtractArrays" class="method">
<h4><span title="System.void">void</span> <strong>SubtractArrays</strong>(<span title="System.Numerics.Complex[]">Complex[]</span> x, <span title="System.Numerics.Complex[]">Complex[]</span> y, <span title="System.Numerics.Complex[]">Complex[]</span> result)</h4>
<div class="content">Does a point wise subtraction of two arrays <code>z = x - y</code>. This can be used
to subtract vectors or matrices. <blockquote class="remarks">
There is no equivalent BLAS routine, but many libraries
provide optimized (parallel and/or vectorized) versions of this
routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> x</h6>
<p class="comments">The array x. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> y</h6>
<p class="comments">The array y. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> result</h6>
<p class="comments">The result of the subtraction. </p>
</div>
</div>
</div>
<div id="SubtractArrays" class="method">
<h4><span title="System.void">void</span> <strong>SubtractArrays</strong>(<span title="System.Single[]">Single[]</span> x, <span title="System.Single[]">Single[]</span> y, <span title="System.Single[]">Single[]</span> result)</h4>
<div class="content">Does a point wise subtraction of two arrays <code>z = x - y</code>. This can be used
to subtract vectors or matrices. <blockquote class="remarks">
There is no equivalent BLAS routine, but many libraries
provide optimized (parallel and/or vectorized) versions of this
routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Single[]">Single[]</span></code> x</h6>
<p class="comments">The array x. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> y</h6>
<p class="comments">The array y. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> result</h6>
<p class="comments">The result of the subtraction. </p>
</div>
</div>
</div>
<div id="SubtractArrays" class="method">
<h4><span title="System.void">void</span> <strong>SubtractArrays</strong>(<span title="System.Double[]">Double[]</span> x, <span title="System.Double[]">Double[]</span> y, <span title="System.Double[]">Double[]</span> result)</h4>
<div class="content">Does a point wise subtraction of two arrays <code>z = x - y</code>. This can be used
to subtract vectors or matrices. <blockquote class="remarks">
There is no equivalent BLAS routine, but many libraries
provide optimized (parallel and/or vectorized) versions of this
routine.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Double[]">Double[]</span></code> x</h6>
<p class="comments">The array x. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> y</h6>
<p class="comments">The array y. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> result</h6>
<p class="comments">The result of the subtraction. </p>
</div>
</div>
</div>
<div id="SvdSolve" class="method">
<h4><span title="System.void">void</span> <strong>SvdSolve</strong>(<span title="MathNet.Numerics.Complex32[]">Complex32[]</span> a, <span title="System.int">int</span> rowsA, <span title="System.int">int</span> columnsA, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> b, <span title="System.int">int</span> columnsB, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> x)</h4>
<div class="content">Solves A*X=B for X using the singular value decomposition of A.
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> a</h6>
<p class="comments">On entry, the M by N matrix to decompose. </p>
<h6><code><span title="System.int">int</span></code> rowsA</h6>
<p class="comments">The number of rows in the A matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsA</h6>
<p class="comments">The number of columns in the A matrix. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> b</h6>
<p class="comments">The B matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsB</h6>
<p class="comments">The number of columns of B. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> x</h6>
<p class="comments">On exit, the solution matrix. </p>
</div>
</div>
</div>
<div id="SvdSolve" class="method">
<h4><span title="System.void">void</span> <strong>SvdSolve</strong>(<span title="System.Numerics.Complex[]">Complex[]</span> a, <span title="System.int">int</span> rowsA, <span title="System.int">int</span> columnsA, <span title="System.Numerics.Complex[]">Complex[]</span> b, <span title="System.int">int</span> columnsB, <span title="System.Numerics.Complex[]">Complex[]</span> x)</h4>
<div class="content">Solves A*X=B for X using the singular value decomposition of A.
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> a</h6>
<p class="comments">On entry, the M by N matrix to decompose. </p>
<h6><code><span title="System.int">int</span></code> rowsA</h6>
<p class="comments">The number of rows in the A matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsA</h6>
<p class="comments">The number of columns in the A matrix. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> b</h6>
<p class="comments">The B matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsB</h6>
<p class="comments">The number of columns of B. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> x</h6>
<p class="comments">On exit, the solution matrix. </p>
</div>
</div>
</div>
<div id="SvdSolve" class="method">
<h4><span title="System.void">void</span> <strong>SvdSolve</strong>(<span title="System.Double[]">Double[]</span> a, <span title="System.int">int</span> rowsA, <span title="System.int">int</span> columnsA, <span title="System.Double[]">Double[]</span> b, <span title="System.int">int</span> columnsB, <span title="System.Double[]">Double[]</span> x)</h4>
<div class="content">Solves A*X=B for X using the singular value decomposition of A.
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Double[]">Double[]</span></code> a</h6>
<p class="comments">On entry, the M by N matrix to decompose. </p>
<h6><code><span title="System.int">int</span></code> rowsA</h6>
<p class="comments">The number of rows in the A matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsA</h6>
<p class="comments">The number of columns in the A matrix. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> b</h6>
<p class="comments">The B matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsB</h6>
<p class="comments">The number of columns of B. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> x</h6>
<p class="comments">On exit, the solution matrix. </p>
</div>
</div>
</div>
<div id="SvdSolve" class="method">
<h4><span title="System.void">void</span> <strong>SvdSolve</strong>(<span title="System.Single[]">Single[]</span> a, <span title="System.int">int</span> rowsA, <span title="System.int">int</span> columnsA, <span title="System.Single[]">Single[]</span> b, <span title="System.int">int</span> columnsB, <span title="System.Single[]">Single[]</span> x)</h4>
<div class="content">Solves A*X=B for X using the singular value decomposition of A.
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Single[]">Single[]</span></code> a</h6>
<p class="comments">On entry, the M by N matrix to decompose. </p>
<h6><code><span title="System.int">int</span></code> rowsA</h6>
<p class="comments">The number of rows in the A matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsA</h6>
<p class="comments">The number of columns in the A matrix. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> b</h6>
<p class="comments">The B matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsB</h6>
<p class="comments">The number of columns of B. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> x</h6>
<p class="comments">On exit, the solution matrix. </p>
</div>
</div>
</div>
<div id="SvdSolveFactored" class="method">
<h4><span title="System.void">void</span> <strong>SvdSolveFactored</strong>(<span title="System.int">int</span> rowsA, <span title="System.int">int</span> columnsA, <span title="System.Numerics.Complex[]">Complex[]</span> s, <span title="System.Numerics.Complex[]">Complex[]</span> u, <span title="System.Numerics.Complex[]">Complex[]</span> vt, <span title="System.Numerics.Complex[]">Complex[]</span> b, <span title="System.int">int</span> columnsB, <span title="System.Numerics.Complex[]">Complex[]</span> x)</h4>
<div class="content">Solves A*X=B for X using a previously SVD decomposed matrix.
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.int">int</span></code> rowsA</h6>
<p class="comments">The number of rows in the A matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsA</h6>
<p class="comments">The number of columns in the A matrix. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> s</h6>
<p class="comments">The s values returned by <a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#SingularValueDecomposition">SingularValueDecomposition</a>. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> u</h6>
<p class="comments">The left singular vectors returned by <a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#SingularValueDecomposition">SingularValueDecomposition</a>. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> vt</h6>
<p class="comments">The right singular vectors returned by <a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#SingularValueDecomposition">SingularValueDecomposition</a>. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> b</h6>
<p class="comments">The B matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsB</h6>
<p class="comments">The number of columns of B. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> x</h6>
<p class="comments">On exit, the solution matrix. </p>
</div>
</div>
</div>
<div id="SvdSolveFactored" class="method">
<h4><span title="System.void">void</span> <strong>SvdSolveFactored</strong>(<span title="System.int">int</span> rowsA, <span title="System.int">int</span> columnsA, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> s, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> u, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> vt, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> b, <span title="System.int">int</span> columnsB, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> x)</h4>
<div class="content">Solves A*X=B for X using a previously SVD decomposed matrix.
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.int">int</span></code> rowsA</h6>
<p class="comments">The number of rows in the A matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsA</h6>
<p class="comments">The number of columns in the A matrix. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> s</h6>
<p class="comments">The s values returned by <a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#SingularValueDecomposition">SingularValueDecomposition</a>. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> u</h6>
<p class="comments">The left singular vectors returned by <a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#SingularValueDecomposition">SingularValueDecomposition</a>. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> vt</h6>
<p class="comments">The right singular vectors returned by <a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#SingularValueDecomposition">SingularValueDecomposition</a>. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> b</h6>
<p class="comments">The B matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsB</h6>
<p class="comments">The number of columns of B. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> x</h6>
<p class="comments">On exit, the solution matrix. </p>
</div>
</div>
</div>
<div id="SvdSolveFactored" class="method">
<h4><span title="System.void">void</span> <strong>SvdSolveFactored</strong>(<span title="System.int">int</span> rowsA, <span title="System.int">int</span> columnsA, <span title="System.Double[]">Double[]</span> s, <span title="System.Double[]">Double[]</span> u, <span title="System.Double[]">Double[]</span> vt, <span title="System.Double[]">Double[]</span> b, <span title="System.int">int</span> columnsB, <span title="System.Double[]">Double[]</span> x)</h4>
<div class="content">Solves A*X=B for X using a previously SVD decomposed matrix.
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.int">int</span></code> rowsA</h6>
<p class="comments">The number of rows in the A matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsA</h6>
<p class="comments">The number of columns in the A matrix. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> s</h6>
<p class="comments">The s values returned by <a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#SingularValueDecomposition">SingularValueDecomposition</a>. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> u</h6>
<p class="comments">The left singular vectors returned by <a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#SingularValueDecomposition">SingularValueDecomposition</a>. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> vt</h6>
<p class="comments">The right singular vectors returned by <a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#SingularValueDecomposition">SingularValueDecomposition</a>. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> b</h6>
<p class="comments">The B matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsB</h6>
<p class="comments">The number of columns of B. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> x</h6>
<p class="comments">On exit, the solution matrix. </p>
</div>
</div>
</div>
<div id="SvdSolveFactored" class="method">
<h4><span title="System.void">void</span> <strong>SvdSolveFactored</strong>(<span title="System.int">int</span> rowsA, <span title="System.int">int</span> columnsA, <span title="System.Single[]">Single[]</span> s, <span title="System.Single[]">Single[]</span> u, <span title="System.Single[]">Single[]</span> vt, <span title="System.Single[]">Single[]</span> b, <span title="System.int">int</span> columnsB, <span title="System.Single[]">Single[]</span> x)</h4>
<div class="content">Solves A*X=B for X using a previously SVD decomposed matrix.
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.int">int</span></code> rowsA</h6>
<p class="comments">The number of rows in the A matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsA</h6>
<p class="comments">The number of columns in the A matrix. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> s</h6>
<p class="comments">The s values returned by <a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#SingularValueDecomposition">SingularValueDecomposition</a>. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> u</h6>
<p class="comments">The left singular vectors returned by <a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#SingularValueDecomposition">SingularValueDecomposition</a>. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> vt</h6>
<p class="comments">The right singular vectors returned by <a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm#SingularValueDecomposition">SingularValueDecomposition</a>. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> b</h6>
<p class="comments">The B matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsB</h6>
<p class="comments">The number of columns of B. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> x</h6>
<p class="comments">On exit, the solution matrix. </p>
</div>
</div>
</div>
<div id="ThinQRFactor" class="method">
<h4><span title="System.void">void</span> <strong>ThinQRFactor</strong>(<span title="System.Double[]">Double[]</span> a, <span title="System.int">int</span> rowsA, <span title="System.int">int</span> columnsA, <span title="System.Double[]">Double[]</span> r, <span title="System.Double[]">Double[]</span> tau)</h4>
<div class="content">Computes the QR factorization of A. <blockquote class="remarks">
This is similar to the GEQRF and ORGQR LAPACK routines.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Double[]">Double[]</span></code> a</h6>
<p class="comments">On entry, it is the M by N A matrix to factor. On exit,
it is overwritten with the Q matrix of the QR factorization. </p>
<h6><code><span title="System.int">int</span></code> rowsA</h6>
<p class="comments">The number of rows in the A matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsA</h6>
<p class="comments">The number of columns in the A matrix. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> r</h6>
<p class="comments">On exit, A N by N matrix that holds the R matrix of the
QR factorization. </p>
<h6><code><span title="System.Double[]">Double[]</span></code> tau</h6>
<p class="comments">A min(m,n) vector. On exit, contains additional information
to be used by the QR solve routine. </p>
</div>
</div>
</div>
<div id="ThinQRFactor" class="method">
<h4><span title="System.void">void</span> <strong>ThinQRFactor</strong>(<span title="MathNet.Numerics.Complex32[]">Complex32[]</span> a, <span title="System.int">int</span> rowsA, <span title="System.int">int</span> columnsA, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> r, <span title="MathNet.Numerics.Complex32[]">Complex32[]</span> tau)</h4>
<div class="content">Computes the QR factorization of A. <blockquote class="remarks">
This is similar to the GEQRF and ORGQR LAPACK routines.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> a</h6>
<p class="comments">On entry, it is the M by N A matrix to factor. On exit,
it is overwritten with the Q matrix of the QR factorization. </p>
<h6><code><span title="System.int">int</span></code> rowsA</h6>
<p class="comments">The number of rows in the A matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsA</h6>
<p class="comments">The number of columns in the A matrix. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> r</h6>
<p class="comments">On exit, A N by N matrix that holds the R matrix of the
QR factorization. </p>
<h6><code><span title="MathNet.Numerics.Complex32[]">Complex32[]</span></code> tau</h6>
<p class="comments">A min(m,n) vector. On exit, contains additional information
to be used by the QR solve routine. </p>
</div>
</div>
</div>
<div id="ThinQRFactor" class="method">
<h4><span title="System.void">void</span> <strong>ThinQRFactor</strong>(<span title="System.Single[]">Single[]</span> a, <span title="System.int">int</span> rowsA, <span title="System.int">int</span> columnsA, <span title="System.Single[]">Single[]</span> r, <span title="System.Single[]">Single[]</span> tau)</h4>
<div class="content">Computes the QR factorization of A. <blockquote class="remarks">
This is similar to the GEQRF and ORGQR LAPACK routines.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Single[]">Single[]</span></code> a</h6>
<p class="comments">On entry, it is the M by N A matrix to factor. On exit,
it is overwritten with the Q matrix of the QR factorization. </p>
<h6><code><span title="System.int">int</span></code> rowsA</h6>
<p class="comments">The number of rows in the A matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsA</h6>
<p class="comments">The number of columns in the A matrix. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> r</h6>
<p class="comments">On exit, A N by N matrix that holds the R matrix of the
QR factorization. </p>
<h6><code><span title="System.Single[]">Single[]</span></code> tau</h6>
<p class="comments">A min(m,n) vector. On exit, contains additional information
to be used by the QR solve routine. </p>
</div>
</div>
</div>
<div id="ThinQRFactor" class="method">
<h4><span title="System.void">void</span> <strong>ThinQRFactor</strong>(<span title="System.Numerics.Complex[]">Complex[]</span> a, <span title="System.int">int</span> rowsA, <span title="System.int">int</span> columnsA, <span title="System.Numerics.Complex[]">Complex[]</span> r, <span title="System.Numerics.Complex[]">Complex[]</span> tau)</h4>
<div class="content">Computes the QR factorization of A. <blockquote class="remarks">
This is similar to the GEQRF and ORGQR LAPACK routines.
</blockquote>
<div class="parameters">
<h5>Parameters</h5>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> a</h6>
<p class="comments">On entry, it is the M by N A matrix to factor. On exit,
it is overwritten with the Q matrix of the QR factorization. </p>
<h6><code><span title="System.int">int</span></code> rowsA</h6>
<p class="comments">The number of rows in the A matrix. </p>
<h6><code><span title="System.int">int</span></code> columnsA</h6>
<p class="comments">The number of columns in the A matrix. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> r</h6>
<p class="comments">On exit, A N by N matrix that holds the R matrix of the
QR factorization. </p>
<h6><code><span title="System.Numerics.Complex[]">Complex[]</span></code> tau</h6>
<p class="comments">A min(m,n) vector. On exit, contains additional information
to be used by the QR solve routine. </p>
</div>
</div>
</div>
<div id="ToString" class="method">
<h4><span title="System.string">string</span> <strong>ToString</strong>()</h4>
<div class="content">
</div>
</div>
<h3 class="section">Public Properties</h3>
<div id="Instance" class="method">
<h4><a href="../MathNet.Numerics.Providers.LinearAlgebra/ManagedLinearAlgebraProvider.htm">ManagedLinearAlgebraProvider</a> <strong>Instance</strong> get; </h4>
<div class="content">
</div>
</div>
<div id="footer">
<p>Based on v5.0.0.0 of MathNet.Numerics (Math.NET Numerics)</p>
<p>Generated by <a href="http://docu.jagregory.com">docu</a></p>
</div>
</body>
</html>