static void test_congruences(uint32_t n) {
uint32_t k;
composite_t *tmp, *root;
uint32_t nroots;
composite_t *roots[n];
nroots = 0;
for (k=0; k<n; k++) {
print_composite(stdout, composite[k]);
printf("\n");
signature_composite(composite[k], label, &sgn);
printf("---> signature = ");
print_signature(stdout, &sgn);
printf("\n");
root = congruence_table_find(&tbl, &sgn, label);
if (root == NULL) {
printf("---> not in congruence table\n");
} else {
printf("---> congruent to term: ");
print_composite(stdout, root);
printf("\n");
}
tmp = congruence_table_get(&tbl, composite[k], &sgn, label);
printf("---> get returns: ");
print_composite(stdout, tmp);
printf("\n");
if (tmp == composite[k] && root == NULL) {
printf("---> added as congruence root\n");
roots[nroots] = tmp;
nroots ++;
} else if (tmp == root && root != NULL) {
printf("---> confirmed congruence\n");
} else {
printf("\n*** BUG: get/find disagree ***\n");
}
printf("\n");
fflush(stdout);
}
for (k=0; k<nroots; k++) {
tmp = roots[k];
printf("---> removing root: ");
print_composite(stdout, tmp);
printf("\n");
congruence_table_remove(&tbl, tmp);
}
printf("\n");
fflush(stdout);
}
void print_eterm_details(FILE *f, egraph_t *egraph, eterm_t t) {
composite_t *c;
fputs("--- Term ", f);
print_eterm_id(f, t);
fputs(" ---\n", f);
c = egraph_term_body(egraph, t);
if (constant_body(c)) {
fputs("constant\n", f);
} else if (c == VARIABLE_BODY) {
fputs("variable\n", f);
} else if (c == NULL) {
fputs("deleted\n", f);
} else {
fputs("body: ", f);
print_composite(f, c);
fputc('\n', f);
}
if (c != NULL) {
fputs("label: ", f);
print_label(f, egraph_term_label(egraph, t));
fputc('\n', f);
}
}
void print_eterm_def(FILE *f, egraph_t *egraph, eterm_t t) {
composite_t *c;
#if 0
thvar_t x;
etype_t tau;
#endif
print_eterm_id(f, t);
c = egraph_term_body(egraph, t);
if (constant_body(c)) {
fputs(" (constant)\n", f);
} else if (c == VARIABLE_BODY) {
fputs(" (variable)\n", f);
} else if (c == NULL) {
fputs(" (deleted)\n", f);
} else {
fputs(" := ", f);
print_composite(f, c);
fputc('\n', f);
}
#if 0
x = egraph_term_base_thvar(egraph, t);
if (x != null_thvar) {
fputs(" thvar: ", f);
print_thvar(f, x);
tau = egraph_term_type(egraph, t);
fputs(", ", f);
print_theory_id(f, tau);
fputc('\n', f);
}
#endif
}
void print_parents_details(FILE *f, use_vector_t *v) {
uint32_t i, n;
composite_t *p;
n = v->last;
for (i=0; i<n; i++) {
p = v->data[i];
if (valid_entry(p)) {
fputs(" ", f);
print_composite(f, p);
fputc('\n', f);
} else if (marked_entry(p)) {
fputs(" ", f);
print_composite(f, unmark_entry(p));
fputs(" [hidden]\n", f);
}
}
}
static void test_eq(arena_t *m, occ_t t1, occ_t t2) {
composite_t *tmp;
tmp = arena_eq_composite(m, t1, t2);
signature_composite(tmp, label, &sgn);
print_composite(stdout, tmp);
printf("\t---> signature = ");
print_signature(stdout, &sgn);
printf("\n");
}
/*
* Term in egraph
*/
void print_eterm(FILE *f, egraph_t *egraph, eterm_t t) {
composite_t *c;
c = egraph_term_body(egraph, t);
if (atomic_body(c)) {
print_eterm_id(f, t);
} else {
print_composite(f, c);
}
}
static void print_composites(uint32_t n) {
uint32_t k;
printf("==== Terms ====\n");
for (k=0; k<n; k++) {
printf("cmp[%"PRIu32"] = ", k);
print_composite(stdout, composite[k]);
printf("\n");
}
fflush(stdout);
}
static void test_signatures(uint32_t n) {
uint32_t k;
for (k=0; k<n; k++) {
printf("cmp[%"PRIu32"] = ", k);
print_composite(stdout, composite[k]);
printf("\n");
signature_composite(composite[k], label, &sgn);
printf("---> signature = ");
print_signature(stdout, &sgn);
printf("\n");
}
}
/*
* Parent vectors: skip all non-valid entries
*/
void print_parents(FILE *f, use_vector_t *v) {
uint32_t i, n;
composite_t *p;
n = v->last;
for (i=0; i<n; i++) {
p = v->data[i];
if (valid_entry(p)) {
fputs(" ", f);
print_composite(f, p);
fputc('\n', f);
}
}
}
static void test_or3(arena_t *m, occ_t t1, occ_t t2, occ_t t3) {
occ_t aux[3];
composite_t *tmp;
aux[0] = t1;
aux[1] = t2;
aux[2] = t3;
tmp = arena_or_composite(m, 3, aux);
signature_or(tmp, label, &sgn);
print_composite(stdout, tmp);
printf("\t---> signature = ");
print_signature(stdout, &sgn);
printf("\n");
}
int main(unsigned argc, char *argv[])
{
unsigned h, i, j, k, n, e[N], f[N];
unsigned en, nn;
double last, dl, max, val, d, dd, vval;
init_prime_logs();
setlinebuf(stdout);
vval=0.0;
dd= 1.0;
if (argc > 1 && 1 != sscanf(argv[1],"%lf",&vval))
exit( printf("usage: %s [ln_minimal_number [at_least_d]]\n",argv[0]), 1);
if (argc > 2 && (1 != sscanf(argv[2],"%lf",&dd) || dd <= 0.0))
exit( printf("usage: %s [ln_minimal_number [at_least_d]]\n",argv[0]), 1);
for (i=0;i<N;i++)
e[i]=0;
n=nn=0;
for (k=0;n<N;k++)
{
print_composite(k, vval, dd, f, nn);
last=vval;
max= last + 0.6931471805599453; /** ln(2); **/
dl= dd;
vval= max;
for (i=0;i<n;i++)
e[i]=0;
n=1;
val= 0.0;
d = 1.0;
do {
i=0;
do {
while (e[i]+1 > 2*(unsigned)(lnp[n]/lnp[i]))
i++;
if (i==n) n++;
en= e[i]+1;
for (j=0;j<=i;j++)
{
val -= e[j]*lnp[j];
d /= e[j]+1;
e[j]=en;
if ((en+1)*lnp[j] < lnp[n-1])
e[j]= lnp[n-1]/lnp[j];
val += e[j]*lnp[j];
d *= e[j]+1;
}
if (val > vval && en==1) goto done;
i++;
} while (val > vval);
if (val > last && d > dl*(1.0+1e-12))
{
dd= d;
vval= val;
nn=n;
for (i=0;i<n;i++)
f[i]=e[i];
}
} while (1);
done:
}
return 0;
}
/*
* Print a congruence root c = composite in the congruence table
*/
static void print_congruence_root(FILE *f, composite_t *c) {
print_eterm_id(f, c->id);
fputs(" := ", f);
print_composite(f, c);
fputc('\n', f);
}
/*
* Print definitions of all terms
*/
void print_egraph_terms(FILE *f, egraph_t *egraph) {
composite_t *c;
uint32_t i, n;
thvar_t x;
n = egraph->terms.nterms;
for (i=0; i<n; i++) {
print_eterm_id(f, i);
c = egraph_term_body(egraph, i);
if (constant_body(c)) {
fputs(" (constant) ", f);
} else if (c == VARIABLE_BODY) {
fputs(" (variable) ", f);
} else if (c == NULL) {
fputs(" (deleted) ", f);
} else {
fputs(" := ", f);
print_composite(f, c);
}
fputs("\t\t", f);
print_type(f, egraph->types, egraph_term_real_type(egraph, i));
// fputs("\t\tetype = ", f);
// print_etype(f, egraph_class_type(egraph, i));
x = egraph_term_base_thvar(egraph, i);
if (x != null_thvar) {
fputs("\t\t", f);
switch(egraph_term_type(egraph, i)) {
case ETYPE_INT:
fprintf(f, "arith(i!%"PRId32")\t\t", x);
break;
case ETYPE_REAL:
fprintf(f, "arith(z!%"PRId32")\t\t", x);
break;
case ETYPE_BV:
fprintf(f, "bv(u!%"PRId32")\t\t", x);
break;
case ETYPE_FUNCTION:
fprintf(f, "fun(f!%"PRId32")", x);
break;
case ETYPE_BOOL:
fprintf(f, "lit(p!%"PRId32")\t\t", x);
print_bval(f, bvar_value(egraph->core, x));
break;
case ETYPE_TUPLE:
fprintf(f, "tup(g!%"PRId32")", x);
break;
default:
fprintf(f, "BADTHVAR(%"PRId32")", x);
break;
}
} else {
if (egraph_term_is_true(egraph, i)) {
fputs("\t\t(true term)", f);
} else if (egraph_term_is_false(egraph, i)) {
fputs("\t\t(false term)", f);
}
}
fputc('\n', f);
}
}
