﻿ f07th Method
f07th returns error bounds for the solution of a real triangular system of linear equations with multiple right-hand sides, $AX=B$ or ${A}^{\mathrm{T}}X=B$.

# Syntax

C#
```public static void f07th(
string uplo,
string trans,
string diag,
int n,
int nrhs,
double[,] a,
double[,] b,
double[,] x,
double[] ferr,
double[] berr,
out int info
)```
Visual Basic
```Public Shared Sub f07th ( _
uplo As String, _
trans As String, _
diag As String, _
n As Integer, _
nrhs As Integer, _
a As Double(,), _
b As Double(,), _
x As Double(,), _
ferr As Double(), _
berr As Double(), _
<OutAttribute> ByRef info As Integer _
)```
Visual C++
```public:
static void f07th(
String^ uplo,
String^ trans,
String^ diag,
int n,
int nrhs,
array<double,2>^ a,
array<double,2>^ b,
array<double,2>^ x,
array<double>^ ferr,
array<double>^ berr,
[OutAttribute] int% info
)```
F#
```static member f07th :
uplo : string *
trans : string *
diag : string *
n : int *
nrhs : int *
a : float[,] *
b : float[,] *
x : float[,] *
ferr : float[] *
berr : float[] *
info : int byref -> unit
```

#### Parameters

uplo
Type: System..::..String
On entry: specifies whether $A$ is upper or lower triangular.
${\mathbf{uplo}}=\text{"U"}$
$A$ is upper triangular.
${\mathbf{uplo}}=\text{"L"}$
$A$ is lower triangular.
Constraint: ${\mathbf{uplo}}=\text{"U"}$ or $\text{"L"}$.
trans
Type: System..::..String
On entry: indicates the form of the equations.
${\mathbf{trans}}=\text{"N"}$
The equations are of the form $AX=B$.
${\mathbf{trans}}=\text{"T"}$ or $\text{"C"}$
The equations are of the form ${A}^{\mathrm{T}}X=B$.
Constraint: ${\mathbf{trans}}=\text{"N"}$, $\text{"T"}$ or $\text{"C"}$.
diag
Type: System..::..String
On entry: indicates whether $A$ is a nonunit or unit triangular matrix.
${\mathbf{diag}}=\text{"N"}$
$A$ is a nonunit triangular matrix.
${\mathbf{diag}}=\text{"U"}$
$A$ is a unit triangular matrix; the diagonal elements are not referenced and are assumed to be $1$.
Constraint: ${\mathbf{diag}}=\text{"N"}$ or $\text{"U"}$.
n
Type: System..::..Int32
On entry: $n$, the order of the matrix $A$.
Constraint: ${\mathbf{n}}\ge 0$.
nrhs
Type: System..::..Int32
On entry: $r$, the number of right-hand sides.
Constraint: ${\mathbf{nrhs}}\ge 0$.
a
Type: array<System..::..Double,2>[,](,)[,][,]
An array of size [dim1, dim2]
Note: dim1 must satisfy the constraint: $\mathrm{dim1}\ge \mathrm{max}\phantom{\rule{0.125em}{0ex}}\left(1,{\mathbf{n}}\right)$
Note: the second dimension of the array a must be at least $\mathrm{max}\phantom{\rule{0.125em}{0ex}}\left(1,{\mathbf{n}}\right)$.
On entry: the $n$ by $n$ triangular matrix $A$.
• If ${\mathbf{uplo}}=\text{"U"}$, $A$ is upper triangular and the elements of the array below the diagonal are not referenced.
• If ${\mathbf{uplo}}=\text{"L"}$, $A$ is lower triangular and the elements of the array above the diagonal are not referenced.
• If ${\mathbf{diag}}=\text{"U"}$, the diagonal elements of $A$ are assumed to be $1$, and are not referenced.
b
Type: array<System..::..Double,2>[,](,)[,][,]
An array of size [dim1, dim2]
Note: dim1 must satisfy the constraint: $\mathrm{dim1}\ge \mathrm{max}\phantom{\rule{0.125em}{0ex}}\left(1,{\mathbf{n}}\right)$
Note: the second dimension of the array b must be at least $\mathrm{max}\phantom{\rule{0.125em}{0ex}}\left(1,{\mathbf{nrhs}}\right)$.
On entry: the $n$ by $r$ right-hand side matrix $B$.
x
Type: array<System..::..Double,2>[,](,)[,][,]
An array of size [dim1, dim2]
Note: dim1 must satisfy the constraint: $\mathrm{dim1}\ge \mathrm{max}\phantom{\rule{0.125em}{0ex}}\left(1,{\mathbf{n}}\right)$
Note: the second dimension of the array x must be at least $\mathrm{max}\phantom{\rule{0.125em}{0ex}}\left(1,{\mathbf{nrhs}}\right)$.
On entry: the $n$ by $r$ solution matrix $X$, as returned by f07te.
ferr
Type: array<System..::..Double>[]()[][]
An array of size [nrhs]
On exit: ${\mathbf{ferr}}\left[\mathit{j}-1\right]$ contains an estimated error bound for the $\mathit{j}$th solution vector, that is, the $\mathit{j}$th column of $X$, for $\mathit{j}=1,2,\dots ,r$.
berr
Type: array<System..::..Double>[]()[][]
An array of size [nrhs]
On exit: ${\mathbf{berr}}\left[\mathit{j}-1\right]$ contains the component-wise backward error bound $\beta$ for the $\mathit{j}$th solution vector, that is, the $\mathit{j}$th column of $X$, for $\mathit{j}=1,2,\dots ,r$.
info
Type: System..::..Int32%
On exit: ${\mathbf{info}}=0$ unless the method detects an error (see [Error Indicators and Warnings]).

# Description

f07th returns the backward errors and estimated bounds on the forward errors for the solution of a real triangular system of linear equations with multiple right-hand sides $AX=B$ or ${A}^{\mathrm{T}}X=B$. The method handles each right-hand side vector (stored as a column of the matrix $B$) independently, so we describe the function of f07th in terms of a single right-hand side $b$ and solution $x$.
Given a computed solution $x$, the method computes the component-wise backward error $\beta$. This is the size of the smallest relative perturbation in each element of $A$ and $b$ such that $x$ is the exact solution of a perturbed system
 $A+δAx=b+δbδaij≤βaij and δbi≤βbi.$
Then the method estimates a bound for the component-wise forward error in the computed solution, defined by:
 $maxixi-x^i/maxixi$
where $\stackrel{^}{x}$ is the true solution.
For details of the method, see the F07 class.

# References

Golub G H and Van Loan C F (1996) Matrix Computations (3rd Edition) Johns Hopkins University Press, Baltimore

# Error Indicators and Warnings

Some error messages may refer to parameters that are dropped from this interface (LDA, LDB, LDX) In these cases, an error in another parameter has usually caused an incorrect value to be inferred.
${\mathbf{info}}<0$
If ${\mathbf{info}}=-i$, argument $i$ had an illegal value. An explanatory message is output, and execution of the program is terminated.
${\mathbf{ifail}}=-9000$
An error occured, see message report.
${\mathbf{ifail}}=-6000$
Invalid Parameters $〈\mathit{\text{value}}〉$
${\mathbf{ifail}}=-4000$
Invalid dimension for array $〈\mathit{\text{value}}〉$
${\mathbf{ifail}}=-8000$
Negative dimension for array $〈\mathit{\text{value}}〉$
${\mathbf{ifail}}=-6000$
Invalid Parameters $〈\mathit{\text{value}}〉$
${\mathbf{ifail}}=-6000$
Invalid Parameters $〈\mathit{\text{value}}〉$

# Accuracy

The bounds returned in ferr are not rigorous, because they are estimated, not computed exactly; but in practice they almost always overestimate the actual error.

# Parallelism and Performance

None.

A call to f07th, for each right-hand side, involves solving a number of systems of linear equations of the form $Ax=b$ or ${A}^{\mathrm{T}}x=b$; the number is usually $4$ or $5$ and never more than $11$. Each solution involves approximately ${n}^{2}$ floating-point operations.
The complex analogue of this method is (F07TVF not in this release).

# Example

This example solves the system of equations $AX=B$ and to compute forward and backward error bounds, where
 $A=4.300.000.000.00-3.96-4.870.000.000.400.31-8.020.00-0.270.07-5.950.12 and B=-12.90-21.5016.7514.93-17.556.33-11.048.09.$

Example program (C#): f07the.cs

Example program data: f07the.d

Example program results: f07the.r