Efficient test for pythagorean triples in modulo integer space - c

Question

I was wondering what the most effective formula, for testing if three numbers are a pythagorean triple is.
Just as a reminder: a pythagorean triple are three integers where a²+b²=c².
I mean not the most effective formula in terms of time, but a formula that is the most efficient in terms of not causing an overflow on a specific integer(lets say 32-bit unsigned int).
I was trying a bit with rearrangements of a*a + b*b == c*c:
Let's assume a<=b<c, then the best formula I could get to is:
2b*(c-b) == (a+b-c) * (a-b+c)
with this formula can be proven, that the right side is smaller than a*c and so should be the left side, but a*c doesn't look like a huge improvement of c*c.
So my question is, if there is a better formula for this conditional that works with bigger numbers without overflowing an integer space. The execution time of the formula doesn't matter that much, besides it should be O(1).
PS: I don't know if I should post such a question here or on Mathematics SE, but to me it seems to be more about programming.

Answer 1

EDIT If you need to have 32bit integers all the way down then you can just modify the math to fit your requirement. To keep it simple I do the math (squaring and summing) on 16bit chunks of data and use a struct that contains 2 unsigned ints as the result.
http://ideone.com/er2TaS
#include <iostream>
using namespace std;
struct u64 {
unsigned int lo;
unsigned int hi;
bool of;
};
u64 square(unsigned int a) {
u64 result;
unsigned int alo = (a & 0xffff);
unsigned int ahi = (a >> 16);
unsigned int aalo = alo * alo;
unsigned int aami = alo * ahi;
unsigned int aahi = ahi * ahi;
unsigned int aa1 = aalo & 0xffff;
unsigned int aa2 = (aalo >> 16) + (aami & 0xffff) + (aami & 0xffff);
unsigned int aa3 = (aa2 >> 16) + (aami >> 16) + (aami >> 16) + (aahi & 0xffff);
unsigned int aa4 = (aa3 >> 16) + (aahi >> 16);
result.lo = (aa1 & 0xffff) | ((aa2 & 0xffff) << 16);
result.hi = (aa3 & 0xffff) | (aa4 << 16);
result.of = false; // 0xffffffff^2 can't overflow
return result;
}
u64 sum(u64 a, u64 b) {
u64 result;
unsigned int a1 = a.lo & 0xffff;
unsigned int a2 = a.lo >> 16;
unsigned int a3 = a.hi & 0xffff;
unsigned int a4 = a.hi >> 16;
unsigned int b1 = b.lo & 0xffff;
unsigned int b2 = b.lo >> 16;
unsigned int b3 = b.hi & 0xffff;
unsigned int b4 = b.hi >> 16;
unsigned int s1 = a1 + b1;
unsigned int s2 = a2 + b2 + (s1 >> 16);
unsigned int s3 = a3 + b3 + (s2 >> 16);
unsigned int s4 = a4 + b4 + (s3 >> 16);
result.lo = (s1 & 0xffff) | ((s2 & 0xffff) << 16);
result.hi = (s3 & 0xffff) | ((s4 & 0xffff) << 16);
result.of = (s4 > 0xffff ? true : false);
return result;
}
bool isTriple(unsigned int a, unsigned int b, unsigned int c) {
u64 aa = square(a);
u64 bb = square(b);
u64 cc = square(c);
u64 aabb = sum(aa, bb);
return aabb.lo == cc.lo && aabb.hi == cc.hi && aabb.of == false;
}
int main() {
cout << isTriple(3,4,5) << endl;
cout << isTriple(2800,9600,10000) << endl;
return 0;
}
Conerting your 32bit integers to 64bit longs or even floating point doubles would edit reduce the chance of overflow and continue being, programmatically, O(1) since all the major architectures (x86, ARM, etc) have int to double conversion op codes at the low level and casting up to a long from int is also an O(1) operation.
bool isTriple(int a, int b, int c) {
long long bigA = a;
long long bigB = b;
long long bigC = c;
return bigA * bigA + bigB * bigB == bigC * bigC;
}

Answer 2

I think little rearrangement would help a lot.
a²+b²=c²
can be written as b²=c²-a²
which is b² = (c-a)(c+a)
and hence we arrive at
b/(c+a) = (c-a)/b
or (c+a)/b = b/(c-a)
Now using the above equation, you do not need to compute squares.
So we must do this
if(((c+a)/(double)b)==((double)(b)/(c-a)))
printf("Yes it is pythagorean triples");
else printf("No it is not");