C ++, 275.000.000+
Vamos nos referir a pares cuja magnitude é exatamente representável, como (x, 0) , como pares honestos e a todos os outros pares como pares desonestos de magnitude m , onde m é a magnitude relatada incorretamente do par. O primeiro programa do post anterior usou um conjunto de pares estreitamente relacionados de pares honestos e desonestos:
(x, 0) e (x, 1) , respectivamente, para x suficientemente grandes. O segundo programa usou o mesmo conjunto de pares desonestos, mas estendeu o conjunto de pares honestos, procurando todos os pares honestos de magnitude integral. O programa não termina em dez minutos, mas encontra a grande maioria de seus resultados muito cedo, o que significa que a maior parte do tempo de execução é desperdiçada. Em vez de continuar procurando pares honestos cada vez menos frequentes, esse programa usa o tempo livre para fazer a próxima coisa lógica: estender o conjunto de pares desonestos .
No post anterior, sabemos que para todos os números inteiros grandes o suficiente r , sqrt (r 2 + 1) = r , em que sqrt é a função de raiz quadrada de ponto flutuante. Nosso plano de ataque é encontrar pares P = (x, y) tais que x 2 + y 2 = r 2 + 1 para algum número inteiro grande o suficiente r . Isso é simples o suficiente, mas procurar ingenuamente esses pares individuais é muito lento para ser interessante. Queremos encontrar esses pares em massa, assim como fizemos para pares honestos no programa anterior.
Seja { v , w } um par de vetores ortonormal. Para todos os escalares reais r , || r v + w || 2 = r 2 + 1 . No ℝ 2 , este é um resultado direto do teorema de Pitágoras:
Estamos à procura de vetores V e w tal que existe um número inteiro r para o qual x e y também são inteiros. Como observação lateral, observe que o conjunto de pares desonestos que usamos nos dois programas anteriores era simplesmente um caso especial disso, onde { v , w } era a base padrão de ℝ 2 ; desta vez, queremos encontrar uma solução mais geral. É aqui que os trigêmeos pitagóricos (trigêmeos inteiros (a, b, c) satisfazem a 2 + b 2 = c 2, que usamos no programa anterior) voltam.
Seja (a, b, c) um trigêmeo pitagórico. Os vectores de v = (b / c, a / c) e w = (-a / C, b / c), (e também
w = (a / c, b / c) ) são ortonormais, como é fácil de verificar . Como se vê, para qualquer escolha do trigêmeo pitagórico, existe um número inteiro r tal que x e y são números inteiros. Para provar isso e encontrar efetivamente r e P , precisamos de um pouco de teoria dos números / grupos; Vou poupar os detalhes. De qualquer maneira, suponha que tenhamos nossa integral r , x e y . Ainda faltam algumas coisas: precisamos de rser grande o suficiente e queremos um método rápido para derivar muitos outros pares semelhantes deste. Felizmente, existe uma maneira simples de fazer isso.
Observe que a projeção de P em v é r v , portanto r = P · v = (x, y) · (b / c, a / c) = xb / c + ya / c , tudo isso para dizer que xb + ya = rc . Como resultado, para todos os números inteiros n , (x + bn) 2 + (y + an) 2 = (x 2 + y 2 ) + 2 (xb + ya) n + (a 2 + b 2 ) n 2 = ( r 2 + 1) + 2 (rc) n + (c 2 ) n 2 = (r + cn) 2 + 1. Em outras palavras, a magnitude ao quadrado dos pares da forma
(x + bn, y + an) é (r + cn) 2 + 1 , que é exatamente o tipo de pares que estamos procurando! Para n grande o suficiente , esses são pares desonestos de magnitude r + cn .
É sempre bom olhar para um exemplo concreto. Se pegarmos o trigêmeo pitagórico (3, 4, 5) , então em r = 2 , temos P = (1, 2) (você pode verificar que (1, 2) · (4/5, 3/5) = 2 e, claramente, um 2 + 2 2 = 2 2 + 1 .) a adição de 5 a r e (4, 3) de P nos leva a r '= 2 + 5 = 7 e P' = (1 + 4, 2 + 3) = (5, 5) . Lo e eis que 5 2 + 5 2 = 7 2 + 1. As próximas coordenadas são r '' = 12 e P '' = (9, 8) e, novamente, 9 2 + 8 2 = 12 2 + 1 , e assim por diante ...
Uma vez que r é grande o suficiente, nós começar a receber desonestas pares com incrementos de magnitude de 5 . São aproximadamente 27.797.402 / 5 pares desonestos.
Então agora temos muitos pares desonestos de magnitude integral. Podemos facilmente associá-los aos pares honestos do primeiro programa para formar falsos positivos e, com o devido cuidado, também podemos usar os pares honestos do segundo programa. Isso é basicamente o que esse programa faz. Como o programa anterior, ele também encontra a maioria dos resultados muito cedo - chega a 200.000.000 de falsos positivos em alguns segundos - e depois diminui consideravelmente.
Compile com g++ flspos.cpp -oflspos -std=c++11 -msse2 -mfpmath=sse -O3. Para verificar os resultados, adicione -DVERIFY(isso será notavelmente mais lento).
Corra com flspos. Qualquer argumento da linha de comandos para o modo detalhado.
#include <cstdio>
#define _USE_MATH_DEFINES
#undef __STRICT_ANSI__
#include <cmath>
#include <cfloat>
#include <vector>
#include <iterator>
#include <algorithm>
using namespace std;
/* Make sure we actually work with 64-bit precision */
#if defined(VERIFY) && FLT_EVAL_METHOD != 0 && FLT_EVAL_METHOD != 1
# error "invalid FLT_EVAL_METHOD (did you forget `-msse2 -mfpmath=sse'?)"
#endif
template <typename T> struct widen;
template <> struct widen<int> { typedef long long type; };
template <typename T>
inline typename widen<T>::type mul(T x, T y) {
return typename widen<T>::type(x) * typename widen<T>::type(y);
}
template <typename T> inline T div_ceil(T a, T b) { return (a + b - 1) / b; }
template <typename T> inline typename widen<T>::type sq(T x) { return mul(x, x); }
template <typename T>
T gcd(T a, T b) { while (b) { T t = a; a = b; b = t % b; } return a; }
template <typename T>
inline typename widen<T>::type lcm(T a, T b) { return mul(a, b) / gcd(a, b); }
template <typename T>
T div_mod_n(T a, T b, T n) {
if (b == 0) return a == 0 ? 0 : -1;
const T n_over_b = n / b, n_mod_b = n % b;
for (T m = 0; m < n; m += n_over_b + 1) {
if (a % b == 0) return m + a / b;
a -= b - n_mod_b;
if (a < 0) a += n;
}
return -1;
}
template <typename T> struct pythagorean_triplet { T a, b, c; };
template <typename T>
struct pythagorean_triplet_generator {
typedef pythagorean_triplet<T> result_type;
private:
typedef typename widen<T>::type WT;
result_type p_triplet;
WT p_c2b2;
public:
pythagorean_triplet_generator(const result_type& triplet = {3, 4, 5}) :
p_triplet(triplet), p_c2b2(sq(triplet.c) - sq(triplet.b))
{}
const result_type& operator*() const { return p_triplet; }
const result_type* operator->() const { return &p_triplet; }
pythagorean_triplet_generator& operator++() {
do {
if (++p_triplet.b == p_triplet.c) {
++p_triplet.c;
p_triplet.b = ceil(p_triplet.c * M_SQRT1_2);
p_c2b2 = sq(p_triplet.c) - sq(p_triplet.b);
} else
p_c2b2 -= 2 * p_triplet.b - 1;
p_triplet.a = sqrt(p_c2b2);
} while (sq(p_triplet.a) != p_c2b2 || gcd(p_triplet.b, p_triplet.a) != 1);
return *this;
}
result_type operator()() { result_type t = **this; ++*this; return t; }
};
int main(int argc, const char* argv[]) {
const bool verbose = argc > 1;
const int min = 1 << 26;
const int max = sqrt(1ll << 53);
const size_t small_triplet_count = 1000;
vector<pythagorean_triplet<int>> small_triplets;
small_triplets.reserve(small_triplet_count);
generate_n(
back_inserter(small_triplets),
small_triplet_count,
pythagorean_triplet_generator<int>()
);
int found = 0;
auto add = [&] (int x1, int y1, int x2, int y2) {
#ifdef VERIFY
auto n1 = sq(x1) + sq(y1), n2 = sq(x2) + sq(y2);
if (x1 < y1 || x2 < y2 || x1 > max || x2 > max ||
n1 == n2 || sqrt(n1) != sqrt(n2)
) {
fprintf(stderr, "Wrong false-positive: (%d, %d) (%d, %d)\n",
x1, y1, x2, y2);
return;
}
#endif
if (verbose) printf("(%d, %d) (%d, %d)\n", x1, y1, x2, y2);
++found;
};
int output_counter = 0;
for (int x = min; x <= max; ++x) add(x, 0, x, 1);
for (pythagorean_triplet_generator<int> i; i->c <= max; ++i) {
const auto& t1 = *i;
for (int n = div_ceil(min, t1.c); n <= max / t1.c; ++n)
add(n * t1.b, n * t1.a, n * t1.c, 1);
auto find_false_positives = [&] (int r, int x, int y) {
{
int n = div_ceil(min - r, t1.c);
int min_r = r + n * t1.c;
int max_n = n + (max - min_r) / t1.c;
for (; n <= max_n; ++n)
add(r + n * t1.c, 0, x + n * t1.b, y + n * t1.a);
}
for (const auto t2 : small_triplets) {
int m = div_mod_n((t2.c - r % t2.c) % t2.c, t1.c % t2.c, t2.c);
if (m < 0) continue;
int sr = r + m * t1.c;
int c = lcm(t1.c, t2.c);
int min_n = div_ceil(min - sr, c);
int min_r = sr + min_n * c;
if (min_r > max) continue;
int x1 = x + m * t1.b, y1 = y + m * t1.a;
int x2 = t2.b * (sr / t2.c), y2 = t2.a * (sr / t2.c);
int a1 = t1.a * (c / t1.c), b1 = t1.b * (c / t1.c);
int a2 = t2.a * (c / t2.c), b2 = t2.b * (c / t2.c);
int max_n = min_n + (max - min_r) / c;
int max_r = sr + max_n * c;
for (int n = min_n; n <= max_n; ++n) {
add(
x2 + n * b2, y2 + n * a2,
x1 + n * b1, y1 + n * a1
);
}
}
};
{
int m = div_mod_n((t1.a - t1.c % t1.a) % t1.a, t1.b % t1.a, t1.a);
find_false_positives(
/* r = */ (mul(m, t1.c) + t1.b) / t1.a,
/* x = */ (mul(m, t1.b) + t1.c) / t1.a,
/* y = */ m
);
} {
int m = div_mod_n((t1.b - t1.c % t1.b) % t1.b, t1.a, t1.b);
find_false_positives(
/* r = */ (mul(m, t1.c) + t1.a) / t1.b,
/* x = */ m,
/* y = */ (mul(m, t1.a) + t1.c) / t1.b
);
}
if (output_counter++ % 50 == 0)
printf("%d\n", found), fflush(stdout);
}
printf("%d\n", found);
}