Dear All,

we have released version 0.6 of the igraph package today. This is a

major new version, with a lot of new features, and (sadly) it is not

completely compatible with code that was written for the previous

igraph versions. (See “Major new features” below for details.)

I have included below a list of (bigger) changes. Please see the

details in the release notes and the NEWS section at the igraph

homepage: http://igraph.sf.net

Best Regards,

Gabor

=====================

Major new features

=====================

– Vertices and edges are numbered from 1 instead of 0.

Note that this makes most of the old R igraph code incompatible

with igraph 0.6. If you want to use your old code, please use

the igraph0 package. See more at http://igraph.sf.net/relnotes-

– The ‘[‘ and ‘[[‘ operators can now be used on igraph graphs,

for ‘[‘ the graph behaves as an adjacency matrix, for ‘[[‘ is

is treated as an adjacency list. It is also much simpler to

manipulate the graph structure, i.e. add/remove edges and vertices,

with some new operators. See more at ?graph.structure.

– In all functions that take a vector or list of vertices or edges,

vertex/edge names can be given instead of the numeric ids.

– New package ‘igraphdata’, contains a number of data sets that can

be used directly in igraph.

– Igraph now supports loading graphs from the Nexus online data

repository, see nexus.get(), nexus.info(), nexus.list() and

nexus.search().

– All the community structure finding algorithm return a ‘communities’

object now, which has a bunch of useful operations, see

?communities for details.

– Vertex and edge attributes are handled much better now. They

are kept whenever possible, and can be combined via a flexible API.

See ?attribute.combination.

– R now prints igraph graphs to the screen in a more structured and

informative way. The output of summary() was also updated

accordingly.

=====================

R: Other new features

=====================

– It is possible to mark vertex groups on plots, via

shading. Communities and cohesive blocks are plotted using this by

default.

– Some igraph demos are now available, see a list via

‘demo(package=”igraph”)’.

– igraph now tries to select the optimal layout algorithm, when

plotting a graph.

– Added a simple console, using Tcl/Tk. It contains a text area

for status messages and also a status bar. See igraph.console().

– Reimplemented igraph options support, see igraph.options() and

getIgraphOpt().

– Igraph functions can now print status messages.

===========================

R: New or updated functions

===========================

Community detection

——————-

– The multi-level modularity optimization community structure detection

algorithm by Blondel et al. was added, see multilevel.community().

– Distance between two community structures: compare.communities().

– Community structure via exact modularity optimization,

optimal.community().

– Hierarchical random graphs and community finding, porting the code

from Aaron Clauset. See hrg.game(), hrg.fit(), etc.

– Added the InfoMAP community finding method, thanks to Emmanuel

Navarro for the code. See infomap.community().

Shortest paths

————–

– Eccentricity (eccentricity()), and radius (radius()) calculations.

– Shortest path calculations with get.shortest.paths() can now

return the edges along the shortest paths.

– get.all.shortest.paths() now supports edge weights.

Centrality

———-

– Centralization scores for degree, closeness, betweenness and

eigenvector centrality. See centralization.scores().

– Personalized Page-Rank scores, see page.rank().

– Subgraph centrality, subgraph.centrality().

– Authority (authority.score()) and hub (hub.score()) scores support

edge weights now.

– Support edge weights in betweenness and closeness calculations.

– bonpow(), Bonacich’s power centrality and alpha.centrality(),

Alpha centrality calculations now use sparse matrices by default.

– Eigenvector centrality calculation, evcent() now works for

directed graphs.

– Betweenness calculation can now use arbitrarily large integers,

this is required for some lattice-like graphs to avoid overflow.

Input/output and file formats

—————————–

– Support the DL file format in graph.read(). See

http://www.analytictech.com/

– Support writing the LEDA file format in write.graph().

Plotting and layouts

——————–

– Star layout: layout.star().

– Layout based on multidimensional scaling, layout.mds().

– New layouts layout.grid() and layout.grid.3d().

– Sugiyama layout algorithm for layered directed acyclic graphs,

layout.sugiyama().

Graph generators

—————-

– New graph generators: static.fitness.game(), static.power.law.game().

– barabasi.game() was rewritten and it supports three algorithms now,

the default algorithm does not generate multiple or loop edges.

The graph generation process can now start from a supplied graph.

– The Watts-Strogatz graph generator, igraph_watts_strogatz() can

now create graphs without loop edges.

Others

——

– Added the Spectral Coarse Graining algorithm, see scg().

– The cohesive.blocks() function was rewritten in C, it is much faster

now. It has a nicer API, too. See demo(“cohesive”).

– Added generic breadth-first and depth-first search implementations

with many callbacks, graph.bfs() and graph_dfs().

– Support vertex and edge coloring in the VF2 (sub)graph isomorphism

functions (graph.isomorphic.vf2(), graph.count.isomorphisms.vf2()

graph.get.isomorphisms.vf2(), graph.subisomorphic.vf2(),

graph.count.subisomorphisms.

– Assortativity coefficient, assortativity(), assortativity.nominal()

and assortativity.degree().

– Vertex operators that work by vertex names:

graph.intersection.by.name(), graph.union.by.name(),

graph.difference.by.name(). Thanks to Magnus Torfason for

contributing his code!

– Function to calculate a non-induced subraph: subgraph.edges().

– More comprehensive maximum flow and minimum cut calculation,

see functions graph.maxflow(), graph.mincut(), stCuts(), stMincuts().

– Check whether a directed graph is a DAG, is.dag().

– has.multiple() to decide whether a graph has multiple edges.

– Added a function to calculate a diversity score for the vertices,

graph.diversity().

– Graph Laplacian calculation (graph.laplacian()) supports edge

weights now.

– Biconnected component calculation, biconnected.components()

now returns the components themselves.

– bipartite.projection() calculates multiplicity of edges.

– Maximum cardinality search: maximum.cardinality.search() and

chordality test: is.chordal()

– Convex hull computation, convex.hull().

– Contract vertices, contract.vertices().