Formerly, ```formatfloat``` struggled with formatting exact powers of 10
as created by ```parsenum``` because of small differences in how those
powers of 10 were calculated: ```formatfloat``` multiplied together a few
values of 10^(2^Y) from a lookup table, but ```parsenum``` used
```pow(10, X)```.  This was mitigated in micropython#8905 by adding 2eps of extra
margin when comparing values ("aggressive rounding up").

This patch instead eliminates the discrepency by using ```pow()``` in
```formatfloat``` also.  This eliminates the need for the 2eps margin, as
well as the lookup tables.  It is likely slower to run, however.

In addition, this patch directly estimates the power-of-10 exponent from
the power-of-2 exponent in the floating-point representation.

This change surfaced a previously-noted problem with parsing numbers
including trailing zeros.  The fix to that problem, micropython#8980, is included
in this PR to ensure the tests pass.

Signed-off-by: Dan Ellis <dan.ellis@gmail.com>

Formerly, ```formatfloat``` struggled with formatting exact powers of 10
as created by ```parsenum``` because of small differences in how those
powers of 10 were calculated: ```formatfloat``` multiplied together a few
values of 10^(2^Y) from a lookup table, but ```parsenum``` used
```pow(10, X)```.  This was mitigated in micropython#8905 by adding 2eps of extra
margin when comparing values ("aggressive rounding up").

This patch instead eliminates the discrepency by using ```pow()``` in
```formatfloat``` also.  This eliminates the need for the 2eps margin, as
well as the lookup tables.  It is likely slower to run, however.

In addition, this patch directly estimates the power-of-10 exponent from
the power-of-2 exponent in the floating-point representation.

This change surfaced a previously-noted problem with parsing numbers
including trailing zeros.  The fix to that problem, micropython#8980, is included
in this PR to ensure the tests pass.

Signed-off-by: Dan Ellis <dan.ellis@gmail.com>

Formerly, ```formatfloat``` struggled with formatting exact powers of 10
as created by ```parsenum``` because of small differences in how those
powers of 10 were calculated: ```formatfloat``` multiplied together a few
values of 10^(2^Y) from a lookup table, but ```parsenum``` used
```pow(10, X)```.  This was mitigated in micropython#8905 by adding 2eps of extra
margin when comparing values ("aggressive rounding up").

This patch instead eliminates the discrepency by using ```pow()``` in
```formatfloat``` also.  This eliminates the need for the 2eps margin, as
well as the lookup tables.  It is likely slower to run, however.

In addition, this patch directly estimates the power-of-10 exponent from
the power-of-2 exponent in the floating-point representation.

This change surfaced a previously-noted problem with parsing numbers
including trailing zeros.  The fix to that problem, micropython#8980, is included
in this PR to ensure the tests pass.

Signed-off-by: Dan Ellis <dan.ellis@gmail.com>

Formerly, ```formatfloat``` struggled with formatting exact powers of 10
as created by ```parsenum``` because of small differences in how those
powers of 10 were calculated: ```formatfloat``` multiplied together a few
values of 10^(2^Y) from a lookup table, but ```parsenum``` used
```pow(10, X)```.  This was mitigated in micropython#8905 by adding 2eps of extra
margin when comparing values ("aggressive rounding up").

This patch instead removes the discrepency by using ```pow()``` in
```formatfloat``` also.  This eliminates the need for the 2eps margin, as
well as the lookup tables.  It is likely slower to run, however.

In addition, this patch directly estimates the power-of-10 exponent from
the power-of-2 exponent in the floating-point representation.

This change surfaced a previously-noted problem with parsing numbers
including trailing zeros.  The fix to that problem, micropython#8980, is included
in this PR to ensure the tests pass.

Signed-off-by: Dan Ellis <dan.ellis@gmail.com>

Formerly, ```formatfloat``` struggled with formatting exact powers of 10
as created by ```parsenum``` because of small differences in how those
powers of 10 were calculated: ```formatfloat``` multiplied together a few
values of 10^(2^Y) from a lookup table, but ```parsenum``` used
```pow(10, X)```.  This was mitigated in micropython#8905 by adding 2eps of extra
margin when comparing values ("aggressive rounding up").

This patch instead removes the discrepency by using ```pow()``` in
```formatfloat``` also.  This eliminates the need for the 2eps margin, as
well as the lookup tables.  It is likely slower to run, however.

In addition, this patch directly estimates the power-of-10 exponent from
the power-of-2 exponent in the floating-point representation.

This change surfaced a previously-noted problem with parsing numbers
including trailing zeros.  The fix to that problem, micropython#8980, is included
in this PR to make the tests pass.

Signed-off-by: Dan Ellis <dan.ellis@gmail.com>

Formerly, ```formatfloat``` struggled with formatting exact powers of 10
as created by ```parsenum``` because of small differences in how those
powers of 10 were calculated: ```formatfloat``` multiplied together a few
values of 10^(2^Y) from a lookup table, but ```parsenum``` used
```pow(10, X)```.  This was mitigated in micropython#8905 by adding 2eps of extra
margin when comparing values ("aggressive rounding up").

This patch instead removes the discrepency by using ```pow()``` in
```formatfloat``` also.  This eliminates the need for the 2eps margin, as
well as the lookup tables.  It is likely slower to run, however.

In addition, this patch directly estimates the power-of-10 exponent from
the power-of-2 exponent in the floating-point representation.

This change surfaced a previously-noted problem with parsing numbers
including trailing zeros.  The fix to that problem, micropython#8980, is included
in this PR to make the tests pass.

Signed-off-by: Dan Ellis <dan.ellis@gmail.com>

Formerly, ```formatfloat``` struggled with formatting exact powers of 10
as created by ```parsenum``` because of small differences in how those
powers of 10 were calculated: ```formatfloat``` multiplied together a few
values of 10^(2^Y) from a lookup table, but ```parsenum``` used
```pow(10, X)```.  This was mitigated in micropython#8905 by adding 2eps of extra
margin when comparing values ("aggressive rounding up").

This patch instead removes the discrepency by using ```pow()``` in
```formatfloat``` also.  This eliminates the need for the 2eps margin, as
well as the lookup tables.  It is likely slower to run, however.

In addition, this patch directly estimates the power-of-10 exponent from
the power-of-2 exponent in the floating-point representation.

This change surfaced a previously-noted problem with parsing numbers
including trailing zeros.  The fix to that problem, micropython#8980, is included
in this PR to make the tests pass.

Signed-off-by: Dan Ellis <dan.ellis@gmail.com>

Formerly, ```formatfloat``` struggled with formatting exact powers of 10
as created by ```parsenum``` because of small differences in how those
powers of 10 were calculated: ```formatfloat``` multiplied together a few
values of 10^(2^Y) from a lookup table, but ```parsenum``` used
```pow(10, X)```.  This was mitigated in micropython#8905 by adding 2eps of extra
margin when comparing values ("aggressive rounding up").

This patch instead removes the discrepency by using ```pow()``` in
```formatfloat``` also.  This eliminates the need for the 2eps margin, as
well as the lookup tables.  It is likely slower to run, however.

In addition, this patch directly estimates the power-of-10 exponent from
the power-of-2 exponent in the floating-point representation.

This change surfaced a previously-noted problem with parsing numbers
including trailing zeros.  The fix to that problem, micropython#8980, is included
in this PR to make the tests pass.

Signed-off-by: Dan Ellis <dan.ellis@gmail.com>

Formerly, ```formatfloat``` struggled with formatting exact powers of 10
as created by ```parsenum``` because of small differences in how those
powers of 10 were calculated: ```formatfloat``` multiplied together a few
values of 10^(2^Y) from a lookup table, but ```parsenum``` used
```pow(10, X)```.  This was mitigated in micropython#8905 by adding 2eps of extra
margin when comparing values ("aggressive rounding up").

This patch instead removes the discrepency by using ```pow()``` in
```formatfloat``` also.  This eliminates the need for the 2eps margin, as
well as the lookup tables.  It is likely slower to run, however.

In addition, this patch directly estimates the power-of-10 exponent from
the power-of-2 exponent in the floating-point representation.

This change surfaced a previously-noted problem with parsing numbers
including trailing zeros.  The fix to that problem, micropython#8980, is included
in this PR to make the tests pass.

Signed-off-by: Dan Ellis <dan.ellis@gmail.com>

Formerly, ```formatfloat``` struggled with formatting exact powers of 10
as created by ```parsenum``` because of small differences in how those
powers of 10 were calculated: ```formatfloat``` multiplied together a few
values of 10^(2^Y) from a lookup table, but ```parsenum``` used
```pow(10, X)```.  This was mitigated in micropython#8905 by adding 2eps of extra
margin when comparing values ("aggressive rounding up").

This patch instead removes the discrepency by using ```pow()``` in
```formatfloat``` also.  This eliminates the need for the 2eps margin, as
well as the lookup tables.  It is likely slower to run, however.

In addition, this patch directly estimates the power-of-10 exponent from
the power-of-2 exponent in the floating-point representation.

This change surfaced a previously-noted problem with parsing numbers
including trailing zeros.  The fix to that problem, micropython#8980, is included
in this PR to make the tests pass.

Signed-off-by: Dan Ellis <dan.ellis@gmail.com>

Formerly, ```formatfloat``` struggled with formatting exact powers of 10
as created by ```parsenum``` because of small differences in how those
powers of 10 were calculated: ```formatfloat``` multiplied together a few
values of 10^(2^Y) from a lookup table, but ```parsenum``` used
```pow(10, X)```.  This was mitigated in micropython#8905 by adding 2eps of extra
margin when comparing values ("aggressive rounding up").

This patch instead removes the discrepency by using ```pow()``` in
```formatfloat``` also.  This eliminates the need for the 2eps margin, as
well as the lookup tables.  It is likely slower to run, however.

In addition, this patch directly estimates the power-of-10 exponent from
the power-of-2 exponent in the floating-point representation.

This change surfaced a previously-noted problem with parsing numbers
including trailing zeros.  The fix to that problem, micropython#8980, is included
in this PR to make the tests pass.

Signed-off-by: Dan Ellis <dan.ellis@gmail.com>

Formerly, ```formatfloat``` struggled with formatting exact powers of 10
as created by ```parsenum``` because of small differences in how those
powers of 10 were calculated: ```formatfloat``` multiplied together a few
values of 10^(2^Y) from a lookup table, but ```parsenum``` used
```pow(10, X)```.  This was mitigated in micropython#8905 by adding 2eps of extra
margin when comparing values ("aggressive rounding up").

This patch instead removes the discrepency by using ```pow()``` in
```formatfloat``` also.  This eliminates the need for the 2eps margin, as
well as the lookup tables.  It is likely slower to run, however.

In addition, this patch directly estimates the power-of-10 exponent from
the power-of-2 exponent in the floating-point representation.

This change surfaced a previously-noted problem with parsing numbers
including trailing zeros.  The fix to that problem, micropython#8980, is included
in this PR to make the tests pass.

Signed-off-by: Dan Ellis <dan.ellis@gmail.com>

Formerly, ```formatfloat``` struggled with formatting exact powers of 10
as created by ```parsenum``` because of small differences in how those
powers of 10 were calculated: ```formatfloat``` multiplied together a few
values of 10^(2^Y) from a lookup table, but ```parsenum``` used
```pow(10, X)```.  This was mitigated in micropython#8905 by adding 2eps of extra
margin when comparing values ("aggressive rounding up").

This patch instead removes the discrepency by using ```pow()``` in
```formatfloat``` also.  This eliminates the need for the 2eps margin, as
well as the lookup tables.  It is likely slower to run, however.

In addition, this patch directly estimates the power-of-10 exponent from
the power-of-2 exponent in the floating-point representation.

This change surfaced a previously-noted problem with parsing numbers
including trailing zeros.  The fix to that problem, micropython#8980, is included
in this PR to make the tests pass.

Signed-off-by: Dan Ellis <dan.ellis@gmail.com>

Formerly, ```formatfloat``` struggled with formatting exact powers of 10
as created by ```parsenum``` because of small differences in how those
powers of 10 were calculated: ```formatfloat``` multiplied together a few
values of 10^(2^Y) from a lookup table, but ```parsenum``` used
```pow(10, X)```.  This was mitigated in micropython#8905 by adding 2eps of extra
margin when comparing values ("aggressive rounding up").

This patch instead removes the discrepency by using ```pow()``` in
```formatfloat``` also.  This eliminates the need for the 2eps margin, as
well as the lookup tables.  It is likely slower to run, however.

In addition, this patch directly estimates the power-of-10 exponent from
the power-of-2 exponent in the floating-point representation.

This change surfaced a previously-noted problem with parsing numbers
including trailing zeros.  The fix to that problem, micropython#8980, is included
in this PR to make the tests pass.

Signed-off-by: Dan Ellis <dan.ellis@gmail.com>

I tested this by fetching a .txt file repeatedly using curl while
running the fancy camera demo. (100+ times without failure). I also
repeatedly loaded the filesystem view http://.../fs/#/sd/ which worked
10+ times without failure, but does take some time (multiple seconds) to
show a listing with a few dozen files.

(I suspect there's an accidentally quadratic behavior in oofatfs to stat
every file in a directory, because it repeatedly does a linear search of
the directory for the stat information of each file, but that's not an
issue for Right Now(TM))

Closes: micropython#8980