Since it sounds like you are running out of space at the low end, can't you just multiply all values by 10^10 and go from there?

Unfortunately not. the range is limited +-2, with iteration terminating when the addition of two components is > 4; so, I need more precision in the intermediate terms.

---

With the rise and rise of 'Social' network sites: 'Computers are making people easier to use everyday'

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority". I'm with torvalds on this

In the absence of evidence, opinion is indistinguishable from prejudice. Agile (and TDD) debunked

0.00000000000000002025 is 21 digits, so obviously you need more than 18 digits.

Using a single byte for the fixed point will get me down to +-1e-127

I think you are misunderstanding "fixed point". Fixed point means the exponent part is always the same. For example, with 64 bit signed integers:

• 0.0000000045 is represented by the integer value 450000000
• Your maximum value of 4.0 would be represented by the integer value 400000000000000000
• Your minimum, -4.0 would be -400000000000000000

But you need more than 18 digits, so you need to cascade. Though I misspoke. What you cascade depends the underlying hardware. For a PC with 64 bit integers, you need to cascade 3 or 4 32 bit integers to your needed digits. For a PC with 32 bit integers, you need to cascade at least 5 16 bit integers.

Let's assume your PC has 64 bit integers. To add 2 numbers, A and B, you split them into Ah, Am, Al, Bh, Bm and Bl, then do the additions:

/* C */
sint64_t A, B, Ah, Am, Al, Bh, Bm, Bl, Ch, Cl, /* etc */;
sint128 C;
Al = A & 0xFFFFFFFF;
Am = A >> 32;
Ah = A >> 64;
Bl = B & 0xFFFFFFFF;
Bm = A >> 32;
Bh = A >> 64;
Cl = Al + Bl;
Cm = Am + Bm + (Cl >> 32);
Ch = Ah + Bh + (Cm >> 32);
C = (Ch << 64) + ((Cm & 0xFFFFFFFF) << 32)  + (Cl & 0xFFFFFFFF);
[download]

Of course, there are some easy optimizations to this I leave as an exercise for the reader. Also leaving subtraction, multiplication and division as exercises for the reader.

Note: sint64_t and sint128_t are the C99 standard type names for "exactly 64/128 bit, signed integer"

Welcome to the world of "bit bashing".

I think you are misunderstanding "fixed point".

The point was that the programmer chooses where to fix the point. He can even have multiple fixed point types and move between them for different calculations or parts of the same calculation.

But you're right. At that point in the conversation I wasn't really thinking things through.

As I've looked into it more, I realise that I need more than 64-bits of precision.

---

With the rise and rise of 'Social' network sites: 'Computers are making people easier to use everyday'

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority". I'm with torvalds on this

In the absence of evidence, opinion is indistinguishable from prejudice. Agile (and TDD) debunked

0.00000000000000002025 which becomes 0.0000000000000000 with doubles.

Thinking on this more, I wonder if you are really having string-ification problem. Digits could be getting lost in that process. The value in normalized notation is 2.025 * 10^-17, which is well within the capabilities of doubles, which use double-precision floating-point format

Update: Fixed a typo.

I came back to look at your other post above, and noticed this one that I somehow missed before.

The value in normalized notation is 2.025 * 10^-17, which is well within the capabilities of doubles,

You're right of course, it is. Until you add it to a value in the range -1.xe0 .. 1.xe0; then it disappears.

---

With the rise and rise of 'Social' network sites: 'Computers are making people easier to use everyday'

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority". I'm with torvalds on this

In the absence of evidence, opinion is indistinguishable from prejudice. Agile (and TDD) debunked

Until you add it to a value in the range -1.xe0 .. 1.xe0; then it disappears.

Right. I had forgotten the addition from your original post.

I'm thinking that cascading 3 or 4 32 bit integers (as I demonstrated in an earlier post) to create 96 or 128 bit integers will get you what you are looking for.