C++ equivalent to Java's BigInteger

A

Alf P. Steinbach

* (e-mail address removed):
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.

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.

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++?

Cheers, & hth.

- Alf
 
J

James Kanze

* (e-mail address removed):

<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.)
 
M

mearvk

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


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.


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:[email protected]
Conseils en informatique orientée objet/
                   Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34- 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.
 
J

Jerry Coffin

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

http://java.sun.com/javase/6/docs/api/java/math/BigInteger.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.
 
P

Phil Endecott

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

http://java.sun.com/javase/6/docs/api/java/math/BigInteger.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.
 
M

mearvk

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!
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Members online

Forum statistics

Threads
473,744
Messages
2,569,483
Members
44,902
Latest member
Elena68X5

Latest Threads

Top