// tostring, not for drawing
void
gridfont_print
(
gridfont *gf
)
{
printf("GRID FONT\n");
printf("State: %s\n", gridfont_statestrings[gf->state]);
if (gf->state & (GRIDFONT_BAD | GRIDFONT_EMPTY)) return;
printf("Max width: %d\t Max height: %d\n", gf->maxwidth, gf->maxheight);
printf("Midline: %d\t Baseline: %d\n", gf->midline, gf->baseline);
printf("Letter space: %d\t Word space: %d\n", gf->letterspace, gf->wordspace);
for (int i = 0; i < GRIDFONT_NUMCHARS; i++) {
if (gf->chars[i] != NULL) {
printf("%c:\t Width: %d\t", (char)i, gf->widths[i]);
bitvector_print(gf->chars[i]);
}
}
}
boolformula_t *learn_core (void *info,
uscalar_t num_vars,
membership_t membership, membership_t comembership,
equivalence_t equivalence, int mode)
{
equivalence_result_t *eq_result;
conjunction *conjecture;
vector *bases;
bases = vector_new (0);
conjecture = get_conjecture (bases);
boolformula_t* b_conjecture = cdnfformula_to_boolformula (conjecture);
vector_free (conjecture);
eq_result = (*equivalence) (info, num_vars, boolformula_copy (b_conjecture));
if (eq_result->is_equal) {
//fprintf(stderr,"Number of Variables Used : %d\n", (unsigned int)num_vars);
free(eq_result);
return b_conjecture;
} else {
boolformula_free(b_conjecture);
}
#ifdef DEBUG
fprintf (stderr, "add first basis with ");
bitvector_print (eq_result->counterexample);
#endif
assert (bitvector_length (eq_result->counterexample) == num_vars + 1);
add_basis (bases, eq_result->counterexample);
bitvector_free (eq_result->counterexample);
free(eq_result);
while (true) {
vector *I;
bitvector *v;
uscalar_t j, length;
conjecture = get_conjecture (bases);
#ifdef DEBUG
fprintf (stderr, "new conjecture = ");
boolformula_print (conjecture);
#endif
boolformula_t* b_conjecture = cdnfformula_to_boolformula (conjecture);
vector_free (conjecture);
eq_result = (*equivalence) (info, num_vars, boolformula_copy (b_conjecture));
if (eq_result->is_equal) {
//fprintf(stderr,"Number of Variables Used : %d\n", (unsigned int)num_vars);
cleanup (bases);
free (eq_result);
return b_conjecture;
} else {
boolformula_free(b_conjecture);
}
/* H_i's are still in bases, only free the conjunction */
assert (bitvector_length (eq_result->counterexample) == num_vars + 1);
v = eq_result->counterexample;
I = get_indices_to_modify (bases, v);
if (vector_length (I) == 0) {
if(mode==CDNF_Plus3 && (*membership)(info,v)==true) {
#ifdef DEBUG
fprintf (stderr, "conflict detected on: ");
bitvector_print (v);
fprintf (stderr, "num of variables: %d \n",num_vars);
#endif
refine_bases(info, membership,comembership,bases,mode);
num_vars++;
} else {
#ifdef DEBUG
fprintf (stderr, "add basis: ");
bitvector_print (v);
#endif
add_basis (bases, v);
}
bitvector_free (v);
free(eq_result);
vector_free (I);
continue;
}
free(eq_result);
#ifdef DEBUG
fprintf (stderr, "fix m_dnf with ");
bitvector_print (v);
#endif
length = vector_length (I);
for (j = 0; j < length; j++) {
uscalar_t i;
basis *B;
bitvector *a_i, *v_i, *xor;
vector *T_i;
disjunction *H_i;
monomial *m;
i = (uscalar_t) vector_get (I, j);
B = (basis *) vector_get (bases, i);
a_i = B->a;
T_i = B->T;
H_i = B->H;
v_i = bitvector_copy (v);
walk (info, membership, v_i, a_i);
xor = bitvector_xor (v_i, a_i);
/* when xor == 0, a conflict has occurred. */
/* assert (!bitvector_is_zeros (xor)); */
if (bitvector_is_zeros (xor)) {
#ifdef DEBUG
fprintf (stderr, "conflict with the basis ");
bitvector_print (a_i);
#endif
bitvector_free (xor);
bitvector_free (v_i);
if(mode==CDNF_PlusPlus||mode==CDNF_Plus3) {
/* increase the number of variables */
#ifdef DEBUG
fprintf (stderr, "num of variables: %d \n",num_vars);
#endif
refine_bases (info, membership, comembership, bases,mode);
num_vars++;
} else {
bitvector_free (v);
vector_free (I);
return NULL;
}
break;
}
#ifdef DEBUG
fprintf (stderr, "add support ");
bitvector_print (v_i);
#endif
/* store v_i in T_i */
/* note that the original CDNF algorithm stores xor in S_i */
vector_add (T_i, v_i);
/* compute M_DNF (v_i + a_i) */
m = cdnfformula_monomial_M_DNF (xor);
/* compute m (x ^ a_i) */
m = compute_m_of_x_xor_a (m, a_i);
vector_add (H_i, m);
bitvector_free (xor);
}
bitvector_free (v);
vector_free (I);
}
}
void refine_bases (void *info,
membership_t membership, membership_t comembership,
vector *bases, int mode)
{
uscalar_t i, length;
length = vector_length (bases);
#ifdef DEBUG
fprintf (stderr, "refine bases, num of DNF = %d",length);
#endif
for (i = 0; i < length; i++) {
basis *B;
bitvector *a_i;
vector *T_i;
uscalar_t l, T_i_len, j;
bool b;
B = (basis *) vector_get (bases, i);
/*
* extends each unsatisfying assignment by FALSE
*/
a_i = B->a;
l = bitvector_length (a_i);
bitvector_resize (a_i, l + 1);
bitvector_set (a_i, l, false);
if(mode==CDNF_PlusPlus)
b = (*comembership) (info, a_i) == true ? false : true;
else
b=false;
bitvector_set (a_i, l, b);
#ifdef DEBUG
fprintf (stderr, "extends basis: ");
bitvector_print (a_i);
#endif
#ifdef DEBUG
fprintf (stderr, "extends support: ");
#endif
T_i = B->T;
T_i_len = vector_length (T_i);
/* except the last basis, all bases have at least one support */
assert (i == length - 1 || T_i_len > 0);
for (j = 0; j < T_i_len; j++) {
bitvector *v;
bool c;
/*
* extends v to v+b if MEM (v+b) = YES
* to v+!b if MEM (v+b) = NO
*/
v = (bitvector *)vector_get (T_i, j);
assert (bitvector_length (v) == l);
bitvector_resize (v, l + 1);
bitvector_set (v, l, b);
c = (*membership) (info, v) == true ? b : !b;
if (c != b)
bitvector_set (v, l, c);
#ifdef DEBUG
bitvector_print (v);
#endif
}
/* clean up disjunction for the current basis */
cdnfformula_disjunction_free (B->H);
B->H = NULL;
/* remove the last basis if it has no support */
if (T_i_len == 0) {
assert (i == length - 1);
bitvector_free (a_i);
vector_free (T_i);
free (vector_get (bases, length - 1));
vector_resize (bases, length - 1);
}
}
/*
* reconstruct disjunctions for the bases
*/
rebuild_disjunctions (bases);
}
