How to floor a number using the NTL library (C++)

Question

I am building a C++ program to verify a mathematical conjecture for up to 100 billion iterations. In order to test such high numbers, I cannot use a C++ int, so I am using the NTL library, using the type ZZ as my number type.

My algorithm looks like this:

ZZ generateNthSeq(ZZ n)
{
    return floor(n*sqrt(2));
}

I have the two libraries being imported:

#include <cmath>
#include <NTL/ZZ.h>

But obviously this cannot compile because I get the error:

$ g++ deepness*.cpp
deepness.cpp: In function ‘NTL::ZZ generateNthSeq(NTL::ZZ)’:
deepness.cpp:41: error: no matching function for call to ‘floor(NTL::ZZ)’
/usr/include/bits/mathcalls.h:185: note: candidates are: double floor(double)
/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/cmath:262: note:                 long double std::floor(long double)
/usr/lib/gcc/x86_64-redhat-linux/4.4.7/../../../../include/c++/4.4.7/cmath:258: note:                 float std::floor(float)

Stating that the floor mathematical operation cannot accept a ZZ class type. But I need the numbers to be pretty big. How can I accomplish what I want to do, which is to floor the function, while using the NTL library?

Answer 1

Note that it doesn't really make sense to apply floor to an integral type (well, it does, it's just a no-op). What you should be really worried about is the fact that your code is apparently passing something of type ZZ into floor!

That is, what can n * sqrt(2) possibly mean here?

Also, before even writing that, I'd've checked the documentation to see if integer * floating point actually exists in the library -- usually for that to be useful at all, you need arbitrary precision floating types available.

---

Checking through the headers, there is only one multiplication operator:

ZZ operator*(const ZZ& a, const ZZ& b);

and there is a conversion constructor:

explicit ZZ(long a);  // promotion constructor

I can't figure out how your code is even compiling. Maybe you're using a different version of the library than I'm looking at, and the conversion constructor is implicit, and your double is getting "promoted" to a ZZ. This is surely not what you want, since promoting sqrt(2) to a ZZ is simply going to give you the integer 1.

You either need to:

• look into whether or not NTL has arbitrary precision floating point capabilities
• switch to a library that does have arbitrary precision floating point capabilities
• convert your calculation to pure integer arithmetic

That last one is fairly easy here: you want

return SqrRoot(sqr(n) * 2); // sqr(n) will be a bit more efficient than `n * n`