(103.416 < 27.1821) is generated in about 1 second.
[6.3] Improving floating-point solutions to simultaneous equations
Round-off errors in matrix calculations can create errors larger than you might expect when finding
solutions to simultaneous equations with simult(). The closer the matrix is to being singular, the worse
the error becomes. In many cases this error can be reduced, as follows.
Suppose we want to find the solution vector x in
[1]
A $ x = b
We would use
simult(A,b)→x
However, because of round-off error, this function really returns x with an error of dx, which results in b
being in error by db, or
[2]
A
$
(
x + dx
)
= b + db
Subtracting [1] from [2], we get
[3]
A $ dx = db
Solve [2] for db, and substitute into [3] to get
[4]
A
$
dx = A
$
(
x + dx
)
− b
Since we know everything on the right-hand side of [4], we can solve [4] for dx:
[5]
dx = A
−1
$ A $
(
x + dx
)
− b
So, if we subtract dx from the original solution (x+dx), we get a better estimate of the real solution x.
Usually, equation [5] is evaluated in double precision, with the intent of getting results that are at least
accurate to single precision. Even though the 89/92+ do not have double precision arithmetic, this
process still results in some improvement. It is also common to apply the improvement process several
times, to ensure convergence and to find an optimal solution. However, the limited precision of the
89/92+ usually prevent this type of repetitive improvment. Repeating the improvement process results
in a solution with more error.
Here is a function that returns the improved solution:
simulti(A,b)
func
local x
simult(A,b)→x
x-(A^⁻1*(A*x-b))
Endfunc
6 - 2
To Next Page
Loading...
Need help?
General
