## CGAL::Ray_d<Kernel>

### Definition

An instance of data type Ray_d is a ray in d-dimensional Euclidean space. It starts in a point called the source of r and it goes to infinity.

### Types

Ray_d<Kernel>::R
| the representation type.
Ray_d<Kernel>::RT
| the ring type.
Ray_d<Kernel>::FT
| the field type.
Ray_d<Kernel>::LA
| the linear algebra layer.

### Creation

Ray_d<Kernel> r;
| introduces some ray in d-dimensional space.
Ray_d<Kernel> r ( Point_d<Kernel> p, Point_d<Kernel> q);
| introduces a ray through p and q and starting at p. Precondition: p and q are distinct and have the same dimension. Precondition: p.dimension()==q.dimension().
Ray_d<Kernel> r ( Point_d<Kernel> p, Direction_d<Kernel> dir);
| introduces a ray starting in p with direction dir. Precondition: p and dir have the same dimension and dir is not degenerate. Precondition: p.dimension()==dir.dimension().
Ray_d<Kernel> r ( Segment_d<Kernel> s);
| introduces a ray through s.source() and s.target() and starting at s.source(). Precondition: s is not degenerate.

### Operations

int | r.dimension () | returns the dimension of the ambient space.
Point_d<Kernel> | r.source () | returns the source point of r.
Point_d<Kernel> | r.point ( int i) | returns a point on r. point(0) is the source. point(i), with i>0, is different from the source. Precondition: i 0.
Direction_d<Kernel>
| r.direction () | returns the direction of r.
Line_d<Kernel> | r.supporting_line ()
|  | returns the supporting line of r.
Ray_d<Kernel> | r.opposite () | returns the ray with direction opposite to r and starting in source.
Ray_d<Kernel> | r.transform ( Aff_transformation_d<Kernel> t)
|  | returns t(r). Precondition: r.dimension()==t.dimension().
Ray_d<Kernel> | r + Vector_d<Kernel> v
|  | returns r+v, i.e., r translated by vector v. Precondition: r.dimension()==v.dimension().
bool | r.has_on ( Point_d<Kernel> p)
|  | A point is on r, iff it is equal to the source of r, or if it is in the interior of r. Precondition: r.dimension()==p.dimension().

### Non-Member Functions

bool | parallel ( r1, r2)
|  | returns true if the unoriented supporting lines of r1 and r2 are parallel and false otherwise. Precondition: r1.dimension()==r2.dimension().

### Implementation

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