## linsolve

Main Content

### Description

example

solves the linear system *A**X* = *B* using one of these methods:

When is

*square*, uses LU factorization with partial pivoting.For all other cases, uses QR factorization with column pivoting.

warns if is ill conditioned (for square matrices) or rank deficient (for rectangular matrices).

example

uses an appropriate solver as determined by the options structure . The fields in are logical values describing properties of the matrix . For example, if is an upper triangular matrix, you can set to make use a solver designed for upper triangular matrices. does not test to verify that has the properties specified in .

example

also returns , which is the reciprocal of the condition number of (for square matrices) or the rank of (for rectangular matrices). You can use any of the input argument combinations in previous syntaxes. With this syntax, does not warn if is ill conditioned or rank deficient.

### Examples

collapse all

### Solve Linear System

Solve a linear system with both and to compare performance.

is the recommended way to solve most linear systems of equations in MATLAB &#;. However, the function performs several checks on the input matrix to determine whether it has any special properties. If you know about the properties of the coefficient matrix ahead of time, then you can use to avoid time-consuming checks for large matrices.

Create a by magic square matrix and extract the lower triangular portion. Set the field of the structure to to indicate that is a lower triangular matrix.

Create a vector of ones for the right-hand side of the linear equation . The number of rows in and must be equal.

Solve the linear system using and time the calculation.

Now, solve the system again using . Specify the options structure so that can select an appropriate solver for a lower triangular matrix.

Compare the execution times to see how much faster is. As with any timing comparison, the results can vary between different computers and releases of MATLAB.

### Suppress Matrix Condition Warnings

Solve a linear system using with two outputs to suppress matrix conditioning warnings.

Create a by Hilbert test matrix. This matrix is nearly singular, with the largest singular value being about larger than the smallest.

Solve a linear system involving with . Since is nearly singular, returns a warning.

Now, solve the same linear system, but specify two outputs to . MATLAB&#; suppresses the warning, and the second output contains the reciprocal condition number of . You can use this syntax to handle ill-conditioned matrices with special cases in your code, without the code producing a warning.

*20×1*10

^{9}× ⋮

### Input Arguments

collapse all

### &#; Coefficient matrix

matrix

Coefficient matrix. appears in the system of linear equations on the left as *A**X* = *B*. The number of rows in must equal the number of rows in .

cannot be sparse. To solve a linear system involving a sparse matrix, use or instead.

**Data Types: ** | **Complex Number Support: **Yes

### &#; Input array

vector | matrix

Input array, specified as a vector or matrix. appears in the system of linear equations on the right as *A**X* = *B*. If is a matrix, then each column in the matrix represents a different vector for the right-hand side.

The number of rows in must equal the number of rows in .

**Data Types: ** | **Complex Number Support: **Yes

### &#; Coefficient matrix properties

structure

Coefficient matrix properties, specified as a structure. Use this structure to specify properties of that uses to select an appropriate solver for the linear system. The fields in the structure contain / values to indicate whether has each property. By default all fields in the structure are assumed to be . This table lists the possible fields in and their corresponding matrix properties.

Field | Matrix Property |
---|---|

Lower triangular (nonzero values appearing only on or below the main diagonal) | |

Upper triangular (nonzero values appearing only on or above the main diagonal) | |

Upper Hessenberg (all zero values below the first subdiagonal) | |

Real symmetric or complex Hermitian (matrix equal to its transpose) | |

Positive definite (all positive eigenvalues) | |

Rectangular matrix (different number of rows and columns) | |

Conjugate transpose &#; Specifies whether the function solves (when ) or the transposed problem (when ) |

**Example: ** specifies that is upper triangular.

**Example: ** sets two fields to specify that is symmetric and positive definite.

#### Valid Combinations

The rows of this table list all combinations of field values in that are valid for . Empty cells are the default value of , and a / entry indicates that accepts either value.

is lower triangular | / | / | |||||

is upper triangular | / | / | |||||

is upper Hessenberg | / | ||||||

is symmetric | / | / | |||||

is rectangular | / | / |

#### Notes on Usage

If has the properties in , then is faster compared to , because invokes the appropriate solver immediately and does not perform any tests to verify that has the specified properties.

If does

*not*have the properties that you specify in , then returns incorrect results and does not return an error message. Therefore, if you are unsure whether has the specified properties, use or instead.

**Data Types: **

### Output Arguments

collapse all

### &#; Linear system solution

vector | matrix

Linear system solution, returned as a vector or matrix that satisfies *A**X* = *B* (or *A*^{T}*X* = *B* if ). The size of depends on whether :

If is -by- and is -by-, then is -by- and is the solution to

*A**X*=*B*.If , then is -by- and is -by-. In this case, is -by- and is the solution to

*A*^{T}*X*=*B*.

### &#; Reciprocal condition number or rank

scalar

Reciprocal condition number or rank, returned as a scalar.

If is a square matrix, then is the reciprocal condition number of .

If is a rectangular matrix, then is the rank of .

If is specified, then is the reciprocal of the condition number of unless is and both and are , in which case, gives the rank of .

### Tips

The speed benefit of can vary depending on the matrix structure and the relative optimization of the underlying algorithms. In some cases (such as with small matrices) there might not be any speed-up compared to . The speed benefit with arises by avoiding costly checks on the properties of large matrices, or by choosing an algorithm that is better suited to the input than the choice that makes.

### Extended Capabilities

### C/C++ Code Generation

Generate C and C++ code using MATLAB&#; Coder&#;.

Usage notes and limitations:

The structure must be a constant scalar. Code generation does not support arrays of options structures.

Code generation only optimizes these cases:

= (the can be either or )

= and =

Other options are equivalent to using .

Code generation does not support sparse matrix inputs for this function.

### GPU Code Generation

Generate CUDA&#; code for NVIDIA&#; GPUs using GPU Coder&#;.

Usage notes and limitations:

The structure must be a constant scalar. Code generation does not support arrays of options structures.

Code generation only optimizes these cases:

= (the can be either or )

= and =

Other options are equivalent to using .

Code generation does not support sparse matrix inputs for this function.

### Thread-Based Environment

Run code in the background using MATLAB&#; or accelerate code with Parallel Computing Toolbox&#; .

This function fully supports thread-based environments. For more information, see Run MATLAB Functions in Thread-Based Environment.

### Distributed Arrays

Partition large arrays across the combined memory of your cluster using Parallel Computing Toolbox&#;.

This function fully supports distributed arrays. For more information, see Run MATLAB Functions with Distributed Arrays (Parallel Computing Toolbox).

**Introduced before Ra**

You have a modified version of this example. Do you want to open this example with your edits?

You clicked a link that corresponds to this MATLAB command:

Run the command by entering it in the MATLAB Command Window. Web browsers do not support MATLAB commands.

Choose a web site to get translated content where available and see local events and offers. Based on your location, we recommend that you select: .

Select web siteYou can also select a web site from the following list:

### How to Get Best Site Performance

Select the China site (in Chinese or English) for best site performance. Other MathWorks country sites are not optimized for visits from your location.

Contact your local office

## Solving Linear Equations

In today's MATLAB Basics, I want to show how to solve a simple set of linear equations. The equations we'll be solving today are shown here-- 2x equals 3y plus 1 and x plus y equals 4. Since this is MATLAB, or Matrix Laboratory, we're going to want to get this into a matrix format.

We can do this by rearranging the top equation to gather all the x's and y's on one side. Once we do that, we get it into the matrix form. To enter this into MATLAB, we'll use the following notation, where we're going to call the left-hand matrix, A, a two-by-two. We'll call our x and y variables matrix B. And then we will call the right-hand side, matrix C.

To enter this into MATLAB, we will use two lines of code. Let's actually type those in. We type these in as a is equal to, and then square brackets for a matrix. We're going to go across the columns-- 2 minus 3. A semicolon to drop down to the next row-- 1 and 1. And then we're going to enter the C matrix by saying, c is equal to 1 and 4.

When we do that, we see that we got a row vector instead of a column vector. We can hit up arrow, and then put an apostrophe. And that's going to transpose our matrix.

Finally, if we want to solve this, we can simply say that b is equal to a back-divide by c. And we'll get our result. If we want to look at this result as a fraction, we could change our format-- format rational. And now we see it as a fraction.

I'm going to go back to my normal format. And we can finally test this. We can say, a times b. And we'll see that that is the right-hand side. Thank you.

## linsolve

Main Content

### Description

example

solves the matrix equation *A**X* = *B*, where is a column vector.

example

also returns the reciprocal of the condition number of if is a square matrix. Otherwise, returns the rank of .

### Examples

collapse all

### Solve Linear Equations in Matrix Form

Solve this system of linear equations in matrix form by using .

From , *x* = 3, *y* = 1 and *z* = &#;5.

### Compute Condition Number of Square Matrix

Compute the reciprocal of the condition number of the square coefficient matrix by using two output arguments.

### Compute Rank of Nonsquare Matrix

If the coefficient matrix is rectangular, returns the rank of the coefficient matrix as the second output argument. Show this behavior.

### Input Arguments

collapse all

### &#; Coefficient matrix

symbolic matrix

Coefficient matrix, specified as a symbolic matrix.

### &#; Right side of equations

symbolic vector | symbolic matrix

Right side of equations, specified as a symbolic vector or matrix.

### Output Arguments

collapse all

### &#; Solution

symbolic vector | symbolic matrix

Solution, returned as a symbolic vector or matrix.

### &#; Reciprocal condition number or rank

symbolic number | symbolic expression

Reciprocal condition number or rank, returned as a symbolic number of expression. If is a square matrix, returns the condition number of . Otherwise, returns the rank of .

### More About

collapse all

### Matrix Representation of System of Linear Equations

A system of linear equations is as follows.

This system can be represented as the matrix equation , where *A* is the coefficient matrix.

is the vector containing the right sides of equations.

### Tips

If the solution is not unique, issues a warning, chooses one solution, and returns it.

If the system does not have a solution, issues a warning and returns with all elements set to .

Calling for numeric matrices that are not symbolic objects invokes the MATLAB

^{®}function. This function accepts real arguments only. If your system of equations uses complex numbers, use to convert at least one matrix to a symbolic matrix, and then call .

**Introduced in Rb**

You clicked a link that corresponds to this MATLAB command:

Run the command by entering it in the MATLAB Command Window. Web browsers do not support MATLAB commands.

Choose a web site to get translated content where available and see local events and offers. Based on your location, we recommend that you select: .

Select web siteYou can also select a web site from the following list:

### How to Get Best Site Performance

Select the China site (in Chinese or English) for best site performance. Other MathWorks country sites are not optimized for visits from your location.

Contact your local office

## mldivide, \

Main Content

### Description

example

solves the system of linear equations . The matrices and must have the same number of rows. MATLAB^{®} displays a warning message if is badly scaled or nearly singular, but performs the calculation regardless.

If is a scalar, then is equivalent to .

If is a square -by- matrix and is a matrix with rows, then is a solution to the equation , if it exists.

If is a rectangular -by- matrix with , and is a matrix with rows, then \ returns a least-squares solution to the system of equations .

is an alternative way to execute \, but is rarely used. It enables operator overloading for classes.

### Examples

collapse all

### System of Equations

Solve a simple system of linear equations, .

*3×1*

### Linear System with Singular Matrix

Solve a linear system of equations involving a singular matrix, .

*4×1*

When is between and , MATLAB&#; issues a nearly singular warning, but proceeds with the calculation. When working with ill-conditioned matrices, an unreliable solution can result even though the residual is relatively small. In this particular example, the norm of the residual is zero, and an exact solution is obtained, although is small.

When is equal to , the singular warning appears.

In this case, division by zero leads to computations with and/or , making the computed result unreliable.

### Least-Squares Solution of Underdetermined System

Solve a system of linear equations, .

### Linear System with Sparse Matrix

Solve a simple system of linear equations using sparse matrices.

Consider the matrix equation .

### Input Arguments

collapse all

### , &#; Operands

vectors | full matrices | sparse matrices

Operands, specified as vectors, full matrices, or sparse matrices. and must have the same number of rows.

If or has an integer data type, the other input must be scalar. Operands with an integer data type cannot be complex.

**Data Types: ** | | | | | | | | | | | **Complex Number Support: **Yes

### Output Arguments

collapse all

### &#; Solution

vector | full matrix | sparse matrix

Solution, returned as a vector, full matrix, or sparse matrix. If is an -by- matrix and is an -by- matrix, then is an -by- matrix, including the case when .

If has full storage, is also full. If is sparse, then has the same storage as .

### Tips

The operators and are related to each other by the equation .

If is a square matrix, then is roughly equal to , but MATLAB processes differently and more robustly.

If the rank of is less than the number of columns in , then is not necessarily the minimum norm solution. You can compute the minimum norm least-squares solution using or .

Use objects to efficiently solve a linear system multiple times with different right-hand sides. objects are well-suited to solving problems that require repeated solutions, since the decomposition of the coefficient matrix does not need to be performed multiple times.

### Algorithms

collapse all

The versatility of in solving linear systems stems from its ability to take advantage of symmetries in the problem by dispatching to an appropriate solver. This approach aims to minimize computation time. The first distinction the function makes is between *full* (also called “*dense*”) and *sparse* input arrays.

### Algorithm for Full Inputs

The flow chart below shows the algorithm path when inputs and are **full**.

### Algorithm for Sparse Inputs

If is full and is sparse then converts to a full matrix and uses the full algorithm path (above) to compute a solution with full storage. If is sparse, the storage of the solution is the same as that of and follows the algorithm path for **sparse** inputs, shown below.

### Extended Capabilities

### Tall Arrays

Calculate with arrays that have more rows than fit in memory.

This function supports tall arrays with the limitation:

For the syntax , the array must be a scalar or a tall matrix with the same number of rows as .

For more information, see Tall Arrays for Out-of-Memory Data.

### C/C++ Code Generation

Generate C and C++ code using MATLAB&#; Coder&#;.

Usage notes and limitations:

For sparse matrix inputs, the language standard must be C99 or later.

### GPU Code Generation

Generate CUDA&#; code for NVIDIA&#; GPUs using GPU Coder&#;.

Usage notes and limitations:

For sparse matrix inputs, the language standard must be C99 or later.

### Thread-Based Environment

Run code in the background using MATLAB&#; or accelerate code with Parallel Computing Toolbox&#; .

This function fully supports thread-based environments. For more information, see Run MATLAB Functions in Thread-Based Environment.

### GPU Arrays

Accelerate code by running on a graphics processing unit (GPU) using Parallel Computing Toolbox&#;.

Usage notes and limitations:

If is rectangular, then it must also be nonsparse.

The MATLAB function prints a warning if is badly scaled, nearly singular, or rank deficient. The is unable to check for this condition. Take action to avoid this condition.

bit integers are not supported.

For more information, see Run MATLAB Functions on a GPU (Parallel Computing Toolbox).

### Distributed Arrays

Partition large arrays across the combined memory of your cluster using Parallel Computing Toolbox&#;.

Usage notes and limitations:

The MATLAB function prints a warning if is badly scaled, nearly singular, or rank deficient. The distributed array is unable to check for this condition. Take action to avoid this condition.

If is an M-by-N complex matrix with N > M, for distributed arrays, computes a solution that minimizes . The result is the same as the result of .

For more information, see Run MATLAB Functions with Distributed Arrays (Parallel Computing Toolbox).

**Introduced before Ra**

You have a modified version of this example. Do you want to open this example with your edits?

You clicked a link that corresponds to this MATLAB command:

Run the command by entering it in the MATLAB Command Window. Web browsers do not support MATLAB commands.

Choose a web site to get translated content where available and see local events and offers. Based on your location, we recommend that you select: .

Select web siteYou can also select a web site from the following list:

### How to Get Best Site Performance

Select the China site (in Chinese or English) for best site performance. Other MathWorks country sites are not optimized for visits from your location.

Contact your local office

## Matrix system solve matlab

## Select a Web Site

### Solve System of Linear Equations

This section shows you how to solve a system of linear equations using the Symbolic Math Toolbox&#x;.

### Solve System of Linear Equations Using linsolve

A system of linear equations

can be represented as the matrix equation , where *A* is the coefficient matrix,

and is the vector containing the right sides of equations,

If you do not have the system of linear equations in the form , use to convert the equations into this form. Consider the following system.

Declare the system of equations.

Use to convert the equations into the form . The second input to specifies the independent variables in the equations.

Use to solve for the vector of unknowns .

From , *x* = 3, *y* = 1 and *z* =

### Solve System of Linear Equations Using solve

Use instead of if you have the equations in the form of expressions and not a matrix of coefficients. Consider the same system of linear equations.

Declare the system of equations.

Solve the system of equations using . The inputs to are a vector of equations, and a vector of variables to solve the equations for.

returns the solutions in a structure array. To access the solutions, index into the array.

### Related Topics

## Select a Web Site

### Systems of Linear Equations

### Computational Considerations

One of the most important problems in technical computing is the solution of systems of simultaneous linear equations.

In matrix notation, the general problem takes the following form: Given two matrices *A* and *b*, does there exist a unique matrix *x*, so that *A**x*= *b* or *x**A*= *b*?

It is instructive to consider a 1-by-1 example. For example, does the equation

7*x* = 21

have a unique solution?

The answer, of course, is yes. The equation has the unique solution *x* = 3. The solution is easily obtained by division:

*x* = 21/7 = 3.

The solution is *not* ordinarily obtained by computing the inverse of 7, that is 7^{&#;1}= , and then multiplying 7^{&#;1} by This would be more work and, if 7^{&#;1} is represented to a finite number of digits, less accurate. Similar considerations apply to sets of linear equations with more than one unknown; MATLAB^{®} solves such equations without computing the inverse of the matrix.

Although it is not standard mathematical notation, MATLAB uses the division terminology familiar in the scalar case to describe the solution of a general system of simultaneous equations. The two division symbols, *slash*, /, and *backslash*, \, correspond to the two MATLAB functions and . These operators are used for the two situations where the unknown matrix appears on the left or right of the coefficient matrix:

Denotes the solution to the matrix equation | |

Denotes the solution to the matrix equation |

Think of “dividing” both sides of the equation *Ax* = *b* or *xA* = *b* by *A*. The coefficient matrix is always in the “denominator.”

The dimension compatibility conditions for require the two matrices and to have the same number of rows. The solution then has the same number of columns as and its row dimension is equal to the column dimension of . For , the roles of rows and columns are interchanged.

In practice, linear equations of the form *Ax* = *b* occur more frequently than those of the form *xA* = *b*. Consequently, the backslash is used far more frequently than the slash. The remainder of this section concentrates on the backslash operator; the corresponding properties of the slash operator can be inferred from the identity:

The coefficient matrix need not be square. If has size *m*-by-*n*, then there are three cases:

m = n | Square system. Seek an exact solution. |

m > n | Overdetermined system, with more equations than unknowns. Find a least-squares solution. |

m < n | Underdetermined system, with fewer equations than unknowns. Find a basic solution with at most |

#### The mldivide Algorithm

The operator employs different solvers to handle different kinds of coefficient matrices. The various cases are diagnosed automatically by examining the coefficient matrix. For more information, see the “Algorithms” section of the reference page.

### General Solution

The general solution to a system of linear equations *Ax*= *b* describes all possible solutions. You can find the general solution by:

Solving the corresponding homogeneous system

*Ax*=*0*. Do this using the command, by typing . This returns a basis for the solution space to*Ax*=*0*. Any solution is a linear combination of basis vectors.Finding a particular solution to the nonhomogeneous system

*Ax*=*b*.

You can then write any solution to *Ax*= *b* as the sum of the particular solution to *Ax* =*b*, from step 2, plus a linear combination of the basis vectors from step 1.

The rest of this section describes how to use MATLAB to find a particular solution to *Ax* =*b*, as in step 2.

### Square Systems

The most common situation involves a square coefficient matrix and a single right-hand side column vector .

#### Nonsingular Coefficient Matrix

If the matrix is nonsingular, then the solution, , is the same size as . For example:

It can be confirmed that is exactly equal to .

If and are square and the same size, is also that size:

It can be confirmed that is exactly equal to .

Both of these examples have exact, integer solutions. This is because the coefficient matrix was chosen to be , which is a full rank matrix (nonsingular).

#### Singular Coefficient Matrix

A square matrix *A* is singular if it does not have linearly independent columns. If *A* is singular, the solution to *Ax* = *b* either does not exist, or is not unique. The backslash operator, , issues a warning if is nearly singular or if it detects exact singularity.

If *A* is singular and *Ax* = *b* has a solution, you can find a particular solution that is not unique, by typing

is a pseudoinverse of *A*. If *Ax* = *b* does not have an exact solution, then returns a least-squares solution.

For example:

is singular, as you can verify by typing

Since *A* is not full rank, it has some singular values equal to zero.

**Exact Solutions.** For , the equation *Ax* = *b* has an exact solution, given by

Verify that is an exact solution by typing

**Least-Squares Solutions.** However, if , *Ax* = *b* does not have an exact solution. In this case, returns a least-squares solution. If you type

you do not get back the original vector .

You can determine whether *Ax* =*b* has an exact solution by finding the row reduced echelon form of the augmented matrix . To do so for this example, enter

Since the bottom row contains all zeros except for the last entry, the equation does not have a solution. In this case, returns a least-squares solution.

### Overdetermined Systems

This example shows how overdetermined systems are often encountered in various kinds of curve fitting to experimental data.

A quantity is measured at several different values of time to produce the following observations. You can enter the data and view it in a table with the following statements.

*6×2 table*t y ___ ____ 0

Try modeling the data with a decaying exponential function

.

The preceding equation says that the vector should be approximated by a linear combination of two other vectors. One is a constant vector containing all ones and the other is the vector with components . The unknown coefficients, and , can be computed by doing a least-squares fit, which minimizes the sum of the squares of the deviations of the data from the model. There are six equations in two unknowns, represented by a 6-by-2 matrix.

*6×2*

Use the backslash operator to get the least-squares solution.

In other words, the least-squares fit to the data is

The following statements evaluate the model at regularly spaced increments in , and then plot the result together with the original data:

is not exactly equal to , but the difference might well be less than measurement errors in the original data.

A rectangular matrix is rank deficient if it does not have linearly independent columns. If is rank deficient, then the least-squares solution to is not unique. issues a warning if is rank deficient and produces a least-squares solution. You can use to find the solution that has the minimum norm among all solutions.

### Underdetermined Systems

This example shows how the solution to underdetermined systems is not unique. Underdetermined linear systems involve more unknowns than equations. The matrix left division operation in MATLAB finds a basic least-squares solution, which has at most nonzero components for an -by- coefficient matrix.

Here is a small, random example:

The linear system involves two equations in four unknowns. Since the coefficient matrix contains small integers, it is appropriate to use the command to display the solution in rational format. The particular solution is obtained with

One of the nonzero components is because is the column of with largest norm. The other nonzero component is because dominates after is eliminated.

The complete general solution to the underdetermined system can be characterized by adding to an arbitrary linear combination of the null space vectors, which can be found using the function with an option requesting a rational basis.

It can be confirmed that is zero and that the residual is small for any vector , where

Since the columns of are the null space vectors, the product is a linear combination of those vectors:

To illustrate, choose an arbitrary and construct .

Calculate the norm of the residual.

When infinitely many solutions are available, the solution with minimum norm is of particular interest. You can use to compute the minimum-norm least-squares solution. This solution has the smallest possible value for .

### Solving for Several Right-Hand Sides

Some problems are concerned with solving linear systems that have the same coefficient matrix , but different right-hand sides . When the different values of are available at the same time, you can construct as a matrix with several columns and solve all of the systems of equations at the same time using a single backslash command: .

However, sometimes the different values of are not all available at the same time, which means you need to solve several systems of equations consecutively. When you solve one of these systems of equations using slash (/) or backslash (\), the operator factorizes the coefficient matrix and uses this matrix decomposition to compute the solution. However, each subsequent time you solve a similar system of equations with a different , the operator computes the same decomposition of , which is a redundant computation.

The solution to this problem is to precompute the decomposition of , and then reuse the factors to solve for the different values of . In practice, however, precomputing the decomposition in this manner can be difficult since you need to know which decomposition to compute (LU, LDL, Cholesky, and so on) as well as how to multiply the factors to solve the problem. For example, with LU decomposition you need to solve two linear systems to solve the original system *Ax = b*:

Instead, the recommended method for solving linear systems with several consecutive right-hand sides is to use objects. These objects enable you to leverage the performance benefits of precomputing the matrix decomposition, but they *do not* require knowledge of how to use the matrix factors. You can replace the previous LU decomposition with:

If you are unsure which decomposition to use, chooses the correct type based on the properties of , similar to what backslash does.

Here is a simple test of the possible performance benefits of this approach. The test solves the same sparse linear system times using both backslash (\) and .

For this problem, the solution is much faster than using backslash alone, yet the syntax remains simple.

### Iterative Methods

If the coefficient matrix A is large and sparse, factorization methods are generally not efficient. *Iterative methods* generate a series of approximate solutions. MATLAB provides several iterative methods to handle large, sparse input matrices.

Function | Description |
---|---|

Preconditioned conjugate gradients method. This method is appropriate for Hermitian positive definite coefficient matrix A. | |

BiConjugate Gradients Method | |

BiConjugate Gradients Stabilized Method | |

BiCGStab(l) Method | |

Conjugate Gradients Squared Method | |

Generalized Minimum Residual Method | |

LSQR Method | |

Minimum Residual Method. This method is appropriate for Hermitian coefficient matrix A. | |

Quasi-Minimal Residual Method | |

Symmetric LQ Method | |

Transpose-Free QMR Method |

### Multithreaded Computation

MATLAB supports multithreaded computation for a number of linear algebra and element-wise numerical functions. These functions automatically execute on multiple threads. For a function or expression to execute faster on multiple CPUs, a number of conditions must be true:

The function performs operations that easily partition into sections that execute concurrently. These sections must be able to execute with little communication between processes. They should require few sequential operations.

The data size is large enough so that any advantages of concurrent execution outweigh the time required to partition the data and manage separate execution threads. For example, most functions speed up only when the array contains several thousand elements or more.

The operation is not memory-bound; processing time is not dominated by memory access time. As a general rule, complicated functions speed up more than simple functions.

, , , and show significant increase in speed on large double-precision arrays (on order of 10, elements or more) when multithreading is enabled.

### See Also

| | | |

### Related Topics

### Similar news:

- Charlottesville va rentals
- Lisa gomez age
- Prestamos sin tener credito
- Modular sit in kayak
- Custom off white presto
- Princess room ideas
- Gold round metal arch
- Weather longview wa
- 09g transmission fluid change
- 15 ft inflatable pool
- Roku 3 vs 4

In the last meeting, her anus was already well developed, so now the member easily slipped inside. Falmerka sighed, completely relaxed. Orc, with a smile from ear to ear, began to fuck her in the ass. Keeping his hands on the buttocks of the falmerka, he gouged her rectum, as if driving piles.

**18624**18625 18626