C++ equivalent to Java's BigInteger

[mearvk]

Does C++ or C have something roughly equivalent to this:

http://java.sun.com/javase/6/docs/ap...igInteger.html

What I need is a way to quickly convert between decimal and binary and
from char*/string to a numeric representation.

Thanks!

[jkherciueh]

mearvk wrote:

Does C++ or C have something roughly equivalent to this:

http://java.sun.com/javase/6/docs/ap...igInteger.html

What I need is a way to quickly convert between decimal and binary and
from char*/string to a numeric representation.

Such facilities are not part of the C++ standard, but they are available as
third-party libraries. You could check whether the gnu mp bignum library
offers what you need.
Best

Kai-Uwe Bux

[James Kanze]

On Jan 5, 11:41 am, "Alf P. Steinbach" <[e-mail]:

* [e-mail]:

mearvk wrote:

Does C++ or C have something roughly equivalent to this:
http://java.sun.com/javase/6/docs/ap...igInteger.html

What I need is a way to quickly convert between decimal and binary and
from char*/string to a numeric representation.

Such facilities are not part of the C++ standard, but they
are available as third-party libraries. You could check
whether the gnu mp bignum library offers what you need.

<url:http://java.sun.com/j2se/1.5.0/docs/guide/math/enhancements.html>

<quote>
Java 2 SDK 1.3

* Performance enhancements in BigInteger
Class java.math.BigInteger has been reimplemented in pure Java
programming-language code. Previously, BigInteger's implementation was
based on an underlying C library. On a high-quality VM, the new
implementation performs all operations faster than the old
implementation. The speed-up can be as much as 5x or more, depending on
the operation being performed and the length of the operands.
</quote>

Depending on how much of the above is misdirection, it could
be truly amazing.

I presume that by "misdirection", you mean misinformation.

If the 5x speedup is due only to avoiding using some
inefficient way to call native code and perhaps inefficient
conversion between Java and native data, then it's not at all
amazing and not at all something positive for Java: in that
case, it just says that calling native codf from Java is
extremely inefficient.

But if the speedup is due only to e.g. optimization made
possible by just-in-time compilation, then there's a lesson
here.

I'd like to see the exact benchmarks first. I can imagine
certain cases where JIT could create such a speed up---e.g. if
all of the test cases involved constants, or in some very
specific cases of chained operations. A cross module optimizer
using profiling output could, at least potentially, also do some
of these optimizations. They probably don't apply universally,
however, and a lot of other cases (perhaps more typical) won't
show a similar speed up.

What is sure, of course, is that there is no cross-module
optimization between Java and C routines called via JNI, where
as all of the JIT compilers do cross-module optimization
(relatively easy, given the environment in which they operate).
And it shouldn't be very difficult at all to design a benchmark
which benefits particularly from such cross-module optimization.

Anyways, to the OP, note that the original Java BigInt was
just a Java wrapper for the a C library, presumably GMP.

So the real question for a language like Java is, always, does
it have something roughly equivalent to the functionality
available in C++?

The real difference here, of course, is that the library is
standard in Java, so 1) all Java programmers will know where to
look for it, if they need it, and 2) all Java programmers will
use the same library. Being standard is an advantage. (Whether
it's an important advantage is another question. In the case of
string, I think it definitely is, but in this case, I'm not so
sure.)

--
James Kanze (GABI Software) email:ja*********@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[mearvk]

On Jan 5, 12:55*pm, James Kanze <[e-mail]:

On Jan 5, 11:41 am, "Alf P. Steinbach" <[e-mail]:

* [e-mail]:

mearvk wrote:
>Does C++ or C have something roughly equivalent to this:
>>http://java.sun.com/javase/6/docs/ap...igInteger.html
>What I need is a way to quickly convert between decimal and binary and
>from char*/string to a numeric representation.
Such facilities are not part of the C++ standard, but they
are available as third-party libraries. You could check
whether the gnu mp bignum library offers what you need.

<url:http://java.sun.com/j2se/1.5.0/docs/guide/math/enhancements.html>
<quote>
Java 2 SDK 1.3

* * ** Performance enhancements in BigInteger
* * * *Class java.math.BigInteger has been reimplemented in pureJava
programming-language code. Previously, BigInteger's implementation was
based on an underlying C library. On a high-quality VM, the new
implementation performs all operations faster than the old
implementation. The speed-up can be as much as 5x or more, depending on
the operation being performed and the length of the operands.
</quote>
Depending on how much of the above is misdirection, it could
be truly amazing.

I presume that by "misdirection", you mean misinformation.

If the 5x speedup is due only to avoiding using some
inefficient way to call native code and perhaps inefficient
conversion between Java and native data, then it's not at all
amazing and not at all something positive for Java: in that
case, it just says that calling native codf from Java is
extremely inefficient.
But if the speedup is due only to e.g. optimization made
possible by just-in-time compilation, then there's a lesson
here.

I'd like to see the exact benchmarks first. *I can imagine
certain cases where JIT could create such a speed up---e.g. if
all of the test cases involved constants, or in some very
specific cases of chained operations. *A cross module optimizer
using profiling output could, at least potentially, also do some
of these optimizations. *They probably don't apply universally,
however, and a lot of other cases (perhaps more typical) won't
show a similar speed up.

What is sure, of course, is that there is no cross-module
optimization between Java and C routines called via JNI, where
as all of the JIT compilers do cross-module optimization
(relatively easy, given the environment in which they operate).
And it shouldn't be very difficult at all to design a benchmark
which benefits particularly from such cross-module optimization.

Anyways, to the OP, note that the original Java BigInt was
just a Java wrapper for the a C library, presumably GMP.
So the real question for a language like Java is, always, does
it have something roughly equivalent to the functionality
available in C++?

The real difference here, of course, is that the library is
standard in Java, so 1) all Java programmers will know where to
look for it, if they need it, and 2) all Java programmers will
use the same library. *Being standard is an advantage. *(Whether
it's an important advantage is another question. *In the case of
string, I think it definitely is, but in this case, I'm not so
sure.)

--
James Kanze (GABI Software) * * * * * * email:[e-mail]
Conseils en informatique orientée objet/
* * * * * * * * * *Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]- Hide quoted text -

- Show quoted text -

GMP looked very promising but it looks like it's intended primarily
for Linux. It is beyond my understanding to get it to compile on a
Windows environment, which for my client, is where it needs to run.

Thanks.

[Jerry Coffin]

In article <977f29eb-ba55-4ba2-914a-66cd951c8400
@i72g2000hsd.googlegroups.com>, me****@gmail.com says...

Does C++ or C have something roughly equivalent to this:

http://java.sun.com/javase/6/docs/ap...igInteger.html

What I need is a way to quickly convert between decimal and binary and
from char*/string to a numeric representation.

A couple of possibilities include Arjen Lenstra's LIP package:

http://www.win.tue.nl/~klenstra/

and Victor Shoup's NTL packaage:

http://www.shoup.net/ntl/

LIP is quite small, and relatively easy to use, but the interface is
pure C (not C++) so (for example) reading a couple numbers, adding them
together, then writing out the result looks something like:

// warning: untested code, written from memory...
#include "lip.h"

int main() {
verylong x=0, y=0, z=0;

zread(&x);
zread(&y);
zadd(x, y, &z);
zwrite(z);
return 0;
}

A C++ interface using operator overloading could obviously improve
readability a bit (at the expense, perhaps, of slower code from creating
some temporaries).

Doing a bit of looking, it looks like I've made a couple of minor
modifications to the code. First of all, I commented out a prototype for
calloc at line 1116 of lip.c (it probably includes a standard header
that already prototypes it?). Second, I added:

#pragma comment(lib, "ws2_32.lib")

at line 495 of lip.h. offhand, I don't remember what network functions
it's using, and that's probably why I added this -- it saves having to
explicitly link against a library that isn't obviously related to
anything you're doing.

NTL is a much larger library (to put it mildly) but it's pretty easy to
use. It does include a C++ interface that does operator overloading, so
your code looks a bit more natural. Code equivalent to the above would
look something like:

// warning: untested code, written from memory...
#include <iostream>
#include "NTL/zz.h"

int main() {
NTL::ZZ x, y, z;

std::cin >x >y;
z = x + y;
std::cout << z;
return 0;
}

There are, of course, quite a few more out there as well, but I've found
both of these to work quite nicely under Windows.

--
Later,
Jerry.

The universe is a figment of its own imagination.

[Phil Endecott]

mearvk wrote:

Does C++ or C have something roughly equivalent to this:

http://java.sun.com/javase/6/docs/ap...igInteger.html

What I need is a way to quickly convert between decimal and binary and
from char*/string to a numeric representation.

Try google("boost bigint"). IIRC there were proposals for a GSoC
project to do it; I don't think a "finished product" was ever delivered,
but you may be able to find something useable for your purposes, perhaps
in the Boost "sandbox" or "vault".
Phil.

[mearvk]

On Jan 7, 10:50*am, Phil Endecott <[e-mail]>
wrote:

mearvk wrote:

Does C++ or C have something roughly equivalent to this:

http://java.sun.com/javase/6/docs/ap...igInteger.html

What I need is a way to quickly convert between decimal and binary and
from char*/string to a numeric representation.

Try google("boost bigint"). *IIRC there were proposals for a GSoC
project to do it; I don't think a "finished product" was ever delivered,
but you may be able to find something useable for your purposes, perhaps
in the Boost "sandbox" or "vault".

Phil.

I ended up using LIP. It was only 3 files and only required a little
coding on my part.

Thanks to everyone!