songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #7660 from afabri/Arrangement-typo-GF 

Arrangement: small doc fixes
This commit is contained in:
Laurent Rineau 2023-09-07 10:46:26 +02:00
parent b32a8331ed 7f1d36c514
commit 6ce966767b
28 changed files with 94 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
Algebraic_foundations/doc/Algebraic_foundations/Algebraic_foundations.txt
View File

@ -169,8 +169,8 @@ Every \cgal `Kernel` comes with two <I>real number types</I>
(number types embeddable into the real numbers). One of them is a
`FieldNumberType`, and the other a `RingNumberType`. The
coordinates of the basic kernel objects (points, vectors, etc.) come
from one of these types (the `FieldNumberType` in case of Cartesian
kernels, and the `RingNumberType` for Homogeneous kernels).
from one of these types (the `FieldNumberType` in case of %Cartesian
kernels, and the `RingNumberType` for %Homogeneous kernels).
The concept `FieldNumberType` combines the requirements of the
concepts `Field` and `RealEmbeddable`, while
@ -277,4 +277,3 @@ subsequent chapters.
*/
} /* namespace CGAL */

3
Algebraic_foundations/doc/Algebraic_foundations/Concepts/FieldNumberType.h
View File

@ -5,7 +5,7 @@
The concept `FieldNumberType` combines the requirements of the concepts
`Field` and `RealEmbeddable`.
A model of `FieldNumberType` can be used as a template parameter
for Cartesian kernels.
for %Cartesian kernels.
\cgalRefines{Field,RealEmbeddable}
@ -32,4 +32,3 @@ public:
/// @}
}; /* end FieldNumberType */

3
Algebraic_foundations/doc/Algebraic_foundations/Concepts/RingNumberType.h
View File

@ -6,7 +6,7 @@
The concept `RingNumberType` combines the requirements of the concepts
`IntegralDomainWithoutDivision` and `RealEmbeddable`.
A model of `RingNumberType` can be used as a template parameter
for Homogeneous kernels.
for homogeneous kernels.
\cgalRefines{IntegralDomainWithoutDivision,RealEmbeddable}
@ -32,4 +32,3 @@ class RingNumberType {
public:
}; /* end RingNumberType */

8
Arrangement_on_surface_2/doc/Arrangement_on_surface_2/Arrangement_on_surface_2.txt
View File

@ -117,8 +117,8 @@ special type of objects. They must, however, supply the relevant
traits class, which mainly involves algebraic computations. A traits
class also encapsulates the number types used to represent coordinates
of geometric objects and to carry out algebraic operations on them. It
encapsulates the type of coordinate system used (e.g., Cartesian and
Homogeneous), and the geometric or algebraic computation methods
encapsulates the type of coordinate system used (e.g., %Cartesian and
homogeneous), and the geometric or algebraic computation methods
themselves. The precise minimal sets of requirements the actual traits
classes must conform to are organized as a hierarchy of concepts; see
Section \ref aos_sec-geom_traits.
@ -4780,7 +4780,7 @@ or line segments. The \link Arr_conic_traits_2::Curve_2
`Curve_2`\endlink and the derived \link
Arr_conic_traits_2::X_monotone_curve_2 `X_monotone_curve_2`\endlink
classes also support basic access functions such as `source()`,
`target()`, and `orientation()`.
`target()`, and `%orientation()`.
<!-- ------------------------------------------------------------------------- -->
\cgalFigureBegin{aos_fig-conics,conics.png}
@ -5067,7 +5067,7 @@ substitute the template parameters `RatKernel`, `AlgKernel`, and
the same requirements of the corresponding types used to instantiate
the `Arr_conic_traits_2` class template. Here, the use of the
`CORE_algebraic_number_traits` class is also recommended with
Cartesian kernels instantiated with the `Rational` and `Algebraic`
%Cartesian kernels instantiated with the `Rational` and `Algebraic`
number types defined by this class. The examples given in this manual
use the type definitions listed below. These types are defined in the
header file `arr_Bezier.h`.

2
Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_circle_segment_traits_2.h
View File

@ -168,7 +168,7 @@ public:
/*! The `Point_2` number-type nested within the traits class represents
* a Cartesian point whose coordinates are algebraic numbers of type
* a %Cartesian point whose coordinates are algebraic numbers of type
* `CoordNT`.
*/
class Point_2 {

2
Arrangement_on_surface_2/doc/Arrangement_on_surface_2/CGAL/Arr_conic_traits_2.h
View File

@ -274,7 +274,7 @@ public:
*/
Point_2(const Algebraic& hx, const Algebraic& hy, const Algebraic& hz);
/*! constructs from Cartesian coordinates.
/*! constructs from %Cartesian coordinates.
*/
Point_2(const Algebraic& x, const Algebraic& y);:

4
Barycentric_coordinates_2/doc/Barycentric_coordinates_2/Concepts/BarycentricTraits_2.h
View File

@ -159,7 +159,7 @@ typedef unspecified_type Less_xy_2;
`Comparison_result operator(const Point_2& p, const Point_2& q)`
that compares the Cartesian x-coordinates of the points `p` and `q`.
that compares the %Cartesian x-coordinates of the points `p` and `q`.
*/
typedef unspecified_type Compare_x_2;
@ -168,7 +168,7 @@ typedef unspecified_type Compare_x_2;
`Comparison_result operator(const Point_2& p, const Point_2& q)`
that compares the Cartesian y-coordinates of the points `p` and `q`.
that compares the %Cartesian y-coordinates of the points `p` and `q`.
*/
typedef unspecified_type Compare_y_2;

8
Bounding_volumes/doc/Bounding_volumes/CGAL/Approximate_min_ellipsoid_d.h
View File

@ -8,7 +8,7 @@ An object of class `Approximate_min_ellipsoid_d` is an approximation to the
ellipsoid of smallest volume enclosing a finite multiset of points
in \f$ d\f$-dimensional Euclidean space \f$ \E^d\f$, \f$ d\ge 2\f$.
An <I>ellipsoid</I> in \f$ \E^d\f$ is a Cartesian pointset of the form \f$ \{
An <I>ellipsoid</I> in \f$ \E^d\f$ is a %Cartesian pointset of the form \f$ \{
x\in\E^d \mid x^T E x + x^T e + \eta\leq 0 \}\f$, where \f$ E\f$ is some
positive definite matrix from the set \f$ \mathbb{R}^{d\times d}\f$, \f$ e\f$ is some
real \f$ d\f$-vector, and \f$ \eta\in\mathbb{R}\f$. A pointset \f$ P\subseteq \E^d\f$ is
@ -94,7 +94,7 @@ is actually achieved; the performance of the algorithm in this respect
highly depends on the input pointset. Values of at least \f$ 0.01\f$ for
\f$ \epsilon\f$ are usually handled without problems.
Internally, the algorithm represents the input points' Cartesian
Internally, the algorithm represents the input points' %Cartesian
coordinates as `double`'s. For this conversion to work, the input
point coordinates must be convertible to `double`. Also, in order
to compute the achieved epsilon \f$ \epsilon'\f$ mentioned above, the algorithm
@ -171,7 +171,7 @@ typedef unspecified_type Cartesian_const_iterator;
/*!
A model of STL concept
`RandomAccessIterator` with value type `double` that is used
to iterate over the Cartesian center coordinates of the computed
to iterate over the %Cartesian center coordinates of the computed
ellipsoid, see `center_cartesian_begin()`.
*/
typedef unspecified_type Center_coordinate_iterator;
@ -313,7 +313,7 @@ int dimension() const;
/*!
returns an iterator pointing to the first of the \f$ d\f$ Cartesian
returns an iterator pointing to the first of the \f$ d\f$ %Cartesian
coordinates of the computed ellipsoid's center.
The returned point is a floating-point approximation to the

2
Bounding_volumes/doc/Bounding_volumes/CGAL/Min_ellipse_2_traits_2.h
View File

@ -46,7 +46,7 @@ bool is_circle();
/*!
gives a double approximation of the
ellipse's conic equation. If `K` is a Cartesian kernel, the ellipse
ellipse's conic equation. If `K` is a %Cartesian kernel, the ellipse
is the set of all points \f$ (x,y)\f$ satisfying \f$ rx^2+sy^2+txy+ux+vy+w=0\f$. In the
Homogeneous case, the ellipse is the set of points \f$ (hx,hy,hw)\f$ satisfying
\f$ r(hx)^2+s(hy)^2+t(hx)(hy)+u(hx)(hw)+v(hy)(hw)+w(hw)^2=0\f$.

2
Bounding_volumes/doc/Bounding_volumes/CGAL/Min_sphere_of_spheres_d.h
View File

@ -90,7 +90,7 @@ be used in such a case. (For exact number types
Currently, we require `Traits::FT` to be either an exact number
type or `double` or `float`; other inexact number types are
not supported at this time. Also, the current implementation only
handles spheres with Cartesian coordinates; homogeneous representation
handles spheres with %Cartesian coordinates; homogeneous representation
is not supported yet.
\cgalHeading{Example}

2
Kernel_23/doc/Kernel_23/CGAL/Filtered_predicate.h
View File

@ -21,7 +21,7 @@ we use the function objects `C2E` and `C2F`, which must be of the form
\cgalHeading{Example}
The following example defines an efficient and exact version of the
orientation predicate over three points using the Cartesian representation
orientation predicate over three points using the %Cartesian representation
with double coordinates and without reference counting
(`Simple_cartesian::Point_2`).
Of course, the orientation predicate can already be found in the kernel, but

28
Kernel_23/doc/Kernel_23/CGAL/Kernel/global_functions.h
View File

@ -753,7 +753,7 @@ const CGAL::Point_3<Kernel>& r);
/// @{
/*!
Compares the Cartesian coordinates of points `p` and
Compares the %Cartesian coordinates of points `p` and
`q` lexicographically in \f$ xy\f$ order: first
\f$ x\f$-coordinates are compared, if they are equal, \f$ y\f$-coordinates
are compared. This is the same function as `compare_xy` and exists for compatibility with `Point_d<Kernel>`.
@ -763,7 +763,7 @@ Comparison_result
compare_lexicographically(const CGAL::Point_2<Kernel>& p, const CGAL::Point_2<Kernel>& q);
/*!
Compares the Cartesian coordinates of points `p` and
Compares the %Cartesian coordinates of points `p` and
`q` lexicographically in \f$ xyz\f$ order: first
\f$ x\f$-coordinates are compared, if they are equal, \f$ y\f$-coordinates
are compared, and if both \f$ x\f$- and \f$ y\f$- coordinate are equal,
@ -1144,7 +1144,7 @@ global function are available.
/// @{
/*!
Compares the Cartesian coordinates of points `p` and
Compares the %Cartesian coordinates of points `p` and
`q` lexicographically in \f$ xy\f$ order: first
\f$ x\f$-coordinates are compared, if they are equal, \f$ y\f$-coordinates
are compared.
@ -1154,7 +1154,7 @@ Comparison_result
compare_xy(const CGAL::Point_2<Kernel>& p, const CGAL::Point_2<Kernel>& q);
/*!
Compares the Cartesian coordinates of points `p` and `q`
Compares the %Cartesian coordinates of points `p` and `q`
lexicographically in \f$ xy\f$ order: first \f$ x\f$-coordinates are
compared, if they are equal, \f$ y\f$-coordinates are compared.
@ -1177,7 +1177,7 @@ compare_xy(const CGAL::Point_3<Kernel>& p, const CGAL::Point_3<Kernel>& q);
/// @{
/*!
Compares the \f$ x\f$ and \f$ y\f$ Cartesian coordinates of points `p` and
Compares the \f$ x\f$ and \f$ y\f$ %Cartesian coordinates of points `p` and
`q` lexicographically.
*/
template <typename CircularKernel>
@ -1186,7 +1186,7 @@ Comparison_result
const CGAL::Circular_arc_point_2<CircularKernel> &q);
/*!
Compares the \f$ x\f$ and \f$ y\f$ Cartesian coordinates of points `p` and
Compares the \f$ x\f$ and \f$ y\f$ %Cartesian coordinates of points `p` and
`q` lexicographically.
*/
template <typename CircularKernel>
@ -1209,7 +1209,7 @@ compare_xy(const CGAL::Circular_arc_point_2<CircularKernel> &p,
/*!
Compares the \f$ x\f$ and \f$ y\f$ Cartesian coordinates of points `p` and
Compares the \f$ x\f$ and \f$ y\f$ %Cartesian coordinates of points `p` and
`q` lexicographically.
*/
template <typename SphericalKernel>
@ -1218,7 +1218,7 @@ Comparison_result
const CGAL::Circular_arc_point_3<SphericalKernel> &q);
/*!
Compares the \f$ x\f$ and \f$ y\f$ Cartesian coordinates of points `p` and
Compares the \f$ x\f$ and \f$ y\f$ %Cartesian coordinates of points `p` and
`q` lexicographically.
*/
template <typename SphericalKernel>
@ -1442,13 +1442,13 @@ global function are available.
*/
/// @{
/*!
compares Cartesian \f$ y\f$-coordinates of `p` and `q`.
compares %Cartesian \f$ y\f$-coordinates of `p` and `q`.
*/
template <typename Kernel>
Comparison_result compare_y(const CGAL::Point_2<Kernel> &p,
const CGAL::Point_2<Kernel> &q);
/*!
compares Cartesian \f$ y\f$-coordinates of `p` and `q`.
compares %Cartesian \f$ y\f$-coordinates of `p` and `q`.
*/
template <typename Kernel>
Comparison_result compare_y(const CGAL::Point_3<Kernel> &p,
@ -1564,7 +1564,7 @@ global function are available.
/// @{
/*!
Compares the Cartesian coordinates of points `p` and
Compares the %Cartesian coordinates of points `p` and
`q` lexicographically in \f$ xyz\f$ order: first
\f$ x\f$-coordinates are compared, if they are equal, \f$ y\f$-coordinates
are compared, and if both \f$ x\f$- and \f$ y\f$- coordinate are equal,
@ -1587,7 +1587,7 @@ compare_xyz(const CGAL::Point_3<Kernel>& p, const CGAL::Point_3<Kernel>& q);
*/
/// @{
/*! Compares the Cartesian coordinates of points `p` and `q` lexicographically.
/*! Compares the %Cartesian coordinates of points `p` and `q` lexicographically.
*/
template <typename SphericalKernel>
Comparison_result
@ -1595,7 +1595,7 @@ compare_xyz(const CGAL::Circular_arc_point_3<SphericalKernel> &p,
const CGAL::Circular_arc_point_3<SphericalKernel> &q);
/*!
Compares the Cartesian coordinates of points `p` and `q` lexicographically.
Compares the %Cartesian coordinates of points `p` and `q` lexicographically.
*/
template <typename SphericalKernel>
Comparison_result
@ -1682,7 +1682,7 @@ compare_z(const CGAL::Circular_arc_point_3<SphericalKernel> &p, const CGAL::Poin
/// @{
/*!
Compares the Cartesian coordinates of points `p` and
Compares the %Cartesian coordinates of points `p` and
`q` lexicographically in \f$ yx\f$ order: first
\f$ y\f$-coordinates are compared, if they are equal, \f$ x\f$-coordinates
are compared.

12
Kernel_23/doc/Kernel_23/CGAL/Vector_2.h
View File

@ -13,7 +13,7 @@ will explicitly state where you can pass this constant as an argument
instead of a vector initialized with zeros.
\cgalModels `Kernel::Vector_2`
\cgalModels `Hashable` if `Kernel` is a cartesian kernel and if `Kernel::FT` is `Hashable`
\cgalModels `Hashable` if `Kernel` is a %Cartesian kernel and if `Kernel::FT` is `Hashable`
*/
template< typename Kernel >
@ -25,7 +25,7 @@ public:
/*!
An iterator for enumerating the
Cartesian coordinates of a vector.
%Cartesian coordinates of a vector.
*/
typedef unspecified_type Cartesian_const_iterator;
@ -119,7 +119,7 @@ Kernel::FT y() const;
/// \name Convenience Operators
/// The following operations are for convenience and for compatibility
/// with higher dimensional vectors. Again they come in a Cartesian
/// with higher dimensional vectors. Again they come in a %Cartesian
/// and homogeneous flavor.
/// @{
@ -131,7 +131,7 @@ returns the i'th homogeneous coordinate of `v`.
Kernel::RT homogeneous(int i) const;
/*!
returns the i'th Cartesian coordinate of `v`.
returns the i'th %Cartesian coordinate of `v`.
\pre `0 <= i <= 1`.
*/
Kernel::FT cartesian(int i) const;
@ -143,13 +143,13 @@ returns `cartesian(i)`.
Kernel::FT operator[](int i) const;
/*!
returns an iterator to the Cartesian coordinates
returns an iterator to the %Cartesian coordinates
of `v`, starting with the 0th coordinate.
*/
Cartesian_const_iterator cartesian_begin() const;
/*!
returns an off the end iterator to the Cartesian
returns an off the end iterator to the %Cartesian
coordinates of `v`.
*/
Cartesian_const_iterator cartesian_end() const;

68
Kernel_23/doc/Kernel_23/Concepts/FunctionObjectConcepts.h
View File

@ -478,7 +478,7 @@ public:
\ingroup PkgKernel23ConceptsFunctionObjects
\cgalConcept
A type representing an iterator to the Cartesian coordinates of a point
A type representing an iterator to the %Cartesian coordinates of a point
in two dimensions.
\cgalRefines{CopyConstructible,Assignable,DefaultConstructible}
@ -495,7 +495,7 @@ public:
\ingroup PkgKernel23ConceptsFunctionObjects
\cgalConcept
A type representing an iterator to the Cartesian coordinates of a point
A type representing an iterator to the %Cartesian coordinates of a point
in three dimensions.
\cgalRefines{CopyConstructible,Assignable,DefaultConstructible}
@ -1365,7 +1365,7 @@ public:
/// @{
/*!
Compares the Cartesian coordinates of points `p` and
Compares the %Cartesian coordinates of points `p` and
`q` lexicographically in \f$ xyz\f$ order: first
\f$ x\f$-coordinates are compared, if they are equal, \f$ y\f$-coordinates
are compared. If they are equal, \f$ z\f$-coordinates are compared.
@ -1395,7 +1395,7 @@ public:
/// @{
/*!
Compares the Cartesian coordinates of points `p` and
Compares the %Cartesian coordinates of points `p` and
`q` lexicographically in \f$ xy\f$ order: first
\f$ x\f$-coordinates are compared, if they are equal, \f$ y\f$-coordinates
are compared.
@ -1425,7 +1425,7 @@ public:
/*!
Compares the Cartesian coordinates of points `p` and
Compares the %Cartesian coordinates of points `p` and
`q` lexicographically in \f$ xy\f$ order: first
\f$ x\f$-coordinates are compared, if they are equal, \f$ y\f$-coordinates
are compared.
@ -1458,7 +1458,7 @@ public:
/// @{
/*!
compares the Cartesian \f$ x\f$-coordinates of points `p` and `q`
compares the %Cartesian \f$ x\f$-coordinates of points `p` and `q`
*/
Comparison_result operator()(const Kernel::Point_2&p,
const Kernel::Point_2&q);
@ -1514,7 +1514,7 @@ public:
/// @{
/*!
Compares the Cartesian \f$ x\f$-coordinates of points `p` and
Compares the %Cartesian \f$ x\f$-coordinates of points `p` and
`q`
*/
Comparison_result operator()(const Kernel::Point_3&p,
@ -1633,7 +1633,7 @@ public:
/// @{
/*!
Compares the Cartesian coordinates of points `p` and
Compares the %Cartesian coordinates of points `p` and
`q` lexicographically in \f$ yx\f$ order: first
\f$ y\f$-coordinates are compared, if they are equal, \f$ x\f$-coordinates
are compared.
@ -1666,7 +1666,7 @@ public:
/// @{
/*!
Compares the Cartesian \f$ y\f$-coordinates of points `p` and
Compares the %Cartesian \f$ y\f$-coordinates of points `p` and
`q`
*/
Comparison_result operator()(const Kernel::Point_2&p,
@ -1725,7 +1725,7 @@ public:
/// @{
/*!
Compares the Cartesian \f$ y\f$-coordinates of points `p` and
Compares the %Cartesian \f$ y\f$-coordinates of points `p` and
`q`
*/
Comparison_result operator()(const Kernel::Point_3&p,
@ -1752,7 +1752,7 @@ public:
/// @{
/*!
Compares the Cartesian \f$ z\f$-coordinates of points `p` and
Compares the %Cartesian \f$ z\f$-coordinates of points `p` and
`q`
*/
Comparison_result operator()(const Kernel::Point_3&p,
@ -3983,25 +3983,25 @@ public:
/*!
returns an iterator on the 0'th Cartesian coordinate of `p`.
returns an iterator on the 0'th %Cartesian coordinate of `p`.
*/
Kernel::Cartesian_const_iterator_2 operator()(const Kernel::Point_2
&p);
/*!
returns the past the end iterator of the Cartesian coordinates of `p`.
returns the past the end iterator of the %Cartesian coordinates of `p`.
*/
Kernel::Cartesian_const_iterator_2 operator()(const Kernel::Point_2
&p, int);
/*!
returns an iterator on the 0'th Cartesian coordinate of `v`.
returns an iterator on the 0'th %Cartesian coordinate of `v`.
*/
Kernel::Cartesian_const_iterator_2 operator()(const Kernel::Vector_2
&v);
/*!
returns the past the end iterator of the Cartesian coordinates of `v`.
returns the past the end iterator of the %Cartesian coordinates of `v`.
*/
Kernel::Cartesian_const_iterator_2 operator()(const Kernel::Vector_2
&v, int);
@ -4028,25 +4028,25 @@ public:
/// @{
/*!
returns an iterator on the 0'th Cartesian coordinate of `p`.
returns an iterator on the 0'th %Cartesian coordinate of `p`.
*/
Kernel::Cartesian_const_iterator_3 operator()(const Kernel::Point_3
&p);
/*!
returns the past the end iterator of the Cartesian coordinates of `p`.
returns the past the end iterator of the %Cartesian coordinates of `p`.
*/
Kernel::Cartesian_const_iterator_3 operator()(const Kernel::Point_3
&p, int);
/*!
returns an iterator on the 0'th Cartesian coordinate of `v`.
returns an iterator on the 0'th %Cartesian coordinate of `v`.
*/
Kernel::Cartesian_const_iterator_3 operator()(const Kernel::Vector_3
&v);
/*!
returns the past the end iterator of the Cartesian coordinates of `v`.
returns the past the end iterator of the %Cartesian coordinates of `v`.
*/
Kernel::Cartesian_const_iterator_3 operator()(const Kernel::Vector_3
&v, int);
@ -5992,7 +5992,7 @@ public:
/// @{
/*!
introduces a variable with Cartesian coordinates
introduces a variable with %Cartesian coordinates
\f$ (0,0)\f$.
*/
Kernel::Point_2 operator()(const CGAL::Origin &CGAL::ORIGIN);
@ -6033,7 +6033,7 @@ public:
/// @{
/*!
introduces a point with Cartesian coordinates\f$ (0,0,0)\f$.
introduces a point with %Cartesian coordinates\f$ (0,0,0)\f$.
*/
Kernel::Point_3 operator()(const CGAL::Origin &CGAL::ORIGIN);
@ -7287,19 +7287,19 @@ public:
/// @{
/*!
introduces a weighted point with Cartesian coordinates
introduces a weighted point with %Cartesian coordinates
\f$ (0,0)\f$ and weight \f$ 0 \f$.
*/
Kernel::Weighted_point_2 operator()(const CGAL::Origin &CGAL::ORIGIN);
/*!
introduces a weighted point with Cartesian coordinates
introduces a weighted point with %Cartesian coordinates
those of \f$ p \f$ and weight \f$ 0 \f$.
*/
Kernel::Weighted_point_2 operator()(const Kernel::Point_2& p);
/*!
introduces a weighted point with Cartesian coordinates
introduces a weighted point with %Cartesian coordinates
those of \f$ p \f$ and weight \f$ w \f$.
*/
Kernel::Weighted_point_2 operator()(const Kernel::Point_2& p, const Kernel::FT& w);
@ -7325,19 +7325,19 @@ public:
/// @{
/*!
introduces a weighted point with Cartesian coordinates
introduces a weighted point with %Cartesian coordinates
\f$ (0,0,0)\f$ and weight \f$ 0 \f$.
*/
Kernel::Weighted_point_3 operator()(const CGAL::Origin &CGAL::ORIGIN);
/*!
introduces a weighted point with Cartesian coordinates
introduces a weighted point with %Cartesian coordinates
those of \f$ p \f$ and weight \f$ 0 \f$.
*/
Kernel::Weighted_point_3 operator()(const Kernel::Point_3& p);
/*!
introduces a weighted point with Cartesian coordinates
introduces a weighted point with %Cartesian coordinates
those of \f$ p \f$ and weight \f$ w \f$.
*/
Kernel::Weighted_point_3 operator()(const Kernel::Point_3& p, const Kernel::FT& w);
@ -7590,8 +7590,8 @@ public:
/*!
returns true iff `p` and `q` have the same Cartesian \f$ x\f$-coordinate
and the same Cartesian \f$ y\f$-coordinate.
returns true iff `p` and `q` have the same %Cartesian \f$ x\f$-coordinate
and the same %Cartesian \f$ y\f$-coordinate.
*/
bool operator()(const Kernel::Point_3&p,
const Kernel::Point_3&q);
@ -7617,7 +7617,7 @@ public:
/// @{
/*!
returns true iff `p` and `q` have the same Cartesian \f$ x\f$-coordinate.
returns true iff `p` and `q` have the same %Cartesian \f$ x\f$-coordinate.
*/
bool operator()(const Kernel::Point_2&p,
const Kernel::Point_2&q);
@ -7643,7 +7643,7 @@ public:
/// @{
/*!
returns true iff `p` and `q` have the same Cartesian \f$ x\f$-coordinate.
returns true iff `p` and `q` have the same %Cartesian \f$ x\f$-coordinate.
*/
bool operator()(const Kernel::Point_3&p,
const Kernel::Point_3&q);
@ -7669,7 +7669,7 @@ public:
/// @{
/*!
returns true iff `p` and `q` have the same Cartesian \f$ y\f$-coordinate.
returns true iff `p` and `q` have the same %Cartesian \f$ y\f$-coordinate.
*/
bool operator()(const Kernel::Point_2&p,
const Kernel::Point_2&q);
@ -7695,7 +7695,7 @@ public:
/// @{
/*!
returns true iff `p` and `q` have the same Cartesian \f$ y\f$-coordinate.
returns true iff `p` and `q` have the same %Cartesian \f$ y\f$-coordinate.
*/
bool operator()(const Kernel::Point_3&p,
const Kernel::Point_3&q);
@ -7721,7 +7721,7 @@ public:
/// @{
/*!
returns true iff `p` and `q` have the same Cartesian \f$ z\f$-coordinate.
returns true iff `p` and `q` have the same %Cartesian \f$ z\f$-coordinate.
*/
bool operator()(const Kernel::Point_3&p,
const Kernel::Point_3&q);

4
Kernel_d/doc/Kernel_d/CGAL/Epeck_d.h
View File

@ -79,9 +79,9 @@ Point_d(ForwardIterator first, ForwardIterator end);
\pre `i` is non-negative and less than the dimension. */
double operator[](int i)const;
/*! returns an iterator pointing to the zeroth Cartesian coordinate. */
/*! returns an iterator pointing to the zeroth %Cartesian coordinate. */
Cartesian_const_iterator_d cartesian_begin()const;
/*! returns an iterator pointing beyond the last Cartesian coordinate. */
/*! returns an iterator pointing beyond the last %Cartesian coordinate. */
Cartesian_const_iterator_d cartesian_end()const;
};

3
Kernel_d/doc/Kernel_d/Concepts/Kernel--CartesianConstIterator_d.h
View File

@ -3,7 +3,7 @@
\ingroup PkgKernelDKernelConcept
\cgalConcept
A type representing an iterator to the Cartesian coordinates of a point
A type representing an iterator to the %Cartesian coordinates of a point
in `d` dimensions.
\cgalRefines{CopyConstructible,Assignable,DefaultConstructible}
@ -18,4 +18,3 @@ class Kernel_d::CartesianConstIterator_d {
public:
}; /* end Kernel_d::CartesianConstIterator_d */

3
Nef_2/doc/Nef_2/Concepts/ExtendedKernelTraits_2.h
View File

@ -8,7 +8,7 @@ geometry\cgalFootnote{It is called extended geometry for simplicity,
though it is not a real geometry in the classical sense}. Let `K` be
an instance of the data type `ExtendedKernelTraits_2`. The central
notion of extended geometry are extended points. An extended point
represents either a standard affine point of the Cartesian plane or a
represents either a standard affine point of the %Cartesian plane or a
non-standard point representing the equivalence class of rays where
two rays are equivalent if one is contained in the other.
@ -353,4 +353,3 @@ const char* output_identifier() ;
/// @}
}; /* end ExtendedKernelTraits_2 */

2
Nef_3/doc/Nef_3/Nef_3.txt
View File

@ -448,7 +448,7 @@ We recommend the use of the \cgal kernels `Homogeneous`,
The homogeneous kernel provides reliable fast performance. In combination with
`leda_integer` it is the fastest kernel for `Nef_polyhedron_3`. The
`Exact_predicates_exact_constructions_kernel` uses filtering. In non-degenerate
scenarios it's faster than the Homogeneous kernel. The most
scenarios it's faster than the homogeneous kernel. The most
important advantage of the filtered kernel is that it is a %Cartesian
kernel, which allows the proper handling of OFF files using
floating-point coordinates.

4
Number_types/doc/Number_types/NumberTypeSupport.txt
View File

@ -120,7 +120,7 @@ To use these classes, \gmp and \mpfr must be installed.
\anchor ledant
\leda provides number types that can be used for exact computation
with both Cartesian and homogeneous representations. If you are using
with both %Cartesian and homogeneous representations. If you are using
homogeneous representation with the built-in integer types
`short`, `int`, and `long` as ring type, exactness of
computations can be guaranteed only if your input data come from a
@ -130,7 +130,7 @@ integers of arbitrary length. (Of course the length is
somehow bounded by the resources of your computer.) It can be used as
ring type in homogeneous kernels and leads to exact
computation as long as all intermediate results are rational. For the
same kind of problems, Cartesian representation with number type
same kind of problems, %Cartesian representation with number type
`leda_rational` leads to exact computation as well.
The number type `leda_bigfloat` in \leda is a variable precision
floating-point type. Rounding mode and precision (i.e.\ mantissa length) of

2
Polygon_mesh_processing/doc/Polygon_mesh_processing/Concepts/PMPDistanceTraits.h
View File

@ -19,7 +19,7 @@ public:
/*! 3D point type
* It must be default constructible, and can be constructed from 3 objects of type `FT`.
* `bool operator<(Point_3, Point_3)` to lexicographically compare two points must be available.
* Access to Cartesian coordinates must be possible using `Point_3::x()`, `Point_3::y(), Point_3::z()` and
* Access to %Cartesian coordinates must be possible using `Point_3::x()`, `Point_3::y(), Point_3::z()` and
* `FT operator[](int i)` with `0 <= i < 3`.
*
* There must be a specialization of `CGAL::Kernel_traits` such that

5
Polynomial/doc/Polynomial/Concepts/PolynomialTraits_d--IsZeroAt.h
View File

@ -4,7 +4,7 @@
\cgalConcept
This `AdaptableFunctor` returns whether a
`PolynomialTraits_d::Polynomial_d` \f$ p\f$ is zero at a given Cartesian point,
`PolynomialTraits_d::Polynomial_d` \f$ p\f$ is zero at a given %Cartesian point,
which is represented as an iterator range.
\cgalRefines{AdaptableFunctor,CopyConstructible,DefaultConstructible}
@ -32,7 +32,7 @@ typedef bool result_type;
/*!
Computes whether \f$ p\f$ is zero at the Cartesian point given by the iterator range,
Computes whether \f$ p\f$ is zero at the %Cartesian point given by the iterator range,
where `begin` is referring to the innermost variable.
\pre (end-begin == `PolynomialTraits_d::d`)
@ -47,4 +47,3 @@ InputIterator end );
/// @}
}; /* end PolynomialTraits_d::IsZeroAt */

5
Polynomial/doc/Polynomial/Concepts/PolynomialTraits_d--SignAt.h
View File

@ -4,7 +4,7 @@
\cgalConcept
This `AdaptableFunctor` returns the sign of a
`PolynomialTraits_d::Polynomial_d` \f$ p\f$ at given Cartesian point represented
`PolynomialTraits_d::Polynomial_d` \f$ p\f$ at given %Cartesian point represented
as an iterator range.
This functor is well defined if `PolynomialTraits_d::Innermost_coefficient_type` is
@ -35,7 +35,7 @@ typedef CGAL::Sign result_type;
/*!
Returns the sign of \f$ p\f$ at the given Cartesian point, where `begin` is referring
Returns the sign of \f$ p\f$ at the given %Cartesian point, where `begin` is referring
to the innermost variable.
\pre (`end-begin` == `PolynomialTraits_d::d`)
\pre `std::iterator_traits< InputIterator >::%value_type` is `ExplicitInteroperable` with `PolynomialTraits_d::Innermost_coefficient_type`.
@ -49,4 +49,3 @@ InputIterator end );
/// @}
}; /* end PolynomialTraits_d::SignAt */

8
Shape_detection/doc/Shape_detection/Concepts/EfficientRANSACTraits.h
View File

@ -39,7 +39,7 @@ public:
/// The 2D vector type, only required if you want to detect tori
typedef unspecified_type Vector_2;
/// The number type of the Cartesian coordinates of types Point_3
/// The number type of the %Cartesian coordinates of types Point_3
typedef unspecified_type FT;
/// A model of the concept `Range` with random access iterators, providing input points and normals
@ -63,9 +63,9 @@ public:
/*!
* Function object type that provides
* `Point_3 operator()(Origin p)`
* returning the point with 0, 0, 0 as Cartesian coordinates
* returning the point with 0, 0, 0 as %Cartesian coordinates
* and `Point_3 operator()(FT x, FT y, FT z)`
* returning the point with `x`, `y` and `z` as Cartesian coordinates.
* returning the point with `x`, `y` and `z` as %Cartesian coordinates.
*/
typedef unspecified_type Construct_point_3;
@ -106,7 +106,7 @@ public:
/*!
* Function object type that provides
* `Point_2 operator()(FT x, FT y)`
* returning the 2D point with `x` and `y` as Cartesian coordinates.
* returning the 2D point with `x` and `y` as %Cartesian coordinates.
* Only required if you want to detect tori.
*/
typedef unspecified_type Construct_point_2;

2
Spatial_searching/doc/Spatial_searching/CGAL/Fuzzy_sphere.h
View File

@ -76,7 +76,7 @@ less than \f$ r\f$.
bool contains(const Point_d& p) const;
/*!
Test whether the fuzzy sphere contains the point whose Cartesian coordinates
Test whether the fuzzy sphere contains the point whose %Cartesian coordinates
are contained in the range [`begin`, `end`).
*/
template <typename Coord_iterator>

2
Spatial_searching/doc/Spatial_searching/Concepts/FuzzyQueryItem.h
View File

@ -43,7 +43,7 @@ bool contains(Point_d p) const;
/*!
\note Optional: must be defined when used with a `Kd_tree` where `EnablePointsCache` is set to `Tag_true`.
tests whether the query item contains the point whose Cartesian coordinates
tests whether the query item contains the point whose %Cartesian coordinates
are contained in the range [`begin`, `end`).
*/
template <typename Coord_iterator>

3
Stream_support/doc/Stream_support/IOstream.txt
View File

@ -69,7 +69,7 @@ as a sequence of four byte. The format depends on the machine.
The mode `PRETTY`
serves mainly for debugging as the type of the geometric
object is written, as well as the data defining the object. For example
for a point at the origin with Cartesian double coordinates, the output
for a point at the origin with %Cartesian double coordinates, the output
would be `PointC2(0.0, 0.0)`. At the moment \cgal does not
provide input operations for pretty printed data. By default a stream
is in \ascii mode.
@ -519,4 +519,3 @@ which might look as follows:
*/
} /* namespace CGAL */

2
Surface_mesh_deformation/doc/Surface_mesh_deformation/Concepts/RawPoint_3.h
View File

@ -9,7 +9,7 @@ class RawPoint_3
public:
/// \name Creation
/// @{
/// constructor from Cartesian coordinates
/// constructor from %Cartesian coordinates
RawPoint_3(double x, double y, double z);
/// @}

3
Surface_mesh_skeletonization/doc/Surface_mesh_skeletonization/Concepts/MeanCurvatureSkeletonizationTraits.h
View File

@ -28,7 +28,7 @@ typedef unspecified_type FT;
/*!
* Function object type that provides
* `Point_3 operator()(FT x, FT y, FT z) const`
* returning the point with `x`, `y` and `z` as Cartesian coordinates.
* returning the point with `x`, `y` and `z` as %Cartesian coordinates.
*/
typedef unspecified_type Construct_point_3;
@ -186,4 +186,3 @@ compute_z_3_object();
/// @}
}; /* end DelaunayTriangulationTraits_2 */