graph_t *KCoreGraph::subgraph(IntStack *vset) { assert(!vset->empty()); graph_t *g = graph_new(maxsize()); IntStack *nb; int val,preval,val2,preval2; val = vset->head(); preval = val-1; while (val != preval) { nb = neighbourhoods.at(val); if (!nb->empty()) { val2 = nb->head(); preval2 = val2-1; while (val2 != preval2) { if ((val > val2) && vset->contain(val2)) GRAPH_ADD_EDGE(g,val,val2); preval2 = val2; val2 = nb->next(preval2); } } preval = val; val = vset->next(preval); } return g; };
graph_t* MatrixToGraph(double *adjac_mtx_ptr, int iGraphOrder) { int i, j, idx; graph_t *ptrGraph; /* Initialize the graph that we want to return. */ ptrGraph = graph_new(iGraphOrder); /* Loop through the adjacency matrix to create the graph. We assume * that the adjacency matrix is symmetric and only consider the super- * diagonals of the matrix. */ /* The indexing here seems flipped, but it's due to the translation * between MATLAB and C element ordering. */ for (j = 0; j < iGraphOrder; j++) for (i = j + 1; i < iGraphOrder; i++) { /* The matrix adj_mtx is stored as a 1-dimensional array, so * we must convert the coordinate (i, j) to the corresponding * 1-dimensional index. */ idx = j + i * iGraphOrder; /* If the entry of the adjacency matrix is a 1, we want to add * an edge to our graph. */ if(adjac_mtx_ptr[idx] == 1) GRAPH_ADD_EDGE(ptrGraph, i, j); } /* Just to be cautios, ensure that we've produced a valid graph. */ ASSERT(graph_test(ptrGraph, NULL)); return ptrGraph; }
/* Convert an igraph graph to a Cliquer graph */ static void igraph_to_cliquer(const igraph_t *ig, graph_t **cg) { igraph_integer_t vcount, ecount; int i; if (igraph_is_directed(ig)) IGRAPH_WARNING("Edge directions are ignored for clique calculations"); vcount = igraph_vcount(ig); ecount = igraph_ecount(ig); *cg = graph_new(vcount); for (i=0; i < ecount; ++i) { long s, t; s = IGRAPH_FROM(ig, i); t = IGRAPH_TO(ig, i); if (s != t) GRAPH_ADD_EDGE(*cg, s, t); } }
/* * graph_read_dimacs_binary() * * Reads a dimacs-format binary file from file stream fp with the first * line being firstline. * * Returns the newly-allocated graph or NULL if an error occurred. * * TODO: This function leaks memory when reading erroneous files. */ static graph_t *graph_read_dimacs_binary(FILE *fp,char *firstline) { int length=0; graph_t *g; int i,j; char *buffer; char *start; char *end; char **buf; char tmp[10]; if (sscanf(firstline," %d %2s",&length,tmp)!=1) return NULL; if (length<=0) { fprintf(stderr,"Malformed preamble: preamble size < 0.\n"); return NULL; } buffer=malloc(length+2); if (fread(buffer,1,length,fp)<length) { fprintf(stderr,"Malformed preamble: unexpected " "end of file.\n"); free(buffer); return NULL; } g=calloc(1,sizeof(graph_t)); start=buffer; while (start < buffer+length) { end=strchr(start,'\n'); if (end==NULL) end=buffer+length; end[0]=0; if (!parse_input(start,g)) { fprintf(stderr,"Malformed preamble: %s\n",start); free (buffer); return NULL; } start=end+1; } free(buffer); if (g->n <= 0) { fprintf(stderr,"Malformed preamble: number of " "vertices <= 0\n"); free(g); return NULL; } /* Binary part. */ buf=calloc(g->n,sizeof(char*)); for (i=0; i < g->n; i++) { buf[i]=calloc(g->n,1); if (fread(buf[i],1,i/8+1,fp) < (i/8+1)) { fprintf(stderr,"Unexpected end of file when " "reading graph.\n"); return NULL; } } for (i=0; i < g->n; i++) { for (j=0; j<i; j++) { if (buf[i][j/8]&(1<<(7-(j%8)))) { GRAPH_ADD_EDGE(g,i,j); } } free(buf[i]); } free(buf); return g; }
/* * parse_input() * * Parses the string str for ASCII-format dimacs commands, and modifies * the graph g accordingly. * * Returns TRUE if successful, FALSE if a bad command was encountered. * * Note: Ignores all unknown commands. The 'd', 'v' and 'x' commands * (mainly generator-specific information) are ignored silently, * for all others a warning message is printed to stderr. */ static boolean parse_input(char *str,graph_t *g) { int i,j,w; char tmp[16]; for (i=0; i<strlen(str); i++) { if (!isspace((int)str[i])) break; } if (i>=strlen(str)) /* blank line */ return TRUE; if (str[i+1]!=0 && !isspace(str[i+1])) /* not 1-char field */ return FALSE; switch (str[i]) { case 'c': return TRUE; case 'p': if (g->n != 0) return FALSE; if (sscanf(str," p %15s %d %d %2s",tmp,&(g->n),&i,tmp)!=3) return FALSE; if (g->n <= 0) return FALSE; g->edges=calloc(g->n,sizeof(set_t)); for (i=0; i<g->n; i++) g->edges[i]=set_new(g->n); g->weights=calloc(g->n,sizeof(int)); for (i=0; i<g->n; i++) g->weights[i]=1; return TRUE; case 'n': if ((g->n <= 0) || (g->weights == NULL)) return FALSE; if (sscanf(str," n %d %d %2s",&i,&w,tmp)!=2) return FALSE; if (i<1 || i>g->n) return FALSE; if (w<=0) return FALSE; g->weights[i-1]=w; return TRUE; case 'e': if ((g->n <= 0) || (g->edges == NULL)) return FALSE; if (sscanf(str," e %d %d %2s",&i,&j,tmp)!=2) return FALSE; if (i<1 || j<1 || i>g->n || j>g->n) return FALSE; if (i==j) /* We want antireflexive graphs. */ return TRUE; GRAPH_ADD_EDGE(g,i-1,j-1); return TRUE; case 'd': case 'v': case 'x': return TRUE; default: fprintf(stderr,"Warning: ignoring field '%c' in " "input.\n",str[i]); return TRUE; } }
void multibinpacking(Home home, int n, int m, int k, const IntVarArgs& y, const IntVarArgs& x, const IntSharedArray& D, const IntSharedArray& B, IntConLevel) { /// Check input sizes if (n*k != D.size() ) throw ArgumentSizeMismatch("Int::multibinpacking"); if (k != B.size() ) throw ArgumentSizeMismatch("Int::multibinpacking"); if (n != x.size() ) throw ArgumentSizeMismatch("Int::multibinpacking"); if (m*k != y.size() ) throw ArgumentSizeMismatch("Int::multibinpacking"); for (int i=B.size(); i--; ) Limits::nonnegative(B[i],"Int::multibinpacking"); if (home.failed()) return; /// Post first each single binpacking constraint /// Capacity constraint for each dimension for ( int j = 0; j < m; ++j ) for ( int l = 0; l < k; ++l ) { IntView yi(y[j*k+l]); GECODE_ME_FAIL(yi.lq(home,B[l])); } /// Post a binpacking constraints for each dimension for ( int l = 0; l < k; ++l ) { ViewArray<OffsetView> yv(home,m); for (int j=m; j--; ) yv[j] = OffsetView(y[j*k+l],0); ViewArray<BinPacking::Item> xs(home,x.size()); for (int i=xs.size(); i--; ) xs[i] = BinPacking::Item(x[i],D[i*k+l]); Support::quicksort(&xs[0], xs.size()); GECODE_ES_FAIL(Int::BinPacking::Pack::post(home,yv,xs)); } /// Clique Finding and Alldifferent posting { /// Firt construct the conflict graph graph_t* g = graph_new(n); for ( int a = 0; a < n-1; ++a ) { for ( int b = a+1; b < n; ++b ) { int v = a; /// The variable with smaller domain int w = b; unsigned int nl = 0; if ( x[a].size() > x[b].size() ) { v = b; w = a; } IntVarValues i(x[v]); IntVarValues j(x[w]); while ( i() ) { if ( i.val() != j.val() ) { if ( i.val() < j.val() ) break; else ++i; } else { for ( int l = 0; l < k; ++l ) if ( D[a*k+l] + D[b*k+l] > B[l] ) { nl++; break; } ++i; ++j; } } if ( nl >= x[v].size() ) GRAPH_ADD_EDGE(g,a,b); } } /// Consitency cheking: look for the maximum clique clique_options* opts; opts = (clique_options*) malloc (sizeof(clique_options)); opts->time_function=NULL; opts->reorder_function=reorder_by_default; opts->reorder_map=NULL; opts->user_function=NULL; opts->user_data=NULL; opts->clique_list=NULL; opts->clique_list_length=0; set_t s; s = clique_find_single ( g, 0, 0, TRUE, opts); if ( s != NULL ) { if ( set_size(s) > m ) { set_free(s); free(opts); graph_free(g); GECODE_ES_FAIL(ES_FAILED); } if ( true ) { //option == 1 ) { FIXING for ( int a = 0, j = 0; a < n; ++a ) { if ( SET_CONTAINS_FAST(s,a) ) { assert( x[a].in(j) ); IntView xi(x[a]); GECODE_ME_FAIL(xi.eq(home,j++)); } } } } if ( s!=NULL ) set_free(s); /// List every maximal clique in the conflict graph opts->user_function=record_clique_func; clique_find_all ( g, 2, 0, TRUE, opts); for ( int c = 0; c < clique_count; c++ ) { ViewArray<IntView> xv(home, set_size(clique_list[c])); for ( int a = 0, idx = 0; a < n; ++a ) if ( SET_CONTAINS_FAST(clique_list[c],a) ) xv[idx++] = x[a]; GECODE_ES_FAIL(Distinct::Dom<IntView>::post(home,xv)); set_free(clique_list[c]); } free(opts); graph_free(g); } }
int get_h(C_Graphe &G, char *name, int *UB){ int *som = new int[G.nb_sommets]; for(int i=0 ; i<G.nb_sommets ; i++){som[i] = 0;} int cpt=0; int h=0; int nb; *UB = 0; while (cpt <= G.nb_sommets-1){ graph_t *g; g=(graph_t *)calloc(1,sizeof(graph_t)); g->n = G.nb_sommets; g->edges=(set_t *)calloc(g->n,sizeof(set_t)); for (int i=0; i<g->n; i++){ g->edges[i]=set_new(g->n); } g->weights=(int *)calloc(g->n,sizeof(int)); for(int i=0; i<g->n; i++){ g->weights[i]=1; } for(int i=0; i<g->n; i++){ for(int j=i+1; j<g->n; j++){ if( G.matrice_adjacence[i][j] == 0 && i!=j && som[i]+som[j] == 0 ){ GRAPH_ADD_EDGE(g,i,j); // cout<<"adding edge "<<i<<","<<j<<"\n"; } } } set_t s; s = clique_find_single(g,0,0,FALSE,NULL); nb=0; for(int i=0 ; i<G.nb_sommets ; i++){ if (SET_CONTAINS(s,i)){ som[i] = 1; cpt++; nb++; } } h++; *UB=*UB+nb*h; for (int i=0; i<g->n; i++){ set_free(g->edges[i]); } free(g->edges); free(g->weights); free(g); set_free(s); } for (int i=0; i<G.nb_sommets; i++){ if(som[i] == 0){ h++; break; } } ofstream fichier; ostringstream tmp; //Ouverture fichiers tmp.str("");tmp<<"h.col"; fichier.open(tmp.str().c_str(), ios::out|ios::app); if (!fichier){ cerr << "Erreur à l'ouverture du fichier\n"; return 1; } fichier<<name<<" "<<h<<" "<<*UB<<"\n"; fichier.close(); delete [] som; return h; }
void STABLE_max_heur(C_Graphe &G, int *valeur){ int *som = new int[G.nb_sommets]; for(int i=0 ; i<G.nb_sommets ; i++){som[i] = 0;} int cpt=0; int h=0; int nb; *valeur = 0; while (cpt <= G.nb_sommets-1){ graph_t *g; g=(graph_t *)calloc(1,sizeof(graph_t)); g->n = G.nb_sommets; g->edges=(set_t *)calloc(g->n,sizeof(set_t)); for (int i=0; i<g->n; i++){ g->edges[i]=set_new(g->n); } g->weights=(int *)calloc(g->n,sizeof(int)); for(int i=0; i<g->n; i++){ g->weights[i]=1; } for(int i=0; i<g->n; i++){ for(int j=i+1; j<g->n; j++){ if( G.matrice_adjacence[i][j] == 0 && i!=j && som[i]+som[j] == 0 ){ GRAPH_ADD_EDGE(g,i,j); // cout<<"adding edge "<<i<<","<<j<<"\n"; } } } set_t s; s = clique_find_single(g,0,0,FALSE,NULL); nb=0; for(int i=0 ; i<G.nb_sommets ; i++){ if (SET_CONTAINS(s,i)){ som[i] = 1; cpt++; nb++; } } h++; *valeur=*valeur+nb*h; for (int i=0; i<g->n; i++){ set_free(g->edges[i]); } free(g->edges); free(g->weights); free(g); set_free(s); } for (int i=0; i<G.nb_sommets; i++){ if(som[i] == 0){ h++; *valeur=*valeur+h; break; } } delete [] som; return ; }