static Tree traced_simplification(Tree sig)
{
assert(sig);
#ifdef TRACE
cerr << ++TABBER << "Start simplification of : " << ppsig(sig) << endl;
/*
fprintf(stderr, "\nStart simplification of : ");
printSignal(sig, stderr);
fprintf(stderr, "\n");
*/
#endif
Tree r = simplification(sig);
assert(r!=0);
#ifdef TRACE
cerr << --TABBER << "Simplification of : " << ppsig(sig) << " Returns : " << ppsig(r) << endl;
/*
fprintf(stderr, "Simplification of : ");
printSignal(sig, stderr);
fprintf(stderr, " -> ");
printSignal(r, stderr);
fprintf(stderr, "\n");
*/
#endif
return r;
}
static Tree simplification (Tree sig)
{
assert(sig);
int opnum;
Tree t1, t2, t3, t4;
xtended* xt = (xtended*) getUserData(sig);
// primitive elements
if (xt)
{
//return 3;
vector<Tree> args;
for (int i=0; i<sig->arity(); i++) { args.push_back( sig->branch(i) ); }
// to avoid negative power to further normalization
if (xt != gPowPrim) {
return xt->computeSigOutput(args);
} else {
return normalizeAddTerm(xt->computeSigOutput(args));
}
} else if (isSigBinOp(sig, &opnum, t1, t2)) {
BinOp* op = gBinOpTable[opnum];
Node n1 = t1->node();
Node n2 = t2->node();
if (isNum(n1) && isNum(n2)) return tree(op->compute(n1,n2));
else if (op->isLeftNeutral(n1)) return t2;
else if (op->isRightNeutral(n2)) return t1;
else return normalizeAddTerm(sig);
} else if (isSigDelay1(sig, t1)) {
return normalizeDelay1Term (t1);
} else if (isSigFixDelay(sig, t1, t2)) {
return normalizeFixedDelayTerm (t1, t2);
} else if (isSigIntCast(sig, t1)) {
Tree tx;
int i;
double x;
Node n1 = t1->node();
if (isInt(n1, &i)) return t1;
if (isDouble(n1, &x)) return tree(int(x));
if (isSigIntCast(t1, tx)) return t1;
return sig;
} else if (isSigFloatCast(sig, t1)) {
Tree tx;
int i;
double x;
Node n1 = t1->node();
if (isInt(n1, &i)) return tree(double(i));
if (isDouble(n1, &x)) return t1;
if (isSigFloatCast(t1, tx)) return t1;
return sig;
} else if (isSigSelect2(sig, t1, t2, t3)){
Node n1 = t1->node();
if (isZero(n1)) return t2;
if (isNum(n1)) return t3;
if (t2==t3) return t2;
return sig;
} else if (isSigSelect3(sig, t1, t2, t3, t4)){
Node n1 = t1->node();
if (isZero(n1)) return t2;
if (isOne(n1)) return t3;
if (isNum(n1)) return t4;
if (t3==t4) return simplification(sigSelect2(t1,t2,t3));
return sig;
} else {
return sig;
}
}
int main(int argc, char **argv)
{
// initialisation des paramètres de GLUT en fonction
// des arguments sur la ligne de commande
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
maille = Maillage::lectureOff("C:/Users/etu/Downloads/bunny.off", 10);
maille.calculNormalTriangle();
//bunny.Ecriture("bunny.obj");
rayon = 0;
rayonX = (maille.xMax - maille.xMin) / maille.getScale();
rayonY = (maille.yMax - maille.yMin) / maille.getScale();
rayonZ = (maille.zMax - maille.zMin) / maille.getScale();
if (rayonX > rayonY)
{
if (rayonX > rayonZ)
rayon = rayonX;
else
rayon = rayonZ;
}
else
{
if (rayonY> rayonZ)
rayon = rayonY;
else
rayon = rayonZ;
}
std::vector<Vector3D> geometrie = maille.getGeom();
Vector3D centre = maille.getCentreGravite();
double scale = maille.getScale();
for (int i = 0; i < geometrie.size(); i++)
{
geometrie[i] = (geometrie[i] - centre) / scale;
}
maille.setGeom(geometrie);
subdivision(maille.getCentreGravite(), rayon, 1);
simplification();
// définition et création de la fenêtre graphique
glutInitWindowSize(WIDTH, HEIGHT);
glutInitWindowPosition(0, 0);
glutCreateWindow("Primitives graphiques");
// initialisation de OpenGL et de la scène
initGL();
init_scene();
// choix des procédures de callback pour
// le tracé graphique
glutDisplayFunc(&window_display);
// le redimensionnement de la fenêtre
glutReshapeFunc(&window_reshape);
// la gestion des événements clavier
glutKeyboardFunc(&window_key);
glutIdleFunc(&window_idle);
// la boucle prinicipale de gestion des événements utilisateur
glutMainLoop();
return 1;
}
int main(void) {
INFO("MIN-FACTORIZATION");
PRINT_LICENSE_INFORMATION;
PRINT_SYSTEM_INFORMATION;
pmytime timer= MYTIME_create_with_name("Timer");
pmytime ttot= MYTIME_create_with_name("Total");
MYTIME_start(ttot);
plist p= read_factorizations(stdin);
//Inizializzo a NULL
pbit_vect bv=NULL;
MYTIME_start(timer);
INFO("Colored matrix creation...");
bool is_not_window;
//Colorazione della matrice sulla base degli esoni come fattori unici
is_not_window=true;
//Colorazione della matrice sulla base delle finestre di contenimento degli esoni
is_not_window=false;
plist unique_factors= color_matrix_create(p, is_not_window);
// color_matrix_print(p);
INFO("Colored matrix created!");
#if defined (LOG_MSG) && (LOG_LEVEL_DEBUG <= LOG_THRESHOLD)
print_factors_list(unique_factors,is_not_window);
#endif
//exit(1);
/*plistit list_it_est=list_first(p);
while(listit_has_next(list_it_est)){
pEST est=listit_next(list_it_est);
plistit temp=list_first(est->bin_factorizations);
while(listit_has_next(temp)){
fprintf(stdout, ">EST %s\n", est->info->EST_id);
pbit_vect ltemp=(pbit_vect)listit_next(temp);
unsigned int i;
for(i=0; i<ltemp->n; i++){
fprintf(stdout, "%d", BV_get(ltemp,i));
}
fprintf(stdout, "\n");
}
listit_destroy(temp);
}
listit_destroy(list_it_est);
exit(1);*/
MYTIME_stop(timer);
MYTIME_LOG(INFO, timer);
MYTIME_reset(timer);
MYTIME_start(timer);
INFO("Starting simplification");
psimpl psimp= simplification(p,unique_factors);
psimpl_print(psimp);
/*unsigned int j;
fprintf(stdout, "Used: ");
for(j=0; j<psimp->factors_used->n; j++){
if(BV_get(psimp->factors_used,j))
fprintf(stdout, "%d-", j);
}*/
//exit(1);
//fprintf(stdout, "ESTs %d factors %d\n", list_size(p), psimp->factors_used->n);
//exit(1);
/*unsigned int j;
fprintf(stdout, "Used: ");
for(j=0; j<psimp->factors_used->n; j++){
if(BV_get(psimp->factors_used,j))
fprintf(stdout, "%d-", j);
}
fprintf(stdout, "\n");
fprintf(stdout, "ESTs ok: ");
unsigned int c=0;
for(j=0; j<psimp->ests_ok->n; j++){
if(BV_get(psimp->ests_ok,j)){
fprintf(stdout, "%d-", j);
c++;
}
}
fprintf(stdout, "\nSimplified rows %d", c);
fprintf(stdout, "\n");
fprintf(stdout, "Not used: ");
for(j=0; j<psimp->factors_not_used->n; j++){
if(BV_get(psimp->factors_not_used,j))
fprintf(stdout, "%d-", j);
}
fprintf(stdout, "\n");
exit(1);*/
//printf("usati: %s", BV_to_string(psimp->ests_ok));
//exit(1);
plist pl= color_matrix_simplified_create(p,psimp);
//color_matrix_print(pl);
//exit(1);
//Se pl e' vuota significa che tutti i fattori sono necessari
INFO("Simplification terminated!");
MYTIME_stop(timer);
MYTIME_LOG(INFO, timer);
MYTIME_reset(timer);
MYTIME_start(timer);
INFO("Start search of the minimum factorization");
if(!BV_all_true(psimp->ests_ok)){
bv= min_fact(pl);
INFO("Search of the minimum factorization completed");
} else {
INFO("Minimum factorization is already found by simplification.");
}
print_factorizations_result(bv,p,unique_factors,psimp);
unsigned int q;
unsigned int count_used_opt=0;
for(q=0; q<psimp->factors_used->n; q++){
if (BV_get(psimp->factors_used,q)){
//INFO("U %d ", q);
count_used_opt++;
}
}
INFO("Factors used in the optimum: %d", count_used_opt);
MYTIME_stop(timer);
MYTIME_LOG(INFO, timer);
list_destroy(p,(delete_function)EST_destroy);
color_matrix_simplified_destroy(pl);
list_destroy(unique_factors,(delete_function)factor_destroy);
psimpl_destroy(psimp);
//Controllo!! Altrimenti potrebbe dare segm. fault!!
if(bv != NULL)
BV_destroy(bv);
MYTIME_stop(ttot);
MYTIME_LOG(INFO, ttot);
MYTIME_destroy(ttot);
MYTIME_destroy(timer);
}
