CAPD::DynSys Library  6.0.0
Public Types | Public Member Functions | Static Public Member Functions | List of all members
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, 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, NodeDataT > Node
 
typedef std::map< VertexType, Node, lessT > 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...
 
template<typename VertexContainer >
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

template<typename VertexT , typename lessT , typename NodeDataT >
typedef GraphNode<VertexSet, NodeDataT> capd::invset::Graph< VertexT, lessT, NodeDataT >::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

template<typename VertexT , typename lessT , typename NodeDataT >
typedef std::map<VertexType, Node, lessT> capd::invset::Graph< VertexT, lessT, NodeDataT >::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()

template<typename VertexT , typename lessT , typename NodeDataT >
void capd::invset::Graph< VertexT, lessT, NodeDataT >::clearEdges ( )
inlineinherited

removes all edges for the graph

◆ clearInEdges()

template<typename VertexT , typename lessT , typename NodeDataT >
void capd::invset::Graph< VertexT, lessT, NodeDataT >::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()

template<typename VertexT , typename lessT , typename NodeDataT >
void capd::invset::Graph< VertexT, lessT, NodeDataT >::erase ( iterator &  node)
inlineinherited

removes node given by iterator and all edges pointing to it

◆ eraseAcyclicVertices()

template<typename VertexT , typename lessT , typename NodeDataT >
void capd::invset::Graph< VertexT, lessT, NodeDataT >::eraseAcyclicVertices ( )
inlineinherited

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

◆ eraseNodeAndEdges()

template<typename VertexT , typename lessT , typename NodeDataT >
void capd::invset::Graph< VertexT, lessT, NodeDataT >::eraseNodeAndEdges ( iterator &  node)
inlineinherited

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

◆ eraseNoInVertices()

template<typename VertexT , typename lessT , typename NodeDataT >
void capd::invset::Graph< VertexT, lessT, NodeDataT >::eraseNoInVertices ( )
inlineinherited

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

◆ eraseNoOutVertices()

template<typename VertexT , typename lessT , typename NodeDataT >
void capd::invset::Graph< VertexT, lessT, NodeDataT >::eraseNoOutVertices ( )
inlineinherited

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

◆ findCycleLength()

template<typename VertexT , typename lessT , typename NodeDataT >
int capd::invset::Graph< VertexT, lessT, NodeDataT >::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()

template<typename VertexT , typename lessT , typename NodeDataT >
template<typename VertexContainer >
void capd::invset::Graph< VertexT, lessT, NodeDataT >::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()

template<typename VertexT , typename lessT , typename NodeDataT >
VertexSet capd::invset::Graph< VertexT, lessT, NodeDataT >::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()

template<typename VertexT , typename lessT , typename NodeDataT >
const Node& capd::invset::Graph< VertexT, lessT, NodeDataT >::getNode ( const VertexType &  vertex) const
inlineinherited

◆ getNodeData()

template<typename VertexT , typename lessT , typename NodeDataT >
const NodeData& capd::invset::Graph< VertexT, lessT, NodeDataT >::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()

template<typename VertexT , typename lessT , typename NodeDataT >
void capd::invset::Graph< VertexT, lessT, NodeDataT >::insertInEdges ( )
inlineinherited

creates inverted graph

◆ insertNode()

template<typename VertexT , typename lessT , typename NodeDataT >
void capd::invset::Graph< VertexT, lessT, NodeDataT >::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()

template<typename VertexT , typename lessT , typename NodeDataT >
NodeData& capd::invset::Graph< VertexT, lessT, NodeDataT >::nodeData ( const VertexType &  vertex)
inlineinherited

◆ nodes()

template<typename VertexT , typename lessT , typename NodeDataT >
Nodes& capd::invset::Graph< VertexT, lessT, NodeDataT >::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()

template<typename VertexT , typename lessT , typename NodeDataT >
void capd::invset::Graph< VertexT, lessT, NodeDataT >::setNode ( const VertexType &  vertex,
const Node &  node 
)
inlineinherited

◆ setNodeData()

template<typename VertexT , typename lessT , typename NodeDataT >
void capd::invset::Graph< VertexT, lessT, NodeDataT >::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
The documentation for this class was generated from the following file: