documentation:master:fan

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

documentation:master:fan [2020/05/13 16:36] (current)
Line 1: Line 1:
 +====== application fan ======
 + This application deals with polyhedral fans. You can define a fan, e.g. via its ''​[[.:​fan:​PolyhedralFan#​RAYS |RAYS]]''​ and ''​[[.:​fan:​PolyhedralFan#​MAXIMAL_CONES |MAXIMAL_CONES]]''​ and compute several properties like ''​[[.:​fan:​PolyhedralFan#​HASSE_DIAGRAM |HASSE_DIAGRAM]]''​ and ''​[[.:​fan:​PolyhedralFan#​F_VECTOR |F_VECTOR]]''​.
 +
 +imports from:
 +    * application [[.:​common|common]]
 +    * application [[.:​graph|graph]]
 +    * application [[.:​polytope|polytope]]
 +uses:
 +    * application [[.:​group|group]]
 +    * application [[.:​ideal|ideal]]
 +    * application [[.:​topaz|topaz]]
 +
 +===== Objects =====
 +  ** ''​[[.:​fan:​HyperplaneArrangement |HyperplaneArrangement]]'':​\\ ​ A hyperplane arrangement. The hyperplane arrangement is given by a matrix ''​[[.:​fan:​HyperplaneArrangement#​HYPERPLANES |HYPERPLANES]]''​ whose rows are the linear equations of the hyperplanes and an optional support cone. The support cone defaults to being the whole space. Duplicate hyperplanes are ignored, as well as hyperplanes that intersect the support cone trivially. The support cone is subdivided by the hyperplanes resulting in a fan ''​[[.:​fan:​HyperplaneArrangement#​CELL_DECOMPOSITION |CELL_DECOMPOSITION]]''​.
 +  ** ''​[[.:​fan:​PlanarNet |PlanarNet]]'':​\\ ​ A special big object class devoted to planar unfoldings of 3-polytopes. ​ Its main functionality is the visualization.
 +  ** ''​[[.:​fan:​PolyhedralComplex |PolyhedralComplex]]'':​\\ ​ A polyhedral complex. ​ The derivation from ''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​ works like the derivation of ''​[[.:​polytope:​Polytope |Polytope]]''​ from ''​[[.:​polytope:​Cone |Cone]]''​.
 +  ** ''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]'':​\\ ​ A polyhedral fan. The current restriction is that each cone in the fan has to be pointed. ​ This will be relaxed later. If a fan is specified via ''​[[.:​fan:​PolyhedralFan#​INPUT_RAYS |INPUT_RAYS]]''​ and ''​[[.:​fan:​PolyhedralFan#​INPUT_CONES |INPUT_CONES]]''​ each input cone must list all the input rays incident. Once non-trivial linealities are allowed the following will apply: The ''​[[.:​fan:​PolyhedralFan#​RAYS |RAYS]]''​ always lie in a linear subspace which is complementary to the ''​[[.:​fan:​PolyhedralFan#​LINEALITY_SPACE |LINEALITY_SPACE]]''​.
 +  ** ''​[[.:​fan:​SubdivisionOfPoints |SubdivisionOfPoints]]'':​\\ ​ The inhomogeneous variant of ''​[[.:​fan:​SubdivisionOfVectors |SubdivisionOfVectors]]'',​ similar to the derivation of ''​[[.:​polytope:​PointConfiguration |PointConfiguration]]''​ from ''​[[.:​polytope:​VectorConfiguration |VectorConfiguration]]''​.
 +  ** ''​[[.:​fan:​SubdivisionOfVectors |SubdivisionOfVectors]]'':​\\ ​ A subdivision of vectors, in contrast to ''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​ this allows cells with interior points. Similar to the distinction between ''​[[.:​polytope:​Cone |Cone]]''​ and ''​[[.:​polytope:​VectorConfiguration |VectorConfiguration]]''​.
 +  ** ''​[[.:​fan:​Visual_PlanarNet |Visual::​PlanarNet]]'':​\\ ​ Visualization of a 3-polytope as a planar net.
 +  ** ''​[[.:​fan:​Visual_PolyhedralFan |Visual::​PolyhedralFan]]'':​\\ ​ Visualization of a polyhedral fan as a graph
 +
 +===== Functions =====
 +
 +==== Consistency check ====
 + These clients provide consistency checks, e.g. whether a given list of rays and cones defines a polyhedral fan.
 +----
 +{{anchor:​check_fan:​}}
 +  ?  **''​check_fan([[.:​common#​Matrix |Matrix]] rays, [[.:​common#​IncidenceMatrix |IncidenceMatrix]] cones)''​**
 +  :: Checks whether a given set of //rays// together with a list //cones// defines a polyhedral fan. If this is the case, the ouput is the ''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​ defined by //rays// as ''​[[.:​fan:​PolyhedralFan#​INPUT_RAYS |INPUT_RAYS]]'',​ //cones// as ''​[[.:​fan:​PolyhedralFan#​INPUT_CONES |INPUT_CONES]]'',​ //​lineality_space//​ as ''​[[.:​fan:​PolyhedralFan#​LINEALITY_SPACE |LINEALITY_SPACE]]''​ if this option is given.
 +    ? Parameters:
 +    :: ''​[[.:​common#​Matrix |Matrix]]''​ ''​rays''​
 +    :: ''​[[.:​common#​IncidenceMatrix |IncidenceMatrix]]''​ ''​cones''​
 +    ? Options:
 +    : 
 +    :: ''​[[.:​common#​Matrix |Matrix]]''​ ''​lineality_space'':​ Common lineality space for the cones.
 +    :: ''​[[.:​common#​Bool |Bool]]''​ ''​verbose'':​ prints information about the check.
 +    ? Returns:
 +    :''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​
 +
 +
 +----
 +{{anchor:​check_fan_objects:​}}
 +  ?  **''​check_fan_objects([[.:​common#​Array |Array]]<​[[.:​polytope:​Cone |Cone]]> cones)''​**
 +  :: Checks whether the ''​[[.:​polytope:​Cone |Cone]]''​ objects form a polyhedral fan. If this is the case, returns that ''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​.
 +    ? Parameters:
 +    :: ''​[[.:​common#​Array |Array]]<​[[.:​polytope:​Cone |Cone]]>''​ ''​cones''​
 +    ? Options:
 +    : 
 +    :: ''​[[.:​common#​Bool |Bool]]''​ ''​verbose'':​ prints information about the check.
 +    ? Returns:
 +    :''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​
 +
 +
 +----
 +
 +==== Finite metric spaces ====
 + All around Tight spans of finite metric spaces and their conections to polyhedral geometry
 +----
 +{{anchor:​max_metric:​}}
 +  ?  **''​max_metric([[.:​common#​Int |Int]] n)''​**
 +  :: Compute a metric such that the f-vector of its tight span is maximal among all metrics with //n// points.
 +  > See Herrmann and Joswig: Bounds on the f-vectors of tight spans, Contrib. Discrete Math., Vol.2, (2007)
 +    ? Parameters:
 +    :: ''​[[.:​common#​Int |Int]]''​ ''​n'':​ the number of points
 +    ? Returns:
 +    :''​[[.:​common#​Matrix |Matrix]]''​
 +    ? Example:
 +    :: To compute the max-metric of five points and display the f-vector of its tight span, do this:
 +    :: <code perl> > $M = max_metric(5);​
 + > $PC = metric_tight_span($M,​extended=>​1);​
 + > print $PC->​POLYTOPAL_SUBDIVISION->​TIGHT_SPAN->​F_VECTOR;​
 + 16 20 5
 +</​code>​
 +
 +
 +----
 +{{anchor:​metric_extended_tight_span:​}}
 +  ?  **''​metric_extended_tight_span([[.:​common#​Matrix |Matrix]]<​[[.:​common#​Rational |Rational]]>​ M)''​**
 +  :: Computes a extended tight span which is a ''​[[.:​fan:​PolyhedralComplex |PolyhedralComplex]]''​ with induced from a mertic.
 +    ? Parameters:
 +    :: ''​[[.:​common#​Matrix |Matrix]]<​[[.:​common#​Rational |Rational]]>''​ ''​M'':​ a metric
 +    ? Returns:
 +    :''​[[.:​fan:​PolyhedralComplex |PolyhedralComplex]]''​
 +    ? Example:
 +    :: To compute the thrackle-metric of five points and display the f-vector of its tight span, do this:
 +    :: <code perl> > $M = thrackle_metric(5);​
 + > $PC = metric_extended_tight_span($M);​
 + > print $PC->​F_VECTOR;​
 + 16 20 5
 +</​code>​
 +
 +
 +----
 +{{anchor:​metric_tight_span:​}}
 +  ?  **''​metric_tight_span([[.:​common#​Matrix |Matrix]]<​[[.:​common#​Rational |Rational]]>​ M)''​**
 +  :: Computes a ''​[[.:​fan:​SubdivisionOfPoints |SubdivisionOfPoints]]''​ with a weight function which is induced from a mertic.
 +    ? Parameters:
 +    :: ''​[[.:​common#​Matrix |Matrix]]<​[[.:​common#​Rational |Rational]]>''​ ''​M'':​ a metric
 +    ? Options:
 +    : 
 +    :: ''​[[.:​common#​Bool |Bool]]''​ ''​extended'':​ If true, the extended tight span is computed.
 +    ? Returns:
 +    :''​[[.:​fan:​SubdivisionOfPoints |SubdivisionOfPoints]]''​
 +    ? Example:
 +    :: To compute the thrackle-metric of five points and display the f-vector of its tight span, do this:
 +    :: <code perl> > $M = thrackle_metric(5);​
 + > $PC = metric_tight_span($M,​extended=>​1);​
 + > print $PC->​POLYTOPAL_SUBDIVISION->​TIGHT_SPAN->​F_VECTOR;​
 + 16 20 5
 +</​code>​
 +
 +
 +----
 +{{anchor:​min_metric:​}}
 +  ?  **''​min_metric([[.:​common#​Int |Int]] n)''​**
 +  :: Compute a metric such that the f-vector of its tight span is minimal among all metrics with //n// points.
 +  > See Herrmann and Joswig: Bounds on the f-vectors of tight spans, Contrib. Discrete Math., Vol.2, (2007)
 +    ? Parameters:
 +    :: ''​[[.:​common#​Int |Int]]''​ ''​n'':​ the number of points
 +    ? Returns:
 +    :''​[[.:​common#​Matrix |Matrix]]''​
 +    ? Example:
 +    :: To compute the min-metric of five points and display the f-vector of its tight span, do this:
 +    :: <code perl> > $M = min_metric(5);​
 + > $PC = metric_tight_span($M,​extended=>​1);​
 + > print $PC->​POLYTOPAL_SUBDIVISION->​TIGHT_SPAN->​F_VECTOR;​
 + 16 20 5
 +</​code>​
 +
 +
 +----
 +{{anchor:​thrackle_metric:​}}
 +  ?  **''​thrackle_metric([[.:​common#​Int |Int]] n)''​**
 +  :: Compute a thrackle ​ metric on //n// points. This metric can be interpreted as a lifting function for the thrackle triangulation.
 +  > See De Loera, Sturmfels and Thomas: Gröbner bases and triangulations of the second hypersimplex,​ Combinatorica 15 (1995)
 +    ? Parameters:
 +    :: ''​[[.:​common#​Int |Int]]''​ ''​n'':​ the number of points
 +    ? Returns:
 +    :''​[[.:​common#​Matrix |Matrix]]''​
 +    ? Example:
 +    :: To compute the thrackle-metric of five points and display the f-vector of its tight span, do this:
 +    :: <code perl> > $M = thrackle_metric(5);​
 + > $PC = metric_extended_tight_span($M);​
 + > print $PC->​F_VECTOR;​
 + 16 20 5
 +</​code>​
 +
 +
 +----
 +{{anchor:​tight_span_max_metric:​}}
 +  ?  **''​tight_span_max_metric([[.:​common#​Int |Int]] n)''​**
 +  :: Compute a ''​[[.:​fan:​SubdivisionOfPoints |SubdivisionOfPoints]]''​ with a tight span of a metric such that the f-vector is maximal among all metrics with //n// points.
 +  > See Herrmann and Joswig: Bounds on the f-vectors of tight spans, Contrib. Discrete Math., Vol.2, (2007)
 +    ? Parameters:
 +    :: ''​[[.:​common#​Int |Int]]''​ ''​n'':​ the number of points
 +    ? Returns:
 +    :''​[[.:​fan:​SubdivisionOfPoints |SubdivisionOfPoints]]''​
 +    ? Example:
 +    :: To compute the f-vector of the tight span with maximal f-vector, do this:
 +    :: <code perl> > print tight_span_max_metric(5)->​POLYTOPAL_SUBDIVISION->​TIGHT_SPAN->​F_VECTOR;​
 + 11 15 5
 +</​code>​
 +
 +
 +----
 +{{anchor:​tight_span_min_metric:​}}
 +  ?  **''​tight_span_min_metric([[.:​common#​Int |Int]] n)''​**
 +  :: Compute a ''​[[.:​fan:​SubdivisionOfPoints |SubdivisionOfPoints]]''​ with a tight span of a metric such that the f-vector is minimal among all metrics with //n// points.
 +  > See Herrmann and Joswig: Bounds on the f-vectors of tight spans, Contrib. Discrete Math., Vol.2, (2007)
 +    ? Parameters:
 +    :: ''​[[.:​common#​Int |Int]]''​ ''​n'':​ the number of points
 +    ? Returns:
 +    :''​[[.:​fan:​SubdivisionOfPoints |SubdivisionOfPoints]]''​
 +    ? Example:
 +    :: To compute the f-vector of the tight span with minimal f-vector, do this:
 +    :: <code perl> > print tight_span_min_metric(5)->​POLYTOPAL_SUBDIVISION->​TIGHT_SPAN->​F_VECTOR;​
 + 11 15 5
 +</​code>​
 +
 +
 +----
 +{{anchor:​tight_span_thrackle_metric:​}}
 +  ?  **''​tight_span_thrackle_metric([[.:​common#​Int |Int]] n)''​**
 +  :: Compute ''​[[.:​fan:​SubdivisionOfPoints |SubdivisionOfPoints]]''​ with a tight span of th thrackle ​ metric on //n// points. This metric can be interpreted as a lifting function which induces the thrackle triangulation of the second hypersimplex.
 +  > See De Loera, Sturmfels and Thomas: Gröbner bases and triangulations of the second hypersimplex,​ Combinatorica 15 (1995)
 +    ? Parameters:
 +    :: ''​[[.:​common#​Int |Int]]''​ ''​n'':​ the number of points
 +    ? Returns:
 +    :''​[[.:​fan:​SubdivisionOfPoints |SubdivisionOfPoints]]''​
 +    ? Example:
 +    :: To compute the $f$-vector, do this:
 +    :: <code perl> > print tight_span_min_metric(5)->​POLYTOPAL_SUBDIVISION->​TIGHT_SPAN->​F_VECTOR;​
 + 11 15 5
 +</​code>​
 +
 +
 +----
 +
 +==== Geometry ====
 + These functions capture geometric information of the object. ​ Geometric properties depend on geometric information of the object, like, e.g., vertices or facets.
 +----
 +{{anchor:​cell_decomposition_brute_force:​}}
 +  ?  **''​cell_decomposition_brute_force''​**
 +  :: This function computes the ''​[[.:​fan:​HyperplaneArrangement#​CELL_DECOMPOSITION |CELL_DECOMPOSITION]]''​ of a given hyperplane arrangement in a brute force way, by just considering every possible signature. Since not every signature gives a valid cell, it is much cheaper to traverse the cells of ''​[[.:​fan:​HyperplaneArrangement#​CELL_DECOMPOSITION |CELL_DECOMPOSITION]]''​ by flipping the walls. This method is here for verifying results of our other algorithms.
 +
 +
 +----
 +{{anchor:​generating_polyhedron_facets:​}}
 +  ?  **''​generating_polyhedron_facets([[.:​fan:​PolyhedralFan |PolyhedralFan]] P)''​**
 +  :: The facets of a polyhedron that has the fan //P// as its [[.:​fan#​normal_fan |normal fan]], or the empty matrix ​ if no such polyhedron exists.
 +    ? Parameters:
 +    :: ''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​ ''​P''​
 +    ? Returns:
 +    :''​[[.:​common#​Matrix |Matrix]]<​Scalar>''​
 +
 +
 +----
 +{{anchor:​induced_subdivision:​}}
 +  ?  **''​induced_subdivision<​Scalar>​([[.:​polytope:​VectorConfiguration |VectorConfiguration]]<​Scalar>​ pc, [[.:​common#​Matrix |Matrix]]<​Scalar>​ R, [[.:​common#​Set |Set]] I)''​**
 +  :: Calculate the subdivision induced on a point configuration by a height function h. The height function is specified as the sum of a set of rows of a matrix. Using the RAYS of the secondary_fan of the configuration works well.
 +    ? Type Parameters:
 +    :: ''​Scalar'':​ the underlying number type
 +    ? Parameters:
 +    :: ''​[[.:​polytope:​VectorConfiguration |VectorConfiguration]]<​Scalar>''​ ''​pc'':​ (or polytope/​cone) the input configuration
 +    :: ''​[[.:​common#​Matrix |Matrix]]<​Scalar>''​ ''​R'':​ a matrix such that R->​cols() == pc->​N_VECTORS
 +    :: ''​[[.:​common#​Set |Set]]''​ ''​I'':​ (or ARRAY) a set of indices that select rows from R
 +    ? Options:
 +    : 
 +    :: ''​[[.:​common#​Bool |Bool]]''​ ''​verbose'':​ print the final height function used=? Default 0
 +    ? Returns:
 +    :''​[[.:​common#​Set |Set]]<​[[.:​common#​Set |Set]]>''​
 +  ?  **''​induced_subdivision''​**
 +  :: Calculate the subdivision induced on a polytope by a height function h.
 +
 +
 +----
 +
 +==== Producing a fan ====
 + These clients provide standard constructions for ''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​ objects, e.g. from polytopes (''​[[.:​fan#​face_fan |face_fan]]''​ or ''​[[.:​fan#​normal_fan |normal_fan]]''​) or from other fans (via projection, refinement or product).
 +----
 +{{anchor:​cell_decomposition_rs:​}}
 +  ?  **''​cell_decomposition_rs''​**
 +  :: Produce the cell decomposition induced by a hyperplane arrangement
 +
 +
 +----
 +{{anchor:​common_refinement:​}}
 +  ?  **''​common_refinement([[.:​fan:​PolyhedralFan |PolyhedralFan]] f1, [[.:​fan:​PolyhedralFan |PolyhedralFan]] f2)''​**
 +  :: Computes the common refinement of two fans.
 +    ? Parameters:
 +    :: ''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​ ''​f1''​
 +    :: ''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​ ''​f2''​
 +    ? Returns:
 +    :''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​
 +
 +
 +----
 +{{anchor:​face_fan:​}}
 +  ?  **''​face_fan<​Coord>​([[.:​polytope:​Polytope |Polytope]] p, [[.:​common#​Vector |Vector]] v)''​**
 +  :: Computes the face fan of //p//.
 +    ? Type Parameters:
 +    :: ''​Coord''​
 +    ? Parameters:
 +    :: ''​[[.:​polytope:​Polytope |Polytope]]''​ ''​p''​
 +    :: ''​[[.:​common#​Vector |Vector]]''​ ''​v'':​ a relative interior point of the polytope
 +    ? Returns:
 +    :''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​
 +  ?  **''​face_fan<​Coord>​([[.:​polytope:​Polytope |Polytope]] p)''​**
 +  :: Computes the face fan of //p//. the polytope has to be //​CENTERED//​
 +    ? Type Parameters:
 +    :: ''​Coord''​
 +    ? Parameters:
 +    :: ''​[[.:​polytope:​Polytope |Polytope]]''​ ''​p''​
 +    ? Returns:
 +    :''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​
 +
 +
 +----
 +{{anchor:​gfan_secondary_fan:​}}
 +  ?  **''​gfan_secondary_fan([[.:​common#​Matrix |Matrix]] M)''​**
 +  :: Call [[:​external_software#​gfan]] to compute the secondary fan of a point configuration.
 +    ? Parameters:
 +    :: ''​[[.:​common#​Matrix |Matrix]]''​ ''​M'':​ a matrix whose rows are the vectors in the configuration
 +    ? Returns:
 +    :''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​
 +  ?  **''​gfan_secondary_fan([[.:​polytope:​PointConfiguration |PointConfiguration]] P)''​**
 +  :: Call [[:​external_software#​gfan]] to compute the secondary fan of a point configuration.
 +    ? Parameters:
 +    :: ''​[[.:​polytope:​PointConfiguration |PointConfiguration]]''​ ''​P''​
 +    ? Returns:
 +    :''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​
 +
 +
 +----
 +{{anchor:​graph_associahedron_fan:​}}
 +  ?  **''​graph_associahedron_fan([[.:​graph:​Graph |Graph]] G)''​**
 +  :: Produce the dual fan of a graph associahedron.
 +    ? Parameters:
 +    :: ''​[[.:​graph:​Graph |Graph]]''​ ''​G'':​ the input graph
 +    ? Returns:
 +    :''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​
 +
 +
 +----
 +{{anchor:​groebner_fan:​}}
 +  ?  **''​groebner_fan([[.:​ideal:​Ideal |Ideal]] I)''​**
 +  :: Call [[:​external_software#​gfan]] to compute the greobner fan of an ideal.
 +    ? Parameters:
 +    :: ''​[[.:​ideal:​Ideal |Ideal]]''​ ''​I'':​ input ideal
 +    ? Returns:
 +    :''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​
 +
 +
 +----
 +{{anchor:​intersection:​}}
 +  ?  **''​intersection([[.:​fan:​PolyhedralFan |PolyhedralFan]] F, [[.:​common#​Matrix |Matrix]] H)''​**
 +  :: Construct a new fan as the intersection of given fan with a subspace.
 +    ? Parameters:
 +    :: ''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​ ''​F''​
 +    :: ''​[[.:​common#​Matrix |Matrix]]''​ ''​H'':​ equations of subspace
 +    ? Returns:
 +    :''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​
 +
 +
 +----
 +{{anchor:​k_skeleton:​}}
 +  ?  **''​k_skeleton<​Coord>​([[.:​fan:​PolyhedralFan |PolyhedralFan]] F, [[.:​common#​Int |Int]] k)''​**
 +  :: Computes the //​k//​-skeleton of the polyhedral fan //F//, i.e. the subfan of //F// consisting of all cones of dimension <=//k//.
 +    ? Type Parameters:
 +    :: ''​Coord''​
 +    ? Parameters:
 +    :: ''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​ ''​F''​
 +    :: ''​[[.:​common#​Int |Int]]''​ ''​k'':​ the desired top dimension
 +    ? Returns:
 +    :''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​
 +
 +
 +----
 +{{anchor:​normal_fan:​}}
 +  ?  **''​normal_fan<​Coord>​([[.:​polytope:​Polytope |Polytope]] p)''​**
 +  :: Computes the normal fan of //p//.
 +    ? Type Parameters:
 +    :: ''​Coord''​
 +    ? Parameters:
 +    :: ''​[[.:​polytope:​Polytope |Polytope]]''​ ''​p''​
 +    ? Returns:
 +    :''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​
 +
 +
 +----
 +{{anchor:​planar_net:​}}
 +  ?  **''​planar_net([[.:​polytope:​Polytope |Polytope]] p)''​**
 +  :: Computes a planar net of the 3-polytope //p//. Note that it is an open problem if such a planar net always exists.
 +     * PROGRAM MIGHT TERMINATE WITH AN EXCEPTION *
 +  .. If it does, please, notify the polymake team!  Seriously.
 +    ? Parameters:
 +    :: ''​[[.:​polytope:​Polytope |Polytope]]''​ ''​p''​
 +    ? Returns:
 +    :''​[[.:​fan:​PlanarNet |PlanarNet]]''​
 +
 +
 +----
 +{{anchor:​product:​}}
 +  ?  **''​product([[.:​fan:​PolyhedralFan |PolyhedralFan]] F1, [[.:​fan:​PolyhedralFan |PolyhedralFan]] F2)''​**
 +  :: Construct a new polyhedral fan as the __product__ of two given polyhedral fans //F1// and //F2//.
 +    ? Parameters:
 +    :: ''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​ ''​F1''​
 +    :: ''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​ ''​F2''​
 +    ? Options:
 +    : 
 +    :: ''​[[.:​common#​Bool |Bool]]''​ ''​no_coordinates'':​ only combinatorial information is handled
 +    ? Returns:
 +    :''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​
 +
 +
 +----
 +{{anchor:​project_full:​}}
 +  ?  **''​project_full([[.:​fan:​PolyhedralFan |PolyhedralFan]] P)''​**
 +  :: Orthogonally project a fan to a coordinate subspace such that redundant columns are omitted, i.e., the affine hull of the support of the projection is full-dimensional,​ without changing the combinatorial type.
 +    ? Parameters:
 +    :: ''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​ ''​P''​
 +    ? Options:
 +    : 
 +    :: ''​[[.:​common#​Bool |Bool]]''​ ''​no_labels'':​ Do not copy ''​[[.:​fan:​PolyhedralComplex#​VERTEX_LABELS |VERTEX_LABELS]]''​ to the projection. default: 0
 +    ? Returns:
 +    :''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​
 +    ? Example:
 +    :: x and y axis in 3-space
 +    :: <code perl> > $f = new PolyhedralFan(INPUT_RAYS=>​[[1,​0,​0],​[0,​1,​0]],​ INPUT_CONES=>​[[0],​[1]]);​
 + > $pf = project_full($f);​
 + > print $pf->​RAYS;​
 + 1 0
 + 0 1
 +</​code>​
 +    :: <code perl> > print $pf->​MAXIMAL_CONES;​
 + {0}
 + {1}
 +</​code>​
 +
 +
 +----
 +
 +==== Producing a hyperplane arrangement ====
 + These clients provide constructions for ''​[[.:​fan:​HyperplaneArrangement |HyperplaneArrangement]]''​ objects.
 +----
 +{{anchor:​facet_arrangement:​}}
 +  ?  **''​facet_arrangement''​**
 +  ::
 +
 +
 +----
 +{{anchor:​hypersimplex_vertex_splits:​}}
 +  ?  **''​hypersimplex_vertex_splits([[.:​common#​Int |Int]] k, [[.:​common#​Int |Int]] d)''​**
 +  :: Produce the arrangement of vertex splits of the hypersimplex $ Δ(k,d) $
 +    ? Parameters:
 +    :: ''​[[.:​common#​Int |Int]]''​ ''​k'':​ number of 1s
 +    :: ''​[[.:​common#​Int |Int]]''​ ''​d'':​ ambient dimension
 +    ? Options:
 +    : 
 +    :: ''​[[.:​common#​Bool |Bool]]''​ ''​group''​
 +    :: ''​[[.:​common#​Bool |Bool]]''​ ''​no_vertices'':​ do not compute vertices
 +    :: ''​[[.:​common#​Bool |Bool]]''​ ''​no_facets'':​ do not compute facets
 +    :: ''​[[.:​common#​Bool |Bool]]''​ ''​no_vif'':​ do not compute vertices in facets
 +    ? Returns:
 +    :''​[[.:​polytope:​Polytope |Polytope]]''​
 +    ? Example:
 +    :: This corresponds to the hypersimplex in dimension 4 with vertices with exactly two 1-entries and computes its symmetry group:
 +    :: <code perl> > $H = hypersimplex_vertex_splits(2,​4,​group=>​1);​
 +</​code>​
 +
 +
 +----
 +
 +==== Producing a polyhedral complex ====
 + These clients provide constructions for ''​[[.:​fan:​PolyhedralComplex |PolyhedralComplex]]''​ objects.
 +----
 +{{anchor:​mixed_subdivision:​}}
 +  ?  **''​mixed_subdivision([[.:​polytope:​Polytope |Polytope]] P_0, [[.:​polytope:​Polytope |Polytope]] P_1, [[.:​common#​Array |Array]]<​[[.:​common#​Set |Set]]> VIF, Scalar t_0, Scalar t_1)''​**
 +  :: Create a weighted mixed subdivision of the scaled Minkowski sum of two polytopes, using the Cayley trick. The polytopes must have the same dimension, at least one of them must be pointed. ​ The vertices of the first polytope //P_0// are weighted with //t_0//, and the vertices of the second polytope //P_1// with //t_1//. Default values are //​t_0//​=//​t_1//​=1.
 +    ? Parameters:
 +    :: ''​[[.:​polytope:​Polytope |Polytope]]''​ ''​P_0'':​ the first polytope
 +    :: ''​[[.:​polytope:​Polytope |Polytope]]''​ ''​P_1'':​ the second polytope
 +    :: ''​[[.:​common#​Array |Array]]<​[[.:​common#​Set |Set]]>''​ ''​VIF'':​ the indices of the vertices of the mixed cells
 +    :: ''​Scalar''​ ''​t_0'':​ the weight for the vertices of //P_0//; default 1
 +    :: ''​Scalar''​ ''​t_1'':​ the weight for the vertices of //P_1//; default 1
 +    ? Options:
 +    : 
 +    :: ''​[[.:​common#​Bool |Bool]]''​ ''​no_labels'':​ Do not copy ''​[[.:​fan:​PolyhedralComplex#​VERTEX_LABELS |VERTEX_LABELS]]''​ from the original polytopes. default: 0
 +    ? Returns:
 +    :''​[[.:​fan:​PolyhedralComplex |PolyhedralComplex]]''​
 +  ?  **''​mixed_subdivision([[.:​common#​Int |Int]] m, [[.:​polytope:​Polytope |Polytope]] C, [[.:​common#​Array |Array]]<​[[.:​common#​Set |Set]]> a)''​**
 +  :: Create a weighted mixed subdivision of a Cayley embedding of a sequence of polytopes. ​ Each vertex //v// of the //i//-th polytope is weighted with //​t_i//, ​ the //i//-th entry of the optional array //​t//​. ​
 +    ? Parameters:
 +    :: ''​[[.:​common#​Int |Int]]''​ ''​m'':​ the number of polytopes giving rise to the Cayley embedding
 +    :: ''​[[.:​polytope:​Polytope |Polytope]]''​ ''​C'':​ the Cayley embedding of the input polytopes
 +    :: ''​[[.:​common#​Array |Array]]<​[[.:​common#​Set |Set]]>''​ ''​a'':​ triangulation of C
 +    ? Options:
 +    : 
 +    :: ''​[[.:​common#​Vector |Vector]]<​Scalar>''​ ''​t'':​ scaling for the Cayley embedding; defaults to the all-1 vector
 +    :: ''​[[.:​common#​Bool |Bool]]''​ ''​no_labels'':​ Do not copy ''​[[.:​fan:​PolyhedralComplex#​VERTEX_LABELS |VERTEX_LABELS]]''​ from the original polytopes. default: 0
 +    ? Returns:
 +    :''​[[.:​fan:​PolyhedralComplex |PolyhedralComplex]]''​
 +  ?  **''​mixed_subdivision([[.:​common#​Array |Array]]<​[[.:​polytope:​Polytope |Polytope]]>​ A, [[.:​common#​Array |Array]]<​[[.:​common#​Set |Set]]> VIF)''​**
 +  :: Create a weighted mixed subdivision of a sequence (P1,...,Pm) of polytopes, using the Cayley trick. ​ All polytopes must have the same dimension, at least one of them must be pointed. ​ Each vertex //v// of the //i//-th polytope is weighted with //​t_i//, ​ the //i//-th entry of the optional array //​t//​. ​
 +    ? Parameters:
 +    :: ''​[[.:​common#​Array |Array]]<​[[.:​polytope:​Polytope |Polytope]]>''​ ''​A'':​ the input polytopes
 +    :: ''​[[.:​common#​Array |Array]]<​[[.:​common#​Set |Set]]>''​ ''​VIF'':​ the indices of the vertices of the mixed cells
 +    ? Options:
 +    : 
 +    :: ''​[[.:​common#​Vector |Vector]]<​Scalar>''​ ''​t'':​ scaling for the Cayley embedding; defaults to the all-1 vector
 +    :: ''​[[.:​common#​Bool |Bool]]''​ ''​no_labels'':​ Do not copy ''​[[.:​fan:​PolyhedralComplex#​VERTEX_LABELS |VERTEX_LABELS]]''​ from the original polytopes. default: 0
 +    ? Returns:
 +    :''​[[.:​fan:​PolyhedralComplex |PolyhedralComplex]]''​
 +
 +
 +----
 +{{anchor:​tiling_quotient:​}}
 +  ?  **''​tiling_quotient<​Coord>​([[.:​polytope:​Polytope |Polytope]] P, [[.:​polytope:​Polytope |Polytope]] Q)''​**
 +  :: Calculates the quotient of //P// by //Q//+L, where //Q//+L is a lattice tiling. The result is a polytopal complex inside //​Q//​. ​
 +    ? Type Parameters:
 +    :: ''​Coord''​
 +    ? Parameters:
 +    :: ''​[[.:​polytope:​Polytope |Polytope]]''​ ''​P'':​ a polytope
 +    :: ''​[[.:​polytope:​Polytope |Polytope]]''​ ''​Q'':​ a polytope that tiles space
 +    ? Returns:
 +    :''​[[.:​fan:​PolyhedralComplex |PolyhedralComplex]]''​
 +
 +
 +----
 +
 +==== Symmetry ====
 + These functions capture information of the object that is concerned with the action of permutation groups.
 +----
 +{{anchor:​combinatorial_symmetries:​}}
 +  ?  **''​combinatorial_symmetries([[.:​fan:​PolyhedralFan |PolyhedralFan]] f)''​**
 +  :: Compute the combinatorial symmetries (i.e., automorphisms of the face lattice) of a given fan //f//. They are stored in terms of a GROUP.RAYS_ACTION and a GROUP.MAXIMAL_CONES_ACTION property in //f//, and the GROUP.MAXIMAL_CONES_ACTION is also returned.
 +    ? Parameters:
 +    :: ''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​ ''​f''​
 +    ? Returns:
 +    :''​[[.:​group:​PermutationAction |PermutationAction]]''​
 +    ? Example:
 +    :: To get the ray symmetry group of the square and print its generators, type the following:
 +    :: <code perl> > print combinatorial_symmetries(normal_fan(polytope::​cube(2)))->​GENERATORS;​
 + 2 3 0 1
 + 1 0 3 2
 + 0 2 1 3
 +</​code>​
 +    :: <code perl> > $f = normal_fan(polytope::​cube(2));​ combinatorial_symmetries($f);​
 + > print $f->​GROUP->​RAYS_ACTION->​GENERATORS;​
 + 0 1 3 2
 + 1 0 2 3
 + 2 3 0 1
 +</​code>​
 +    :: <code perl> > print $f->​GROUP->​MAXIMAL_CONES_ACTION->​GENERATORS;​
 + 2 3 0 1
 + 1 0 3 2
 + 0 2 1 3
 +</​code>​
 +
 +
 +----
 +{{anchor:​cones_action:​}}
 +  ?  **''​cones_action([[.:​fan:​PolyhedralFan |PolyhedralFan]] f, [[.:​common#​Int |Int]] k)''​**
 +  :: Returns the permutation action induced by the symmetry group of the fan //f// on the set of //​k//​-dimensional cones. This action is not stored as a property of //f//, because polymake doesn'​t support dynamic names of properties. Be aware that the set of //​k//​-dimensional cones itself is ''​%% $f->​CONES->​[$k-1] %%''​.
 +    ? Parameters:
 +    :: ''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​ ''​f'':​ the input fan
 +    :: ''​[[.:​common#​Int |Int]]''​ ''​k'':​ the dimension of the cones to induce the action on
 +    ? Returns:
 +    :''​[[.:​group:​PermutationAction |PermutationAction]]''​
 +    ? Example:
 +    :: Consider a 3-cube //c//. To calculate the induced action of //​Aut//​(//​c//​) on the set of 2-dimensional cones of the normal fan, type
 +    :: <code perl> > $f = fan::​normal_fan(polytope::​cube(3,​ group=>​1));​
 + > print fan::​cones_action($f,​2)->​properties();​
 + name: CONES_ACTION(2)
 + type: PermutationAction<​Int,​ Rational>​
 + ​description:​ action induced on 2-dimensional cones
 + 
 + ​GENERATORS
 + 0 3 4 1 2 5 7 6 8 10 9 11
 + 1 0 2 5 6 3 4 7 9 8 11 10
 + 0 2 1 4 3 8 9 10 5 6 7 11
 +</​code>​
 +    :: <code perl> > print $f->​CONES->​[1];​
 + {2 4}
 + {0 4}
 + {0 2}
 + {1 4}
 + {1 2}
 + {3 4}
 + {0 3}
 + {1 3}
 + {2 5}
 + {0 5}
 + {1 5}
 + {3 5}
 +</​code>​
 +
 +
 +----
 +{{anchor:​orbit_complex:​}}
 +  ?  **''​orbit_complex([[.:​fan:​PolyhedralComplex |PolyhedralComplex]] input_complex,​ [[.:​common#​Array |Array]]<​[[.:​common#​Array |Array]]<​[[.:​common#​Int |Int]]%%>>​%% gens)''​**
 +  :: Constructs the orbit complex of a given polyhedral complex //​input_complex//​ with respect to a given set of generators //gens//.
 +    ? Parameters:
 +    :: ''​[[.:​fan:​PolyhedralComplex |PolyhedralComplex]]''​ ''​input_complex'':​ the generating complex of the orbit complex
 +    :: ''​[[.:​common#​Array |Array]]<​[[.:​common#​Array |Array]]<​[[.:​common#​Int |Int]]%%>>​%%''​ ''​gens'':​ the generators of a permutation group that acts on the coordinates of the ambient space
 +    ? Returns:
 +    :''​[[.:​fan:​PolyhedralComplex |PolyhedralComplex]]''​
 +    ? Example:
 +    :: To calculate an orbit complex with respect to a group of coordinate permutations,​ follow these steps: First specify a seed complex:
 +    :: <code perl> > $f=new PolyhedralComplex(VERTICES=>​[[1,​1,​1],​[1,​1,​0],​[1,​-1,​-1]],​ MAXIMAL_POLYTOPES=>​[[0,​1],​[1,​2]]);​
 +</​code>​
 +    ::  Then define the orbit complex by specifying a permutation action on coordinates:​
 +    :: <code perl> > $oc = orbit_complex($f,​ [[1,0]]);
 +</​code>​
 +    ::  The only properties of $oc defined so far reside in GROUP:
 +    :: <code perl> > print $oc->​GROUP->​properties();​
 + type: Group as PolyhedralComplex<​Rational>::​GROUP
 + 
 + ​COORDINATE_ACTION
 + type: PermutationAction<​Int,​ Rational>​ as PolyhedralComplex<​Rational>::​GROUP::​COORDINATE_ACTION
 + 
 + ​MAXIMAL_POLYTOPES_ACTION
 + type: PermutationAction<​Int,​ Rational>​ as PolyhedralComplex<​Rational>::​GROUP::​MAXIMAL_POLYTOPES_ACTION
 +</​code>​
 +    ::  Now you can calculate the ''​[[.:​fan:​PolyhedralComplex#​VERTICES |VERTICES]]''​ and ''​[[.:​fan:​PolyhedralComplex#​MAXIMAL_POLYTOPES |MAXIMAL_POLYTOPES]]''​ of the orbit fan. IMPORTANT: You must ask for ''​[[.:​fan:​PolyhedralComplex#​VERTICES |VERTICES]]''​ before ''​[[.:​fan:​PolyhedralComplex#​MAXIMAL_POLYTOPES |MAXIMAL_POLYTOPES]]''​.
 +    :: <code perl> > print $oc->​VERTICES;​
 + 1 1 1
 + 1 1 0
 + 1 -1 -1
 + 1 0 1
 +</​code>​
 +    :: <code perl> > print $oc->​N_MAXIMAL_POLYTOPES;​
 + 4
 +</​code>​
 +  ?  **''​orbit_complex([[.:​fan:​PolyhedralFan |PolyhedralFan]] input_fan, [[.:​group:​PermutationAction |PermutationAction]] a)''​**
 +  :: Constructs the orbit fan of a given fan //​input_fan//​ with respect to a given group action //a//.
 +    ? Parameters:
 +    :: ''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​ ''​input_fan'':​ the generating fan of the orbit fan
 +    :: ''​[[.:​group:​PermutationAction |PermutationAction]]''​ ''​a'':​ the action of a permutation group on the coordinates of the ambient space
 +    ? Returns:
 +    :''​[[.:​polytope:​Polytope |Polytope]]''​
 +    ? Example:
 +    :: To calculate an orbit complex with respect to a group of coordinate permutations,​ follow these steps: First specify a seed complex:
 +    :: <code perl> > $f=new PolyhedralComplex(VERTICES=>​[[1,​1,​1],​[1,​1,​0],​[1,​1/​2,​1/​4]],​ MAXIMAL_POLYTOPES=>​[[0,​2],​[1,​2]]);​
 +</​code>​
 +    ::  Then define the orbit complex by specifying a matrix group action on the coordinates:​
 +    :: <code perl> > $oc = orbit_complex($f,​ polytope::​cube(2,​group=>​1)->​GROUP->​MATRIX_ACTION);​
 +</​code>​
 +    ::  The only properties of $oc defined so far reside in GROUP:
 +    ::  Now you can calculate the ''​[[.:​fan:​PolyhedralComplex#​VERTICES |VERTICES]]''​ and ''​[[.:​fan:​PolyhedralComplex#​MAXIMAL_POLYTOPES |MAXIMAL_POLYTOPES]]''​ of the orbit fan. IMPORTANT: You must ask for ''​[[.:​fan:​PolyhedralComplex#​VERTICES |VERTICES]]''​ before ''​[[.:​fan:​PolyhedralComplex#​MAXIMAL_POLYTOPES |MAXIMAL_POLYTOPES]]''​.
 +    :: <code perl> > print $oc->​VERTICES;​
 + 1 1 1
 + 1 1 0
 + 1 1/2 1/4
 + 1 -1 -1
 + 1 -1 1
 + 1 1 -1
 + 1 -1 0
 + 1 0 -1
 + 1 0 1
 + 1 -1/2 -1/4
 + 1 -1/2 1/4
 + 1 -1/4 -1/2
 + 1 -1/4 1/2
 + 1 1/4 -1/2
 + 1 1/4 1/2
 + 1 1/2 -1/4
 +</​code>​
 +    :: <code perl> > print $oc->​N_MAXIMAL_POLYTOPES;​
 + 16
 +</​code>​
 +
 +
 +----
 +{{anchor:​orbit_fan:​}}
 +  ?  **''​orbit_fan([[.:​fan:​PolyhedralFan |PolyhedralFan]] input_fan, [[.:​common#​Array |Array]]<​[[.:​common#​Array |Array]]<​[[.:​common#​Int |Int]]%%>>​%% gens)''​**
 +  :: Constructs the orbit fan of a given fan //​input_fan//​ with respect to a given set of generators //gens//.
 +    ? Parameters:
 +    :: ''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​ ''​input_fan'':​ the generating fan of the orbit fan
 +    :: ''​[[.:​common#​Array |Array]]<​[[.:​common#​Array |Array]]<​[[.:​common#​Int |Int]]%%>>​%%''​ ''​gens'':​ the generators of a permutation group that acts on the coordinates of the ambient space
 +    ? Returns:
 +    :''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​
 +    ? Example:
 +    :: To calculate an orbit fan, follow these steps: First specify a seed fan:
 +    :: <code perl> > $f=new PolyhedralFan(RAYS=>​[[1,​1],​[1,​0],​[-1,​-1]],​ MAXIMAL_CONES=>​[[0,​1],​[1,​2]]);​
 +</​code>​
 +    ::  Then define the orbit fan by specifying coordinate permutations:​
 +    :: <code perl> > $of = orbit_fan($f,​[[1,​0]]);​
 +</​code>​
 +    ::  The only properties of $of defined so far reside in GROUP:
 +    :: <code perl> > print $of->​GROUP->​properties();​
 + name: unnamed#0
 + type: Group as PolyhedralFan<​Rational>::​GROUP
 + 
 + ​HOMOGENEOUS_COORDINATE_ACTION
 + type: PermutationAction<​Int,​ Rational>​
 + 
 + ​MAXIMAL_CONES_ACTION
 + type: PermutationAction<​Int,​ Rational>​ as PolyhedralFan<​Rational>::​GROUP::​MAXIMAL_CONES_ACTION
 +
 +</​code>​
 +    ::  Now you can calculate the ''​[[.:​fan:​PolyhedralFan#​RAYS |RAYS]]''​ and ''​[[.:​fan:​PolyhedralFan#​MAXIMAL_CONES |MAXIMAL_CONES]]''​ of the orbit fan. IMPORTANT: You must ask for ''​[[.:​fan:​PolyhedralFan#​RAYS |RAYS]]''​ before ''​[[.:​fan:​PolyhedralFan#​MAXIMAL_CONES |MAXIMAL_CONES]]''​.
 +    :: <code perl> > print $of->​RAYS;​
 + 1 1
 + 1 0
 + -1 -1
 + 0 1
 +</​code>​
 +    :: <code perl> > print $of->​N_MAXIMAL_CONES;​
 + 4
 +</​code>​
 +  ?  **''​orbit_fan<​Scalar>​([[.:​fan:​PolyhedralFan |PolyhedralFan]] input_fan, [[.:​common#​Array |Array]]<​[[.:​common#​Matrix |Matrix]]<​Scalar%%>>​%% gens)''​**
 +  :: Constructs the orbit fan of a given fan //​input_fan//​ with respect to a given set of matrix group generators //gens//.
 +    ? Type Parameters:
 +    :: ''​Scalar'':​ underlying number type
 +    ? Parameters:
 +    :: ''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​ ''​input_fan'':​ the generating fan of the orbit fan
 +    :: ''​[[.:​common#​Array |Array]]<​[[.:​common#​Matrix |Matrix]]<​Scalar%%>>​%%''​ ''​gens'':​ the generators of a matrix group that acts on the ambient space
 +    ? Returns:
 +    :''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]''​
 +    ? Example:
 +    :: To calculate an orbit fan, follow these steps: First specify a seed fan:
 +    :: <code perl> > $f=new PolyhedralFan(RAYS=>​[[1,​1,​1],​[1,​1,​0],​[1,​1/​2,​1/​4]],​MAXIMAL_CONES=>​[[0,​2],​[1,​2]]);​
 +</​code>​
 +    ::  Then define the orbit fan by specifying a matrix group action:
 +    :: <code perl> > $of = orbit_fan($f,​polytope::​cube(2,​group=>​1)->​GROUP->​MATRIX_ACTION);​
 +</​code>​
 +    ::  The only properties of $of defined so far reside in GROUP:
 +    :: <code perl> > print $of->​GROUP->​properties();​
 + name: unnamed#0
 + type: Group as PolyhedralFan<​Rational>::​GROUP
 + 
 + ​MATRIX_ACTION
 + type: MatrixActionOnVectors<​Rational>​
 + 
 + ​MAXIMAL_CONES_ACTION
 + type: PermutationAction<​Int,​ Rational>​ as PolyhedralFan<​Rational>::​GROUP::​MAXIMAL_CONES_ACTION
 +
 +</​code>​
 +    ::  Now you can calculate the ''​[[.:​fan:​PolyhedralFan#​RAYS |RAYS]]''​ and ''​[[.:​fan:​PolyhedralFan#​MAXIMAL_CONES |MAXIMAL_CONES]]''​ of the orbit fan. IMPORTANT: You must ask for ''​[[.:​fan:​PolyhedralFan#​RAYS |RAYS]]''​ before ''​[[.:​fan:​PolyhedralFan#​MAXIMAL_CONES |MAXIMAL_CONES]]''​.
 +    :: <code perl> > print $of->​RAYS;​
 + 1 1 1
 + 1 1 0
 + 1 1/2 1/4
 + 1 -1 -1
 + 1 -1 1
 + 1 1 -1
 + 1 -1 0
 + 1 0 -1
 + 1 0 1
 + 1 -1/2 -1/4
 + 1 -1/2 1/4
 + 1 -1/4 -1/2
 + 1 -1/4 1/2
 + 1 1/4 -1/2
 + 1 1/4 1/2
 + 1 1/2 -1/4
 +</​code>​
 +    :: <code perl> > print $of->​N_MAXIMAL_CONES;​
 + 16
 +</​code>​
 +
 +
 +----
 +
 +==== Triangulations,​ subdivisions and volume ====
 + These functions collect information about triangulations and other subdivisions of the object and properties usually computed from such, as the volume.
 +----
 +{{anchor:​secondary_fan:​}}
 +  ?  **''​secondary_fan([[.:​polytope:​VectorConfiguration |VectorConfiguration]] V)''​**
 +  :: Calculate the secondary fan of a point or vector configuration,​ or polytope.
 +    ? Parameters:
 +    :: ''​[[.:​polytope:​VectorConfiguration |VectorConfiguration]]''​ ''​V'':​ (or polytope) the input configuration
 +    ? Options:
 +    : 
 +    :: ''​[[.:​common#​Array |Array]]<​[[.:​common#​Set |Set]]>''​ ''​initial_subdivision'':​ a seed subdivision of //V//
 +    :: ''​[[.:​common#​Matrix |Matrix]]''​ ''​restrict_to'':​ the equations defining a subspace that the secondary fan should be restricted to
 +    :: ''​[[.:​common#​Int |Int]]''​ ''​seed'':​ controls the outcome of the random number generator for generating a randomized initial subdivision
 +    ? Returns:
 +    :''​[[.:​fan:​PolyhedralFan |PolyhedralFan]]<​Scalar>''​
 +  ?  **''​secondary_fan''​**
 +  ::
 +
 +
 +----
 +
 +==== Visualization ====
 + These functions are for visualization.
 +----
 +{{anchor:​splitstree:​}}
 +  ?  **''​splitstree([[.:​common:​Visual_Object |Visual::​Object]] vis_obj ...)''​**
 +  :: Call [[:​external_software#​SplitsTree]] with the given visual objects.
 +    ? Parameters:
 +    :: ''​[[.:​common:​Visual_Object |Visual::​Object]]''​ ''​vis_obj ...'':​ objects to display
 +    ? Options:
 +    : 
 +    :: ''​[[.:​common#​String |String]]''​ ''​File'':​ "​filename"​ or "​AUTO" ​ Only create a NEXUS format file, don't start the GUI.  The ''​.nex''​ suffix is automatically added to the file name.  Specify //AUTO// if you want the filename be automatically derived from the drawing title. ​ You can also use any expression allowed for the ''​open''​ function, ​ including "​-"​ for terminal output, "&​HANDLE"​ for an already opened file handle, ​ or "| program"​ for a pipe.
 +
 +
 +----
 +{{anchor:​visual_splitstree:​}}
 +  ?  **''​visual_splitstree([[.:​common#​Matrix |Matrix]]<​[[.:​common#​Rational |Rational]]>​ M)''​**
 +  :: Visualize the splits of a finite metric space (that is, a planar image of a tight span). ​ Calls SplitsTree.
 +    ? Parameters:
 +    :: ''​[[.:​common#​Matrix |Matrix]]<​[[.:​common#​Rational |Rational]]>''​ ''​M'':​ Matrix defining a metric
 +    ? Options:
 +    : 
 +    :: ''​[[.:​common#​Array |Array]]<​[[.:​common#​String |String]]>''​ ''​taxa'':​ Labels for the taxa
 +    :: ''​[[.:​common#​String |String]]''​ ''​name'':​ Name of the drawing
 +    ? Returns:
 +    :''​[[.:​common:​Visual_Object |Visual::​Object]]''​
 +
 +
 +----
 +
 +==== Other ====
 + ​Special purpose functions.
 +----
 +{{anchor:​building_set:​}}
 +  ?  **''​building_set([[.:​common#​Array |Array]]<​[[.:​common#​Set |Set]]> generators, [[.:​common#​Int |Int]] n)''​**
 +  :: Produce a building set from a family of sets.
 +    ? Parameters:
 +    :: ''​[[.:​common#​Array |Array]]<​[[.:​common#​Set |Set]]>''​ ''​generators'':​ the generators of the building set
 +    :: ''​[[.:​common#​Int |Int]]''​ ''​n'':​ the size of the ground set
 +    ? Returns:
 +    :''​[[.:​common#​PowerSet |PowerSet]]''​
 +
 +
 +----
 +{{anchor:​cone_of_tubing:​}}
 +  ?  **''​cone_of_tubing([[.:​graph:​Graph |Graph]] G, [[.:​graph:​Graph |Graph]] T)''​**
 +  :: Output the cone of a tubing
 +    ? Parameters:
 +    :: ''​[[.:​graph:​Graph |Graph]]''​ ''​G'':​ the input graph
 +    :: ''​[[.:​graph:​Graph |Graph]]''​ ''​T'':​ the input tubing
 +    ? Returns:
 +    :''​[[.:​polytope:​Cone |Cone]]''​
 +
 +
 +----
 +{{anchor:​flip_tube:​}}
 +  ?  **''​flip_tube([[.:​graph:​Graph |Graph]] G, [[.:​graph:​Graph |Graph]] T, [[.:​common#​Int |Int]] t)''​**
 +  :: Flip a tubing in a tube
 +    ? Parameters:
 +    :: ''​[[.:​graph:​Graph |Graph]]''​ ''​G'':​ the input graph
 +    :: ''​[[.:​graph:​Graph |Graph]]''​ ''​T'':​ the input tubing
 +    :: ''​[[.:​common#​Int |Int]]''​ ''​t'':​ the tube to flip, identified by its root
 +    ? Returns:
 +    :''​[[.:​graph:​Graph |Graph]]''​
 +
 +
 +----
 +{{anchor:​is_b_nested:​}}
 +  ?  **''​is_B_nested([[.:​common#​Set |Set]]<​[[.:​common#​Set |Set]]> check_me, [[.:​common#​PowerSet |PowerSet]] B)''​**
 +  :: Check if a family of sets is nested wrt a given building set.
 +    ? Parameters:
 +    :: ''​[[.:​common#​Set |Set]]<​[[.:​common#​Set |Set]]>''​ ''​check_me'':​ the would-be nested sets
 +    :: ''​[[.:​common#​PowerSet |PowerSet]]''​ ''​B'':​ the building set
 +    ? Returns:
 +    :''​[[.:​common#​Bool |Bool]]''​
 +
 +
 +----
 +{{anchor:​is_building_set:​}}
 +  ?  **''​is_building_set([[.:​common#​PowerSet |PowerSet]] check_me, [[.:​common#​Int |Int]] n)''​**
 +  :: Check if a family of sets is a building set.
 +    ? Parameters:
 +    :: ''​[[.:​common#​PowerSet |PowerSet]]''​ ''​check_me'':​ the would-be building set
 +    :: ''​[[.:​common#​Int |Int]]''​ ''​n'':​ the size of the ground set
 +    ? Returns:
 +    :''​[[.:​common#​Bool |Bool]]''​
 +
 +
 +----
 +{{anchor:​tubes_of_graph:​}}
 +  ?  **''​tubes_of_graph([[.:​graph:​Graph |Graph]] G)''​**
 +  :: Output the set of all tubes of a graph
 +    ? Parameters:
 +    :: ''​[[.:​graph:​Graph |Graph]]''​ ''​G'':​ the input graph
 +    ? Returns:
 +    :''​[[.:​common#​Set |Set]]<​[[.:​common#​Set |Set]]>''​
 +
 +
 +----
 +{{anchor:​tubes_of_tubing:​}}
 +  ?  **''​tubes_of_tubing([[.:​graph:​Graph |Graph]] G, [[.:​graph:​Graph |Graph]] T)''​**
 +  :: Output the tubes of a tubing
 +    ? Parameters:
 +    :: ''​[[.:​graph:​Graph |Graph]]''​ ''​G'':​ the input graph
 +    :: ''​[[.:​graph:​Graph |Graph]]''​ ''​T'':​ the input tubing
 +    ? Returns:
 +    :''​[[.:​common#​Set |Set]]<​[[.:​common#​Set |Set]]>''​
 +
 +
 +----
 +{{anchor:​tubing_of_graph:​}}
 +  ?  **''​tubing_of_graph([[.:​graph:​Graph |Graph]] G)''​**
 +  :: Output one tubing of a graph
 +    ? Parameters:
 +    :: ''​[[.:​graph:​Graph |Graph]]''​ ''​G'':​ the input graph
 +    ? Returns:
 +    :''​[[.:​common#​Set |Set]]<​[[.:​common#​Set |Set]]>''​
 +
 +
 +----
 +
 +==== no category ====
 +{{anchor:​make_hyperplanes_unique_in_support:​}}
 +  ?  **''​make_hyperplanes_unique_in_support''​**
 +  ::​UNDOCUMENTED
 +
 +
 +----
 +
 +===== Small Object Types =====
 +
 +==== no category ====
 +{{anchor:​sedentaritydecoration:​}}
 +  ?  **''​SedentarityDecoration''​**
 +  ::​UNDOCUMENTED
 +
 +
 +----
  
  • documentation/master/fan.txt
  • Last modified: 2020/05/13 16:36
  • (external edit)