An instance of data type Line_d is an oriented line in d-dimensional Euclidean space.


the linear algebra layer.


Line_d<Kernel> l;
introduces a variable l of type Line_d<Kernel>.

Line_d<Kernel> l ( Point_d<Kernel> p, Point_d<Kernel> q);
introduces a line through p and q and oriented from p to q.
Precondition: p and q are distinct and have the same dimension.

Line_d<Kernel> l ( Point_d<Kernel> p, Direction_d<Kernel> dir);
introduces a line through p with direction dir.
Precondition: p.dimension()==dir.dimension(), dir is not degenerate.

Line_d<Kernel> l ( Segment_d<Kernel> s);
introduces a variable l of type Line_d<Kernel> and initializes it to the line through s.source() and with direction from s.source() to
Precondition: s is not degenerate.

Line_d<Kernel> l ( Ray_d<Kernel> r);
introduces a variable l of type Line_d<Kernel> and initializes it to the line through r.point(1) and r.point(2).


int l.dimension () returns the dimension of the ambient space.

Point_d<Kernel> l.point ( int i) returns an arbitrary point on l. It holds that point(i) == point(j), iff i==j. Furthermore, l is directed from point(i) to point(j), for all i < j.

Line_d<Kernel> l.opposite () returns the line (point(2),point(1)) of opposite direction.

Direction_d<Kernel> l.direction () returns the direction of l.

Line_d<Kernel> l.transform ( Aff_transformation_d<Kernel> t)
returns t(l).
Precondition: l.dimension()==t.dimension().

Line_d<Kernel> l + Vector_d<Kernel> v returns l+v, i.e., l translated by vector v.
Precondition: l.dimension()==v.dimension().

Point_d<Kernel> l.projection ( Point_d<Kernel> p)
returns the point of intersection of l with the hyperplane that is orthogonal to l and that contains p.
Precondition: l.dimension()==p.dimension().

bool l.has_on ( Point_d<Kernel> p) returns true if p lies on l and false otherwise.
Precondition: l.dimension()==p.dimension().

Non-Member Functions

bool weak_equality ( l1, l2) Test for equality as unoriented lines.
Precondition: l1.dimension()==l2.dimension().

bool parallel ( l1, l2) returns true if l1 and l2 are parallel as unoriented lines and false otherwise.
Precondition: l1.dimension()==l2.dimension().


Lines are implemented by a pair of points as an item type. All operations like creation, initialization, tests, direction calculation, input and output on a line l take time O(l.dimension()). dimension(), coordinate and point access, and identity test take constant time. The operations for intersection calculation also take time O(l.dimension()). The space requirement is O(l.dimension()).