netcomplexity.h File Reference

Network complexity measures. More...

#include <pack_base.h>
#include <ref.h>
#include <graph.h>
#include <vector>
#include <map>
#include <set>
#include <utility>
#include <algorithm>
#include <iostream>
#include <stdio.h>
#include <math.h>
#include <assert.h>
#include "nauty_sizes.h"
#include <pack_stl.h>
#include <classdesc_access.h>
#include "netcomplexity.cd"

Include dependency graph for netcomplexity.h:

Go to the source code of this file.

Classes
class	ecolab::bitref
class	ecolab::const_bitref
class	ecolab::bitvect
class	ecolab::Rep_const_iterator< Rep >
	An iterator suitable for "duck-typing" with Graph. More...
class	ecolab::BitRep
class	ecolab::NautyRep
class	ecolab::BiDirectionalBitRep

Namespaces
	ecolab
	_OPENMP

Macros
#define	WORDSIZE   64
#define	SETWORD_LONG

Typedefs
typedef unsigned long	ecolab::setword

Functions
unsigned	ecolab::SETWD (unsigned pos)
unsigned	ecolab::SETBT (unsigned pos)
setword	ecolab::BITMASK (unsigned x)
void	ecolab::ADDELEMENT (setword *setadd, unsigned pos)
void	ecolab::DELELEMENT (setword *setadd, unsigned pos)
void	ecolab::FLIPELEMENT (setword *setadd, unsigned pos)
bool	ecolab::ISELEMENT (const setword *setadd, unsigned pos)
void	ecolab::EMPTYSET (setword *setadd, unsigned m)
template<class T >
void	ecolab::iota (typename T::iterator p, const typename T::iterator &end, typename T::value_type val)
void	ecolab::iota (vector< unsigned >::iterator p, const vector< unsigned >::iterator &end, unsigned val)
void	ecolab::iota (unsigned *p, const unsigned *end, unsigned val)
bitvect	ecolab::num (const bitvect &x, unsigned i, unsigned nbits)
template<class T , class U >
void	ecolab::asgRep (T &x, const U &y)
template<class T , class Graph >
void	ecolab::asgRepGraph (T &x, const Graph &y)
	convert between an EcoLab Graph type and a BitRep type
BitRep	ecolab::permute (const BitRep &x, const vector< unsigned > &perm)
void	ecolab::ecolab_nauty (const NautyRep &g, NautyRep &canonical, double &lnomega, bool do_canonical, int invMethod=0)
	EcoLab interface to Nauty. More...
double	ecolab::saucy_lnomega (const DiGraph &)
double	ecolab::igraph_lnomega (const DiGraph &g, int method)
NautyRep	ecolab::canonicalise (const NautyRep &x)
BitRep	ecolab::start_perm (unsigned nodes, unsigned links)
double	ecolab::lnfactorial (unsigned x)
double	ecolab::lnCombine (unsigned x, unsigned y)
double	ecolab::baseComplexity (unsigned n, unsigned l, bool bidirectional=false)
double	ecolab::complexity (NautyRep x, bool bidirectional=false)
double	ecolab::canonical (BitRep &canon, const Graph &g)
	SuperNOVA automorphism algorithm: More...
template<class G >
double	ecolab::canonical (BitRep &canon, const GraphAdaptor< G > &g)
template<class G >
double	ecolab::canonical (BitRep &canon, const ConcreteGraph< G > &g)
template<class G >
double	ecolab::canonical (BitRep &canon, const G &g)
setword	ecolab::bitrange (unsigned i)
template<class T >
vector< T >	ecolab::num (const vector< T > &x, unsigned start, unsigned nbits)
bool	ecolab::equal (const bitvect &x, const bitvect &y, unsigned len, unsigned offs)
template<class T >
bool	ecolab::equal (const T &x, const T &y, unsigned len, unsigned offs)
template<class T >
void	ecolab::setvec (vector< T > &x, const bitvect &y)
double	ecolab::ODcomplexity (const DiGraph &x)
	Offdiagonal complexity.
double	ecolab::MA (const DiGraph &x)
	Medium articulation.
ostream &	operator<< (ostream &s, const ecolab::bitvect &x)
ostream &	operator<< (ostream &s, const ecolab::BitRep &x)
ostream &	operator<< (ostream &s, const ecolab::BiDirectionalBitRep &x)
ostream &	operator<< (ostream &s, const ecolab::NautyRep &x)
double	ecolab::complexity (const Graph &g)
	Network complexity.
template<class G >
double	ecolab::complexity (const GraphAdaptor< G > &g)
template<class G >
double	ecolab::complexity (const ConcreteGraph< G > &g)
template<class G >
double	ecolab::complexity (const G &g)

Variables
const setword	ecolab::MSK64 =0xFFFFFFFFFFFFFFFFUL
const setword	ecolab::MSK63C =0x7FFFFFFFFFFFFFFFUL
const setword	ecolab::ALLBITS =MSK64
const setword	ecolab::bitt []

Detailed Description

Network complexity measures.