#include <capd/invset/MapGraph.h>

Public Types
typedef MapT	MapType

typedef MapType::VectorType	VectorType

typedef MapType::MatrixType	MatrixType

typedef VectorType::ScalarType	ScalarType

typedef ScalarType::BoundType	BoundType

typedef MapGraphNodeData< VectorType, MatrixType >	NodeData

typedef VertexT	VertexType

typedef Graph< VertexType, lessT, NodeData >	GraphType

typedef CubicalMap< MapType, GraphType, ResolutionT >	CubicalMapType

typedef GraphType::OrderType	OrderType

typedef GraphType::VertexSet	VertexSet

typedef ResolutionT	ResolutionType

typedef CubicalMapType::iterator	iterator

typedef CubicalMapType::const_iterator	const_iterator

typedef GraphType::VertexSet	SetVertex
	deprecated More...

typedef GraphNode< VertexSet, MapGraphNodeData< MapT::VectorType, MapT::MatrixType > >	Node

typedef std::map< VertexType, Node, less< capd::vectalg::Vector< int, 0 > > >	Nodes

Public Member Functions
	MapGraph (MapType &map, const ResolutionType &resolution)

void	saveCoordSys (const char *fileName) const

void	loadCoordSys (const char *fileName)

const ResolutionType &	getResolution () const

MapType &	getMap ()

VectorType	vertexToCube (const VertexType &vertex) const
	converts VertexType to Cube using current resolution More...

void	getCubeCenter (const VertexType &vertex, PointVector &result)

void	setDomain (const VectorType &domain)
	it grids domain with given resolution and for each box adds corresponding vertex to graph More...

void	setDomain (const std::list< VectorType > &domainList)
	it grids domain with given resolution and for each box adds corresponding vertex to graph G More...

void	constructCubicalMap ()

void	computeImageOfCubeWithConstraints (const VertexType &vertex, const ConstraintsT &constraints, VertexSet &cubicalImage)
	checks whenever set x is contained (at least partly) in the domain. More...

void	constructCubicalMapWithConstraints (const ConstraintsT &constraints)
	constructs cubical map with range restricted by constraints. More...

void	constructCubicalMapRestrictedTo (const std::list< VectorType > &range)
	constructs cubical map with range restricted to given list of interval vectors More...

void	bisectGraph (int indexOfCoeff)

void	removeIncorrectVertices (VertexSet &vertices, const ConstraintsT &constraints) const
	Removes vertices that do not belong to the domain. More...

void	removeIncorrectNodes (const ConstraintsT &constraints)

void	computeExitSet (VertexContainer &exitSet)
	For given CubicalMap it computes exit set. More...

void	save (const char *fileName) const

void	load (const char *fileName)

Nodes &	nodes ()

const Node &	getNode (const VertexType &vertex) const

void	setNode (const VertexType &vertex, const Node &node)

void	insertNode (const VertexType &vertex)

const NodeData &	getNodeData (const VertexType &vertex) const

NodeData &	nodeData (const VertexType &vertex)

void	setNodeData (const VertexType &vertex, const NodeData &nodeData)

void	clearEdges ()
	removes all edges for the graph More...

void	clearInEdges ()
	removes all in-edges from the graph More...

void	insertInEdges ()
	creates inverted graph More...

void	eraseNodeAndEdges (iterator &node)
	it removes node given by iterator and all edges pointing to it More...

void	erase (iterator &node)
	removes node given by iterator and all edges pointing to it More...

void	eraseAcyclicVertices ()
	It iteratively erases acyclic vertices We assume that inverse graph is already created (e.g. by calling insertInEdges()) More...

void	eraseNoInVertices ()
	It iteratively erase vertices that do not have any inward edges. More...

void	eraseNoOutVertices ()
	It iteratively erase vertices that do not have any outward edges. More...

VertexSet	findFixedPoints () const
	returns set of vertices that have self-loop (edge that connects vertex to itself) More...

void	findCycles (VertexContainer result[], int maxlength) const
	finds cyclic vertices to a given maximal cycle length More...

int	findCycleLength (const_iterator vertex, int maxlength) const
	for given vertex returns the shortest cycle length starting at this vertex More...

Static Public Member Functions
static VertexType	resolutionToDenominator (const ResolutionType &resolution)

static VectorType	vertexToVector (const VertexType &vertex, const VertexType &denominator)

static VectorType	vertexToCube (const VertexType &vertex, const ResolutionType &resolution)
	converts VertexType to Cube using given resolution More...

static void	getCubeCenter (const VertexType &vertex, const ResolutionType &resolution, PointVector &result)

static void	centreOfCube (const VertexType &vertex, const VertexType &denominator, PointVector &result)

static void	insertVertexIfNotExists (GraphType &G, const VertexType &v)

static void	insertVertexIfNotExists (VertexSet &G, const VertexType &v)

static void	createGrid (SetType &G, const ResolutionType &resolution, const VectorType &domain)
	it grids domain with given resolution and for each box adds corresponding vertex to set G G can be either graph (GraphType) or only set of vertices (VertexSet) More...

static void	createGrid (SetType &G, const ResolutionType &resolution, const std::list< VectorType > &domain)

static void	constructCubicalMap (MapType &m_f, GraphType &graph, ResolutionType &resolution)
	Creates graph that is a cubical representation of the map f with given resolution It also creates transposed graph. More...

static void	constructCubicalMapWithConstraints (CubicalMap &graph, const ConstraintsT &constraints)
	/////////////////////////////////////////////////////////////////////////////////////////////// / / Creates graph that is a cubical representation of the map f with given resolution / Vertices that do not satisfy constraints are not created. More...

Member Typedef Documentation

◆ BoundType

template<class MapT , class VertexT = capd::vectalg::Vector<int, 0>, class lessT = less<VertexT>, class ResolutionT = VertexT>

typedef ScalarType::BoundType capd::invset::MapGraph< MapT, VertexT, lessT, ResolutionT >::BoundType

◆ const_iterator

template<class MapT , class VertexT = capd::vectalg::Vector<int, 0>, class lessT = less<VertexT>, class ResolutionT = VertexT>

typedef CubicalMapType::const_iterator capd::invset::MapGraph< MapT, VertexT, lessT, ResolutionT >::const_iterator

◆ CubicalMapType

template<class MapT , class VertexT = capd::vectalg::Vector<int, 0>, class lessT = less<VertexT>, class ResolutionT = VertexT>

typedef CubicalMap<MapType, GraphType , ResolutionT> capd::invset::MapGraph< MapT, VertexT, lessT, ResolutionT >::CubicalMapType

◆ GraphType

template<class MapT , class VertexT = capd::vectalg::Vector<int, 0>, class lessT = less<VertexT>, class ResolutionT = VertexT>

typedef Graph<VertexType, lessT, NodeData> capd::invset::MapGraph< MapT, VertexT, lessT, ResolutionT >::GraphType

◆ iterator

template<class MapT , class VertexT = capd::vectalg::Vector<int, 0>, class lessT = less<VertexT>, class ResolutionT = VertexT>

typedef CubicalMapType::iterator capd::invset::MapGraph< MapT, VertexT, lessT, ResolutionT >::iterator

◆ MapType

template<class MapT , class VertexT = capd::vectalg::Vector<int, 0>, class lessT = less<VertexT>, class ResolutionT = VertexT>

typedef MapT capd::invset::MapGraph< MapT, VertexT, lessT, ResolutionT >::MapType

◆ MatrixType

template<class MapT , class VertexT = capd::vectalg::Vector<int, 0>, class lessT = less<VertexT>, class ResolutionT = VertexT>

typedef MapType::MatrixType capd::invset::MapGraph< MapT, VertexT, lessT, ResolutionT >::MatrixType

◆ Node

typedef GraphNode<VertexSet, MapGraphNodeData< MapT::VectorType, MapT::MatrixType > > capd::invset::Graph< capd::vectalg::Vector< int, 0 > , less< capd::vectalg::Vector< int, 0 > > , MapGraphNodeData< MapT::VectorType, MapT::MatrixType > >::Node

inherited

◆ NodeData

template<class MapT , class VertexT = capd::vectalg::Vector<int, 0>, class lessT = less<VertexT>, class ResolutionT = VertexT>

typedef MapGraphNodeData<VectorType, MatrixType> capd::invset::MapGraph< MapT, VertexT, lessT, ResolutionT >::NodeData

◆ Nodes

typedef std::map<VertexType, Node, less< capd::vectalg::Vector< int, 0 > > > capd::invset::Graph< capd::vectalg::Vector< int, 0 > , less< capd::vectalg::Vector< int, 0 > > , MapGraphNodeData< MapT::VectorType, MapT::MatrixType > >::Nodes

inherited

◆ OrderType

template<class MapT , class VertexT = capd::vectalg::Vector<int, 0>, class lessT = less<VertexT>, class ResolutionT = VertexT>

typedef GraphType::OrderType capd::invset::MapGraph< MapT, VertexT, lessT, ResolutionT >::OrderType

◆ ResolutionType

template<class MapT , class VertexT = capd::vectalg::Vector<int, 0>, class lessT = less<VertexT>, class ResolutionT = VertexT>

typedef ResolutionT capd::invset::MapGraph< MapT, VertexT, lessT, ResolutionT >::ResolutionType

◆ ScalarType

template<class MapT , class VertexT = capd::vectalg::Vector<int, 0>, class lessT = less<VertexT>, class ResolutionT = VertexT>

typedef VectorType::ScalarType capd::invset::MapGraph< MapT, VertexT, lessT, ResolutionT >::ScalarType

◆ SetVertex

typedef GraphType::VertexSet capd::invset::CubicalMap< MapT, Graph< capd::vectalg::Vector< int, 0 >, less< capd::vectalg::Vector< int, 0 > >, MapGraphNodeData< MapT::VectorType, MapT::MatrixType > > , capd::vectalg::Vector< int, 0 > >::SetVertex

inherited

deprecated

◆ VectorType

template<class MapT , class VertexT = capd::vectalg::Vector<int, 0>, class lessT = less<VertexT>, class ResolutionT = VertexT>

typedef MapType::VectorType capd::invset::MapGraph< MapT, VertexT, lessT, ResolutionT >::VectorType

◆ VertexSet

template<class MapT , class VertexT = capd::vectalg::Vector<int, 0>, class lessT = less<VertexT>, class ResolutionT = VertexT>

typedef GraphType::VertexSet capd::invset::MapGraph< MapT, VertexT, lessT, ResolutionT >::VertexSet

◆ VertexType

template<class MapT , class VertexT = capd::vectalg::Vector<int, 0>, class lessT = less<VertexT>, class ResolutionT = VertexT>

typedef VertexT capd::invset::MapGraph< MapT, VertexT, lessT, ResolutionT >::VertexType

Constructor & Destructor Documentation

◆ MapGraph()

template<class MapT , class VertexT = capd::vectalg::Vector<int, 0>, class lessT = less<VertexT>, class ResolutionT = VertexT>

capd::invset::MapGraph< MapT, VertexT, lessT, ResolutionT >::MapGraph	(	MapType &	map,
		const ResolutionType &	resolution
	)

inline

Member Function Documentation

◆ bisectGraph()

void capd::invset::CubicalMap< MapT, Graph< capd::vectalg::Vector< int, 0 >, less< capd::vectalg::Vector< int, 0 > >, MapGraphNodeData< MapT::VectorType, MapT::MatrixType > > , capd::vectalg::Vector< int, 0 > >::bisectGraph ( int indexOfCoeff )

inlineinherited

◆ centreOfCube()

static void capd::invset::CubicalMap< MapT, Graph< capd::vectalg::Vector< int, 0 >, less< capd::vectalg::Vector< int, 0 > >, MapGraphNodeData< MapT::VectorType, MapT::MatrixType > > , capd::vectalg::Vector< int, 0 > >::centreOfCube	(	const VertexType &	vertex,
		const VertexType &	denominator,
		PointVector &	result
	)

inlinestaticinherited

◆ clearEdges()

void capd::invset::Graph< capd::vectalg::Vector< int, 0 > , less< capd::vectalg::Vector< int, 0 > > , MapGraphNodeData< MapT::VectorType, MapT::MatrixType > >::clearEdges

inlineinherited

removes all edges for the graph

◆ clearInEdges()

void capd::invset::Graph< capd::vectalg::Vector< int, 0 > , less< capd::vectalg::Vector< int, 0 > > , MapGraphNodeData< MapT::VectorType, MapT::MatrixType > >::clearInEdges

inlineinherited

removes all in-edges from the graph

◆ computeExitSet()

void capd::invset::CubicalMap< MapT, Graph< capd::vectalg::Vector< int, 0 >, less< capd::vectalg::Vector< int, 0 > >, MapGraphNodeData< MapT::VectorType, MapT::MatrixType > > , capd::vectalg::Vector< int, 0 > >::computeExitSet ( VertexContainer & exitSet )

inlineinherited

For given CubicalMap it computes exit set.

In exitSet we return all cubes that possibly escape map domain

Parameters

[out] exitSet it can be either VertexSet or Graph

◆ computeImageOfCubeWithConstraints()

void capd::invset::CubicalMap< MapT, Graph< capd::vectalg::Vector< int, 0 >, less< capd::vectalg::Vector< int, 0 > >, MapGraphNodeData< MapT::VectorType, MapT::MatrixType > > , capd::vectalg::Vector< int, 0 > >::computeImageOfCubeWithConstraints	(	const VertexType &	vertex,
		const ConstraintsT &	constraints,
		VertexSet &	cubicalImage
	)

inlineinherited

checks whenever set x is contained (at least partly) in the domain.

Creates graph that is a cubical representation of the map f with given resolution / Edges pointing out of range are not created. / It also creates inverted graph / / we assume that: / - domain is already set / - all edges in a graph are removed /

◆ constructCubicalMap() [1/2]

void capd::invset::CubicalMap< MapT, Graph< capd::vectalg::Vector< int, 0 >, less< capd::vectalg::Vector< int, 0 > >, MapGraphNodeData< MapT::VectorType, MapT::MatrixType > > , capd::vectalg::Vector< int, 0 > >::constructCubicalMap

inlineinherited

◆ constructCubicalMap() [2/2]

static void capd::invset::CubicalMap< MapT, Graph< capd::vectalg::Vector< int, 0 >, less< capd::vectalg::Vector< int, 0 > >, MapGraphNodeData< MapT::VectorType, MapT::MatrixType > > , capd::vectalg::Vector< int, 0 > >::constructCubicalMap	(	MapType &	m_f,
		GraphType &	graph,
		ResolutionType &	resolution
	)

inlinestaticinherited

Creates graph that is a cubical representation of the map f with given resolution It also creates transposed graph.

we assume that:

domain is already set
all edges in a graph are removed

◆ constructCubicalMapRestrictedTo()

void capd::invset::CubicalMap< MapT, Graph< capd::vectalg::Vector< int, 0 >, less< capd::vectalg::Vector< int, 0 > >, MapGraphNodeData< MapT::VectorType, MapT::MatrixType > > , capd::vectalg::Vector< int, 0 > >::constructCubicalMapRestrictedTo ( const std::list< VectorType > & range )

inlineinherited

constructs cubical map with range restricted to given list of interval vectors

◆ constructCubicalMapWithConstraints() [1/2]

void capd::invset::CubicalMap< MapT, Graph< capd::vectalg::Vector< int, 0 >, less< capd::vectalg::Vector< int, 0 > >, MapGraphNodeData< MapT::VectorType, MapT::MatrixType > > , capd::vectalg::Vector< int, 0 > >::constructCubicalMapWithConstraints ( const ConstraintsT & constraints )

inlineinherited

constructs cubical map with range restricted by constraints.

◆ constructCubicalMapWithConstraints() [2/2]

static void capd::invset::CubicalMap< MapT, Graph< capd::vectalg::Vector< int, 0 >, less< capd::vectalg::Vector< int, 0 > >, MapGraphNodeData< MapT::VectorType, MapT::MatrixType > > , capd::vectalg::Vector< int, 0 > >::constructCubicalMapWithConstraints	(	CubicalMap< MapT, Graph< capd::vectalg::Vector< int, 0 >, less< capd::vectalg::Vector< int, 0 > >, MapGraphNodeData< MapT::VectorType, MapT::MatrixType > >, capd::vectalg::Vector< int, 0 > > &	graph,
		const ConstraintsT &	constraints
	)

inlinestaticinherited

/////////////////////////////////////////////////////////////////////////////////////////////// / / Creates graph that is a cubical representation of the map f with given resolution / Vertices that do not satisfy constraints are not created.

/ It also creates inverted graph / / we assume that: / - domain is already set / - all edges in a graph are removed / //////////////////////////////////////////////////////////////////////////////////////////////

◆ createGrid() [1/2]

static void capd::invset::CubicalMap< MapT, Graph< capd::vectalg::Vector< int, 0 >, less< capd::vectalg::Vector< int, 0 > >, MapGraphNodeData< MapT::VectorType, MapT::MatrixType > > , capd::vectalg::Vector< int, 0 > >::createGrid	(	SetType &	G,
		const ResolutionType &	resolution,
		const std::list< VectorType > &	domain
	)

inlinestaticinherited

◆ createGrid() [2/2]

static void capd::invset::CubicalMap< MapT, Graph< capd::vectalg::Vector< int, 0 >, less< capd::vectalg::Vector< int, 0 > >, MapGraphNodeData< MapT::VectorType, MapT::MatrixType > > , capd::vectalg::Vector< int, 0 > >::createGrid	(	SetType &	G,
		const ResolutionType &	resolution,
		const VectorType &	domain
	)

inlinestaticinherited

it grids domain with given resolution and for each box adds corresponding vertex to set G G can be either graph (GraphType) or only set of vertices (VertexSet)

◆ erase()

void capd::invset::Graph< capd::vectalg::Vector< int, 0 > , less< capd::vectalg::Vector< int, 0 > > , MapGraphNodeData< MapT::VectorType, MapT::MatrixType > >::erase ( iterator & node )

inlineinherited

removes node given by iterator and all edges pointing to it

◆ eraseAcyclicVertices()

void capd::invset::Graph< capd::vectalg::Vector< int, 0 > , less< capd::vectalg::Vector< int, 0 > > , MapGraphNodeData< MapT::VectorType, MapT::MatrixType > >::eraseAcyclicVertices

inlineinherited

It iteratively erases acyclic vertices We assume that inverse graph is already created (e.g. by calling insertInEdges())

◆ eraseNodeAndEdges()

void capd::invset::Graph< capd::vectalg::Vector< int, 0 > , less< capd::vectalg::Vector< int, 0 > > , MapGraphNodeData< MapT::VectorType, MapT::MatrixType > >::eraseNodeAndEdges ( iterator & node )

inlineinherited

it removes node given by iterator and all edges pointing to it

◆ eraseNoInVertices()

void capd::invset::Graph< capd::vectalg::Vector< int, 0 > , less< capd::vectalg::Vector< int, 0 > > , MapGraphNodeData< MapT::VectorType, MapT::MatrixType > >::eraseNoInVertices

inlineinherited

It iteratively erase vertices that do not have any inward edges.

◆ eraseNoOutVertices()

void capd::invset::Graph< capd::vectalg::Vector< int, 0 > , less< capd::vectalg::Vector< int, 0 > > , MapGraphNodeData< MapT::VectorType, MapT::MatrixType > >::eraseNoOutVertices

inlineinherited

It iteratively erase vertices that do not have any outward edges.

◆ findCycleLength()

int capd::invset::Graph< capd::vectalg::Vector< int, 0 > , less< capd::vectalg::Vector< int, 0 > > , MapGraphNodeData< MapT::VectorType, MapT::MatrixType > >::findCycleLength	(	const_iterator	vertex,
		int	maxlength
	)		const

inlineinherited

for given vertex returns the shortest cycle length starting at this vertex

(for self-loop length = 0, for a-b-a length=1 etc.) returns -1 if it does not find cycle with length less or equal to maxlength.

◆ findCycles()

void capd::invset::Graph< capd::vectalg::Vector< int, 0 > , less< capd::vectalg::Vector< int, 0 > > , MapGraphNodeData< MapT::VectorType, MapT::MatrixType > >::findCycles	(	VertexContainer	result[],
		int	maxlength
	)		const

inlineinherited

finds cyclic vertices to a given maximal cycle length

in result[n] it returns vertices that belongs to some cycle of length n + 1 if vertex belongs to more than one cycle than the shortest cycle is concerned

◆ findFixedPoints()

VertexSet capd::invset::Graph< capd::vectalg::Vector< int, 0 > , less< capd::vectalg::Vector< int, 0 > > , MapGraphNodeData< MapT::VectorType, MapT::MatrixType > >::findFixedPoints

inlineinherited

returns set of vertices that have self-loop (edge that connects vertex to itself)

◆ getCubeCenter() [1/2]

static void capd::invset::CubicalMap< MapT, Graph< capd::vectalg::Vector< int, 0 >, less< capd::vectalg::Vector< int, 0 > >, MapGraphNodeData< MapT::VectorType, MapT::MatrixType > > , capd::vectalg::Vector< int, 0 > >::getCubeCenter	(	const VertexType &	vertex,
		const ResolutionType &	resolution,
		PointVector &	result
	)

inlinestaticinherited

◆ getCubeCenter() [2/2]

void capd::invset::CubicalMap< MapT, Graph< capd::vectalg::Vector< int, 0 >, less< capd::vectalg::Vector< int, 0 > >, MapGraphNodeData< MapT::VectorType, MapT::MatrixType > > , capd::vectalg::Vector< int, 0 > >::getCubeCenter	(	const VertexType &	vertex,
		PointVector &	result
	)

inlineinherited

◆ getMap()

MapType& capd::invset::CubicalMap< MapT, Graph< capd::vectalg::Vector< int, 0 >, less< capd::vectalg::Vector< int, 0 > >, MapGraphNodeData< MapT::VectorType, MapT::MatrixType > > , capd::vectalg::Vector< int, 0 > >::getMap

inlineinherited

◆ getNode()

const Node& capd::invset::Graph< capd::vectalg::Vector< int, 0 > , less< capd::vectalg::Vector< int, 0 > > , MapGraphNodeData< MapT::VectorType, MapT::MatrixType > >::getNode ( const VertexType & vertex ) const

inlineinherited

◆ getNodeData()

const NodeData& capd::invset::Graph< capd::vectalg::Vector< int, 0 > , less< capd::vectalg::Vector< int, 0 > > , MapGraphNodeData< MapT::VectorType, MapT::MatrixType > >::getNodeData ( const VertexType & vertex ) const

inlineinherited

◆ getResolution()

const ResolutionType& capd::invset::CubicalMap< MapT, Graph< capd::vectalg::Vector< int, 0 >, less< capd::vectalg::Vector< int, 0 > >, MapGraphNodeData< MapT::VectorType, MapT::MatrixType > > , capd::vectalg::Vector< int, 0 > >::getResolution

inlineinherited

◆ insertInEdges()

void capd::invset::Graph< capd::vectalg::Vector< int, 0 > , less< capd::vectalg::Vector< int, 0 > > , MapGraphNodeData< MapT::VectorType, MapT::MatrixType > >::insertInEdges

inlineinherited

creates inverted graph

◆ insertNode()

void capd::invset::Graph< capd::vectalg::Vector< int, 0 > , less< capd::vectalg::Vector< int, 0 > > , MapGraphNodeData< MapT::VectorType, MapT::MatrixType > >::insertNode ( const VertexType & vertex )

inlineinherited

◆ insertVertexIfNotExists() [1/2]

static void capd::invset::CubicalMap< MapT, Graph< capd::vectalg::Vector< int, 0 >, less< capd::vectalg::Vector< int, 0 > >, MapGraphNodeData< MapT::VectorType, MapT::MatrixType > > , capd::vectalg::Vector< int, 0 > >::insertVertexIfNotExists	(	GraphType &	G,
		const VertexType &	v
	)

inlinestaticinherited

◆ insertVertexIfNotExists() [2/2]

static void capd::invset::CubicalMap< MapT, Graph< capd::vectalg::Vector< int, 0 >, less< capd::vectalg::Vector< int, 0 > >, MapGraphNodeData< MapT::VectorType, MapT::MatrixType > > , capd::vectalg::Vector< int, 0 > >::insertVertexIfNotExists	(	VertexSet &	G,
		const VertexType &	v
	)

inlinestaticinherited

◆ load()

void capd::invset::CubicalMap< MapT, Graph< capd::vectalg::Vector< int, 0 >, less< capd::vectalg::Vector< int, 0 > >, MapGraphNodeData< MapT::VectorType, MapT::MatrixType > > , capd::vectalg::Vector< int, 0 > >::load ( const char * fileName )

inlineinherited

◆ loadCoordSys()

template<class MapT , class VertexT = capd::vectalg::Vector<int, 0>, class lessT = less<VertexT>, class ResolutionT = VertexT>

void capd::invset::MapGraph< MapT, VertexT, lessT, ResolutionT >::loadCoordSys ( const char * fileName )

inline

◆ nodeData()

NodeData& capd::invset::Graph< capd::vectalg::Vector< int, 0 > , less< capd::vectalg::Vector< int, 0 > > , MapGraphNodeData< MapT::VectorType, MapT::MatrixType > >::nodeData ( const VertexType & vertex )

inlineinherited

◆ nodes()

Nodes& capd::invset::Graph< capd::vectalg::Vector< int, 0 > , less< capd::vectalg::Vector< int, 0 > > , MapGraphNodeData< MapT::VectorType, MapT::MatrixType > >::nodes

inlineinherited

◆ removeIncorrectNodes()

void capd::invset::CubicalMap< MapT, Graph< capd::vectalg::Vector< int, 0 >, less< capd::vectalg::Vector< int, 0 > >, MapGraphNodeData< MapT::VectorType, MapT::MatrixType > > , capd::vectalg::Vector< int, 0 > >::removeIncorrectNodes ( const ConstraintsT & constraints )

inlineinherited

◆ removeIncorrectVertices()

void capd::invset::CubicalMap< MapT, Graph< capd::vectalg::Vector< int, 0 >, less< capd::vectalg::Vector< int, 0 > >, MapGraphNodeData< MapT::VectorType, MapT::MatrixType > > , capd::vectalg::Vector< int, 0 > >::removeIncorrectVertices	(	VertexSet &	vertices,
		const ConstraintsT &	constraints
	)		const

inlineinherited

Removes vertices that do not belong to the domain.

Removes vertices that do not satisfy constraints

◆ resolutionToDenominator()

static VertexType capd::invset::CubicalMap< MapT, Graph< capd::vectalg::Vector< int, 0 >, less< capd::vectalg::Vector< int, 0 > >, MapGraphNodeData< MapT::VectorType, MapT::MatrixType > > , capd::vectalg::Vector< int, 0 > >::resolutionToDenominator ( const ResolutionType & resolution )

inlinestaticinherited

◆ save()

void capd::invset::CubicalMap< MapT, Graph< capd::vectalg::Vector< int, 0 >, less< capd::vectalg::Vector< int, 0 > >, MapGraphNodeData< MapT::VectorType, MapT::MatrixType > > , capd::vectalg::Vector< int, 0 > >::save ( const char * fileName ) const

inlineinherited

◆ saveCoordSys()

template<class MapT , class VertexT = capd::vectalg::Vector<int, 0>, class lessT = less<VertexT>, class ResolutionT = VertexT>

void capd::invset::MapGraph< MapT, VertexT, lessT, ResolutionT >::saveCoordSys ( const char * fileName ) const

inline

◆ setDomain() [1/2]

void capd::invset::CubicalMap< MapT, Graph< capd::vectalg::Vector< int, 0 >, less< capd::vectalg::Vector< int, 0 > >, MapGraphNodeData< MapT::VectorType, MapT::MatrixType > > , capd::vectalg::Vector< int, 0 > >::setDomain ( const std::list< VectorType > & domainList )

inlineinherited

it grids domain with given resolution and for each box adds corresponding vertex to graph G

◆ setDomain() [2/2]

void capd::invset::CubicalMap< MapT, Graph< capd::vectalg::Vector< int, 0 >, less< capd::vectalg::Vector< int, 0 > >, MapGraphNodeData< MapT::VectorType, MapT::MatrixType > > , capd::vectalg::Vector< int, 0 > >::setDomain ( const VectorType & domain )

inlineinherited

it grids domain with given resolution and for each box adds corresponding vertex to graph

◆ setNode()

void capd::invset::Graph< capd::vectalg::Vector< int, 0 > , less< capd::vectalg::Vector< int, 0 > > , MapGraphNodeData< MapT::VectorType, MapT::MatrixType > >::setNode	(	const VertexType &	vertex,
		const Node &	node
	)

inlineinherited

◆ setNodeData()

void capd::invset::Graph< capd::vectalg::Vector< int, 0 > , less< capd::vectalg::Vector< int, 0 > > , MapGraphNodeData< MapT::VectorType, MapT::MatrixType > >::setNodeData	(	const VertexType &	vertex,
		const NodeData &	nodeData
	)

inlineinherited

◆ vertexToCube() [1/2]

VectorType capd::invset::CubicalMap< MapT, Graph< capd::vectalg::Vector< int, 0 >, less< capd::vectalg::Vector< int, 0 > >, MapGraphNodeData< MapT::VectorType, MapT::MatrixType > > , capd::vectalg::Vector< int, 0 > >::vertexToCube ( const VertexType & vertex ) const

inlineinherited

converts VertexType to Cube using current resolution

◆ vertexToCube() [2/2]

static VectorType capd::invset::CubicalMap< MapT, Graph< capd::vectalg::Vector< int, 0 >, less< capd::vectalg::Vector< int, 0 > >, MapGraphNodeData< MapT::VectorType, MapT::MatrixType > > , capd::vectalg::Vector< int, 0 > >::vertexToCube	(	const VertexType &	vertex,
		const ResolutionType &	resolution
	)

inlinestaticinherited

converts VertexType to Cube using given resolution

◆ vertexToVector()

static VectorType capd::invset::CubicalMap< MapT, Graph< capd::vectalg::Vector< int, 0 >, less< capd::vectalg::Vector< int, 0 > >, MapGraphNodeData< MapT::VectorType, MapT::MatrixType > > , capd::vectalg::Vector< int, 0 > >::vertexToVector	(	const VertexType &	vertex,
		const VertexType &	denominator
	)

inlinestaticinherited

Public Types

Public Member Functions

Static Public Member Functions

Member Typedef Documentation

◆ BoundType

◆ const_iterator

◆ CubicalMapType

◆ GraphType

◆ iterator

◆ MapType

◆ MatrixType

◆ Node

◆ NodeData

◆ Nodes

◆ OrderType

◆ ResolutionType

◆ ScalarType

◆ SetVertex

◆ VectorType

◆ VertexSet

◆ VertexType

Constructor & Destructor Documentation

◆ MapGraph()

Member Function Documentation

◆ bisectGraph()

◆ centreOfCube()

◆ clearEdges()

◆ clearInEdges()

◆ computeExitSet()

◆ computeImageOfCubeWithConstraints()

◆ constructCubicalMap() [1/2]

◆ constructCubicalMap() [2/2]

◆ constructCubicalMapRestrictedTo()

◆ constructCubicalMapWithConstraints() [1/2]

◆ constructCubicalMapWithConstraints() [2/2]

◆ createGrid() [1/2]

◆ createGrid() [2/2]

◆ erase()

◆ eraseAcyclicVertices()

◆ eraseNodeAndEdges()

◆ eraseNoInVertices()

◆ eraseNoOutVertices()

◆ findCycleLength()

◆ findCycles()

◆ findFixedPoints()

◆ getCubeCenter() [1/2]

◆ getCubeCenter() [2/2]

◆ getMap()

◆ getNode()

◆ getNodeData()

◆ getResolution()

◆ insertInEdges()

◆ insertNode()

◆ insertVertexIfNotExists() [1/2]

◆ insertVertexIfNotExists() [2/2]

◆ load()

◆ loadCoordSys()

◆ nodeData()

◆ nodes()

◆ removeIncorrectNodes()

◆ removeIncorrectVertices()

◆ resolutionToDenominator()

◆ save()

◆ saveCoordSys()

◆ setDomain() [1/2]

◆ setDomain() [2/2]

◆ setNode()

◆ setNodeData()

◆ vertexToCube() [1/2]

◆ vertexToCube() [2/2]

◆ vertexToVector()