CAPD DynSys Library 5.2.0
capd::invset::MapGraph< MapT, VertexT, lessT, ResolutionT > Class Template Reference

#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, MatrixTypeNodeData
 
typedef VertexT VertexType
 
typedef Graph< VertexType, lessT, NodeDataGraphType
 
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 ResolutionTypegetResolution () const
 
MapTypegetMap ()
 
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)
 
Nodesnodes ()
 
const NodegetNode (const VertexType &vertex) const
 
void setNode (const VertexType &vertex, const Node &node)
 
void insertNode (const VertexType &vertex)
 
const NodeDatagetNodeData (const VertexType &vertex) const
 
NodeDatanodeData (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]exitSetit 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 ( ) const
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 ( ) const
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