static
long ll_LLL_XD(mat_ZZ& B, mat_ZZ* U, xdouble delta, long deep,
LLLCheckFct check, xdouble **B1, xdouble **mu,
xdouble *b, xdouble *c,
long m, long init_k, long &quit)
{
NTL_TLS_GLOBAL_ACCESS(red_fudge);
long n = B.NumCols();
long i, j, k, Fc1;
ZZ MU;
xdouble mu1;
xdouble t1;
ZZ T1;
xdouble *tp;
NTL_TLS_LOCAL_INIT(xdouble, bound, (to_xdouble(0)));
if (bound == 0) {
// we tolerate a 15% loss of precision in computing
// inner products in ComputeGS.
bound = 1;
for (i = 2*long(0.15*NTL_DOUBLE_PRECISION); i > 0; i--) {
bound = bound * 2;
}
}
xdouble half = to_xdouble(0.5);
xdouble half_plus_fudge = 0.5 + red_fudge;
quit = 0;
k = init_k;
vec_long st_mem;
st_mem.SetLength(m+2);
long *st = st_mem.elts();
for (i = 1; i < k; i++)
st[i] = i;
for (i = k; i <= m+1; i++)
st[i] = 1;
UniqueArray<xdouble> buf_store;
buf_store.SetLength(m+1);
xdouble *buf = buf_store.get();
long rst;
long counter;
long trigger_index;
long small_trigger;
long cnt;
long max_k = 0;
double tt;
while (k <= m) {
if (k > max_k) {
max_k = k;
}
if (verbose) {
tt = GetTime();
if (tt > LastTime + LLLStatusInterval)
LLLStatus(max_k, tt, m, B);
}
if (st[k] == k)
rst = 1;
else
rst = k;
if (st[k] < st[k+1]) st[k+1] = st[k];
ComputeGS(B, B1, mu, b, c, k, bound, st[k], buf);
st[k] = k;
counter = 0;
trigger_index = k;
small_trigger = 0;
cnt = 0;
do {
// size reduction
counter++;
if (counter > 10000) {
cerr << "LLL_XD: warning--possible infinite loop\n";
counter = 0;
}
Fc1 = 0;
for (j = rst-1; j >= 1; j--) {
t1 = fabs(mu[k][j]);
if (t1 > half_plus_fudge) {
if (!Fc1) {
if (j > trigger_index ||
(j == trigger_index && small_trigger)) {
cnt++;
if (cnt > 10) {
inc_red_fudge();
half_plus_fudge = 0.5 + red_fudge;
cnt = 0;
}
}
trigger_index = j;
small_trigger = (t1 < 4);
}
Fc1 = 1;
mu1 = mu[k][j];
if (mu1 >= 0)
mu1 = ceil(mu1-half);
else
mu1 = floor(mu1+half);
xdouble *mu_k = mu[k];
xdouble *mu_j = mu[j];
if (mu1 == 1) {
for (i = 1; i <= j-1; i++)
mu_k[i] -= mu_j[i];
}
else if (mu1 == -1) {
for (i = 1; i <= j-1; i++)
mu_k[i] += mu_j[i];
}
else {
for (i = 1; i <= j-1; i++)
MulSub(mu_k[i], mu_k[i], mu1, mu_j[i]);
}
mu_k[j] -= mu1;
conv(MU, mu1);
// cout << j << " " << MU << "\n";
RowTransform(B(k), B(j), MU);
if (U) RowTransform((*U)(k), (*U)(j), MU);
}
}
if (Fc1) {
for (i = 1; i <= n; i++)
conv(B1[k][i], B(k, i));
b[k] = InnerProduct(B1[k], B1[k], n);
ComputeGS(B, B1, mu, b, c, k, bound, 1, buf);
}
} while (Fc1);
if (check && (*check)(B(k)))
quit = 1;
if (b[k] == 0) {
for (i = k; i < m; i++) {
// swap i, i+1
swap(B(i), B(i+1));
tp = B1[i]; B1[i] = B1[i+1]; B1[i+1] = tp;
t1 = b[i]; b[i] = b[i+1]; b[i+1] = t1;
if (U) swap((*U)(i), (*U)(i+1));
}
for (i = k; i <= m+1; i++) st[i] = 1;
m--;
if (quit) break;
continue;
}
if (quit) break;
if (deep > 0) {
// deep insertions
xdouble cc = b[k];
long l = 1;
while (l <= k-1 && delta*c[l] <= cc) {
cc = cc - mu[k][l]*mu[k][l]*c[l];
l++;
}
if (l <= k-1 && (l <= deep || k-l <= deep)) {
// deep insertion at position l
for (i = k; i > l; i--) {
// swap rows i, i-1
swap(B(i), B(i-1));
tp = B1[i]; B1[i] = B1[i-1]; B1[i-1] = tp;
tp = mu[i]; mu[i] = mu[i-1]; mu[i-1] = tp;
t1 = b[i]; b[i] = b[i-1]; b[i-1] = t1;
if (U) swap((*U)(i), (*U)(i-1));
}
k = l;
continue;
}
} // end deep insertions
// test LLL reduction condition
if (k > 1 && delta*c[k-1] > c[k] + mu[k][k-1]*mu[k][k-1]*c[k-1]) {
// swap rows k, k-1
swap(B(k), B(k-1));
tp = B1[k]; B1[k] = B1[k-1]; B1[k-1] = tp;
tp = mu[k]; mu[k] = mu[k-1]; mu[k-1] = tp;
t1 = b[k]; b[k] = b[k-1]; b[k-1] = t1;
if (U) swap((*U)(k), (*U)(k-1));
k--;
NumSwaps++;
// cout << "- " << k << "\n";
}
else {
k++;
// cout << "+ " << k << "\n";
}
}
if (verbose) {
LLLStatus(m+1, GetTime(), m, B);
}
return m;
}
void inv(RR& z, const RR& a)
{
NTL_TLS_LOCAL_INIT(RR, one, (to_RR(1)));
div(z, one, a);
}
// FIXME: This could potentially be shared across threads, using
// a "lazy table".
static inline
Vec<long> *get_brc_mem()
{
NTL_TLS_LOCAL_INIT(Vec< Vec<long> >, brc_mem_vec, (INIT_SIZE, NTL_FFTMaxRoot+1));
return brc_mem_vec.elts();
}