int main (void) { matrix_t r = read_matrix (); matrix_t mayw; matrix_t mustw; dm_copy(&r, &mayw); dm_copy(&r, &mustw); printf ("matrix:\n"); dm_print (stdout, &r); // nub dm_sort_rows (&r, &mayw, &mustw, &max_row_first); dm_nub_rows (&r, &mayw, &mustw, &eq_rows, NULL); // optimize dm_optimize (&r, &mayw, &mustw); // sort again dm_sort_rows (&r, &mayw, &mustw, &max_row_first); printf ("matrix:\n"); dm_print (stdout, &r); printf ("state mapping:\n"); state_mapping (&r); printf ("transition mapping:\n"); transition_mapping (&r); printf ("dependencies:\n"); dependencies (&r); return 0; }
int main (void) { bitvector_t b1; bitvector_t b2; bitvector_create (&b1, 20); user_bitvector_print (&b1); bitvector_set (&b1, 4); user_bitvector_print (&b1); bitvector_copy (&b2, &b1); bitvector_unset (&b1, 4); user_bitvector_print (&b1); user_bitvector_print (&b2); // test is_empty printf ("is_empty b1? %c (should be t)\n", bitvector_is_empty(&b1)?'t':'f'); printf ("is_empty b2? %c (should be f)\n", bitvector_is_empty(&b2)?'t':'f'); // set even/odd bits in b1/b2 for(int i=0; i<20; ++i) { if (i%2) { bitvector_set(&b1,i); } else { bitvector_set(&b2,i); } } // print before union printf ("before union\n"); user_bitvector_print (&b1); user_bitvector_print (&b2); // disjoint? printf ("b1,b2 are disjoint %c (should be t)\n", bitvector_is_disjoint(&b1, &b2)?'t':'f'); printf ("union\n"); bitvector_union(&b1, &b2); // disjoint? printf ("b1,b2 are disjoint %c (should be f)\n", bitvector_is_disjoint(&b1, &b2)?'t':'f'); // print after union user_bitvector_print (&b1); user_bitvector_print (&b2); printf ("intersect\n"); bitvector_intersect(&b1, &b2); // disjoint? printf ("b1,b2 are disjoint %c (should be f)\n", bitvector_is_disjoint(&b1, &b2)?'t':'f'); // print after intersection user_bitvector_print (&b1); user_bitvector_print (&b2); printf ("invert b1\n"); bitvector_invert(&b1); // print after inversion user_bitvector_print (&b1); // disjoint? printf ("b1,b2 are disjoint %c (should be t)\n", bitvector_is_disjoint(&b1, &b2)?'t':'f'); bitvector_free (&b2); bitvector_free (&b1); matrix_t m1; matrix_t m2; dm_create (&m1, 10, 10); print_matrix (&m1); printf ("dm_set(4,4)\n"); dm_set (&m1, 4, 4); print_matrix (&m1); printf ("dm_unset(4,4)\n"); dm_unset (&m1, 4, 4); print_matrix (&m1); printf ("test shift permutation (3,4,5)(6,7)\n"); printf ("before\n"); dm_set (&m1, 3, 3); dm_set (&m1, 4, 4); dm_set (&m1, 5, 5); dm_set (&m1, 6, 6); dm_set (&m1, 7, 7); print_matrix (&m1); printf ("after\n"); // create permutation_group, apply permutation_group_t o1; dm_create_permutation_group (&o1, 2, NULL); dm_add_to_permutation_group (&o1, 3); dm_add_to_permutation_group (&o1, 4); dm_add_to_permutation_group (&o1, 5); dm_close_group (&o1); dm_add_to_permutation_group (&o1, 6); dm_add_to_permutation_group (&o1, 7); dm_permute_cols (&m1, &o1); print_matrix (&m1); dm_free_permutation_group (&o1); printf ("swap cols 6,7\n"); dm_swap_cols (&m1, 6, 7); print_matrix (&m1); printf ("swap rows 6,7\n"); dm_swap_rows (&m1, 6, 7); print_matrix (&m1); printf ("copy\n"); dm_create(&m2, dm_nrows(&m1), dm_ncols(&m1)); dm_copy (&m1, &m2); // TODO: needs some more work print_matrix (&m2); dm_sort_rows (&m1, &min_row_first); print_matrix (&m1); dm_sort_rows (&m1, &max_row_first); print_matrix (&m1); dm_print_perm (&(m1.row_perm)); printf ("to nub rows added & resorted\n"); dm_set (&m1, 7, 3); dm_set (&m1, 8, 4); dm_sort_rows (&m1, &max_row_first); print_matrix (&m1); printf ("flatten \n"); dm_flatten (&m1); print_matrix (&m1); dm_print_perm (&(m1.row_perm)); printf ("nub sorted\n"); //dm_nub_rows (&m1, &eq_rows, NULL); print_matrix (&m1); dm_print_perm (&(m1.row_perm)); /* * printf("again, now to test row order & nub idx\n"); dm_free(&m1); * dm_create(&m1, 10, 10); dm_set(&m1, 0,0); dm_set(&m1, 1,0); * dm_set(&m1, 2,3); dm_set(&m1, 3,3); print_matrix(&m1); * * printf("nub sorted\n"); * * dm_nub_rows(&m1); * * print_matrix(&m1); * * dm_print_perm(&(m1.row_perm)); */ printf ("optimize sorted\n"); dm_set (&m1, 0, 7); dm_set (&m1, 1, 6); dm_set (&m1, 3, 9); printf ("before\n"); print_matrix (&m1); dm_optimize (&m1); printf ("after\n"); print_matrix (&m1); printf ("resorted\n"); dm_sort_rows (&m1, &max_row_first); print_matrix (&m1); /* dm_nub_cols(&m1); dm_ungroup_rows(&m1); dm_ungroup_cols(&m1); print_matrix (&m1); */ // get bitvector from matrix text bitvector_create (&b1, 6); bitvector_create (&b2, 10); printf ("bitvector of row 0\n"); user_bitvector_print (&b2); printf ("bitvector of col 8\n"); user_bitvector_print (&b1); bitvector_free (&b2); bitvector_free (&b1); printf ("count test\n"); for (int i = 0; i < dm_nrows (&m1); i++) printf ("ones in row %d: %d\n", i, dm_ones_in_row (&m1, i)); for (int i = 0; i < dm_ncols (&m1); i++) printf ("ones in col %d: %d\n", i, dm_ones_in_col (&m1, i)); printf ("iterator test\n"); dm_row_iterator_t mx; dm_col_iterator_t my; for (int i = 0; i < dm_nrows (&m1); i++) { printf ("iterator row: %d\n", i); dm_create_row_iterator (&mx, &m1, i); int r; while ((r = dm_row_next (&mx)) != -1) printf (" next: %d\n", r); printf ("\n\n"); } for (int i = 0; i < dm_ncols (&m1); i++) { printf ("iterator col: %d\n", i); dm_create_col_iterator (&my, &m1, i); int r; while ((r = dm_col_next (&my)) != -1) printf (" next: %d\n", r); printf ("\n\n"); } printf ("projection test\n"); int s0[10]; int src[10]; int prj[2]; int tgt[10]; // initialize for (int i = 0; i < 10; i++) { s0[i] = -i; src[i] = i; } // do projection int prj_n = dm_project_vector (&m1, 0, src, prj); // print projection printf ("projection:"); for (int i = 0; i < prj_n; i++) { printf (" %d", prj[i]); } printf ("\n"); printf ("expansion test\n"); // do expansion int exp_n = dm_expand_vector (&m1, 0, s0, prj, tgt); (void)exp_n; // print expansion printf ("expansion:"); for (int i = 0; i < 10; i++) { printf (" %d", tgt[i]); } printf ("\n"); // subsumption printf ("subsumption test:\n"); dm_swap_rows (&m1, 0, 3); dm_swap_rows (&m1, 1, 2); dm_flatten (&m1); print_matrix (&m1); dm_subsume_rows (&m1, &eq_rows, NULL); printf ("after subsumption:\n"); print_matrix (&m1); printf ("\n"); printf ("after ungrouping:\n"); dm_ungroup_rows (&m1); print_matrix (&m1); printf ("\n"); printf ("column sort test:\n"); dm_flatten (&m1); printf ("max col first:\n"); dm_sort_cols (&m1, &max_col_first); print_matrix (&m1); printf ("min col first:\n"); dm_sort_cols (&m1, &min_col_first); print_matrix (&m1); printf ("nub columns test:\n"); dm_set (&m1, 0, 1); dm_set (&m1, 3, 1); dm_set (&m1, 3, 4); dm_set (&m1, 3, 5); dm_sort_cols (&m1, &max_col_first); // dm_flatten(&m1); printf ("max col first:\n"); print_matrix (&m1); //printf ("subsume columns:\n"); //dm_subsume_cols (&m1, &eq_cols, NULL); //dm_subsume_rows (&m1, &eq_rows, NULL); print_matrix (&m1); printf ("column permutation:\n"); dm_print_perm (&(m1.col_perm)); printf ("optimize columns:\n"); dm_optimize (&m1); print_matrix (&m1); //printf ("ungroup columns:\n"); //dm_ungroup_cols (&m1); //print_matrix (&m1); //printf ("all permutations:\n"); //dm_set (&m1, 0, 9); //dm_nub_cols(&m1, &eq_cols, NULL); //print_matrix (&m1); //dm_all_perm (&m1); dm_free (&m2); dm_free (&m1); return 0; }
void pins_model_init(model_t model) { lts_type_t ltstype; matrix_t *dm_info = malloc(sizeof(matrix_t)); matrix_t *dm_read_info = malloc(sizeof(matrix_t)); matrix_t *dm_must_write_info = malloc(sizeof(matrix_t)); // get ltstypes ltstype=lts_type_create(); const int state_length = pnml_vars; // adding types int ntypes = 2; int int_type = lts_type_add_type(ltstype, "int", NULL); int act_type =lts_type_add_type(ltstype, "action", NULL); lts_type_set_format (ltstype, int_type, LTStypeDirect); lts_type_set_format (ltstype, act_type, LTStypeEnum); lts_type_set_state_length(ltstype, state_length); // set state name & type for (int i=0; i < state_length; ++i) { lts_type_set_state_name(ltstype,i,pnml_var_names[i]); lts_type_set_state_typeno(ltstype,i,int_type); } // edge label types lts_type_set_edge_label_count (ltstype, 1); lts_type_set_edge_label_name(ltstype, 0, "action"); lts_type_set_edge_label_type(ltstype, 0, "action"); lts_type_set_edge_label_typeno(ltstype, 0, act_type); int bool_is_new, bool_type = lts_type_add_type(ltstype, LTSMIN_TYPE_BOOL, NULL); GBsetLTStype(model, ltstype); // must set ltstype before setting initial state // creates tables for types! if (bool_is_new) { GBchunkPutAt(model, bool_type, chunk_str(LTSMIN_VALUE_BOOL_FALSE), 0); GBchunkPutAt(model, bool_type, chunk_str(LTSMIN_VALUE_BOOL_TRUE ), 1); } // setting values for types for (int i = 0; i < pnml_groups; i++) { GBchunkPutAt(model, act_type, chunk_str((char*) pnml_group_names[i]), i); } // get initial state GBsetInitialState(model,pnml_initial_state); for (int i = 0; i < pnml_vars; i++) { if (max_token_count < pnml_initial_state[i]) { max_token_count = pnml_initial_state[i]; } } // get next state GBsetNextStateLong(model, (next_method_grey_t) pnml_get_successor); lts_type_validate(ltstype); // done with ltstype // initialize the state read/write dependency matrices dm_create(dm_read_info, pnml_groups, state_length); dm_create(dm_must_write_info, pnml_groups, state_length); for (int i = 0; i < pnml_groups; i++) { for (int j = 0; j < pnml_sources[i][0]; j++) { dm_set(dm_read_info, i, pnml_sources[i][j*2+1]); dm_set(dm_must_write_info, i, pnml_sources[i][j*2+1]); } for (int j = 0; j < pnml_targets[i][0]; j++) { if (!pnml_safe_places[pnml_targets[i][j*2+1]]) { /* If the place is safe we don't need to mark it read-dependent. */ dm_set(dm_read_info, i, pnml_targets[i][j*2+1]); } dm_set(dm_must_write_info, i, pnml_targets[i][j*2+1]); } } dm_copy(dm_read_info, dm_info); dm_apply_or(dm_info, dm_must_write_info); GBsetDMInfo(model, dm_info); GBsetDMInfoRead(model, dm_read_info); GBsetDMInfoMustWrite(model, dm_must_write_info); GBsetSupportsCopy(model); GBsetExit(model, pnml_exit); matrix_t *dna_info = malloc(sizeof(matrix_t)); dm_create(dna_info, pnml_groups, pnml_groups); for (int i = 0; i < pnml_groups; i++) { for(int j = 0; j < pnml_groups; j++) { const int guards_i = pnml_sources[i][0]; const int guards_j = pnml_sources[j][0]; for (int g = 0; g < guards_i; g++) { const int guard_i = pnml_sources[i][g * 2 + 1]; for (int h = 0; h < guards_j; h++) { const int guard_j = pnml_sources[j][h * 2 + 1]; if (guard_i == guard_j) { dm_set(dna_info, i, j); goto next_dna; } } } next_dna:; } } GBsetDoNotAccordInfo(model, dna_info); matrix_t *gnes_info = malloc(sizeof(matrix_t)); dm_create(gnes_info, pnml_vars, pnml_groups); for(int i = 0; i < pnml_groups; i++) { const int targets = pnml_targets[i][0]; for (int t = 0; t < targets; t++) { const int target = pnml_targets[i][t * 2 + 1]; dm_set(gnes_info, target, i); } } GBsetGuardNESInfo(model, gnes_info); matrix_t *gnds_info = malloc(sizeof(matrix_t)); dm_create(gnds_info, pnml_vars, pnml_groups); for(int i = 0; i < pnml_groups; i++) { const int sources = pnml_sources[i][0]; for (int s = 0; s < sources; s++) { const int source = pnml_sources[i][s * 2 + 1]; dm_set(gnds_info, source, i); } } GBsetGuardNDSInfo(model, gnds_info); matrix_t *ndb_info = malloc(sizeof(matrix_t)); dm_create(ndb_info, pnml_groups, pnml_groups); for (int i = 0; i < pnml_groups; i++) { const int sources = pnml_sources[i][0]; for (int j = 0; j < pnml_groups; j++) { const int targets = pnml_targets[j][0]; for (int s = 0; s < sources; s++) { const int source = pnml_sources[i][s * 2 + 1]; for (int t = 0; t < targets; t++) { const int target = pnml_targets[j][t * 2 + 1]; if (source == target) { dm_set(ndb_info, i, j); goto next_ndb; } } } next_ndb:; } } GBsetMatrix(model, LTSMIN_NOT_LEFT_ACCORDS, ndb_info, PINS_STRICT, PINS_INDEX_OTHER, PINS_INDEX_OTHER); }
int dm_optimize (matrix_t *r, matrix_t *mayw, matrix_t *mustw) { HREassert( dm_ncols(r) == dm_ncols(mayw) && dm_nrows(r) == dm_nrows(mayw) && dm_ncols(r) == dm_ncols(mustw) && dm_nrows(r) == dm_nrows(mustw), "matrix sizes do not match"); matrix_t* test = RTmalloc(sizeof(matrix_t)); dm_create(test, dm_nrows(r), dm_ncols(r)); dm_copy(r, test); dm_apply_or(test, mayw); int d_rot[dm_ncols (r)]; permutation_group_t rot; int best_i = 0, best_j = 0, min = cost_ (r, mayw), last_min = 0; int i, j, c, k, d; int firsts[dm_nrows(r)]; int lasts[dm_nrows(r)]; while (last_min != min) { last_min = min; // initialize first and last integers per row for (i=0; i<dm_nrows(r); i++) { firsts[i] = first_(test,i); lasts[i] = last_(test,i); } // find best rotation for (i = 0; i < dm_ncols (r); i++) { for (j = 0; j < dm_ncols (r); j++) { if (i != j) { c=estimate_cost(test,i,j,firsts,lasts); if (c < min) { min = c; best_i = i; best_j = j; } } } } // rotate if (best_i != best_j) { d = best_i < best_j ? 1 : -1; dm_create_permutation_group (&rot, dm_ncols (r), d_rot); for (k = best_i; k != best_j; k += d) dm_add_to_permutation_group (&rot, k); dm_add_to_permutation_group (&rot, best_j); dm_permute_cols (r, &rot); dm_permute_cols (mayw, &rot); dm_permute_cols (mustw, &rot); dm_permute_cols (test, &rot); dm_free_permutation_group (&rot); DMDBG (printf("best rotation: %d-%d, costs %d\n", best_i, best_j, min)); DMDBG (dm_print_combined (stdout, r, mayw, mustw)); best_i = best_j = 0; } } DMDBG (printf ("cost: %d ", cost_ (r, mayw))); dm_free(test); return 0; }