octaword, double quadword

on wikipedia i read about these types, but is it possible to declare and use them in C?

No, but then it depends on what does octaword and double quadword actually correspond to. Maybe a long or long long will suffice, or you could use an arbitrary precision arithmetic library.

Octaword is 16 bytes, no (8 * 2)? There is no such type in C. So if you really need something that big, you'd have to either use an array or an arbitrary precision arithmetic library (whoa, thanks for that text, laserlight; I love copy n' paste!).
I believe the standard says that long long is 8 bytes? Or does it only say that it's >= long?

Quote:

---

Originally Posted by Elysia

Octaword is 16 bytes, no (8 * 2)?

---

Not strictly. Word size is architecture-specific. Hence not part of the standard. Hell, even byte size is defined as size of char. :)

Quote:

---

Originally Posted by Elysia

I believe the standard says that long long is 8 bytes? Or does it only say that it's >= long?

---

At least as big as long, yes.

I know word is machine specific, but I can't imagine it as less than 2 bytes :p
So it is possible that long long can be 16 bytes, then. Though I think it is unlikely.
So then it simply begs the question: what platform?

The 1999 edition of the C standard states that sizeof(long long) >= sizeof(long), and one can infer that the range of long long has a size of at least 64 bits.

Quote:

---

Originally Posted by Elysia

So it is possible that long long can be 16 bytes, then.

---

Yes, if the range of long long was at least 128 bits in size.

If you have a native 64-bit type, it isn't difficult to do 128-bit arithmetic. It does require some non-portable programming in order to detect carry conditions, but it's not complicated.

Basically:

Code:

---

void AddOctWord( uint64 lo1, uint64 hi1, uint64 lo2, uint64 hi2, uint64 *loResult, uint64 *hiResult )
{
    int carry;
    *loResult = lo1 + lo2;
    carry = GetCarryBit();
    *hiResult = hi1 + hi2 + carry;
}

---

The non-portable code is hidden inside GetCarryBit().

Subtraction, multiplication, division are similar. For multiplication, realize that these numbers are of the form:

lo+hi*2^64.

Thus, the product of two 128-bit quantities is:

(lo1+hi1*2^64)*(lo2+hi2*2^64)

Using distributive law, the above is equal to:

lo1*lo2 + lo1*hi2*2^64 + lo2*hi1*2^64 + hi1*hi2*2^128

Factor it:

(hi1*hi2)*2^128 + (lo1*hi2 + lo2*hi1)*2^64 + lo1*lo2

Now the operations are all purely 64-bit. Just be aware that the first term can overflow if the quantities being multiplied have a geometric average greater than 2^64.