My question is related to this one: Badly conditioned matrix (General::luc)

I’m trying to solve a linear system of the form A.x=b.
As suggested in the referenced post since I’m not really interested in the inverse MMA might preform better if solve the system using x=LinearSolve[A,b], so that’s what I do.

I still get a warning regarding the condition number, and the results I get later on in the computation (which are based on the solution to the linear system), do indeed show problems.

In the referenced post J.M.’s answer provides a way to determine if my matrix is indeed ill conditioned, but I don’t know how can I get a better solution in case it does.

Some technical details:

1. I’m solving this equation over and over again, each time with slightly different matrix A, in order to get down the line the value for each data point, thus I need some general solution as I cannot treat each ill conditioned case separately.
2. I’m a novice on the subject, but I only guess that if I could force MMA to work with better internal accuracy I would eliminate the problem, but there’s no such option as tolerance for the LinearSolve function, as there’s for other linear algebra functions. Am I right? Is there a workaround?
3. A technical detail that might help: my vector b is the same for all data points, and has the form: b={0,0,0,...,0,1}, i.e. all of its entries are zero except for the last one which is unity. This means that if I were to solve the system using inversion, I wouldn’t really need to find Inverse[A], but only its rightmost column. Would finding only this column be easier. I guess Cramer’s rule isn’t very helpful as calculating the determinant is just as bad (right?), but maybe there’s a different way which I’m unaware of?
4. I don’t know if it matters, but my matrix isn’t that large, and has dimensions of 16X16

Update per comments

I shall give more details, as perhaps I wan’t clear enough in the beginning:

1. I iteratively build matrices of dimensions 16X16, which hold numerical values. They all share the following structure:

   • They are rather sparse.
   • Most rows contain small values (with respect to the bottom one).
   • The entries on the diagonal are all non-zero negative values.
   • All other non-zero entries are positive.
   • The bottom row is all ones.
   • An example for one of my badly conditioned matrices (sorry about the formatting):
   • A={{-0.04000323497710545, 0.019998382511436725, 0.019998382511436725,
1.0548487421137532*^-14, 1.0548487421137532*^-14, 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0.,
0.}, {0.01999537041672573, -0.019998382511436725, 0., 0., 0.,
0.03999375292816244,
2.714439127491079*^-6, 3.123535918772422*^-6,
6.247071837545091*^-6, 4.09096791281486*^-7,
9.629649721936179*^-33, 0., 0.,
0., 0., 0.}, {0.01999537041672573, 0., -0.019998382511436725,
0., 0., 0.03999375292816244, 6.51319418358286*^-6,
3.123535918772422*^-6, 0., 2.857413572734654*^-6,
9.629649721936179*^-33, 0., 0., 0., 0., 0.},
{6.247071826996701*^-6, 0., 0., -1.0548487421137532*^-14, 0.,
3.4666738998970245*^-33, 0.017377838870198482,
0.01999687646408122, 0.03999375292816246, 0.002619037593882741,
6.247071837545974*^-6, 0., 0., 0., 0., 0.},
{6.247071826996701*^-6, 0., 0., 0., -1.0548487421137532*^-14,
3.4666738998970245*^-33, 0.041697468145927896,
0.01999687646408122, 0., 0.01829316124631577,
6.247071837545974*^-6, 0., 0., 0., 0., 0.},
{0., 0., 0., 0., 0., -0.07998750585632489, 0., 0., 0., 0., 0.,
6.247071837544959*^-6, 6.247071837544959*^-6,
1.9683065157343793*^-32, 1.0839021819949165*^-32, 0.}, {0., 0.,
0., 0., 0., 0., -0.059084534649437456, 0., 0., 0., 0.,
0.0035343599700000386, 0.017377838870198486,
2.7144391274860995*^-6, 5.520712365254425*^-7, 0.},
{0., 0., 0., 0., 0., 0., 0., -0.03999999999999999, 0., 0., 0.,
0.019996876464081232, 0.01999687646408122,
3.1235359187790123*^-6, 3.1235359187717977*^-6, 0.}, {0., 0.,
0., 0., 0., 0., 0., 0., -0.04, 0., 0., 0.,
0.03999375292816246, 6.2470718375337105*^-6, 0., 0.}, {0., 0.,
0., 0., 0., 0., 0., 0., 0., -0.020915465350562525, 0.,
0.05645626942224363, 0.0026190375938827423,
4.0909679128073285*^-7, 8.818536519796756*^-6, 0.},
{0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -0.000012494143675091948,
1.698670210949542*^-31, 5.827478825726898*^-30,
0.03999375292816246, 0.03999375292816246, 0.}, {0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., -0.07999375292816245, 0., 0.,
0., 6.247071837548034*^-6}, {0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., -0.07999375292816244, 0., 0.,
6.247071837533809*^-6}, {0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., -0.04000624707183754, 0.,
0.03999375292816247}, {0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., -0.04000624707183755, 0.03999375292816246},
{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}}

2. For each of my created matrices I want to solve the equation: $Ax=b$, where $b$ is the constant vector (always the same) b={0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1} (All zeros with one at the end).

3. Currently I use LinearSolve[A,b]. As said before, for each iteration A is slightly different. For some iterations this works well, and for others (like the example I gave here), I get a warning regarding the condition number, and possible numerical error.

4. The question is as before, what can I do to improve the solutions I get. I emphasize that I the solution must be general enough that it can be incorporated into my iterations, when a warning is returned (This can by done using Check for instance to catch warnings).

Update 2

1. Perhaps I should’ve written it to begin with, but the singular nature of my matrix comes as no surprise, as since one of the eigenvalues is very close to zero (perhaps numerically it is), is the reason for the ill-conditioned nature of the matrix.
2. Thanks to Daniel’s and Bill’s suggestions, I’m still able to get satisfactory results.
3. I’m aware of the fact that my question wasn’t formulated in the best way, but I think the the solutions provided are worth keeping for others who might encounter similar issues. Thus I suggest removing the OnHold tag. How would you like me to rewrite the question?