igraph_vector_t *igraph_lazy_adjlist_get_real(igraph_lazy_adjlist_t *al,
igraph_integer_t pno) {
long int no=pno;
int ret;
if (al->adjs[no] == 0) {
al->adjs[no] = igraph_Calloc(1, igraph_vector_t);
if (al->adjs[no] == 0) {
igraph_error("Lazy adjlist failed", __FILE__, __LINE__,
IGRAPH_ENOMEM);
}
ret=igraph_vector_init(al->adjs[no], 0);
if (ret != 0) {
igraph_error("", __FILE__, __LINE__, ret);
}
ret=igraph_neighbors(al->graph, al->adjs[no], no, al->mode);
if (ret != 0) {
igraph_error("", __FILE__, __LINE__, ret);
}
if (al->simplify == IGRAPH_SIMPLIFY) {
igraph_vector_t *v=al->adjs[no];
long int i, p=0, n=igraph_vector_size(v);
for (i=0; i<n; i++) {
if (VECTOR(*v)[i] != no &&
(i==n-1 || VECTOR(*v)[i+1] != VECTOR(*v)[i])) {
VECTOR(*v)[p]=VECTOR(*v)[i];
p++;
}
}
igraph_vector_resize(v, p);
}
}
return al->adjs[no];
}
igraph_vector_t *igraph_lazy_inclist_get_real(igraph_lazy_inclist_t *il,
igraph_integer_t pno) {
long int no=pno;
int ret;
if (il->incs[no] == 0) {
il->incs[no] = igraph_Calloc(1, igraph_vector_t);
if (il->incs[no] == 0) {
igraph_error("Lazy incidence list query failed", __FILE__, __LINE__,
IGRAPH_ENOMEM);
}
ret=igraph_vector_init(il->incs[no], 0);
if (ret != 0) {
igraph_error("", __FILE__, __LINE__, ret);
}
ret=igraph_incident(il->graph, il->incs[no], no, il->mode);
if (ret != 0) {
igraph_error("", __FILE__, __LINE__, ret);
}
}
return il->incs[no];
}
/***************************************************
* Function: DensityGrid::Add *
* Description: Add a node to the density grid *
**************************************************/
void DensityGrid::Add(Node &N)
{
int x_grid, y_grid, z_grid, diam;
float *den_ptr, *fall_ptr;
/* Where to add */
x_grid = (int)((N.x+HALF_VIEW+.5)*VIEW_TO_GRID);
y_grid = (int)((N.y+HALF_VIEW+.5)*VIEW_TO_GRID);
z_grid = (int)((N.z+HALF_VIEW+.5)*VIEW_TO_GRID);
N.sub_x = N.x;
N.sub_y = N.y;
N.sub_z = N.z;
x_grid -= RADIUS;
y_grid -= RADIUS;
z_grid -= RADIUS;
diam = 2*RADIUS;
// check to see that we are inside grid
if ( (x_grid >= GRID_SIZE) || (x_grid < 0) ||
(y_grid >= GRID_SIZE) || (y_grid < 0) ||
(z_grid >= GRID_SIZE) || (z_grid < 0) )
{
// cout << endl << "Error: Exceeded density grid with x_grid = " << x_grid
// << " and y_grid = " << y_grid << ". Program stopped." << endl;
#ifdef MUSE_MPI
MPI_Abort ( MPI_COMM_WORLD, 1 );
#else
igraph_error("Exceeded density grid in DrL", __FILE__,
__LINE__, IGRAPH_EDRL);
#endif
}
/* Add density values */
den_ptr = &Density[z_grid][y_grid][x_grid];
fall_ptr = &fall_off[0][0][0];
for(int i = 0; i <= diam; i++) {
for(int j = 0; j <= diam; j++)
for (int k = 0; k <= diam; k++)
*den_ptr++ += *fall_ptr++;
den_ptr += GRID_SIZE - (diam+1);
}
}
void DensityGrid::Init()
{
try
{
Density = new float[GRID_SIZE][GRID_SIZE][GRID_SIZE];
fall_off = new float[RADIUS*2+1][RADIUS*2+1][RADIUS*2+1];
Bins = new deque<Node>[GRID_SIZE*GRID_SIZE*GRID_SIZE];
}
catch (bad_alloc errora)
{
// cout << "Error: Out of memory! Program stopped." << endl;
#ifdef MUSE_MPI
MPI_Abort ( MPI_COMM_WORLD, 1 );
#else
igraph_error("DrL is out of memory", __FILE__, __LINE__,
IGRAPH_ENOMEM);
#endif
}
// Clear Grid
int i;
for (i=0; i< GRID_SIZE; i++)
for (int j=0; j< GRID_SIZE; j++)
for (int k=0; k < GRID_SIZE; k++) {
Density[i][j][k] = 0;
GET_BIN(i,j,k).erase(GET_BIN(i,j,k).begin(),GET_BIN(i,j,k).end());
}
// Compute fall off
for(i=-RADIUS; i<=RADIUS; i++)
for(int j=-RADIUS; j<=RADIUS; j++)
for (int k=-RADIUS; k<=RADIUS; k++) {
fall_off[i+RADIUS][j+RADIUS][k+RADIUS] =
(float)((RADIUS-fabs((float)i))/RADIUS) *
(float)((RADIUS-fabs((float)j))/RADIUS) *
(float)((RADIUS-fabs((float)k))/RADIUS);
}
}
void igraph_i_graphml_add_attribute_key(const xmlChar** attrs,
struct igraph_i_graphml_parser_state *state) {
xmlChar **it;
igraph_trie_t *trie=0;
igraph_vector_ptr_t *ptrvector=0;
long int id;
int ret;
igraph_i_graphml_attribute_record_t *rec=
igraph_Calloc(1, igraph_i_graphml_attribute_record_t);
if (!state->successful) return;
if (rec==0) {
igraph_error("Cannot parse GraphML file", __FILE__, __LINE__,
IGRAPH_ENOMEM);
igraph_i_graphml_sax_handler_error(state, "Cannot parse GraphML file");
return;
}
IGRAPH_FINALLY(igraph_free, rec);
for (it=(xmlChar**)attrs; *it; it+=2) {
if (xmlStrEqual(*it, toXmlChar("id"))) {
const char *id=(const char*)(*(it+1));
rec->id=strdup(id);
} else if (xmlStrEqual(*it, toXmlChar("attr.name"))) {
const char *name=fromXmlChar(*(it+1));
rec->record.name=strdup(name);
} else if (xmlStrEqual(*it, toXmlChar("attr.type"))) {
if (xmlStrEqual(*(it+1), (xmlChar*)"boolean")) {
rec->type=I_GRAPHML_BOOLEAN;
rec->record.type=IGRAPH_ATTRIBUTE_NUMERIC;
} else if (xmlStrEqual(*(it+1), toXmlChar("string"))) {
rec->type=I_GRAPHML_STRING;
rec->record.type=IGRAPH_ATTRIBUTE_STRING;
} else if (xmlStrEqual(*(it+1), toXmlChar("float"))) {
rec->type=I_GRAPHML_FLOAT;
rec->record.type=IGRAPH_ATTRIBUTE_NUMERIC;
} else if (xmlStrEqual(*(it+1), toXmlChar("double"))) {
rec->type=I_GRAPHML_DOUBLE;
rec->record.type=IGRAPH_ATTRIBUTE_NUMERIC;
} else if (xmlStrEqual(*(it+1), toXmlChar("int"))) {
rec->type=I_GRAPHML_INTEGER;
rec->record.type=IGRAPH_ATTRIBUTE_NUMERIC;
} else if (xmlStrEqual(*(it+1), toXmlChar("long"))) {
rec->type=I_GRAPHML_LONG;
rec->record.type=IGRAPH_ATTRIBUTE_NUMERIC;
} else {
igraph_error("Cannot parse GraphML file, unknown attribute type",
__FILE__, __LINE__, IGRAPH_PARSEERROR);
igraph_i_graphml_sax_handler_error(state, "Cannot parse GraphML file, unknown attribute type");
return;
}
} else if (xmlStrEqual(*it, toXmlChar("for"))) {
/* graph, vertex or edge attribute? */
if (xmlStrEqual(*(it+1), toXmlChar("graph"))) {
trie=&state->g_names;
ptrvector=&state->g_attrs;
} else if (xmlStrEqual(*(it+1), toXmlChar("node"))) {
trie=&state->v_names;
ptrvector=&state->v_attrs;
} else if (xmlStrEqual(*(it+1), toXmlChar("edge"))) {
trie=&state->e_names;
ptrvector=&state->e_attrs;
} else {
igraph_error("Cannot parse GraphML file, unknown attribute type",
__FILE__, __LINE__, IGRAPH_PARSEERROR);
igraph_i_graphml_sax_handler_error(state, "Cannot parse GraphML file, unknown attribute type");
return;
}
}
}
if (trie == 0 && state->successful) {
igraph_error("Cannot parse GraphML file, missing 'for' attribute", __FILE__, __LINE__, IGRAPH_PARSEERROR);
igraph_i_graphml_sax_handler_error(state, "Cannot parse GraphML file, missing 'for' attribute");
return;
}
/* add to trie, attribues */
igraph_trie_get(trie, rec->id, &id);
if (id != igraph_trie_size(trie)-1) {
igraph_error("Cannot parse GraphML file, duplicate attribute",
__FILE__, __LINE__, IGRAPH_PARSEERROR);
igraph_i_graphml_sax_handler_error(state, "Cannot parse GraphML file, duplicate attribute");
return;
}
ret=igraph_vector_ptr_push_back(ptrvector, rec);
if (ret) {
igraph_error("Cannot read GraphML file", __FILE__, __LINE__, ret);
igraph_i_graphml_sax_handler_error(state, "Cannot read GraphML file");
return;
}
/* create the attribute values */
switch (rec->record.type) {
igraph_vector_t *vec;
igraph_strvector_t *strvec;
case IGRAPH_ATTRIBUTE_NUMERIC:
vec=igraph_Calloc(1, igraph_vector_t);
if (vec==0) {
igraph_error("Cannot parse GraphML file", __FILE__, __LINE__,
IGRAPH_ENOMEM);
igraph_i_graphml_sax_handler_error(state, "Cannot parse GraphML file");
return;
}
rec->record.value=vec;
igraph_vector_init(vec, 0);
break;
case IGRAPH_ATTRIBUTE_STRING:
strvec=igraph_Calloc(1, igraph_strvector_t);
if (strvec==0) {
igraph_error("Cannot parse GraphML file", __FILE__, __LINE__,
IGRAPH_ENOMEM);
igraph_i_graphml_sax_handler_error(state, "Cannot parse GraphML file");
return;
}
rec->record.value=strvec;
igraph_strvector_init(strvec, 0);
break;
default: break;
}
IGRAPH_FINALLY_CLEAN(1); /* rec */
}
void igraph_i_graphml_sax_handler_end_document(void *state0) {
struct igraph_i_graphml_parser_state *state=
(struct igraph_i_graphml_parser_state*)state0;
long i, l;
int r;
igraph_i_attribute_record_t idrec, eidrec;
const char *idstr="id";
igraph_bool_t already_has_vertex_id=0, already_has_edge_id=0;
if (!state->successful) return;
if (state->index<0) {
igraph_vector_ptr_t vattr, eattr, gattr;
long int esize=igraph_vector_ptr_size(&state->e_attrs);
const void **tmp;
r=igraph_vector_ptr_init(&vattr,
igraph_vector_ptr_size(&state->v_attrs)+1);
if (r) {
igraph_error("Cannot parse GraphML file", __FILE__, __LINE__, r);
igraph_i_graphml_sax_handler_error(state, "Cannot parse GraphML file");
return;
}
IGRAPH_FINALLY(igraph_vector_ptr_destroy, &vattr);
if (igraph_strvector_size(&state->edgeids) != 0) {
esize++;
}
r=igraph_vector_ptr_init(&eattr, esize);
if (r) {
igraph_error("Cannot parse GraphML file", __FILE__, __LINE__, r);
igraph_i_graphml_sax_handler_error(state, "Cannot parse GraphML file");
return;
}
IGRAPH_FINALLY(igraph_vector_ptr_destroy, &eattr);
r=igraph_vector_ptr_init(&gattr, igraph_vector_ptr_size(&state->g_attrs));
if (r) {
igraph_error("Cannot parse GraphML file", __FILE__, __LINE__, r);
igraph_i_graphml_sax_handler_error(state, "Cannot parse GraphML file");
return;
}
IGRAPH_FINALLY(igraph_vector_ptr_destroy, &gattr);
for (i=0; i<igraph_vector_ptr_size(&state->v_attrs); i++) {
igraph_i_graphml_attribute_record_t *graphmlrec=
VECTOR(state->v_attrs)[i];
igraph_i_attribute_record_t *rec=&graphmlrec->record;
/* Check that the name of the vertex attribute is not 'id'.
If it is then we cannot the complimentary 'id' attribute. */
if (! strcmp(rec->name, idstr)) {
already_has_vertex_id=1;
}
if (rec->type == IGRAPH_ATTRIBUTE_NUMERIC) {
igraph_vector_t *vec=(igraph_vector_t*)rec->value;
long int origsize=igraph_vector_size(vec);
long int nodes=igraph_trie_size(&state->node_trie);
igraph_vector_resize(vec, nodes);
for (l=origsize; l<nodes; l++) {
VECTOR(*vec)[l]=IGRAPH_NAN;
}
} else if (rec->type == IGRAPH_ATTRIBUTE_STRING) {
igraph_strvector_t *strvec=(igraph_strvector_t*)rec->value;
long int origsize=igraph_strvector_size(strvec);
long int nodes=igraph_trie_size(&state->node_trie);
igraph_strvector_resize(strvec, nodes);
for (l=origsize; l<nodes; l++) {
igraph_strvector_set(strvec, l, "");
}
}
VECTOR(vattr)[i]=rec;
}
if (!already_has_vertex_id) {
idrec.name=idstr;
idrec.type=IGRAPH_ATTRIBUTE_STRING;
tmp=&idrec.value;
igraph_trie_getkeys(&state->node_trie, (const igraph_strvector_t **)tmp);
VECTOR(vattr)[i]=&idrec;
} else {
igraph_vector_ptr_pop_back(&vattr);
IGRAPH_WARNING("Could not add vertex ids, "
"there is already an 'id' vertex attribute");
}
for (i=0; i<igraph_vector_ptr_size(&state->e_attrs); i++) {
igraph_i_graphml_attribute_record_t *graphmlrec=
VECTOR(state->e_attrs)[i];
igraph_i_attribute_record_t *rec=&graphmlrec->record;
if (! strcmp(rec->name, idstr)) {
already_has_edge_id=1;
}
if (rec->type == IGRAPH_ATTRIBUTE_NUMERIC) {
igraph_vector_t *vec=(igraph_vector_t*)rec->value;
long int origsize=igraph_vector_size(vec);
long int edges=igraph_vector_size(&state->edgelist)/2;
igraph_vector_resize(vec, edges);
for (l=origsize; l<edges; l++) {
VECTOR(*vec)[l]=IGRAPH_NAN;
}
} else if (rec->type == IGRAPH_ATTRIBUTE_STRING) {
igraph_strvector_t *strvec=(igraph_strvector_t*)rec->value;
long int origsize=igraph_strvector_size(strvec);
long int edges=igraph_vector_size(&state->edgelist)/2;
igraph_strvector_resize(strvec, edges);
for (l=origsize; l<edges; l++) {
igraph_strvector_set(strvec, l, "");
}
}
VECTOR(eattr)[i]=rec;
}
if (igraph_strvector_size(&state->edgeids) != 0) {
if (!already_has_edge_id) {
long int origsize=igraph_strvector_size(&state->edgeids);
eidrec.name=idstr;
eidrec.type=IGRAPH_ATTRIBUTE_STRING;
igraph_strvector_resize(&state->edgeids,
igraph_vector_size(&state->edgelist)/2);
for (; origsize < igraph_strvector_size(&state->edgeids); origsize++) {
igraph_strvector_set(&state->edgeids, origsize, "");
}
eidrec.value=&state->edgeids;
VECTOR(eattr)[(long int)igraph_vector_ptr_size(&eattr)-1]=&eidrec;
} else {
igraph_vector_ptr_pop_back(&eattr);
IGRAPH_WARNING("Could not add edge ids, "
"there is already an 'id' edge attribute");
}
}
for (i=0; i<igraph_vector_ptr_size(&state->g_attrs); i++) {
igraph_i_graphml_attribute_record_t *graphmlrec=
VECTOR(state->g_attrs)[i];
igraph_i_attribute_record_t *rec=&graphmlrec->record;
if (rec->type == IGRAPH_ATTRIBUTE_NUMERIC) {
igraph_vector_t *vec=(igraph_vector_t*)rec->value;
long int origsize=igraph_vector_size(vec);
igraph_vector_resize(vec, 1);
for (l=origsize; l<1; l++) {
VECTOR(*vec)[l]=IGRAPH_NAN;
}
} else if (rec->type == IGRAPH_ATTRIBUTE_STRING) {
igraph_strvector_t *strvec=(igraph_strvector_t*)rec->value;
long int origsize=igraph_strvector_size(strvec);
igraph_strvector_resize(strvec, 1);
for (l=origsize; l<1; l++) {
igraph_strvector_set(strvec, l, "");
}
}
VECTOR(gattr)[i]=rec;
}
igraph_empty_attrs(state->g, 0, state->edges_directed, &gattr);
igraph_add_vertices(state->g, igraph_trie_size(&state->node_trie),
&vattr);
igraph_add_edges(state->g, &state->edgelist, &eattr);
igraph_vector_ptr_destroy(&vattr);
igraph_vector_ptr_destroy(&eattr);
igraph_vector_ptr_destroy(&gattr);
IGRAPH_FINALLY_CLEAN(3);
}
igraph_i_graphml_destroy_state(state);
}
void igraph_i_graphml_sax_handler_start_document(void *state0) {
struct igraph_i_graphml_parser_state *state=
(struct igraph_i_graphml_parser_state*)state0;
int ret;
state->st=START;
state->successful=1;
state->edges_directed=0;
state->destroyed=0;
state->data_key=0;
state->error_message=0;
state->data_char=0;
ret=igraph_vector_ptr_init(&state->v_attrs, 0);
if (ret) {
igraph_error("Cannot parse GraphML file", __FILE__, __LINE__, ret);
igraph_i_graphml_sax_handler_error(state, "Cannot parse GraphML file");
return;
}
IGRAPH_FINALLY(igraph_vector_ptr_destroy, &state->v_attrs);
ret=igraph_vector_ptr_init(&state->e_attrs, 0);
if (ret) {
igraph_error("Cannot parse GraphML file", __FILE__, __LINE__, ret);
igraph_i_graphml_sax_handler_error(state, "Cannot parse GraphML file");
return;
}
IGRAPH_FINALLY(igraph_vector_ptr_destroy, &state->e_attrs);
ret=igraph_vector_ptr_init(&state->g_attrs, 0);
if (ret) {
igraph_error("Cannot parse GraphML file", __FILE__, __LINE__, ret);
igraph_i_graphml_sax_handler_error(state, "Cannot parse GraphML file");
return;
}
IGRAPH_FINALLY(igraph_vector_ptr_destroy, &state->g_attrs);
ret=igraph_vector_init(&state->edgelist, 0);
if (ret) {
igraph_error("Cannot parse GraphML file", __FILE__, __LINE__, ret);
igraph_i_graphml_sax_handler_error(state, "Cannot parse GraphML file");
return;
}
IGRAPH_FINALLY(igraph_vector_destroy, &state->edgelist);
ret=igraph_trie_init(&state->node_trie, 1);
if (ret) {
igraph_error("Cannot parse GraphML file", __FILE__, __LINE__, ret);
igraph_i_graphml_sax_handler_error(state, "Cannot parse GraphML file");
return;
}
IGRAPH_FINALLY(igraph_trie_destroy, &state->node_trie);
ret=igraph_strvector_init(&state->edgeids, 0);
if (ret) {
igraph_error("Cannot parse GraphML file", __FILE__, __LINE__, ret);
igraph_i_graphml_sax_handler_error(state, "Cannot parse GraphML file");
return;
}
IGRAPH_FINALLY(igraph_strvector_destroy, &state->edgeids);
ret=igraph_trie_init(&state->v_names, 0);
if (ret) {
igraph_error("Cannot parse GraphML file", __FILE__, __LINE__, ret);
igraph_i_graphml_sax_handler_error(state, "Cannot parse GraphML file");
return;
}
IGRAPH_FINALLY(igraph_trie_destroy, &state->v_names);
ret=igraph_trie_init(&state->e_names, 0);
if (ret) {
igraph_error("Cannot parse GraphML file", __FILE__, __LINE__, ret);
igraph_i_graphml_sax_handler_error(state, "Cannot parse GraphML file");
return;
}
IGRAPH_FINALLY(igraph_trie_destroy, &state->e_names);
ret=igraph_trie_init(&state->g_names, 0);
if (ret) {
igraph_error("Cannot parse GraphML file", __FILE__, __LINE__, ret);
igraph_i_graphml_sax_handler_error(state, "Cannot parse GraphML file");
return;
}
IGRAPH_FINALLY(igraph_trie_destroy, &state->g_names);
IGRAPH_FINALLY_CLEAN(9);
IGRAPH_FINALLY(igraph_i_graphml_destroy_state, state);
}
void igraph_rng_Python_destroy(void *state) {
igraph_error("Python RNG error, unsupported function called",
__FILE__, __LINE__, IGRAPH_EINTERNAL);
}
