C++ equivalent to Java's BigInteger

Discussion in 'C++' started by mearvk, Jan 5, 2008.

  1. mearvk

    mearvk Guest

    mearvk, Jan 5, 2008
    #1
    1. Advertising

  2. mearvk

    Guest

    mearvk wrote:

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


    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
     
    , Jan 5, 2008
    #2
    1. Advertising

  3. * :
    > mearvk wrote:
    >
    >> 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.

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

    --
    A: Because it messes up the order in which people normally read text.
    Q: Why is it such a bad thing?
    A: Top-posting.
    Q: What is the most annoying thing on usenet and in e-mail?
     
    Alf P. Steinbach, Jan 5, 2008
    #3
  4. mearvk

    James Kanze Guest

    On Jan 5, 11:41 am, "Alf P. Steinbach" <> wrote:
    > * :
    > > mearvk wrote:
    > >> 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.


    > > 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:
    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
     
    James Kanze, Jan 5, 2008
    #4
  5. mearvk

    mearvk Guest

    On Jan 5, 12:55 pm, James Kanze <> wrote:
    > On Jan 5, 11:41 am, "Alf P. Steinbach" <> wrote:
    >
    >
    >
    >
    >
    > > * :
    > > > mearvk wrote:
    > > >> 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.
    > > > 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:
    > 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.
     
    mearvk, Jan 5, 2008
    #5
  6. mearvk

    Jerry Coffin Guest

    In article <977f29eb-ba55-4ba2-914a-66cd951c8400
    @i72g2000hsd.googlegroups.com>, says...
    > 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.

    --
    Later,
    Jerry.

    The universe is a figment of its own imagination.
     
    Jerry Coffin, Jan 6, 2008
    #6
  7. mearvk wrote:
    > 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.
     
    Phil Endecott, Jan 7, 2008
    #7
  8. mearvk

    mearvk Guest

    On Jan 7, 10:50 am, Phil Endecott <>
    wrote:
    > mearvk wrote:
    > > 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.


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

    Thanks to everyone!
     
    mearvk, Jan 10, 2008
    #8
    1. Advertising

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

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. nick
    Replies:
    0
    Views:
    935
  2. nick
    Replies:
    1
    Views:
    32,081
    Eric Sosman
    Oct 26, 2004
  3. j1mb0jay
    Replies:
    25
    Views:
    23,817
    Arne Vajhøj
    May 25, 2008
  4. Stefan Ram
    Replies:
    0
    Views:
    403
    Stefan Ram
    Jul 9, 2008
  5. Patricia Shanahan
    Replies:
    2
    Views:
    493
    Patricia Shanahan
    Jul 9, 2008
Loading...

Share This Page