0

Assume we're on a computer using 32-bit floats (or something similar), and I'm converting back and forth between the $n$ coefficients of a polynomial and the corresponding $n$ roots of the polynomial. Doing this conversion will obviously lead to some loss in precision. My question is: will this loss in precision be significant? Or in other words, is converting back and forth between coefficients and roots numerically stable? And does the stability significantly worsen for large $n$?

chausies
  • 2,438
  • 1
    This depends on how clustered the roots are. Clustered roots make for bad accuracy of the roots, in some sense the roots in a cluster share the available digits of precision. The Wilkinson example tells that clusters have to be identified on the complex sphere, as for example the root sequence $1,2,3,…,20$ is a cluster around the origin after reflection on the unit circle, which explains why the upper roots are so sensitive to coefficient perturbations. /// Some experiment on this or a related topic: https://math.stackexchange.com/questions/4323794/polynomial-for-very-large-number-of-roots – Lutz Lehmann Oct 22 '22 at 21:09
  • Virtually all computer programming languages (e.g. C, Java, Python, ...) have a large integer facility. Further, it is straight forward to [1] create a file of all prime numbers less than $(10)^5,$ use this file to compute the prime factorization of all positive integers less than $(10)^{(10)}.$ This type of processing should be close to instantaneous on a standard PC. ...see next comment – user2661923 Oct 22 '22 at 21:44
  • So, the only bar to manually ensuring as much accuracy as possible is the issue of how to programmatically handle an expression like (for example) $$1 + \sqrt{2}.$$ One way is to immediately convert this expression into $$\frac{N}{D},$$ where $N$ and $D$ are each positive integers somewhere below $(10)^{(500)}.$ The alternative (much more labor intensive programming) approach is to (very carefully) record this value as something like $1 + T$, where you are extremely careful what operations are performed on $T$, and where you don't resolve $T$ until the end of your program. – user2661923 Oct 22 '22 at 21:49
  • Connected: https://math.stackexchange.com/q/2444601/305862 – Jean Marie Oct 23 '22 at 00:21

0 Answers0