int main() {
igraph_t graph;
igraph_vector_ptr_t separators;
long int i, n;
igraph_famous(&graph, "zachary");
igraph_vector_ptr_init(&separators, 0);
igraph_all_minimal_st_separators(&graph, &separators);
n=igraph_vector_ptr_size(&separators);
for (i=0; i<n; i++) {
igraph_bool_t res;
igraph_vector_t *sep=VECTOR(separators)[i];
igraph_is_separator(&graph, igraph_vss_vector(sep), &res);
if (!res) {
printf("Vertex set %li is not a separator!\n", i);
igraph_vector_print(sep);
return 1;
}
}
igraph_destroy(&graph);
for (i=0; i<n; i++) {
igraph_vector_t *v=VECTOR(separators)[i];
igraph_vector_destroy(v);
igraph_Free(v);
}
igraph_vector_ptr_destroy(&separators);
return 0;
}
int main() {
igraph_t g;
igraph_vector_t v=IGRAPH_VECTOR_NULL;
igraph_real_t edges[] = { 0,1, 1,2, 2,2, 2,3, 2,4, 3,4 };
igraph_vector_t v2;
long int i;
igraph_vit_t vit;
igraph_vs_t vs;
igraph_integer_t size;
igraph_vector_view(&v, edges, sizeof(edges)/sizeof(igraph_real_t));
igraph_create(&g, &v, 0, IGRAPH_DIRECTED);
/* Create iterator based on a vector (view) */
igraph_vector_init(&v2, 6);
VECTOR(v2)[0]=0; VECTOR(v2)[1]=2;
VECTOR(v2)[2]=4; VECTOR(v2)[3]=0;
VECTOR(v2)[4]=2; VECTOR(v2)[5]=4;
igraph_vit_create(&g, igraph_vss_vector(&v2), &vit);
i=0;
while (!IGRAPH_VIT_END(vit)) {
if (IGRAPH_VIT_GET(vit) != VECTOR(v2)[i]) {
return 1;
}
IGRAPH_VIT_NEXT(vit);
i++;
}
if (i != igraph_vector_size(&v2)) {
return 2;
}
igraph_vit_destroy(&vit);
igraph_vector_destroy(&v2);
/* Create small vector iterator */
igraph_vs_vector_small(&vs, 0, 2, 4, 0, 2, 4, 2, -1);
igraph_vit_create(&g, vs, &vit);
igraph_vs_size(&g, &vs, &size);
printf("%li ", (long int) size);
for (; !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit)) {
printf("%li ", (long int) IGRAPH_VIT_GET(vit));
}
printf("\n");
igraph_vit_destroy(&vit);
igraph_vs_destroy(&vs);
/* Clean up */
igraph_destroy(&g);
return 0;
}
int ggen_transform_delete(igraph_t *g, enum ggen_transform_t t)
{
igraph_vector_t vertices;
igraph_vector_t degrees;
unsigned int i,vcount,ssize;
int err;
if(g == NULL)
return 1;
vcount = igraph_vcount(g);
err = igraph_vector_init(&vertices,vcount);
if(err) return 1;
err = igraph_vector_init(°rees,vcount);
if(err) goto error_id;
/* find degree of each vertex, igraph_in if we need to identify sources. */
err = igraph_degree(g,°rees,igraph_vss_all(),
(t==GGEN_TRANSFORM_SOURCE)?IGRAPH_IN:IGRAPH_OUT,0);
if(err) goto error;
/* only sources or sinks are of interest */
ssize = 0;
for(i = 0; i < vcount; i++)
if(VECTOR(degrees)[i] == 0)
VECTOR(vertices)[ssize++] = i;
/* delete all identified vertices */
if(ssize > 0)
{
/* we should resize the array to avoid strange behaviors */
err = igraph_vector_resize(&vertices,ssize);
if(err) goto error;
err = igraph_delete_vertices(g,igraph_vss_vector(&vertices));
if(err) goto error;
}
error:
igraph_vector_destroy(°rees);
error_id:
igraph_vector_destroy(&vertices);
return err;
}
int igraph_cohesive_blocks(const igraph_t *graph,
igraph_vector_ptr_t *blocks,
igraph_vector_t *cohesion,
igraph_vector_t *parent,
igraph_t *block_tree) {
/* Some implementation comments. Everything is relatively
straightforward, except, that we need to follow the vertex ids
of the various subgraphs, without having to store two-way
mappings at each level. The subgraphs can overlap, this
complicates things a bit.
The 'Q' vector is used as a double ended queue and it contains
the subgraphs to work on in the future. Some other vectors are
associated with it. 'Qparent' gives the parent graph of a graph
in Q. Qmapping gives the mapping of the vertices from the graph
to the parent graph. Qcohesion is the vertex connectivity of the
graph.
Qptr is an integer and points to the next graph to work on.
*/
igraph_vector_ptr_t Q;
igraph_vector_ptr_t Qmapping;
igraph_vector_long_t Qparent;
igraph_vector_long_t Qcohesion;
igraph_vector_bool_t Qcheck;
long int Qptr=0;
igraph_integer_t conn;
igraph_bool_t is_simple;
igraph_t *graph_copy;
igraph_vector_ptr_t separators;
igraph_vector_t compvertices;
igraph_vector_long_t components;
igraph_vector_bool_t marked;
igraph_vector_long_t compid;
igraph_dqueue_t bfsQ;
igraph_vector_t neis;
if (igraph_is_directed(graph)) {
IGRAPH_ERROR("Cohesive blocking only works on undirected graphs",
IGRAPH_EINVAL);
}
IGRAPH_CHECK(igraph_is_simple(graph, &is_simple));
if (!is_simple) {
IGRAPH_ERROR("Cohesive blocking only works on simple graphs",
IGRAPH_EINVAL);
}
IGRAPH_STATUS("Starting cohesive block calculation.\n", 0);
if (blocks) { igraph_vector_ptr_clear(blocks); }
if (cohesion) { igraph_vector_clear(cohesion); }
if (parent) { igraph_vector_clear(parent); }
IGRAPH_CHECK(igraph_vector_ptr_init(&Q, 1));
IGRAPH_FINALLY(igraph_vector_ptr_destroy, &Q);
IGRAPH_FINALLY(igraph_i_cohesive_blocks_free, &Q);
IGRAPH_CHECK(igraph_vector_ptr_init(&Qmapping, 1));
IGRAPH_FINALLY(igraph_vector_ptr_destroy, &Qmapping);
IGRAPH_FINALLY(igraph_i_cohesive_blocks_free2, &Qmapping);
IGRAPH_CHECK(igraph_vector_long_init(&Qparent, 1));
IGRAPH_FINALLY(igraph_vector_long_destroy, &Qparent);
IGRAPH_CHECK(igraph_vector_long_init(&Qcohesion, 1));
IGRAPH_FINALLY(igraph_vector_long_destroy, &Qcohesion);
IGRAPH_CHECK(igraph_vector_bool_init(&Qcheck, 1));
IGRAPH_FINALLY(igraph_vector_bool_destroy, &Qcheck);
IGRAPH_CHECK(igraph_vector_ptr_init(&separators, 0));
IGRAPH_FINALLY(igraph_vector_ptr_destroy, &separators);
IGRAPH_VECTOR_INIT_FINALLY(&compvertices, 0);
IGRAPH_CHECK(igraph_vector_bool_init(&marked, 0));
IGRAPH_FINALLY(igraph_vector_bool_destroy, &marked);
IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
IGRAPH_CHECK(igraph_dqueue_init(&bfsQ, 100));
IGRAPH_FINALLY(igraph_dqueue_destroy, &bfsQ);
IGRAPH_CHECK(igraph_vector_long_init(&compid, 0));
IGRAPH_FINALLY(igraph_vector_long_destroy, &compid);
IGRAPH_CHECK(igraph_vector_long_init(&components, 0));
IGRAPH_FINALLY(igraph_vector_long_destroy, &components);
/* Put the input graph in the queue */
graph_copy=igraph_Calloc(1, igraph_t);
if (!graph_copy) {
IGRAPH_ERROR("Cannot do cohesive blocking", IGRAPH_ENOMEM);
}
IGRAPH_CHECK(igraph_copy(graph_copy, graph));
VECTOR(Q)[0] = graph_copy;
VECTOR(Qmapping)[0] = 0; /* Identity mapping */
VECTOR(Qparent)[0] = -1; /* Has no parent */
IGRAPH_CHECK(igraph_vertex_connectivity(graph, &conn, /*checks=*/ 1));
VECTOR(Qcohesion)[0] = conn;
VECTOR(Qcheck)[0] = 0;
/* Then work until the queue is empty */
while (Qptr < igraph_vector_ptr_size(&Q)) {
igraph_t *mygraph=VECTOR(Q)[Qptr];
igraph_bool_t mycheck=VECTOR(Qcheck)[Qptr];
long int mynodes=igraph_vcount(mygraph);
long int i, nsep;
long int no, kept=0;
long int cptr=0;
long int nsepv=0;
igraph_bool_t addedsep=0;
IGRAPH_STATUSF(("Candidate %li: %li vertices,",
0, Qptr, mynodes));
IGRAPH_ALLOW_INTERRUPTION();
/* Get the separators */
IGRAPH_CHECK(igraph_minimum_size_separators(mygraph, &separators));
IGRAPH_FINALLY(igraph_i_cohesive_blocks_free3, &separators);
nsep=igraph_vector_ptr_size(&separators);
IGRAPH_STATUSF((" %li separators,", 0, nsep));
/* Remove them from the graph, also mark them */
IGRAPH_CHECK(igraph_vector_bool_resize(&marked, mynodes));
igraph_vector_bool_null(&marked);
for (i=0; i<nsep; i++) {
igraph_vector_t *v=VECTOR(separators)[i];
long int j, n=igraph_vector_size(v);
for (j=0; j<n; j++) {
long int vv=(long int) VECTOR(*v)[j];
if (!VECTOR(marked)[vv]) {
nsepv++;
VECTOR(marked)[vv] = 1;
}
}
}
/* Find the connected components, omitting the separator vertices,
but including the neighboring separator vertices
*/
IGRAPH_CHECK(igraph_i_cb_components(mygraph, &marked,
&components, &no,
&compid, &bfsQ, &neis));
/* Add the separator vertices themselves, as another component,
but only if there is at least one vertex not included in any
separator. */
if (nsepv != mynodes) {
addedsep=1;
for (i=0; i<mynodes; i++) {
if (VECTOR(marked)[i]) {
IGRAPH_CHECK(igraph_vector_long_push_back(&components, i));
}
}
IGRAPH_CHECK(igraph_vector_long_push_back(&components, -1));
no++;
}
IGRAPH_STATUSF((" %li new candidates,", 0, no));
for (i=0; i<no; i++) {
igraph_vector_t *newmapping;
igraph_t *newgraph;
igraph_integer_t maxdeg;
igraph_vector_clear(&compvertices);
while (1) {
long int v=VECTOR(components)[cptr++];
if (v < 0) { break; }
IGRAPH_CHECK(igraph_vector_push_back(&compvertices, v));
}
newmapping=igraph_Calloc(1, igraph_vector_t);
if (!newmapping) {
IGRAPH_ERROR("Cannot do cohesive blocking", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, newmapping);
IGRAPH_VECTOR_INIT_FINALLY(newmapping, 0);
newgraph=igraph_Calloc(1, igraph_t);
if (!newgraph) {
IGRAPH_ERROR("Cannot do cohesive blocking", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, newgraph);
IGRAPH_CHECK(igraph_induced_subgraph_map(mygraph, newgraph,
igraph_vss_vector(&compvertices),
IGRAPH_SUBGRAPH_AUTO,
/*map=*/ 0,
/*invmap=*/ newmapping));
IGRAPH_FINALLY(igraph_destroy, newgraph);
IGRAPH_CHECK(igraph_maxdegree(newgraph, &maxdeg, igraph_vss_all(),
IGRAPH_ALL, IGRAPH_LOOPS));
if (maxdeg > VECTOR(Qcohesion)[Qptr]) {
igraph_integer_t newconn;
kept++;
IGRAPH_CHECK(igraph_vector_ptr_push_back(&Q, newgraph));
IGRAPH_FINALLY_CLEAN(2);
IGRAPH_CHECK(igraph_vector_ptr_push_back(&Qmapping, newmapping));
IGRAPH_FINALLY_CLEAN(2);
IGRAPH_CHECK(igraph_vertex_connectivity(newgraph, &newconn,
/*checks=*/ 1));
IGRAPH_CHECK(igraph_vector_long_push_back(&Qcohesion, newconn));
IGRAPH_CHECK(igraph_vector_long_push_back(&Qparent, Qptr));
IGRAPH_CHECK(igraph_vector_bool_push_back(&Qcheck,
mycheck || addedsep));
} else {
igraph_destroy(newgraph);
igraph_free(newgraph);
igraph_vector_destroy(newmapping);
igraph_free(newmapping);
IGRAPH_FINALLY_CLEAN(4);
}
}
IGRAPH_STATUSF((" keeping %li.\n", 0, kept));
igraph_destroy(mygraph);
igraph_free(mygraph);
VECTOR(Q)[Qptr] = 0;
igraph_i_cohesive_blocks_free3(&separators);
IGRAPH_FINALLY_CLEAN(1);
Qptr++;
}
igraph_vector_long_destroy(&components);
igraph_vector_long_destroy(&compid);
igraph_dqueue_destroy(&bfsQ);
igraph_vector_destroy(&neis);
igraph_vector_bool_destroy(&marked);
igraph_vector_destroy(&compvertices);
igraph_vector_ptr_destroy(&separators);
IGRAPH_FINALLY_CLEAN(7);
if (blocks || cohesion || parent || block_tree) {
igraph_integer_t noblocks=(igraph_integer_t) Qptr, badblocks=0;
igraph_vector_bool_t removed;
long int i, resptr=0;
igraph_vector_long_t rewritemap;
IGRAPH_CHECK(igraph_vector_bool_init(&removed, noblocks));
IGRAPH_FINALLY(igraph_vector_bool_destroy, &removed);
IGRAPH_CHECK(igraph_vector_long_init(&rewritemap, noblocks));
IGRAPH_FINALLY(igraph_vector_long_destroy, &rewritemap);
for (i=1; i<noblocks; i++) {
long int p=VECTOR(Qparent)[i];
while (VECTOR(removed)[p]) { p=VECTOR(Qparent)[p]; }
if (VECTOR(Qcohesion)[p] >= VECTOR(Qcohesion)[i]) {
VECTOR(removed)[i]=1;
badblocks++;
}
}
/* Rewrite the mappings */
for (i=1; i<Qptr; i++) {
long int p=VECTOR(Qparent)[i];
igraph_vector_t *mapping=VECTOR(Qmapping)[i];
igraph_vector_t *pmapping=VECTOR(Qmapping)[p];
long int j, n=igraph_vector_size(mapping);
if (!pmapping) { continue; }
for (j=0; j<n; j++) {
long int v=(long int) VECTOR(*mapping)[j];
VECTOR(*mapping)[j] = VECTOR(*pmapping)[v];
}
}
/* Because we also put the separator vertices in the queue, it is
not ensured that the found blocks are not subsets of each other.
We check this now. */
for (i=1; i<noblocks; i++) {
long int j, ic;
igraph_vector_t *ivec;
if (!VECTOR(Qcheck)[i] || VECTOR(removed)[i]) { continue; }
ivec=VECTOR(Qmapping)[i];
ic=VECTOR(Qcohesion)[i];
for (j=1; j<noblocks; j++) {
igraph_vector_t *jvec;
long int jc;
if (j==i || !VECTOR(Qcheck)[j] || VECTOR(removed)[j]) { continue; }
jvec=VECTOR(Qmapping)[j];
jc=VECTOR(Qcohesion)[j];
if (igraph_i_cb_isin(ivec, jvec) && jc >= ic) {
badblocks++;
VECTOR(removed)[i]=1;
break;
}
}
}
noblocks -= badblocks;
if (blocks) { IGRAPH_CHECK(igraph_vector_ptr_resize(blocks, noblocks)); }
if (cohesion) { IGRAPH_CHECK(igraph_vector_resize(cohesion, noblocks)); }
if (parent) { IGRAPH_CHECK(igraph_vector_resize(parent, noblocks)); }
for (i=0; i<Qptr; i++) {
if (VECTOR(removed)[i]) {
IGRAPH_STATUSF(("Candidate %li ignored.\n", 0, i));
continue;
} else {
IGRAPH_STATUSF(("Candidate %li is a cohesive (sub)block\n", 0, i));
}
VECTOR(rewritemap)[i] = resptr;
if (cohesion) { VECTOR(*cohesion)[resptr]=VECTOR(Qcohesion)[i]; }
if (parent || block_tree) {
long int p=VECTOR(Qparent)[i];
while (p>=0 && VECTOR(removed)[p]) { p=VECTOR(Qparent)[p]; }
if (p>=0) { p=VECTOR(rewritemap)[p]; }
VECTOR(Qparent)[i]=p;
if (parent) { VECTOR(*parent)[resptr]=p; }
}
if (blocks) {
VECTOR(*blocks)[resptr]=VECTOR(Qmapping)[i];
VECTOR(Qmapping)[i]=0;
}
resptr++;
}
/* Plus the original graph */
if (blocks) {
igraph_vector_t *orig=igraph_Calloc(1, igraph_vector_t);
if (!orig) {
IGRAPH_ERROR("Cannot do cohesive blocking", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, orig);
IGRAPH_CHECK(igraph_vector_init_seq(orig, 0, igraph_vcount(graph)-1));
VECTOR(*blocks)[0]=orig;
IGRAPH_FINALLY_CLEAN(1);
}
if (block_tree) {
igraph_vector_t edges;
long int eptr=0;
IGRAPH_VECTOR_INIT_FINALLY(&edges, noblocks*2-2);
for (i=1; i<Qptr; i++) {
if (VECTOR(removed)[i]) { continue; }
VECTOR(edges)[eptr++] = VECTOR(Qparent)[i];
VECTOR(edges)[eptr++] = VECTOR(rewritemap)[i];
}
IGRAPH_CHECK(igraph_create(block_tree, &edges, noblocks,
IGRAPH_DIRECTED));
igraph_vector_destroy(&edges);
IGRAPH_FINALLY_CLEAN(1);
}
igraph_vector_long_destroy(&rewritemap);
igraph_vector_bool_destroy(&removed);
IGRAPH_FINALLY_CLEAN(2);
}
igraph_vector_bool_destroy(&Qcheck);
igraph_vector_long_destroy(&Qcohesion);
igraph_vector_long_destroy(&Qparent);
igraph_i_cohesive_blocks_free2(&Qmapping);
IGRAPH_FINALLY_CLEAN(4);
igraph_vector_ptr_destroy(&Qmapping);
igraph_vector_ptr_destroy(&Q);
IGRAPH_FINALLY_CLEAN(3); /* + the elements of Q, they were
already destroyed */
IGRAPH_STATUS("Cohesive blocking done.\n", 0);
return 0;
}
int igraph_decompose(const igraph_t *graph, igraph_vector_ptr_t *components,
igraph_connectedness_t mode,
long int maxcompno, long int minelements) {
long int actstart;
long int no_of_nodes=igraph_vcount(graph);
long int resco=0; /* number of graphs created so far */
char *already_added;
igraph_dqueue_t q;
igraph_vector_t verts;
igraph_vector_t neis;
long int i;
igraph_t *newg;
if (!igraph_is_directed(graph)) {
mode=IGRAPH_WEAK;
}
if (mode != IGRAPH_WEAK) {
IGRAPH_ERROR("only 'IGRAPH_WEAK' is implemented", IGRAPH_EINVAL);
}
if (maxcompno<0) {
maxcompno=LONG_MAX;
}
igraph_vector_ptr_clear(components);
IGRAPH_FINALLY(igraph_decompose_destroy, components);
already_added=igraph_Calloc(no_of_nodes, char);
if (already_added==0) {
IGRAPH_ERROR("Cannot decompose graph", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, already_added);
IGRAPH_CHECK(igraph_dqueue_init(&q, 100));
IGRAPH_FINALLY(igraph_dqueue_destroy, &q);
IGRAPH_VECTOR_INIT_FINALLY(&verts, 0);
IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
for(actstart=0; resco<maxcompno && actstart < no_of_nodes; actstart++) {
if (already_added[actstart]) { continue; }
IGRAPH_ALLOW_INTERRUPTION();
igraph_vector_clear(&verts);
already_added[actstart]=1;
IGRAPH_CHECK(igraph_vector_push_back(&verts, actstart));
IGRAPH_CHECK(igraph_dqueue_push(&q, actstart));
while (!igraph_dqueue_empty(&q) ) {
long int actvert=(long int) igraph_dqueue_pop(&q);
IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t) actvert,
IGRAPH_ALL));
for (i=0; i<igraph_vector_size(&neis); i++) {
long int neighbor=(long int) VECTOR(neis)[i];
if (already_added[neighbor]==1) { continue; }
IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
IGRAPH_CHECK(igraph_vector_push_back(&verts, neighbor));
already_added[neighbor]=1;
}
}
/* ok, we have a component */
if (igraph_vector_size(&verts)<minelements) { continue; }
newg=igraph_Calloc(1, igraph_t);
if (newg==0) {
IGRAPH_ERROR("Cannot decompose graph", IGRAPH_ENOMEM);
}
IGRAPH_CHECK(igraph_vector_ptr_push_back(components, newg));
IGRAPH_CHECK(igraph_induced_subgraph(graph, newg,
igraph_vss_vector(&verts),
IGRAPH_SUBGRAPH_AUTO));
resco++;
} /* for actstart++ */
igraph_vector_destroy(&neis);
igraph_vector_destroy(&verts);
igraph_dqueue_destroy(&q);
igraph_free(already_added);
IGRAPH_FINALLY_CLEAN(5); /* + components */
return 0;
}
static PyObject *ignp_fun_propagate(PyObject *self, PyObject *args) {
long int num_active = 0;
long int num_susc = 1;
long int limit = 30;
long int i;
float lrAct;
PyObject* mem_addr_o;
long int mem_addr;
/* StateTracker Vars */
PyArrayObject *py_trkr; // 'i64'
/* By EdgeID */
PyArrayObject *py_tie_r; // 'f32'
/* By NodeID */
PyArrayObject *py_act_n; // 'i8'
PyArrayObject *py_thr_n; // 'f32'
PyArrayObject *py_exp_n; // 'i64'
/* By Infection Order*/
PyArrayObject *py_deg; // i64
PyArrayObject *py_nSuc; // i64
PyArrayObject *py_nAct; // i64
PyArrayObject *py_lrAct; // f32
PyArrayObject *py_hom; // i64
PyArrayObject *py_eComp; // i64
PyArrayObject *py_iComp; // i64
PyArrayObject *py_eTri; // i64
PyArrayObject *py_iTri; // i64
PyArrayObject *py_thr; // i32
PyArrayObject *py_exp; // i64
PyArrayObject *py_cTime; // i64
PyObject *g_obj;
igraph_t *g;
igraph_t gc;
long int randID;
long int low = 0;
long int high = -1;
long int ctime = 0;
igraph_rng_t *rGen;
igraph_vit_t nbr_iter;
igraph_vs_t nbr_sel;
igraph_integer_t eid;
igraph_integer_t vdeg;
igraph_integer_t e_comp = 0;
igraph_integer_t i_comp = 0;
igraph_integer_t e_tri = 0;
igraph_integer_t i_tri = 0;
int actv_nbr_count;
//int res, j;
igraph_vector_t temp;
//igraph_vector_t actv_nbrs;
//PySys_WriteStdout("Parse Started\n");
if (!PyArg_ParseTuple(args, "OO!O!O!O!O!O!O!O!O!O!O!O!O!O!O!O!O!",
&g_obj,
&PyArray_Type, &py_trkr, // i64
&PyArray_Type, &py_tie_r, // 'f32'
&PyArray_Type, &py_act_n, // 'i8'
&PyArray_Type, &py_thr_n, // 'i32'
&PyArray_Type, &py_exp_n, // 'i64'
&PyArray_Type, &py_deg, // i64
&PyArray_Type, &py_nSuc, // i64
&PyArray_Type, &py_nAct, // i64
&PyArray_Type, &py_lrAct, // f32
&PyArray_Type, &py_hom, // i64
&PyArray_Type, &py_eComp, // i64
&PyArray_Type, &py_iComp, // i64
&PyArray_Type, &py_eTri, // i64
&PyArray_Type, &py_iTri, // i64
&PyArray_Type, &py_thr, // i64
&PyArray_Type, &py_exp, // i64
&PyArray_Type, &py_cTime // i64
)) {
printf("Parse Failed\n");
Py_RETURN_NONE;
}
//PySys_WriteStdout("Getting Tracker Vars\n");
num_active = (long) ax_i64(py_trkr, 0);
num_susc = (long) ax_i64(py_trkr, 1);
limit = (long) ax_i64(py_trkr, 2);
mem_addr_o = PyObject_CallMethod(g_obj, "_raw_pointer", "()");
mem_addr = PyInt_AsLong(mem_addr_o);
Py_DECREF(mem_addr_o);
if (mem_addr == -1) {
printf("PyInt to Long Failed");
return NULL;
}
g = (igraph_t*) mem_addr;
//Setup Vars
rGen = igraph_rng_default();
//igraph_rng_init(rGen, time(NULL));
high += (long) igraph_vcount(g);
//PySys_WriteStdout("Propagate Starting with %li active of target %li with %li open\n",
// num_active, limit, num_susc);
//Propagate
do {
// get random node
ctime += 1;
randID = igraph_rng_get_integer(rGen, low, high);
if ( ax_i8(py_act_n, randID) != 1 && ax_i64(py_exp_n, randID)>=ax_i32(py_thr_n, randID) ){
//activate
ax_i8(py_act_n,randID) = 1;
lrAct = 0;
//update nbrs
actv_nbr_count = 0;
igraph_vs_adj( &nbr_sel, randID, IGRAPH_ALL);
igraph_vit_create(g, nbr_sel, &nbr_iter);
igraph_vs_size(g, &nbr_sel, &vdeg);
igraph_vector_init(&temp, vdeg);
while( !IGRAPH_VIT_END(nbr_iter) ){
i = (long int) IGRAPH_VIT_GET(nbr_iter);
ax_i64( py_exp_n, i ) += 1;
/* update active nbr count and collect id of active */
if ( ax_i8(py_act_n, i) == i ) {
VECTOR(temp)[actv_nbr_count]=i;
actv_nbr_count += 1;
}
/* update num_susc */
if ( ax_i8(py_act_n, i) == 0 && \
ax_i32(py_thr_n, i) > (float) (ax_i64(py_exp_n, i)-1) && \
ax_i32(py_thr_n, i) <= (float) ax_i64(py_exp_n, i) ){
/*PySys_WriteStdout("%li < %i <= %li\n",
(ax_i64(py_exp_n, i)-1),
ax_i32(py_thr_n, i),
ax_i64(py_exp_n, i) );*/
num_susc += 1;
}
/* Get #active long ties */
if ( ax_i8(py_act_n, i) == 1 ){
igraph_get_eid(g, &eid, randID, i, 0, 1);
lrAct += ax_f32( py_tie_r, eid )>2 ;
}
IGRAPH_VIT_NEXT(nbr_iter);
}
igraph_vit_destroy(&nbr_iter);
igraph_vs_destroy(&nbr_sel);
//Compute Components (among all and active nbrs)
igraph_vs_adj( &nbr_sel, randID, IGRAPH_ALL);
igraph_induced_subgraph(g, &gc, nbr_sel, IGRAPH_SUBGRAPH_CREATE_FROM_SCRATCH);
igraph_clusters(&gc, NULL, NULL, &e_comp, IGRAPH_WEAK);
e_tri = igraph_vcount(&gc);
igraph_destroy(&gc);
igraph_vs_destroy(&nbr_sel);
igraph_induced_subgraph(g, &gc, igraph_vss_vector(&temp), \
IGRAPH_SUBGRAPH_CREATE_FROM_SCRATCH);
igraph_clusters(&gc, NULL, NULL, &i_comp, IGRAPH_WEAK);
i_tri = igraph_vcount(&gc);
//Clean up
igraph_destroy(&gc);
igraph_vector_destroy(&temp);
//PySys_WriteStdout("e_comp: %i, i_comp: %i\n", e_comp, i_comp);
//PySys_WriteStdout("e_tri: %i, i_tri: %i\n", e_tri, i_tri);
//update tracking vars
ax_f32( py_lrAct, num_active ) = (npy_float32) lrAct;
ax_i32( py_thr, num_active) = ax_i32(py_thr_n, randID);
ax_i64( py_deg, num_active) = (npy_int64) vdeg;
ax_i64( py_nSuc, num_active) = (npy_int64) num_susc;
ax_i64( py_nAct, num_active) = (npy_int64) num_active;
//ax_i64( py_hom, num_active) = (npy_int64) num_susc;
ax_i64( py_eComp, num_active) = (npy_int64) e_comp;
ax_i64( py_iComp, num_active) = (npy_int64) i_comp;
ax_i64( py_eTri, num_active) = (npy_int64) e_tri;
ax_i64( py_iTri, num_active) = (npy_int64) i_tri;
ax_i64( py_exp, num_active) = ax_i64(py_exp_n, randID);
ax_i64( py_cTime, num_active) = (npy_int64) ctime;
num_active += 1;
}
} while( num_susc > num_active && num_active < limit);
//PySys_WriteStdout("Propagate Finished with %li active of target %li with %li open\n",
// num_active, limit, num_susc);
//igraph_rng_destroy(rGen);
ax_i64(py_trkr, 0) = (npy_int64) num_active;
ax_i64(py_trkr, 1) = (npy_int64) num_susc ;
ax_i64(py_trkr, 2) = (npy_int64) limit ;
Py_RETURN_NONE;
}
