How to solve Ax=b for large condition numbers - scipy

Question

I am dealing with highly ill-conditioned matrix (cond> 10^25).
I have tried most of scipy methods: splu, gmers solve
and pyamg.krylov.steepest_descent from PyAMG.
also iterative Refinement method:
def iterRef(A, b, tol=1e-5, maxiter=100, verbose=True):
"""
Solve the equation a x = b for x using Iterative Refinement method.
:param A: [(M,M) array_like] A square matrix.
:param b: [(M,) array like]Right-hand side matrix in a x = b.
:param maxIter: [int] max number of iteration for convergence.
:param t: #!
:return x: (M,) or (M, N) ndarray
Solution to the system a x = b. Shape of the return matches the shape of b.
**Reference:**
Burden, R.L. and Faires, J.D., 2011. Numerical analysis.
"""
# declarations
n = len(b)
xx = np.zeros_like(b)
r = np.zeros_like(b)
lu = splu(A)
x = lu.solve(b)
res = np.sum(A.dot(x)-b)
print("res :: A * x - b = {:e}".format(res))
# check if converged
if np.abs(res) < tol:
print("IR ::: A * x - b = {:e}".format(res))
return x
k = 1 # step 1
while (k <= maxiter): # step 2
r = b - A.dot(x) # step 3
y = lu.solve(r) # step 4
xx = copy(x + y) # step 5
if k == 1: # step 6
# t = 16
# COND = np.linalg.norm(y)/np.linalg.norm(xx) * 10**t
# print("cond is ::::", COND)
COND = np.linalg.cond(A.toarray())
norm_ = np.linalg.norm(x-xx) # * np.linalg.norm(x) * 1e10
print("iteration {:3d}, norm = {:e}".format(k, norm_))
if norm_ < tol: # step 7
if verbose:
print("Conditional number of matrix A is: {:e}".format(COND))
print("The procedure was successful.")
print("IR: A * x - b = {:e}".format(np.sum(A.dot(xx)-b)))
print(f"number of iteration is : {k:d}")
print(" ")
return xx
k += 1 # step 8
x = copy(xx) # step 9
print("Max iteration exceeded.")
print("The procedure was not successful.")
print("Conditional number of matrix A is: {:e}".format(COND))
print(" ")
return None
The accuracy depends on condition number and for larger ones, the accuracy disappears.
I tried some method from eigen3: Catalogue of decompositions offered by Eigen:
VectorXd x = A.partialPivLu().solve(b);
VectorXd x = A.fullPivLu().solve(b);
VectorXd x = A.bdcSvd(ComputeThinU | ComputeThinV).solve(b);
Here is the link to github for the full example in python and eigen.
It is possible to use Eigen modules with e.g quad precision or higher? Is there any example?
I am not sure we can do this with scipy modules.
output from C++ file is:
condition number is :3.16172e+28
The relative error for partialPivLu is 0.0000000000000011:
The relative error for fullPivLu is 0.0157277957331164:
The relative error for householderQr is 0.0000000000000020:
The relative error for colPivHouseholderQr is 0.0000000000577384:
The relative error for fullPivHouseholderQr is 0.0157277957331138:
The relative error for completeOrthogonalDecomposition is 0.0157277957331138:
The relative error for llt is -nan:
The relative error for ldlt is 0.0000000001045718:
The relative error for ldlt is 396613336624311706845184.0000000000000000:
The relative error for bdcSvd is 0.0157277957329992:
The relative error for jacobiSvd is 0.0157277957528586:
I put the python and C++ code in the link attached in case.