Vector_d<Kernel>

Navigation: Up Table of Contents Package Overview Bibliography Index Title Acknowledging CGAL

CGAL::Vector_d<Kernel>

Definition

An instance of data type Vector_d<Kernel> is a vector of Euclidean space in dimension d. A vector r = (r₀, … ,r_{d - 1}) can be represented in homogeneous coordinates (h₀, … ,h_d) of number type RT, such that r_i = h_i/h_d which is of type FT. We call the r_i's the Cartesian coordinates of the vector. The homogenizing coordinate h_d is positive.

This data type is meant for use in computational geometry. It realizes free vectors as opposed to position vectors (type Point_d). The main difference between position vectors and free vectors is their behavior under affine transformations, e.g., free vectors are invariant under translations.

Types

Vector_d<Kernel>::LA
	the linear algebra layer.

Vector_d<Kernel>::Cartesian_const_iterator
	a read-only iterator for the Cartesian coordinates.

Vector_d<Kernel>::Homogeneous_const_iterator
	a read-only iterator for the homogeneous coordinates.

Vector_d<Kernel>::Base_vector
	construction tag.

Creation

Vector_d<Kernel> v;

introduces a variable v of type Vector_d<Kernel>.

Vector_d<Kernel> v ( int d, Null_vector);

introduces the zero vector v of type Vector_d<Kernel> in d-dimensional space. For the creation flag CGAL::NULL_VECTOR can be used.

template <class InputIterator>

Vector_d<Kernel> v ( int d, InputIterator first, InputIterator last);

introduces a variable v of type Vector_d<Kernel> in dimension d. If size [first,last) == d this creates a vector with Cartesian coordinates set [first,last). If size [first,last) == p+1 the range specifies the homogeneous coordinates H = set [first,last) = ( ± h₀, ± h₁, … , ± h_d) where the sign chosen is the sign of h_d.

Precondition:

d is nonnegative, [first,last) has d or d+1 elements where the last has to be non-zero.

Requirement:

The value type of InputIterator is RT.

template <class InputIterator>

Vector_d<Kernel> v ( int d, InputIterator first, InputIterator last, RT D);

introduces a variable v of type Vector_d<Kernel> in dimension d initialized to the vector with homogeneous coordinates as defined by H = set [first,last) and D: ( ± H[0], ± H[1], … , ± H[d-1], ± D). The sign chosen is the sign of D.

Precondition:

D is non-zero, the iterator range defines a d-tuple of RT.

Requirement:

The value type of InputIterator is RT.

Vector_d<Kernel> v ( int d, Base_vector, int i);

returns a variable v of type Vector_d<Kernel> initialized to the i-th base vector of dimension d.

Precondition:

0 ≤ i < d.

Vector_d<Kernel> v ( RT x, RT y, RT w = 1);

introduces a variable v of type Vector_d<Kernel> in 2-dimensional space.

Precondition:

w ≠ 0.

Vector_d<Kernel> v ( RT x, RT y, RT z, RT w);

introduces a variable v of type Vector_d<Kernel> in 3-dimensional space.

Precondition:

w ≠ 0.

Operations

int

v.dimension ()

returns the dimension of v.

v.cartesian ( int i)

returns the i-th Cartesian coordinate of v.

Precondition:

0 ≤ i < d.

v [ int i ]

returns the i-th Cartesian coordinate of v.

Precondition:

0 ≤ i < d.

v.homogeneous ( int i)

returns the i-th homogeneous coordinate of v.

Precondition:

0 ≤ i ≤ d.

v.squared_length ()

returns the square of the length of v.

Cartesian_const_iterator

v.cartesian_begin ()

returns an iterator pointing to the zeroth Cartesian coordinate of v.

Cartesian_const_iterator

v.cartesian_end ()

returns an iterator pointing beyond the last Cartesian coordinate of v.

Homogeneous_const_iterator

v.homogeneous_begin ()

returns an iterator pointing to the zeroth homogeneous coordinate of v.

Homogeneous_const_iterator

v.homogeneous_end ()

returns an iterator pointing beyond the last homogeneous coordinate of v.

Direction_d<Kernel>

v.direction ()

returns the direction of v.

Vector_d<Kernel>

v.transform ( Aff_transformation_d<Kernel> t)

returns t(v).

Arithmetic Operators, Tests and IO

Vector_d<Kernel>&	v = RT n*	multiplies all Cartesian coordinates by n.

Vector_d<Kernel>&	v = FT r*	multiplies all Cartesian coordinates by r.

Vector_d<Kernel>	v / RT n	returns the vector with Cartesian coordinates v_i/n, 0 ≤ i < d.

Vector_d<Kernel>	v / FT r	returns the vector with Cartesian coordinates v_i/r, 0 ≤ i < d.

Vector_d<Kernel>&	v /= RT n	divides all Cartesian coordinates by n.

Vector_d<Kernel>&	v /= FT r	divides all Cartesian coordinates by r.

FT	v w*	inner product, i.e., ∑_{0 ≤ i < d} v_i w_i, where v_i and w_i are the Cartesian coordinates of v and w respectively.

Vector_d<Kernel>	v + w	returns the vector with Cartesian coordinates v_i+w_i, 0 ≤ i < d.

Vector_d<Kernel>&	v += w	addition plus assignment.

Vector_d<Kernel>	v - w	returns the vector with Cartesian coordinates v_i-w_i, 0 ≤ i < d.

Vector_d<Kernel>&	v -= w	subtraction plus assignment.

Vector_d<Kernel>	- v	returns the vector in opposite direction.

bool	v.is_zero ()	returns true if v is the zero vector.

Downward compatibility

We provide all operations of the lower dimensional interface x(), y(), z(), hx(), hy(), hz(), hw().

Vector_d<Kernel>	RT n v*	returns the vector with Cartesian coordinates n v_i.

Vector_d<Kernel>	FT r v*	returns the vector with Cartesian coordinates r v_i, 0 ≤ i < d.

Implementation

Vectors are implemented by arrays of variables of type RT. All operations like creation, initialization, tests, vector arithmetic, input and output on a vector v take time O(v.dimension()). coordinate access, dimension() and conversions take constant time. The space requirement of a vector is O(v.dimension()).

Next: Direction_d<Kernel>

Navigation: Up Table of Contents Package Overview Bibliography Index Title Acknowledging CGAL

CGAL Open Source Project. Release 3.5. 1 October 2009.