Operators and functions for type PFACE

&<

&<(f1::PFACE, f2::PFACE)::boolean
&>(f2::PFACE, f1::PFACE)::boolean
f1 &< f2
f2 &> f1

Test whether f1 is a proper face of f2. Both faces must have identical domains.

&<<

&<<(f1::PFACE, f2::PFACE)::boolean
&>>(f2::PFACE, f1::PFACE)::boolean
f1 &<< f2
f2 &>> f1

Test whether f1 is a facet of f2. Both faces must have identical domains.

&<=

&<=(f1::PFACE, f2::PFACE)::boolean
&>=(f2::PFACE, f1::PFACE)::boolean
f1 &<= f2
f2 &>= f1

Test whether f1 is a face of f2. Both faces must have identical domains.

&<>

&<>(f1::PFACE, f2::PFACE)::boolean
f1 &<> f2

Test whether f1 and f2 represent different faces. This is true if their domains are not identical.

&=

&=(f1::PFACE, f2::PFACE)::boolean
f1 &= f2

Test whether f1 and f2 represent the same face. This is false if they domains are not identical.

&x

&x(f1::PFACE, f2::PFACE, ...)::PFACE
f1 &x f2

The Cartesian product of the given faces, considered as a face of the Cartesian product of their domains. See POLYHEDRON[&x].

ambientdim

ambientdim(f::PFACE)::nonnegint

The dimension of the ambient space of f.

codim

codim(f::PFACE)::nonnegint

The codimension of f in its ambient space. See also POLYHEDRON[codim], dim and corank.

convert/CFACE

convert(f::PFACE, CFACE)::CFACE

This functions converts f to the corresponding face of the homogenization convert(domain(f), CONE) of its domain. See also POLYHEDRON[convert/CONE].

convert/POLYHEDRON

convert(f::PFACE, POLYHEDRON)::POLYHEDRON

This functions converts f to the POLYHEDRON representing the same point set.

corank

corank(f::PFACE)::nonnegint

The corank of f in the face lattice of its domain. This is the distance between f and the maximal element of the face lattice. See also rank.

dim

dim(f::PFACE)::integer

The dimension of f. Note that the dimension of a facet of f may be different from dim(f)-1 if the facet is empty. See also POLYHEDRON[dim] and rank.

Examples

	f := maximal(cube(2));

f := PFACE(4,0)

	dim(f); map(dim, pred(f));

2

[1, 1, 1, 1]

If the minimal non-empty faces have positive dimension, then the dimension of the empty face (their common facet) differs by more than 1:

	P := cube(1) &x fullpolyhedron(1); f := support(P, [1, 0]);

P := POLYHEDRON(2,2,1,[2, 0],[1])

f := PFACE(1,1)

	dim(f); map(dim, pred(f));

1

[-1]

domain

domain(f::PFACE)::POLYHEDRON

The polyhedron of which f is a face. Mathematically speaking, f may be a face of many polyhedra, but with the Convex package it is always constructed as the face of a fixed polyhedron. See POLYHEDRON[isface] for a way to change the domain.

Examples

	P := cube(2); f := support(P, [1, 0]);

P := POLYTOPE(2,2,4,4)

f := PFACE(2,1)

	domain(f) &= P;

true

dual

dual(f::PFACE)::PFACE

If P is bounded and contains the origin in is interior (i.e., if P is of type POLYTOPE__0), then there is an order-reversing bijection between the faces of P and of its dual. This function returns the face of dual(P) which is dual to f in this sense. Note that (even as point sets) this is not the same as the dual of f, considered as polyhedron.

In the general case, one can still assign a "dual" face to f (by taking the dual in the category of cones and then intersecting the result with the halfspace at infinity), but this may no longer be a bijection.

Examples

	P := cube(2); f := support(P, [1, 1]);

P := POLYTOPE(2,2,4,4)

f := PFACE(1,2)

	f2 := dual(f); vertices(f2); domain(f2) &= dual(domain(f));

f2 := PFACE(2,1)

[[0, -1], [-1, 0]]

true

	P2 := dual(convert(f, POLYHEDRON)); vertices(P2); rays(P2), lines(P2);

P2 := POLYHEDRON(2,2,1,[1, 1],[1])

[[0, -1]]

[[0, 1]], [[1, -1]]

hspacenos

hspacenos(f::PFACE)::set(posint)

The set of indices of the facets incident to f. The ordering is that of hspaces(domain(f)), see POLYHEDRON[hspaces]. This is a low-level routine.

isbounded

isbounded(f::PFACE)::boolean

Test whether f is bounded.

isempty

isempty(f::PFACE)::boolean

Test whether f is the empty face.

maximum

maximum(f1::PFACE, f2::PFACE, ...)::PFACE

The maximum of f1, f2 ... in the face lattice. All faces must have the same domain, which will also be the domain of the result. At least one face must be given.

minimum

minimum(f1::PFACE, f2::PFACE, ...)::PFACE

The minimum of f1, f2 ... in the face lattice. All faces must have the same domain, which will also be the domain of the result. At least one face must be given.

pred

pred(f::PFACE)::list(PFACE)

A list containing the predecessors of f in the face lattice of domain(f). These are the faces whose rank is one smaller than that of f, or, in other words, the facets of f. See also succ.

Examples

	P := cube(3); f := support(P, [0, 1, 1/5]); vertices(f);

P := POLYTOPE(3,3,8,6)

f := PFACE(4,1)

[[-1, 1, -1], [1, 1, -1], [-1, 1, 1], [1, 1, 1]]

	L := pred(f); map(vertices, L);

L := [PFACE(2,2), PFACE(2,2), PFACE(2,2), PFACE(2,2)]

[[[1, 1, -1], [1, 1, 1]], [[-1, 1, 1], [1, 1, 1]], [[-1, 1, -1], [-1, 1, 1]], [[-1, 1, -1], [1, 1, -1]]]

	f := minimal(P); rank(f); pred(f);

f := PFACE(0,6)

0

[]

rank

rank(f::PFACE)::nonnegint

The rank of f in the face lattice of its domain. This is the distance between f and the empty face. This function behaves better with respect to facets than the dimension.

Examples

	P := fullpolyhedron(2); f1 := maximal(P); f2 := minimal(P);

P := POLYHEDRON(2,2,2,[1, 0],[0])

f1 := PFACE(1,0)

f2 := PFACE(0,1)

	dim(f1), dim(f2);

2, -1

	rank(f1), rank(f2);

1, 0

raynos

raynos(f::PFACE)::set(posint)

The set of indices of the rays incident to f. The ordering is that of rays(domain(f)), see POLYHEDRON[rays]. This is a low-level routine.

rays

rays(f::PFACE)::list(vec)

A list of the rays of f. See POLYHEDRON[rays]. Do not make any assumption about the order.

relint

relint(f::PFACE1)::vec

A point in the relative interior of f.

succ

succ(f::PFACE)::list(PFACE)

A list containing the successors of f in the face lattice of domain(f). These are the faces whose rank is one bigger than that of f, or, in other words, the faces of which f is a facet. See also pred.

Examples

	P := cube(2);

P := POLYTOPE(2,2,4,4)

	L := succ(minimal(P)); map(vertices, L);

L := [PFACE(1,2), PFACE(1,2), PFACE(1,2), PFACE(1,2)]

[[[-1, -1]], [[1, -1]], [[-1, 1]], [[1, 1]]]

	succ(maximal(P));

[]

surface

surface(f::PFACE)::{nonnegative, pos_infinity}

The surface of f with respect to the induced Euclidean volume. This is 0 if and only if f is empty or has only the empty face as facet. See also POLYHEDRON[surface].

vertexnos

vertexnos(f::PFACE)::set(posint)

The set of indices of the vertices incident to f. The ordering is that of vertices(domain(f)), see POLYHEDRON[vertices]. This is a low-level routine.

vertices

vertices(f::PFACE)::list(vec)

A list of the vertices of f. See POLYHEDRON[vertices]. Do not make any assumption about the order.

volume

volume(f::PFACE)::{nonnegative, pos_infinity}

The volume of f with respect to the induced Euclidean volume. Unlike POLYHEDRON[volume], this function never returns 0 for non-empty polyhedra.