/* vim:set ts=4 sw=2 sts=2 et: */

/*

IGraph library.

Copyright (C) 2006-2023 Tamas Nepusz <ntamas@gmail.com>

This program is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation; either version 2 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program; if not, write to the Free Software

Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

02110-1301 USA

*/

#include "attributes.h"

#include "arpackobject.h"

#include "bfsiter.h"

#include "dfsiter.h"

#include "common.h"

#include "convert.h"

#include "edgeseqobject.h"

#include "error.h"

#include "filehandle.h"

#include "graphobject.h"

#include "indexing.h"

#include "memory.h"

#include "pyhelpers.h"

#include "vertexseqobject.h"

#include <float.h>

PyTypeObject* igraphmodule_GraphType;

#define CREATE_GRAPH_FROM_TYPE(py_graph, c_graph, py_type) { \

py_graph = (igraphmodule_GraphObject*) igraphmodule_Graph_subclass_from_igraph_t( \

py_type, &c_graph \

); \

if (py_graph == NULL) { igraph_destroy(&c_graph); } \

}

#define CREATE_GRAPH(py_graph, c_graph) { \

py_graph = (igraphmodule_GraphObject*) igraphmodule_Graph_subclass_from_igraph_t( \

Py_TYPE(self), &c_graph \

); \

if (py_graph == NULL) { igraph_destroy(&c_graph); } \

}

/**********************************************************************

* Basic implementation of igraph.Graph *

**********************************************************************/

/** \defgroup python_interface_graph Graph object

* \ingroup python_interface */

/**

* \ingroup python_interface_graph

* \brief Creates a new igraph object in Python

*

* This function is called whenever a new \c igraph.Graph object is created in

* Python. An optional \c n parameter can be passed from Python,

* representing the number of vertices in the graph. If it is omitted,

* the default value is 0.

*

* <b>Example call from Python:</b>

\verbatim

g = igraph.Graph(5);

\endverbatim

*

* Most of the parameters are processed by \c igraphmodule_Graph_init ; the

* responsibility of \c igraphmodule_Graph_new is only to ensure that the

* \c igraph_t structure is initialized so the user has no chance for messing

* around with an uninitialized structure.

*

* \return the new \c igraph.Graph object or NULL if an error occurred.

*

* \sa igraphmodule_Graph_init

* \sa igraph_empty

*/

PyObject *igraphmodule_Graph_new(PyTypeObject * type, PyObject * args,

PyObject * kwds)

{

igraphmodule_GraphObject *self;

self = (igraphmodule_GraphObject *) ((allocfunc)PyType_GetSlot(type, Py_tp_alloc))(type, 0);

RC_ALLOC("Graph", self);

/* We need to ensure that self->g is a valid igraph_t pointer in case the

* user somehow manages to sneak in a call to a method of the Graph instance

* between __new__() and __init__() (e.g,. by overriding __init__()). We

* will replace it later with the "proper" graph instance in __init__() if

* needed. */

if (igraph_empty(&self->g, 0, IGRAPH_UNDIRECTED)) {

igraphmodule_handle_igraph_error();

return NULL;

}

return (PyObject *) self;

}

/**

* \ingroup python_interface_graph

* \brief Clears the graph object's subobject (before deallocation)

*/

int igraphmodule_Graph_clear(igraphmodule_GraphObject * self)

{

PyObject *tmp;

PyObject_GC_UnTrack(self);

tmp = self->destructor;

self->destructor = NULL;

Py_XDECREF(tmp);

return 0;

}

/**

* \ingroup python_interface_graph

* \brief Support for cyclic garbage collection in Python

*

* This is necessary because the \c igraph.Graph object contains several

* other \c PyObject pointers and they might point back to itself.

*/

int igraphmodule_Graph_traverse(igraphmodule_GraphObject * self,

visitproc visit, void *arg)

{

RC_TRAVERSE("Graph", self);

Py_VISIT(self->destructor);

if (self->g.attr) {

for (int i = 0; i < 3; i++) {

Py_VISIT(((PyObject**)self->g.attr)[i]);

}

}

Py_VISIT(Py_TYPE(self));

return 0;

}

/**

* \ingroup python_interface_graph

* \brief Deallocates a Python representation of a given igraph object

*/

void igraphmodule_Graph_dealloc(igraphmodule_GraphObject * self)

{

PyObject *r;

RC_DEALLOC("Graph", self);

/* Clear weak references */

if (self->weakreflist != NULL) {

PyObject_ClearWeakRefs((PyObject *) self);

}

igraph_destroy(&self->g);

if (self->destructor != NULL && PyCallable_Check(self->destructor)) {

r = PyObject_CallObject(self->destructor, NULL);

if (r) {

Py_DECREF(r);

}

}

igraphmodule_Graph_clear(self);

PY_FREE_AND_DECREF_TYPE(self, igraphmodule_GraphType);

}

/**

* \ingroup python_interface_graph

* \brief Initializes a new \c igraph object in Python

*

* This function is called whenever a new \c igraph.Graph object is initialized in

* Python (note that initializing is not equal to creating: an object might

* be created but not initialized when it is being recovered from a serialized

* state).

*

* Throws \c AssertionError in Python if \c vcount is less than or equal to zero.

* \return the new \c igraph.Graph object or NULL if an error occurred.

*

* \sa igraph_empty

* \sa igraph_create

*/

int igraphmodule_Graph_init(igraphmodule_GraphObject * self,

PyObject * args, PyObject * kwds) {

static char *kwlist[] = { "n", "edges", "directed", "__ptr", NULL };

PyObject *edges = NULL, *dir = Py_False, *ptr_o = 0;

void* ptr = 0;

Py_ssize_t n = 0;

igraph_vector_int_t edges_vector;

igraph_int_t vcount;

igraph_bool_t edges_vector_owned = false;

int retval = 0;

self->destructor = NULL;

self->weakreflist = NULL;

if (!PyArg_ParseTupleAndKeywords(args, kwds, "|nOOO!", kwlist,

&n, &edges, &dir,

&PyCapsule_Type, &ptr_o))

return -1;

/* Safety check: if ptr is not null, it means that we have been explicitly

* given a pointer to an igraph_t for which we must take ownership.

* This means that n should be zero and edges should not be specified */

if (ptr_o && (n != 0 || edges != NULL)) {

PyErr_SetString(PyExc_ValueError, "neither n nor edges should be given "

"in the call to Graph.__init__() when the graph is "

"pre-initialized with a C pointer");

return -1;

}

if (n < 0) {

PyErr_SetString(PyExc_OverflowError, "vertex count must be non-negative");

return -1;

}

if (n > IGRAPH_INTEGER_MAX) {

PyErr_SetString(PyExc_OverflowError, "vertex count too large");

return -1;

}

if (ptr_o) {

/* We must take ownership of an igraph graph. Since we already created

* one in igraphmodule_Graph_new(), we need to destroy that first */

ptr = PyCapsule_GetPointer(ptr_o, "__igraph_t");

if (ptr == 0) {

PyErr_SetString(PyExc_ValueError, "pointer should not be null");

} else {

igraph_destroy(&self->g);

self->g = *(igraph_t*)ptr;

}

} else {

vcount = 0;

if (edges) {

/* Caller specified an edge list, so we use igraph_add_vertices() and

* igraph_add_edges() as needed. But first, we have to convert the Python

* list to a igraph_vector_t */

if (igraphmodule_PyObject_to_edgelist(edges, &edges_vector, 0, &edges_vector_owned)) {

igraphmodule_handle_igraph_error();

return -1;

}

if (igraph_vector_int_size(&edges_vector) > 0) {

vcount = igraph_vector_int_max(&edges_vector) + 1;

}

}

if (vcount < n) {

vcount = n;

}

/* We already have an undirected graph in &self->g. Make it directed first

* if needed */

if (PyObject_IsTrue(dir) && igraph_to_directed(&self->g, IGRAPH_TO_DIRECTED_ARBITRARY) != IGRAPH_SUCCESS) {

igraphmodule_handle_igraph_error();

retval = -1;

goto cleanup;

}

/* Add the vertices first */

if (vcount > 0 && igraph_add_vertices(&self->g, vcount, 0) != IGRAPH_SUCCESS) {

igraphmodule_handle_igraph_error();

retval = -1;

goto cleanup;

}

/* Then the edges */

if (edges && igraph_add_edges(&self->g, &edges_vector, 0) != IGRAPH_SUCCESS) {

igraphmodule_handle_igraph_error();

retval = -1;

goto cleanup;

}

}

cleanup:

if (edges_vector_owned) {

igraph_vector_int_destroy(&edges_vector);

}

return retval;

}

/** \ingroup python_interface_graph

* \brief Creates an \c igraph.Graph subtype from an existing \c igraph_t

*

* The newly created instance (which will be a subtype of \c igraph.Graph)

* will take ownership of the given \c igraph_t. This function is not

* accessible from Python, however it is in the header file for other C API

* functions to use.

*/

PyObject* igraphmodule_Graph_subclass_from_igraph_t(

PyTypeObject* type, igraph_t *graph

) {

PyObject* result_o;

PyObject* capsule;

PyObject* args;

PyObject* kwds;

if (!PyType_IsSubtype(type, igraphmodule_GraphType)) {

PyErr_SetString(PyExc_TypeError, "igraph._igraph.GraphBase expected");

return 0;

}

capsule = PyCapsule_New(graph, "__igraph_t", 0);

if (capsule == 0) {

return 0;

}

args = PyTuple_New(0);

if (args == 0) {

Py_DECREF(capsule);

return 0;

}

kwds = PyDict_New();

if (kwds == 0) {

Py_DECREF(args);

Py_DECREF(capsule);

return 0;

}

if (PyDict_SetItemString(kwds, "__ptr", capsule)) {

Py_DECREF(kwds);

Py_DECREF(args);

Py_DECREF(capsule);

return 0;

}

/* kwds now holds a reference to the capsule so we can release it */

Py_DECREF(capsule);

/* Call the type */

result_o = PyObject_Call((PyObject*) type, args, kwds);

/* Release args and kwds */

Py_DECREF(args);

Py_DECREF(kwds);

return result_o;

}

/** \ingroup python_interface_graph

* \brief Creates an \c igraph.Graph object from an existing \c igraph_t

*

* The newly created \c igraph.Graph object will take ownership of the

* given \c igraph_t. This function is not accessible from Python the

* normal way, but it is exposed via the C API of the Python module.

* See \c api.h for more details.

*/

PyObject* igraphmodule_Graph_from_igraph_t(igraph_t *graph) {

return igraphmodule_Graph_subclass_from_igraph_t(

igraphmodule_GraphType, graph

);

}

/** \ingroup python_interface_graph

* \brief Formats an \c igraph.Graph object in a human-readable format.

*

* This function is rather simple now, it returns the number of vertices

* and edges in a string.

*

* \return the formatted textual representation as a \c PyObject

*/

PyObject *igraphmodule_Graph_str(igraphmodule_GraphObject * self)

{

if (igraph_is_directed(&self->g)) {

return PyUnicode_FromFormat(

"Directed graph (|V| = %" IGRAPH_PRId ", |E| = %" IGRAPH_PRId ")",

igraph_vcount(&self->g), igraph_ecount(&self->g)

);

} else {

return PyUnicode_FromFormat(

"Undirected graph (|V| = %" IGRAPH_PRId ", |E| = %" IGRAPH_PRId ")",

igraph_vcount(&self->g), igraph_ecount(&self->g)

);

}

}

/** \ingroup python_interface_copy

* \brief Creates a copy of the graph

* \return the copy of the graph

*/

PyObject *igraphmodule_Graph_copy(igraphmodule_GraphObject *self, PyObject* Py_UNUSED(_null))

{

igraphmodule_GraphObject *result_o;

igraph_t g;

if (igraph_copy(&g, &self->g)) {

igraphmodule_handle_igraph_error();

return NULL;

}

CREATE_GRAPH(result_o, g);

return (PyObject *) result_o;

}

/**********************************************************************

* The most basic igraph interface *

**********************************************************************/

/** \ingroup python_interface_graph

* \brief Returns the number of vertices in an \c igraph.Graph object.

* \return the number of vertices as a \c PyObject

* \sa igraph_vcount

*/

PyObject *igraphmodule_Graph_vcount(igraphmodule_GraphObject* self, PyObject* Py_UNUSED(_null))

{

return igraphmodule_integer_t_to_PyObject(igraph_vcount(&self->g));

}

/** \ingroup python_interface_graph

* \brief Returns the number of edges in an \c igraph.Graph object.

* \return the number of edges as a \c PyObject

* \sa igraph_ecount

*/

PyObject *igraphmodule_Graph_ecount(igraphmodule_GraphObject* self, PyObject* Py_UNUSED(_null))

{

return igraphmodule_integer_t_to_PyObject(igraph_ecount(&self->g));

}

/** \ingroup python_interface_graph

* \brief Checks whether an \c igraph.Graph object is directed.

* \return \c True if the graph is directed, \c False otherwise.

* \sa igraph_is_directed

*/

PyObject *igraphmodule_Graph_is_directed(igraphmodule_GraphObject* self, PyObject* Py_UNUSED(_null))

{

if (igraph_is_directed(&self->g))

Py_RETURN_TRUE;

Py_RETURN_FALSE;

}

/**

* \ingroup python_interface_graph

* \brief Checks whether a matching is valid in the context of an \c igraph.Graph

* object.

* \sa igraph_is_matching

*/

PyObject *igraphmodule_Graph_is_matching(igraphmodule_GraphObject* self,

PyObject* args, PyObject* kwds) {

static char* kwlist[] = { "matching", "types", NULL };

PyObject *matching_o, *types_o = Py_None;

igraph_vector_int_t* matching = 0;

igraph_vector_bool_t* types = 0;

igraph_bool_t res;

if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O", kwlist, &matching_o,

&types_o))

return NULL;

if (igraphmodule_attrib_to_vector_int_t(matching_o, self, &matching,

ATTRIBUTE_TYPE_VERTEX))

return NULL;

if (igraphmodule_attrib_to_vector_bool_t(types_o, self, &types, ATTRIBUTE_TYPE_VERTEX)) {

if (matching != 0) { igraph_vector_int_destroy(matching); free(matching); }

return NULL;

}

if (igraph_is_matching(&self->g, types, matching, &res)) {

if (matching != 0) { igraph_vector_int_destroy(matching); free(matching); }

if (types != 0) { igraph_vector_bool_destroy(types); free(types); }

igraphmodule_handle_igraph_error();

return NULL;

}

if (matching != 0) { igraph_vector_int_destroy(matching); free(matching); }

if (types != 0) { igraph_vector_bool_destroy(types); free(types); }

if (res)

Py_RETURN_TRUE;

Py_RETURN_FALSE;

}

/**

* \ingroup python_interface_graph

* \brief Checks whether a matching is valid and maximal in the context of an

* \c igraph.Graph object.

* \sa igraph_is_maximal_matching

*/

PyObject *igraphmodule_Graph_is_maximal_matching(igraphmodule_GraphObject* self,

PyObject* args, PyObject* kwds) {

static char* kwlist[] = { "matching", "types", NULL };

PyObject *matching_o, *types_o = Py_None;

igraph_vector_int_t* matching = 0;

igraph_vector_bool_t* types = 0;

igraph_bool_t res;

if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O", kwlist, &matching_o,

&types_o))

return NULL;

if (igraphmodule_attrib_to_vector_int_t(matching_o, self, &matching,

ATTRIBUTE_TYPE_VERTEX))

return NULL;

if (igraphmodule_attrib_to_vector_bool_t(types_o, self, &types, ATTRIBUTE_TYPE_VERTEX)) {

if (matching != 0) { igraph_vector_int_destroy(matching); free(matching); }

return NULL;

}

if (igraph_is_maximal_matching(&self->g, types, matching, &res)) {

if (matching != 0) { igraph_vector_int_destroy(matching); free(matching); }

if (types != 0) { igraph_vector_bool_destroy(types); free(types); }

igraphmodule_handle_igraph_error();

return NULL;

}

if (matching != 0) { igraph_vector_int_destroy(matching); free(matching); }

if (types != 0) { igraph_vector_bool_destroy(types); free(types); }

if (res)

Py_RETURN_TRUE;

Py_RETURN_FALSE;

}

/** \ingroup python_interface_graph

* \brief Checks whether an \c igraph.Graph object is simple.

* \return \c True if the graph is simple, \c False otherwise.

* \sa igraph_is_simple

*/

PyObject *igraphmodule_Graph_is_simple(igraphmodule_GraphObject* self, PyObject* Py_UNUSED(_null)) {

igraph_bool_t res;

if (igraph_is_simple(&self->g, &res, IGRAPH_DIRECTED)) {

igraphmodule_handle_igraph_error();

return NULL;

}

if (res)

Py_RETURN_TRUE;

Py_RETURN_FALSE;

}

/** \ingroup python_interface_graph

* \brief Checks whether an \c igraph.Graph object is a complete graph.

* \return \c True if the graph is complete, \c False otherwise.

* \sa igraph_is_complete

*/

PyObject *igraphmodule_Graph_is_complete(igraphmodule_GraphObject* self, PyObject* Py_UNUSED(_null)) {

igraph_bool_t res;

if (igraph_is_complete(&self->g, &res)) {

igraphmodule_handle_igraph_error();

return NULL;

}

if (res)

Py_RETURN_TRUE;

Py_RETURN_FALSE;

}

/** \ingroup python_interface_graph

* \brief Checks whether a given vertex set forms a clique

*/

PyObject *igraphmodule_Graph_is_clique(igraphmodule_GraphObject * self,

PyObject * args, PyObject * kwds)

{

PyObject *list = Py_None;

PyObject *directed = Py_False;

igraph_bool_t res;

igraph_vs_t vs;

static char *kwlist[] = { "vertices", "directed", NULL };

if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OO", kwlist, &list, &directed)) {

return NULL;

}

if (igraphmodule_PyObject_to_vs_t(list, &vs, &self->g, NULL, NULL)) {

return NULL;

}

if (igraph_is_clique(&self->g, vs, PyObject_IsTrue(directed), &res)) {

igraphmodule_handle_igraph_error();

igraph_vs_destroy(&vs);

return NULL;

}

igraph_vs_destroy(&vs);

if (res)

Py_RETURN_TRUE;

else

Py_RETURN_FALSE;

}

/** \ingroup python_interface_graph

* \brief Checks whether a the given vertices form an independent set

*/

PyObject *igraphmodule_Graph_is_independent_vertex_set(igraphmodule_GraphObject * self,

PyObject * args, PyObject * kwds)

{

PyObject *list = Py_None;

igraph_bool_t res;

igraph_vs_t vs;

static char *kwlist[] = { "vertices", NULL };

if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &list)) {

return NULL;

}

if (igraphmodule_PyObject_to_vs_t(list, &vs, &self->g, NULL, NULL)) {

return NULL;

}

if (igraph_is_independent_vertex_set(&self->g, vs, &res)) {

igraphmodule_handle_igraph_error();

igraph_vs_destroy(&vs);

return NULL;

}

igraph_vs_destroy(&vs);

if (res)

Py_RETURN_TRUE;

else

Py_RETURN_FALSE;

}

/** \ingroup python_interface_graph

* \brief Determines whether a graph is a (directed or undirected) tree

* \sa igraph_is_tree

*/

PyObject *igraphmodule_Graph_is_tree(igraphmodule_GraphObject* self,

PyObject* args, PyObject* kwds)

{

static char *kwlist[] = { "mode", NULL };

PyObject *mode_o = Py_None;

igraph_neimode_t mode = IGRAPH_OUT;

igraph_bool_t res;

if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &mode_o)) {

return NULL;

}

if (igraphmodule_PyObject_to_neimode_t(mode_o, &mode)) {

return NULL;

}

if (igraph_is_tree(&self->g, &res, /* root = */ 0, mode)) {

igraphmodule_handle_igraph_error();

return NULL;

}

if (res) {

Py_RETURN_TRUE;

} else {

Py_RETURN_FALSE;

}

}

/** \ingroup python_interface_graph

* \brief Adds vertices to an \c igraph.Graph

* \return the extended \c igraph.Graph object

* \sa igraph_add_vertices

*/

PyObject *igraphmodule_Graph_add_vertices(igraphmodule_GraphObject * self,

PyObject * args, PyObject * kwds) {

Py_ssize_t n;

if (!PyArg_ParseTuple(args, "n", &n)) {

return NULL;

}

CHECK_SSIZE_T_RANGE(n, "vertex count");

if (igraph_add_vertices(&self->g, n, 0)) {

igraphmodule_handle_igraph_error();

return NULL;

}

Py_RETURN_NONE;

}

/** \ingroup python_interface_graph

* \brief Removes vertices from an \c igraph.Graph

* \return the modified \c igraph.Graph object

*

* \todo Need more error checking on vertex IDs. (igraph fails when an

* invalid vertex ID is given)

* \sa igraph_delete_vertices

*/

PyObject *igraphmodule_Graph_delete_vertices(igraphmodule_GraphObject * self,

PyObject * args, PyObject * kwds) {

PyObject *list = 0;

igraph_vs_t vs;

if (!PyArg_ParseTuple(args, "|O", &list)) return NULL;

/* no arguments means delete all. */

/* Py_None used to mean 'all', but not any more */

if (list == Py_None) {

PyErr_SetString(PyExc_ValueError, "expected number of vertices to delete, got None");

return NULL;

}

/* this already converts no arguments to all vertices */

if (igraphmodule_PyObject_to_vs_t(list, &vs, &self->g, 0, 0)) {

return NULL;

}

if (igraph_delete_vertices(&self->g, vs)) {

igraphmodule_handle_igraph_error();

igraph_vs_destroy(&vs);

return NULL;

}

igraph_vs_destroy(&vs);

Py_RETURN_NONE;

}

/** \ingroup python_interface_graph

* \brief Adds edges to an \c igraph.Graph

* \return the extended \c igraph.Graph object

*

* \todo Need more error checking on vertex IDs. (igraph fails when an

* invalid vertex ID is given)

* \sa igraph_add_edges

*/

PyObject *igraphmodule_Graph_add_edges(igraphmodule_GraphObject * self,

PyObject * args, PyObject * kwds)

{

PyObject *list;

igraph_vector_int_t v;

igraph_bool_t v_owned = false;

if (!PyArg_ParseTuple(args, "O", &list))

return NULL;

if (igraphmodule_PyObject_to_edgelist(list, &v, &self->g, &v_owned))

return NULL;

/* do the hard work :) */

if (igraph_add_edges(&self->g, &v, 0)) {

igraphmodule_handle_igraph_error();

if (v_owned) {

igraph_vector_int_destroy(&v);

}

return NULL;

}

if (v_owned) {

igraph_vector_int_destroy(&v);

}

Py_RETURN_NONE;

}

/** \ingroup python_interface_graph

* \brief Deletes edges from an \c igraph.Graph

* \return the extended \c igraph.Graph object

*

* \todo Need more error checking on vertex IDs. (igraph fails when an

* invalid vertex ID is given)

* \sa igraph_delete_edges

*/

PyObject *igraphmodule_Graph_delete_edges(igraphmodule_GraphObject * self,

PyObject * args, PyObject * kwds)

{

PyObject *list = 0;

igraph_es_t es;

static char *kwlist[] = { "edges", NULL };

if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &list))

return NULL;

/* no arguments means delete all. */

/* Py_None means "do nothing" since igraph 0.10 */

if (list == Py_None) {

Py_RETURN_NONE;

}

/* this already converts no arguments and Py_None to all edges */

if (igraphmodule_PyObject_to_es_t(list, &es, &self->g, 0)) {

/* something bad happened during conversion, return immediately */

return NULL;

}

if (igraph_delete_edges(&self->g, es)) {

igraphmodule_handle_igraph_error();

igraph_es_destroy(&es);

return NULL;

}

igraph_es_destroy(&es);

Py_RETURN_NONE;

}

/**********************************************************************

* Structural properties *

**********************************************************************/

/** \ingroup python_interface_graph

* \brief The degree of some vertices in an \c igraph.Graph

* \return the degree list as a Python object

* \sa igraph_degree

*/

PyObject *igraphmodule_Graph_degree(igraphmodule_GraphObject * self,

PyObject * args, PyObject * kwds)

{

PyObject *list = Py_None;

PyObject *loops = Py_True;

PyObject *dmode_o = Py_None;

igraph_neimode_t dmode = IGRAPH_ALL;

igraph_vector_int_t res;

igraph_vs_t vs;

igraph_bool_t return_single = false;

static char *kwlist[] = { "vertices", "mode", "loops", NULL };

if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOO", kwlist,

&list, &dmode_o, &loops))

return NULL;

if (igraphmodule_PyObject_to_neimode_t(dmode_o, &dmode)) {

return NULL;

}

if (igraphmodule_PyObject_to_vs_t(list, &vs, &self->g, &return_single, 0)) {

return NULL;

}

if (igraph_vector_int_init(&res, 0)) {

igraph_vs_destroy(&vs);

return NULL;

}

if (igraph_degree(&self->g, &res, vs,

dmode, PyObject_IsTrue(loops))) {

igraphmodule_handle_igraph_error();

igraph_vs_destroy(&vs);

igraph_vector_int_destroy(&res);

return NULL;

}

if (!return_single) {

list = igraphmodule_vector_int_t_to_PyList(&res);

} else {

list = igraphmodule_integer_t_to_PyObject(VECTOR(res)[0]);

}

igraph_vector_int_destroy(&res);

igraph_vs_destroy(&vs);

return list;

}

/**

* \ingroup python_interface_graph

* \brief Structural diversity index of some vertices in an \c igraph.Graph

* \sa igraph_diversity

*/

PyObject *igraphmodule_Graph_diversity(igraphmodule_GraphObject * self,

PyObject * args, PyObject * kwds) {

PyObject *list = Py_None;

PyObject *weights_o = Py_None;

igraph_vector_t res, *weights = 0;

igraph_vs_t vs;

igraph_bool_t return_single = false;

igraph_int_t no_of_nodes;

static char *kwlist[] = { "vertices", "weights", NULL };

if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OO", kwlist,

&list, &weights_o))

return NULL;

if (igraphmodule_PyObject_to_vs_t(list, &vs, &self->g, &return_single, 0)) {

igraphmodule_handle_igraph_error();

return NULL;

}

if (igraph_vector_init(&res, 0)) {

igraph_vs_destroy(&vs);

return NULL;

}

if (igraphmodule_attrib_to_vector_t(weights_o, self, &weights,

ATTRIBUTE_TYPE_EDGE)) {

igraph_vs_destroy(&vs);

igraph_vector_destroy(&res);

return NULL;

}

if (weights == 0) {

/* Handle this case here because igraph_diversity bails out when no weights

* are given. */

if (igraph_vs_size(&self->g, &vs, &no_of_nodes)) {

igraphmodule_handle_igraph_error();

igraph_vs_destroy(&vs);

igraph_vector_destroy(&res);

return NULL;

}

if (igraph_vector_resize(&res, no_of_nodes)) {

igraphmodule_handle_igraph_error();

igraph_vs_destroy(&vs);

igraph_vector_destroy(&res);

return NULL;

}

igraph_vector_fill(&res, 1.0);

} else {

if (igraph_diversity(&self->g, weights, &res, vs)) {

igraphmodule_handle_igraph_error();

igraph_vs_destroy(&vs);

igraph_vector_destroy(&res);

igraph_vector_destroy(weights); free(weights);

return NULL;

}

igraph_vector_destroy(weights); free(weights);

}

if (!return_single)

list = igraphmodule_vector_t_to_PyList(&res, IGRAPHMODULE_TYPE_FLOAT);

else

list = PyFloat_FromDouble(VECTOR(res)[0]);

igraph_vector_destroy(&res);

igraph_vs_destroy(&vs);

return list;

}

/** \ingroup python_interface_graph

* \brief The strength (weighted degree) of some vertices in an \c igraph.Graph

* \return the strength list as a Python object

* \sa igraph_strength

*/

PyObject *igraphmodule_Graph_strength(igraphmodule_GraphObject * self,

PyObject * args, PyObject * kwds)

{

PyObject *list = Py_None;

PyObject *loops = Py_True;

PyObject *dmode_o = Py_None;

PyObject *weights_o = Py_None;

igraph_neimode_t dmode = IGRAPH_ALL;

igraph_vector_t res, *weights = 0;

igraph_vs_t vs;

igraph_bool_t return_single = false;

static char *kwlist[] = { "vertices", "mode", "loops", "weights", NULL };

if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOOO", kwlist,

&list, &dmode_o, &loops, &weights_o))

return NULL;

if (igraphmodule_PyObject_to_neimode_t(dmode_o, &dmode)) {

return NULL;

}

if (igraphmodule_PyObject_to_vs_t(list, &vs, &self->g, &return_single, 0)) {

igraphmodule_handle_igraph_error();

return NULL;

}

if (igraph_vector_init(&res, 0)) {

igraph_vs_destroy(&vs);

return NULL;

}

if (igraphmodule_attrib_to_vector_t(weights_o, self, &weights,

ATTRIBUTE_TYPE_EDGE)) {

igraph_vs_destroy(&vs);

igraph_vector_destroy(&res);

return NULL;

}

if (igraph_strength(&self->g, &res, vs, dmode,

PyObject_IsTrue(loops), weights)) {

igraphmodule_handle_igraph_error();

igraph_vs_destroy(&vs);

igraph_vector_destroy(&res);

if (weights) { igraph_vector_destroy(weights); free(weights); }

return NULL;

}

if (weights) { igraph_vector_destroy(weights); free(weights); }

if (!return_single)

list = igraphmodule_vector_t_to_PyList(&res, IGRAPHMODULE_TYPE_FLOAT);

else