C ++，275,000,000+
我们将其幅度可精确表示的对（例如（x，0））称为诚实对，将所有其他对称为不诚实的幅度对m，其中m是该对错误报告的幅度。上一篇文章中的第一个程序使用了一组紧密相关的一对诚实和不诚实对：
（x，0）和（x，1），足够大x。第二个程序使用相同的不诚实对集合，但通过查找所有整数级的诚实对来扩展诚实对集合。该程序不会在十分钟之内终止，但是它会在很早的时候发现绝大多数结果，这意味着大部分运行时都浪费了。该程序不会继续寻找越来越少的诚实对，而是利用业余时间来做下一个合乎逻辑的事情：扩展不诚实对的集合。
从上一篇文章中我们知道，对于所有足够大的整数r，sqrt（r 2 +1）= r，其中sqrt是浮点平方根函数。我们的攻击计划是找到对P =（x，y），使得对于某个足够大的整数r，x 2 + y 2 = r 2 +1。这很简单，但是天真地寻找单个这样的对太慢了，以至于没有意思。我们希望批量查找这些对，就像我们在上一个程序中对诚实对所做的那样。
令{ v，w }为向量的正交对。对于所有实标量r，|| r v + w || 2 = r 2 +1。在ℝ 2，这就是勾股定理的直接结果是：
我们正在寻找向量v和w，以便存在一个整数 r，其中x和y也是整数。作为一个侧面说明，请注意，我们在前面的两个程序使用的一套不诚实对只是这一点，其中一个特例{ v，w ^ }是标准基础ℝ 2 ; 这次我们希望找到一个更通用的解决方案。毕达哥拉斯三胞胎（整数三胞胎（a，b，c）满足a 2 + b 2 = c 2的地方，我们在之前的程序中使用过）。
令（a，b，c）为毕达哥拉斯三联体。向量v =（b / c，a / c）和w =（-a / c，b / c）（以及
w =（a / c，-b / c））是正交的，易于验证。事实证明，对于毕达哥拉斯三重态的任何选择，都存在一个整数r，使得x和y是整数。为了证明这一点，并有效地找到r和P，我们需要一些数/群理论。我将保留细节。无论哪种方式，假设我们都有积分r，x和y。我们还是短的几件事情：我们需要[R足够大，我们希望有一种快速的方法可以从中获得更多相似的对。幸运的是，有一种简单的方法可以完成此操作。
请注意，P在v上的投影为r v，因此r = P · v =（x，y）·（b / c，a / c）= xb / c + ya / c，所有这些都表示xb + ya = rc。结果，对于所有整数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。换句话说，形式为
（x + bn，y + an）的对的平方大小为（r + cn）2 +1，这正是我们要寻找的对的种类！对于足够大的n，它们是幅度r + cn的不诚实对。
看一个具体的例子总是很高兴。如果我们采用毕达哥拉斯三重态（3，4，5），则在r = 2时，我们有P =（1，2）（您可以检查（1，2） ·（4/5，3/5）= 2并且，很明显，1 2 + 2 2 = 2 2 + 1）添加5至ř和（4,3）至P带我们R '= 2 + 5 = 7和P'=（1 + 4,2 + 3）=（5，5）。瞧瞧5 2 + 5 2 = 7 2 +1。下一个坐标是r''= 12和P''=（9，8），同样是9 2 + 8 2 = 12 2 +1，依此类推，依此类推...
一旦r足够大，我们就开始得到幅度增加5的不诚实对。这大约是27,797,402 / 5对不诚实的对。
因此，现在我们有很多整数倍的不诚实对。我们可以很容易地将它们与第一个程序的诚实对配对以形成假阳性，并且在适当注意的情况下，我们也可以使用第二个程序的诚实对。这基本上就是该程序的工作。像以前的程序一样，它也很早就发现了大部分结果-几秒钟之内就得到了200,000,000个误报-，然后放慢了速度。
用编译g++ flspos.cpp -oflspos -std=c++11 -msse2 -mfpmath=sse -O3。要验证结果，请添加-DVERIFY（这会明显慢一些。）
用运行flspos。详细模式的任何命令行参数。
#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);
}