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 (number types embeddable into the real numbers). One of them is a
`FieldNumberType`, and the other a `RingNumberType`. The `FieldNumberType`, and the other a `RingNumberType`. The
coordinates of the basic kernel objects (points, vectors, etc.) come coordinates of the basic kernel objects (points, vectors, etc.) come
from one of these types (the `FieldNumberType` in case of Cartesian from one of these types (the `FieldNumberType` in case of %Cartesian
kernels, and the `RingNumberType` for Homogeneous kernels). kernels, and the `RingNumberType` for %Homogeneous kernels).
The concept `FieldNumberType` combines the requirements of the The concept `FieldNumberType` combines the requirements of the
concepts `Field` and `RealEmbeddable`, while concepts `Field` and `RealEmbeddable`, while
@ -277,4 +277,3 @@ subsequent chapters.
*/ */
} /* namespace CGAL */ } /* 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 The concept `FieldNumberType` combines the requirements of the concepts
`Field` and `RealEmbeddable`. `Field` and `RealEmbeddable`.
A model of `FieldNumberType` can be used as a template parameter A model of `FieldNumberType` can be used as a template parameter
for Cartesian kernels. for %Cartesian kernels.
\cgalRefines{Field,RealEmbeddable} \cgalRefines{Field,RealEmbeddable}
@ -32,4 +32,3 @@ public:
/// @} /// @}
}; /* end FieldNumberType */ }; /* 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 The concept `RingNumberType` combines the requirements of the concepts
`IntegralDomainWithoutDivision` and `RealEmbeddable`. `IntegralDomainWithoutDivision` and `RealEmbeddable`.
A model of `RingNumberType` can be used as a template parameter A model of `RingNumberType` can be used as a template parameter
for Homogeneous kernels. for homogeneous kernels.
\cgalRefines{IntegralDomainWithoutDivision,RealEmbeddable} \cgalRefines{IntegralDomainWithoutDivision,RealEmbeddable}
@ -32,4 +32,3 @@ class RingNumberType {
public: public:
}; /* end RingNumberType */ }; /* 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 traits class, which mainly involves algebraic computations. A traits
class also encapsulates the number types used to represent coordinates class also encapsulates the number types used to represent coordinates
of geometric objects and to carry out algebraic operations on them. It of geometric objects and to carry out algebraic operations on them. It
encapsulates the type of coordinate system used (e.g., Cartesian and encapsulates the type of coordinate system used (e.g., %Cartesian and
Homogeneous), and the geometric or algebraic computation methods homogeneous), and the geometric or algebraic computation methods
themselves. The precise minimal sets of requirements the actual traits themselves. The precise minimal sets of requirements the actual traits
classes must conform to are organized as a hierarchy of concepts; see classes must conform to are organized as a hierarchy of concepts; see
Section \ref aos_sec-geom_traits. 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 `Curve_2`\endlink and the derived \link
Arr_conic_traits_2::X_monotone_curve_2 `X_monotone_curve_2`\endlink Arr_conic_traits_2::X_monotone_curve_2 `X_monotone_curve_2`\endlink
classes also support basic access functions such as `source()`, classes also support basic access functions such as `source()`,
`target()`, and `orientation()`. `target()`, and `%orientation()`.
<!-- ------------------------------------------------------------------------- --> <!-- ------------------------------------------------------------------------- -->
\cgalFigureBegin{aos_fig-conics,conics.png} \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 same requirements of the corresponding types used to instantiate
the `Arr_conic_traits_2` class template. Here, the use of the the `Arr_conic_traits_2` class template. Here, the use of the
`CORE_algebraic_number_traits` class is also recommended with `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 number types defined by this class. The examples given in this manual
use the type definitions listed below. These types are defined in the use the type definitions listed below. These types are defined in the
header file `arr_Bezier.h`. 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 /*! 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`. * `CoordNT`.
*/ */
class Point_2 { 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); 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);: 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)` `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; 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)` `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; 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 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$. 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 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 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 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 highly depends on the input pointset. Values of at least \f$ 0.01\f$ for
\f$ \epsilon\f$ are usually handled without problems. \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 coordinates as `double`'s. For this conversion to work, the input
point coordinates must be convertible to `double`. Also, in order point coordinates must be convertible to `double`. Also, in order
to compute the achieved epsilon \f$ \epsilon'\f$ mentioned above, the algorithm 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 A model of STL concept
`RandomAccessIterator` with value type `double` that is used `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()`. ellipsoid, see `center_cartesian_begin()`.
*/ */
typedef unspecified_type Center_coordinate_iterator; 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. coordinates of the computed ellipsoid's center.
The returned point is a floating-point approximation to the 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 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 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 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$. \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 Currently, we require `Traits::FT` to be either an exact number
type or `double` or `float`; other inexact number types are type or `double` or `float`; other inexact number types are
not supported at this time. Also, the current implementation only 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. is not supported yet.
\cgalHeading{Example} \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} \cgalHeading{Example}
The following example defines an efficient and exact version of the 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 with double coordinates and without reference counting
(`Simple_cartesian::Point_2`). (`Simple_cartesian::Point_2`).
Of course, the orientation predicate can already be found in the kernel, but 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 `q` lexicographically in \f$ xy\f$ order: first
\f$ x\f$-coordinates are compared, if they are equal, \f$ y\f$-coordinates \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>`. 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); 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 `q` lexicographically in \f$ xyz\f$ order: first
\f$ x\f$-coordinates are compared, if they are equal, \f$ y\f$-coordinates \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, 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 `q` lexicographically in \f$ xy\f$ order: first
\f$ x\f$-coordinates are compared, if they are equal, \f$ y\f$-coordinates \f$ x\f$-coordinates are compared, if they are equal, \f$ y\f$-coordinates
are compared. are compared.
@ -1154,7 +1154,7 @@ Comparison_result
compare_xy(const CGAL::Point_2<Kernel>& p, const CGAL::Point_2<Kernel>& q); 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 lexicographically in \f$ xy\f$ order: first \f$ x\f$-coordinates are
compared, if they are equal, \f$ y\f$-coordinates are compared. 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. `q` lexicographically.
*/ */
template <typename CircularKernel> template <typename CircularKernel>
@ -1186,7 +1186,7 @@ Comparison_result
const CGAL::Circular_arc_point_2<CircularKernel> &q); 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. `q` lexicographically.
*/ */
template <typename CircularKernel> 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. `q` lexicographically.
*/ */
template <typename SphericalKernel> template <typename SphericalKernel>
@ -1218,7 +1218,7 @@ Comparison_result
const CGAL::Circular_arc_point_3<SphericalKernel> &q); 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. `q` lexicographically.
*/ */
template <typename SphericalKernel> 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> template <typename Kernel>
Comparison_result compare_y(const CGAL::Point_2<Kernel> &p, Comparison_result compare_y(const CGAL::Point_2<Kernel> &p,
const CGAL::Point_2<Kernel> &q); 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> template <typename Kernel>
Comparison_result compare_y(const CGAL::Point_3<Kernel> &p, 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 `q` lexicographically in \f$ xyz\f$ order: first
\f$ x\f$-coordinates are compared, if they are equal, \f$ y\f$-coordinates \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, 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> template <typename SphericalKernel>
Comparison_result Comparison_result
@ -1595,7 +1595,7 @@ compare_xyz(const CGAL::Circular_arc_point_3<SphericalKernel> &p,
const CGAL::Circular_arc_point_3<SphericalKernel> &q); 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> template <typename SphericalKernel>
Comparison_result 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 `q` lexicographically in \f$ yx\f$ order: first
\f$ y\f$-coordinates are compared, if they are equal, \f$ x\f$-coordinates \f$ y\f$-coordinates are compared, if they are equal, \f$ x\f$-coordinates
are compared. 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. instead of a vector initialized with zeros.
\cgalModels `Kernel::Vector_2` \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 > template< typename Kernel >
@ -25,7 +25,7 @@ public:
/*! /*!
An iterator for enumerating the An iterator for enumerating the
Cartesian coordinates of a vector. %Cartesian coordinates of a vector.
*/ */
typedef unspecified_type Cartesian_const_iterator; typedef unspecified_type Cartesian_const_iterator;
@ -119,7 +119,7 @@ Kernel::FT y() const;
/// \name Convenience Operators /// \name Convenience Operators
/// The following operations are for convenience and for compatibility /// 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. /// and homogeneous flavor.
/// @{ /// @{
@ -131,7 +131,7 @@ returns the i'th homogeneous coordinate of `v`.
Kernel::RT homogeneous(int i) const; 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`. \pre `0 <= i <= 1`.
*/ */
Kernel::FT cartesian(int i) const; Kernel::FT cartesian(int i) const;
@ -143,13 +143,13 @@ returns `cartesian(i)`.
Kernel::FT operator[](int i) const; 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. of `v`, starting with the 0th coordinate.
*/ */
Cartesian_const_iterator cartesian_begin() const; 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`. coordinates of `v`.
*/ */
Cartesian_const_iterator cartesian_end() const; Cartesian_const_iterator cartesian_end() const;

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

@ -478,7 +478,7 @@ public:
\ingroup PkgKernel23ConceptsFunctionObjects \ingroup PkgKernel23ConceptsFunctionObjects
\cgalConcept \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. in two dimensions.
\cgalRefines{CopyConstructible,Assignable,DefaultConstructible} \cgalRefines{CopyConstructible,Assignable,DefaultConstructible}
@ -495,7 +495,7 @@ public:
\ingroup PkgKernel23ConceptsFunctionObjects \ingroup PkgKernel23ConceptsFunctionObjects
\cgalConcept \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. in three dimensions.
\cgalRefines{CopyConstructible,Assignable,DefaultConstructible} \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 `q` lexicographically in \f$ xyz\f$ order: first
\f$ x\f$-coordinates are compared, if they are equal, \f$ y\f$-coordinates \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. 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 `q` lexicographically in \f$ xy\f$ order: first
\f$ x\f$-coordinates are compared, if they are equal, \f$ y\f$-coordinates \f$ x\f$-coordinates are compared, if they are equal, \f$ y\f$-coordinates
are compared. 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 `q` lexicographically in \f$ xy\f$ order: first
\f$ x\f$-coordinates are compared, if they are equal, \f$ y\f$-coordinates \f$ x\f$-coordinates are compared, if they are equal, \f$ y\f$-coordinates
are compared. 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, Comparison_result operator()(const Kernel::Point_2&p,
const Kernel::Point_2&q); 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` `q`
*/ */
Comparison_result operator()(const Kernel::Point_3&p, 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 `q` lexicographically in \f$ yx\f$ order: first
\f$ y\f$-coordinates are compared, if they are equal, \f$ x\f$-coordinates \f$ y\f$-coordinates are compared, if they are equal, \f$ x\f$-coordinates
are compared. 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` `q`
*/ */
Comparison_result operator()(const Kernel::Point_2&p, 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` `q`
*/ */
Comparison_result operator()(const Kernel::Point_3&p, 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` `q`
*/ */
Comparison_result operator()(const Kernel::Point_3&p, 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 Kernel::Cartesian_const_iterator_2 operator()(const Kernel::Point_2
&p); &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 Kernel::Cartesian_const_iterator_2 operator()(const Kernel::Point_2
&p, int); &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 Kernel::Cartesian_const_iterator_2 operator()(const Kernel::Vector_2
&v); &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 Kernel::Cartesian_const_iterator_2 operator()(const Kernel::Vector_2
&v, int); &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 Kernel::Cartesian_const_iterator_3 operator()(const Kernel::Point_3
&p); &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 Kernel::Cartesian_const_iterator_3 operator()(const Kernel::Point_3
&p, int); &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 Kernel::Cartesian_const_iterator_3 operator()(const Kernel::Vector_3
&v); &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 Kernel::Cartesian_const_iterator_3 operator()(const Kernel::Vector_3
&v, int); &v, int);
@ -5992,7 +5992,7 @@ public:
/// @{ /// @{
/*! /*!
introduces a variable with Cartesian coordinates introduces a variable with %Cartesian coordinates
\f$ (0,0)\f$. \f$ (0,0)\f$.
*/ */
Kernel::Point_2 operator()(const CGAL::Origin &CGAL::ORIGIN); 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); 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$. \f$ (0,0)\f$ and weight \f$ 0 \f$.
*/ */
Kernel::Weighted_point_2 operator()(const CGAL::Origin &CGAL::ORIGIN); 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$. those of \f$ p \f$ and weight \f$ 0 \f$.
*/ */
Kernel::Weighted_point_2 operator()(const Kernel::Point_2& p); 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$. those of \f$ p \f$ and weight \f$ w \f$.
*/ */
Kernel::Weighted_point_2 operator()(const Kernel::Point_2& p, const Kernel::FT& w); 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$. \f$ (0,0,0)\f$ and weight \f$ 0 \f$.
*/ */
Kernel::Weighted_point_3 operator()(const CGAL::Origin &CGAL::ORIGIN); 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$. those of \f$ p \f$ and weight \f$ 0 \f$.
*/ */
Kernel::Weighted_point_3 operator()(const Kernel::Point_3& p); 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$. those of \f$ p \f$ and weight \f$ w \f$.
*/ */
Kernel::Weighted_point_3 operator()(const Kernel::Point_3& p, const Kernel::FT& w); 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 returns true iff `p` and `q` have the same %Cartesian \f$ x\f$-coordinate
and the same Cartesian \f$ y\f$-coordinate. and the same %Cartesian \f$ y\f$-coordinate.
*/ */
bool operator()(const Kernel::Point_3&p, bool operator()(const Kernel::Point_3&p,
const Kernel::Point_3&q); 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, bool operator()(const Kernel::Point_2&p,
const Kernel::Point_2&q); 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, bool operator()(const Kernel::Point_3&p,
const Kernel::Point_3&q); 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, bool operator()(const Kernel::Point_2&p,
const Kernel::Point_2&q); 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, bool operator()(const Kernel::Point_3&p,
const Kernel::Point_3&q); 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, bool operator()(const Kernel::Point_3&p,
const Kernel::Point_3&q); 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. */ \pre `i` is non-negative and less than the dimension. */
double operator[](int i)const; 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; 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; 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 \ingroup PkgKernelDKernelConcept
\cgalConcept \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. in `d` dimensions.
\cgalRefines{CopyConstructible,Assignable,DefaultConstructible} \cgalRefines{CopyConstructible,Assignable,DefaultConstructible}
@ -18,4 +18,3 @@ class Kernel_d::CartesianConstIterator_d {
public: public:
}; /* end Kernel_d::CartesianConstIterator_d */ }; /* 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 though it is not a real geometry in the classical sense}. Let `K` be
an instance of the data type `ExtendedKernelTraits_2`. The central an instance of the data type `ExtendedKernelTraits_2`. The central
notion of extended geometry are extended points. An extended point 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 non-standard point representing the equivalence class of rays where
two rays are equivalent if one is contained in the other. two rays are equivalent if one is contained in the other.
@ -353,4 +353,3 @@ const char* output_identifier() ;
/// @} /// @}
}; /* end ExtendedKernelTraits_2 */ }; /* 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 The homogeneous kernel provides reliable fast performance. In combination with
`leda_integer` it is the fastest kernel for `Nef_polyhedron_3`. The `leda_integer` it is the fastest kernel for `Nef_polyhedron_3`. The
`Exact_predicates_exact_constructions_kernel` uses filtering. In non-degenerate `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 important advantage of the filtered kernel is that it is a %Cartesian
kernel, which allows the proper handling of OFF files using kernel, which allows the proper handling of OFF files using
floating-point coordinates. 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 \anchor ledant
\leda provides number types that can be used for exact computation \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 homogeneous representation with the built-in integer types
`short`, `int`, and `long` as ring type, exactness of `short`, `int`, and `long` as ring type, exactness of
computations can be guaranteed only if your input data come from a 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 somehow bounded by the resources of your computer.) It can be used as
ring type in homogeneous kernels and leads to exact ring type in homogeneous kernels and leads to exact
computation as long as all intermediate results are rational. For the 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. `leda_rational` leads to exact computation as well.
The number type `leda_bigfloat` in \leda is a variable precision The number type `leda_bigfloat` in \leda is a variable precision
floating-point type. Rounding mode and precision (i.e.\ mantissa length) of 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 /*! 3D point type
* It must be default constructible, and can be constructed from 3 objects of type `FT`. * 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. * `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`. * `FT operator[](int i)` with `0 <= i < 3`.
* *
* There must be a specialization of `CGAL::Kernel_traits` such that * 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 \cgalConcept
This `AdaptableFunctor` returns whether a 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. which is represented as an iterator range.
\cgalRefines{AdaptableFunctor,CopyConstructible,DefaultConstructible} \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. where `begin` is referring to the innermost variable.
\pre (end-begin == `PolynomialTraits_d::d`) \pre (end-begin == `PolynomialTraits_d::d`)
@ -47,4 +47,3 @@ InputIterator end );
/// @} /// @}
}; /* end PolynomialTraits_d::IsZeroAt */ }; /* end PolynomialTraits_d::IsZeroAt */

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

@ -4,7 +4,7 @@
\cgalConcept \cgalConcept
This `AdaptableFunctor` returns the sign of a 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. as an iterator range.
This functor is well defined if `PolynomialTraits_d::Innermost_coefficient_type` is 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. to the innermost variable.
\pre (`end-begin` == `PolynomialTraits_d::d`) \pre (`end-begin` == `PolynomialTraits_d::d`)
\pre `std::iterator_traits< InputIterator >::%value_type` is `ExplicitInteroperable` with `PolynomialTraits_d::Innermost_coefficient_type`. \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 */ }; /* 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 /// The 2D vector type, only required if you want to detect tori
typedef unspecified_type Vector_2; 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; typedef unspecified_type FT;
/// A model of the concept `Range` with random access iterators, providing input points and normals /// 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 * Function object type that provides
* `Point_3 operator()(Origin p)` * `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)` * 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; typedef unspecified_type Construct_point_3;
@ -106,7 +106,7 @@ public:
/*! /*!
* Function object type that provides * Function object type that provides
* `Point_2 operator()(FT x, FT y)` * `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. * Only required if you want to detect tori.
*/ */
typedef unspecified_type Construct_point_2; 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; 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`). are contained in the range [`begin`, `end`).
*/ */
template <typename Coord_iterator> 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`. \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`). are contained in the range [`begin`, `end`).
*/ */
template <typename Coord_iterator> 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` The mode `PRETTY`
serves mainly for debugging as the type of the geometric serves mainly for debugging as the type of the geometric
object is written, as well as the data defining the object. For example 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 would be `PointC2(0.0, 0.0)`. At the moment \cgal does not
provide input operations for pretty printed data. By default a stream provide input operations for pretty printed data. By default a stream
is in \ascii mode. is in \ascii mode.
@ -519,4 +519,3 @@ which might look as follows:
*/ */
} /* namespace CGAL */ } /* namespace CGAL */

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

@ -9,7 +9,7 @@ class RawPoint_3
public: public:
/// \name Creation /// \name Creation
/// @{ /// @{
/// constructor from Cartesian coordinates /// constructor from %Cartesian coordinates
RawPoint_3(double x, double y, double z); 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 * Function object type that provides
* `Point_3 operator()(FT x, FT y, FT z) const` * `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; typedef unspecified_type Construct_point_3;
@ -186,4 +186,3 @@ compute_z_3_object();
/// @} /// @}
}; /* end DelaunayTriangulationTraits_2 */ }; /* end DelaunayTriangulationTraits_2 */