Avoiding float

[galt_57]

I need to do just a few multiplies of long integers and have a divide
by ten. Can I avoid using floats? Can I use two longs as a 64 bit value
somehow? Thanks.

[Konstantin Miller]

ga*****@hotmail .com wrote:

I need to do just a few multiplies of long integers and have a divide
by ten. Can I avoid using floats? Can I use two longs as a 64 bit value
somehow? Thanks.

Hi!

Can you specify more clearly what you want to do? :-)

Konstantin

[Walter Roberson]

In article <11************ **********@b28g 2000cwb.googleg roups.com>,
<ga*****@hotmai l.comwrote:

>I need to do just a few multiplies of long integers and have a divide
by ten. Can I avoid using floats? Can I use two longs as a 64 bit value
somehow?

You will have to synthesize the arithmetic to do this, but it is not
difficult if you are only doing it for a pair.

Below, let W be the number of bits being multiplied at a time,
and let ** represent exponentiation

Then
(Ahigh * 2**W + Alow) * (Bhigh * 2**W + Blow) is

Ahigh * Bhigh * 2**(W+W) + Ahigh * Blow * 2**W +
Alow * Bhigh * 2**W + Alow * Blow

which is

(Ahigh * Bhigh) * 2**(2*W) +
(Ahigh * Blow + Alow * Bhigh) * 2**W +
Alow * Blow
Now the trick: let Ahigh be the high bits of the original unsigned long A
and let Alow be the low bits -- e.g.,

Alow = A & ~(1L<<W);
Ahigh = A >W;

and similiarily for Bhigh and Blow derived from B. For example, if your
unsigned long can hold 32 bits, you could let W be 16, and Ahigh would
be the top 16 bits of A and Alow would be the bottom 16 bits of A.

If you then multiply Alow * Blow and put the result into an
unsigned long, say T1, then the top W bits of that result are the "carry".
So you calculate Ahigh * Blow + Alow * Bhigh + (T1>>W) and that
gives you the next chunk of bits over -- except you have to
account for carries along the way. Say the result is in T2, then
the "low" unsigned long of the multiplication is
(T2 & ~(1L<<W)) << W | ((T1 & ~(1L<<W))

and so on, just making sure you take into account the carries at
each point. As long as the number of bits at a time that you operate
on does not exceed half the number of bits in an unsigned long,
then the result will always fit within an unsigned long, with the
top bits of that being the carry over to the next stage.
--
Is there any thing whereof it may be said, See, this is new? It hath
been already of old time, which was before us. -- Ecclesiastes

[galt_57]

Konstantin Miller wrote:

ga*****@hotmail .com wrote:

I need to do just a few multiplies of long integers and have a
divide by ten. Can I avoid using floats? Can I use two longs
as a 64 bit value somehow? Thanks.

Hi!

Can you specify more clearly what you want to do? :-)

Konstantin

I have some long values in Liters and I want to convert to gallons (and
back). If I could do integer multiplication and divide by 10 I could
avoid the float library. Thanks.

[Ancient_Hacker]

ga*****@hotmail .com wrote:

I have some long values in Liters and I want to convert to gallons (and
back). If I could do integer multiplication and divide by 10 I could
avoid the float library. Thanks.

Depends on how many liters. And how big your longs are.

You could multiply the liters by 26, then divide by 100.

*But* that means you can't have more than 2^32/26 or 2^64/26 liters to
start with.

So if you have less than 165191049 or 709490156681136 600 liters, you
can do it.

[CBFalconer]

ga*****@hotmail .com wrote:

Konstantin Miller wrote:

>ga*****@hotmail .com wrote:

>>I need to do just a few multiplies of long integers and have a
divide by ten. Can I avoid using floats? Can I use two longs
as a 64 bit value somehow? Thanks.

Can you specify more clearly what you want to do? :-)

I have some long values in Liters and I want to convert to gallons
(and back). If I could do integer multiplication and divide by 10
I could avoid the float library. Thanks.

[1] c:\stds>units gallon litre
* 3.7854118
/ 0.26417205

As you can plainly see, the conversion factors are nowhere near
integral. Besides which, no float library should be required to do
the multiplication or division. The final output is another
matter.

--
Chuck F (cbfalconer at maineline dot net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home .att.net>

[CBFalconer]

ga*****@hotmail .com wrote:

Konstantin Miller wrote:

>ga*****@hotmail .com wrote:

>>I need to do just a few multiplies of long integers and have a
divide by ten. Can I avoid using floats? Can I use two longs
as a 64 bit value somehow? Thanks.

Can you specify more clearly what you want to do? :-)

I have some long values in Liters and I want to convert to gallons
(and back). If I could do integer multiplication and divide by 10
I could avoid the float library. Thanks.

[1] c:\stds>units gallon litre
* 3.7854118
/ 0.26417205

As you can plainly see, the conversion factors are nowhere near
integral. Besides which, no float library should be required to do
the multiplication or division. The final output is another
matter.

--
Chuck F (cbfalconer at maineline dot net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home .att.net>

[Eric Sosman]

ga*****@hotmail .com wrote On 09/07/06 13:53,:

Konstantin Miller wrote:

>>ga*****@hotma il.com wrote:

>>>I need to do just a few multiplies of long integers and have a
divide by ten. Can I avoid using floats? Can I use two longs
as a 64 bit value somehow? Thanks.

Hi!

Can you specify more clearly what you want to do? :-)

Konstantin

I have some long values in Liters and I want to convert to gallons (and
back). If I could do integer multiplication and divide by 10 I could
avoid the float library. Thanks.

Have you considered

long liters, gallons;
liters = ...whatever...;
gallons = liters * 3 / 10;

"Times three, over ten" is a crude approximation to 0.2641721,
but it's the only one I can think of that satisfies your desire
to divide by ten. If you're willing to consider other divisors,
more accurate conversions are possible:

gallons = liters * 26 / 100;
gallons = liters * 264 / 1000;
gallons = liters * 2642 / 10000;
...

You can convert from gallons back to liters the same way,
using various approximations to the conversion factor:

liters = gallons * 4;
liters = gallons * 38 / 10;
liters = gallons * 379 / 100;
...

However, all these conversions, no matter how accurate an
approximation you use, must eventually express the result as a
whole number of gallons or liters. You will need to chop or
round the "true" result to discard the fraction that a long
cannot express, and this introduces an unavoidable error: you
could be low by almost a gallon (if chopping, as shown) or either
high or low by as much as half a gallon (if rounding, not shown).

The error becomes especially nasty when you convert back
again, because the second conversion not only introduces its
own error (by discarding fractions of a liter), but also starts
from the slightly incorrect result of the first conversion. For
example, using the three-digit approximations above:

liters = 4;
gallons = liters * 264 / 1000;
liters = gallons * 339 / 100;

.... will yield liters==3 in the final step. There are at least
three ways to deal with this error:

- Switch to floating-point: There will still be errors, but
they will be much smaller. (For this kind of computation,
but not necessarily for all.)

- Switch to smaller units: Convert between milliliters and
teaspoons or some such. You'll still need to round or
chop, but the errors will be teaspoon-sized instead of
gallon-sized.

- Ignore it: Tell people the missing liter evaporated.

Your choice.

--
Er*********@sun .com

[Keith Thompson]

CBFalconer <cb********@yah oo.comwrites:

ga*****@hotmail .com wrote:

>Konstantin Miller wrote:

>>ga*****@hotmail .com wrote:

I need to do just a few multiplies of long integers and have a
divide by ten. Can I avoid using floats? Can I use two longs
as a 64 bit value somehow? Thanks.

Can you specify more clearly what you want to do? :-)

I have some long values in Liters and I want to convert to gallons
(and back). If I could do integer multiplication and divide by 10
I could avoid the float library. Thanks.

[1] c:\stds>units gallon litre
* 3.7854118
/ 0.26417205

As you can plainly see, the conversion factors are nowhere near
integral. Besides which, no float library should be required to do
the multiplication or division. The final output is another
matter.

The exact ratio, in lowest terms, is 473176473 / 125000000 (or,
expressed as a real number, exactly 3.785411784). (1 liter is 1000
cubic centimeters; 1 US gallon is 231 cubic inches; 1 inch is 2.54
centimeters.)

I don't know where the "divide by 10" comes from, but I suspect the OP
is attempting to do premature optimization.

On most modern non-embedded systems, floating-point arithmetic is
implemented in hardware; only certain functions such as sqrt() and
sin() are implemented in software. If the intent is to improve the
performance of the code, using integer arithmetic rather than
floating-point arithmetic may not be at all helpful (but you can't
tell unless you've actually measured it).

Using exact rational arithmetic is one way to get exact results,
avoiding any possible rounding error, but that's seldom necessary for
gallon/liter conversions. The errors in measurement are likely to be
much larger than any rounding errors. (Be sure to use double, not
float, or use long double if you want even greater precision -- but
long double isn't necessarily more precise than double.)

If you want to do 64-bit integer arithmetic, check whether your
compiler supports "long long". It's new in C99, but many C90-ish
compilers support it as well. (Some compilers may provide a 64-bit
integer type with a different name; consult your documentation.)

There are also libraries for doing arbitrary-precision integer
artithmetic. GNU MP (GMP) is one such library.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <* <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Malcolm]

<ga*****@hotmai l.comwrote in message
news:11******** **************@ b28g2000cwb.goo glegroups.com.. .

>I need to do just a few multiplies of long integers and have a divide
by ten. Can I avoid using floats? Can I use two longs as a 64 bit value
somehow? Thanks.

You can use a double and store the result as an integer * 10. The point of
doing this is that you don't have to mess about with non-standard types,
whilst still having integer arithmetic - you need to throw away the
fraction, of course.
--
www.personal.leeds.ac.uk/~bgy1mm
freeware games to download.