boolean
isautom(graph *g, permutation *perm, boolean digraph, int m, int n)
{
boolean autom=TRUE;
#ifdef _OPENMP
#pragma omp parallel
#endif
{
int stride=1, offs=0;
register set *pg;
register int pos;
set *pgp;
int posp,i;
#ifdef _OPENMP
offs=omp_get_thread_num();
stride=omp_get_num_threads();
#endif
for (i = offs; autom && i < n; i+=stride)
{
pg=g+M*i;
pgp = GRAPHROW(g,perm[i],M);
pos = (digraph ? -1 : i);
while ((pos = nextelement(pg,M,pos)) >= 0)
{
posp = perm[pos];
if (!ISELEMENT(pgp,posp)) autom=FALSE;
}
}
}
return autom;
}
void print_graph(graph_info g)
{
for (int i = 0; i < g.n; i++)
{
for (int j = 0; j < g.n; j++)
printf("%d\t", g.distances[g.n*i + j]);
printf("\n");
}
for (int i = 0; i < g.n; i++)
printf("%d ", g.k[i]);
printf("\n");
unsigned m = (g.n + WORDSIZE - 1) / WORDSIZE;
for(int i = 0; i < g.n; i++)
{
for(int j = 0; j < g.n; j++)
{
if(ISELEMENT(GRAPHROW(g.nauty_graph, i, m), j))
printf("1, ");
else
printf("0, ");
}
printf("\n");
}
printf("\n");
printf("K: %d, D: %d, S: %d, M: %d\n", g.max_k, g.diameter, g.sum_of_distances, g.m);
}
void
Nauty::deleteElement(int ix, int jx)
{
// Right now die if bad index. Can throw exception later
assert(ix < n_ && jx < n_);
set *gv = GRAPHROW(G_, ix, m_);
if (ISELEMENT(gv, jx)) {
DELELEMENT(gv, jx);
}
autoComputed_ = false;
}
static void dump_graph(graph *g, int n)
{
for (int i = 0; i < n; i++) {
set *gv = GRAPHROW(g, i, MAXM);
for (int j = 0; j < n; j++) {
fputs(ISELEMENT(gv, j) ? "+" : ".", stderr);
}
fputs("\n", stderr);
}
}
int
permcycles(int *p, int n, int *len, boolean sort)
/* Puts in len[0..] the cycle lengths of p. If sort, sort them.
Return the number of cycles. */
{
int m,i,j,k,h,nc,leni;
m = (n + WORDSIZE - 1) / WORDSIZE;
DYNALLOC1(set,workset,workset_sz,m,"malloc");
EMPTYSET(workset,m);
nc = 0;
for (i = 0; i < n; ++i)
if (!ISELEMENT(workset,i))
{
k = 1;
for (j = p[i]; j != i; j = p[j])
{
ADDELEMENT(workset,j);
++k;
}
len[nc++] = k;
}
if (sort && nc > 1)
{
j = nc / 3;
h = 1;
do
h = 3 * h + 1;
while (h < j);
do
{
for (i = h; i < nc; ++i)
{
leni = len[i];
for (j = i; len[j-h] > leni; )
{
len[j] = len[j-h];
if ((j -= h) < h) break;
}
len[j] = leni;
}
h /= 3;
}
while (h > 0);
}
return nc;
}
void
commonnbrs(graph *g, int *minadj, int *maxadj, int *minnon, int *maxnon,
int m, int n)
/* Count the common neighbours of pairs of vertices, and give the minimum
and maximum for adjacent and non-adjacent vertices. Undirected only.
Null minimums are n+1 and null maximums are -1.
*/
{
int j,k;
int mina,maxa,minn,maxn;
int cn;
set *gi,*gj;
setword w;
mina = minn = n+1;
maxa = maxn = -1;
for (j = 0, gj = g; j < n; ++j, gj += m)
for (gi = g; gi != gj; gi += m)
{
cn = 0;
for (k = 0; k < m; ++k)
{
w = gi[k] & gj[k];
if (w) cn += POPCOUNT(w);
}
if (ISELEMENT(gi,j))
{
if (cn < mina) mina = cn;
if (cn > maxa) maxa = cn;
}
else
{
if (cn < minn) minn = cn;
if (cn > maxn) maxn = cn;
}
}
*minadj = mina;
*maxadj = maxa;
*minnon = minn;
*maxnon = maxn;
}
boolean
isautom(graphnau *g, permutation *perm, boolean digraph, int m, int n)
{
set *pg;
int pos;
set *pgp;
int posp,i;
for (pg = g, i = 0; i < n; pg += M, ++i)
{
pgp = GRAPHROW(g,perm[i],M);
pos = (digraph ? -1 : i);
while ((pos = nextelement(pg,M,pos)) >= 0)
{
posp = perm[pos];
if (!ISELEMENT(pgp,posp)) return FALSE;
}
}
return TRUE;
}
graph_info *graph_info_from_nauty(graph *g, int n)
{
graph_info *ret = malloc(sizeof(graph_info));
ret->n = n;
ret->distances = malloc(n * n * sizeof(*ret->distances));
ret->k = malloc(n * sizeof(*ret->k));
int m = (n + WORDSIZE - 1) / WORDSIZE;
ret->m = 0; //total number of edges
for (int i = 0; i < n; i++) {
ret->k[i] = 0;
for (int j = 0; j < n; j++) {
if(i == j)
ret->distances[n*i + j] = 0;
else if(ISELEMENT(GRAPHROW(g, i, m), j))
{
ret->distances[n*i + j] = 1;
ret->k[i]++;
ret->m++;
}
else
ret->distances[n*i + j] = GRAPH_INFINITY;
}
}
ret->m /= 2;
ret->max_k = 0;
for (int i = 0; i < n; i++)
if (ret->k[i] > ret->max_k)
ret->max_k = ret->k[i];
floyd_warshall(*ret);
ret->sum_of_distances = calc_sum(*ret);
ret->diameter = calc_diameter(*ret);
ret->nauty_graph = malloc(n * m * sizeof(graph));
ret->gcan = NULL;
memcpy(ret->nauty_graph, g, n * m * sizeof(graph));
return ret;
}
static boolean
seemsbad(char *s)
/* Check graph string for apparent problem, if so, correct it */
{
int i,j,k,m,n;
char *p,x,pq;
set *gj;
long ii;
int r,rr,topbit,nb,lastj;
graph g[16];
if (s[0] != ':') return FALSE; /* not sparse6 */
n = graphsize(s);
if (n != 2 && n != 4 && n != 8 && n != 16) return FALSE;
m = 1;
stringtograph(s,g,m);
if (g[n-1] != bit[n-1]) return FALSE;
if (g[n-2] == 0) return FALSE;
g[n-1] = 0;
p = s+2;
for (i = n-1, nb = 0; i != 0 ; i >>= 1, ++nb) {}
topbit = 1 << (nb-1);
k = 6;
x = 0;
lastj = 0;
for (j = 0; j < n; ++j)
{
gj = GRAPHROW(g,j,m);
for (i = 0; i <= j; ++i)
{
if (ISELEMENT(gj,i))
{
if (j == lastj)
{
x <<= 1;
if (--k == 0)
{
p++;
k = 6;
x = 0;
}
}
else
{
x = (x << 1) | 1;
if (--k == 0)
{
p++;
k = 6;
x = 0;
}
if (j > lastj+1)
{
for (r = 0, rr = j; r < nb; ++r, rr <<= 1)
{
if (rr & topbit) x = (x << 1) | 1;
else x <<= 1;
if (--k == 0)
{
p++;
k = 6;
x = 0;
}
}
x <<= 1;
if (--k == 0)
{
p++;
k = 6;
x = 0;
}
}
lastj = j;
}
for (r = 0, rr = i; r < nb; ++r, rr <<= 1)
{
if (rr & topbit) x = (x << 1) | 1;
else x <<= 1;
if (--k == 0)
{
p++;
k = 6;
x = 0;
}
}
}
}
}
if (k != 6)
{
if (k >= nb+1 && lastj == n-2 && n == (1<<nb))
{
*p++ = BIAS6 + ((x << k) | ((1 << (k-1)) - 1));
return TRUE;
}
else
return FALSE;
}
}
