void EnumerationDyn<FT>::enumerate(int first, int last, FT &fmaxdist, long fmaxdistexpo,
const vector<FT> &target_coord, const vector<enumxt> &subtree,
const vector<enumf> &pruning, bool _dual, bool subtree_reset)
{
bool solvingsvp = target_coord.empty();
dual = _dual;
pruning_bounds = pruning;
target = target_coord;
if (last == -1)
last = _gso.d;
d = last - first;
fx.resize(d);
FPLLL_CHECK(d < maxdim, "enumerate: dimension is too high");
FPLLL_CHECK((solvingsvp || !dual), "CVP for dual not implemented! What does that even mean? ");
FPLLL_CHECK((subtree.empty() || !dual), "Subtree enumeration for dual not implemented!");
resetflag = !_max_indices.empty();
if (resetflag)
reset_depth = _max_indices[last - subtree.size() - 1];
if (solvingsvp)
{
for (int i = 0; i < d; ++i)
center_partsum[i] = 0.0;
}
else
{
for (int i = 0; i < d; ++i)
center_partsum[i] = target_coord[i + first].get_d();
}
FT fr, fmu, fmaxdistnorm;
long rexpo, normexp = -1;
for (int i = 0; i < d; ++i)
{
fr = _gso.get_r_exp(i + first, i + first, rexpo);
normexp = max(normexp, rexpo + fr.exponent());
}
fmaxdistnorm.mul_2si(fmaxdist, dual ? normexp - fmaxdistexpo : fmaxdistexpo - normexp);
maxdist = fmaxdistnorm.get_d(GMP_RNDU);
_evaluator.set_normexp(normexp);
if (dual)
{
for (int i = 0; i < d; ++i)
{
fr = _gso.get_r_exp(i + first, i + first, rexpo);
fr.mul_2si(fr, rexpo - normexp);
rdiag[d - i - 1] = enumf(1.0) / fr.get_d();
}
for (int i = 0; i < d; ++i)
{
for (int j = i + 1; j < d; ++j)
{
_gso.get_mu(fmu, j + first, i + first);
mut[d - j - 1][d - i - 1] = -fmu.get_d();
}
}
}
else
{
for (int i = 0; i < d; ++i)
{
fr = _gso.get_r_exp(i + first, i + first, rexpo);
fr.mul_2si(fr, rexpo - normexp);
rdiag[i] = fr.get_d();
}
for (int i = 0; i < d; ++i)
{
for (int j = i + 1; j < d; ++j)
{
_gso.get_mu(fmu, j + first, i + first);
mut[i][j] = fmu.get_d();
}
}
}
subsoldists = rdiag;
save_rounding();
prepare_enumeration(subtree, solvingsvp, subtree_reset);
do_enumerate();
restore_rounding();
fmaxdistnorm = maxdist; // Exact
fmaxdist.mul_2si(fmaxdistnorm, dual ? fmaxdistexpo - normexp : normexp - fmaxdistexpo);
if (dual && !_evaluator.empty())
{
for (auto it = _evaluator.begin(), itend = _evaluator.end(); it != itend; ++it)
reverse_by_swap(it->second, 0, d - 1);
}
}
/* this functions copies, in a less than intelligent fashion, the Nadav's code
* from hspell_check_word. TODO: use the same code for both functions. */
int hspell_enum_splits(struct dict_radix *dict, const char *word,
hspell_word_split_callback_func *enumf)
{
int preflen=0, count=0;
int hashebrew;
const char *w=word;
struct prefix_node *n;
/* ignore empty words: */
hashebrew=0;
while(*w){
if(*w>='א' && *w<='ת'){
hashebrew=1;
break;
}
preflen++;
w++;
}
if(!hashebrew)
return -1; /* ignore empty words */
n=prefix_tree;
if(hspell_debug)
fprintf(stderr,"enum_splits looking %s\n",w);
while(*w && n){
/* eat up the " if necessary, to recognize words like
* ה"שטיח". or הידיעה ש"המידע...".
* See the Academy's punctuation rules (see לשוננו לעם, טבת,
* תשס"ב) for an explanation of this rule (we're probably don't
* support here everything they suggested; in particular I
* don't recognize a single quote as valid form of merchaot).
*/
if(*w=='"'){
preflen++;
w++;
continue;
}
/* The first case here is the Academia's "ha-ktiv hasar
* ha-niqqud" rule of doubling a consonant waw in the middle
* a word, unless it's already next to a waw. When adding a
* prefix, any initial waw in a word will necessarily
* become a consonant waw in the middle of the word.
* The "else if" below is the normal check.
*/
if(n!=prefix_tree && *w=='ו' && w[-1]!='ו'){
if(w[1]=='ו'){
if(w[2]!='ו' && (lookup(dict,w+1) & n->mask)){
w++;
/* for example: הוועד */
if(hspell_debug)
fprintf(stderr,"found %s: double waw.\n",w);
enumf(word, w, preflen++, n->mask);
n=n->next[*w-'א']; w++;
count++;
continue;
} else if(lookup(dict,w) & n->mask){
/* for example: הווים */
if(hspell_debug)
fprintf(stderr,"found %s: nondouble waw.\n",w);
enumf(word, w, preflen++, n->mask);
n=n->next[*w-'א']; w++;
count++;
continue;
}
}
} else {
if (hspell_debug) fprintf (stderr, "enum_splits: tried %s mask %d prefmask %d\n",w,lookup(dict,w), n->mask);
if(lookup(dict,w) & n->mask) {
enumf(word, w, preflen++, n->mask);
n=n->next[*w-'א']; w++;
count++;
continue;
} /* found word! */
}
/* try the next prefix... */
if(*w>='א' && *w<='ת'){
n=n->next[*w-'א'];
preflen++;
w++;
} else {
break;
}
}
if(n && !*w){
/* allow prefix followed by nothing (or a non-word like
* number, maqaf, etc.) */
if(hspell_debug) fprintf(stderr,"Accepting empty word\n");
enumf(word, w, preflen, n->mask);
count++;
} /* else
return 0; unrecognized (misspelled) word */
if (hspell_debug) fprintf(stderr, "enum_splits found %d splits\n", count);
return count;
}
