Incorrect use of backticks

Missing or double backticks corrected.

Circular_kernel_2/doc/Circular_kernel_2/Concepts/AlgebraicKernelForCircles.h

@@ -29,7 +29,7 @@ A model of `RingNumberType`.
 typedef unspecified_type RT;
 
 /*!
-A model of `FieldNumberType``<RT>`.
+A model of `FieldNumberType<RT>`.
 */
 typedef unspecified_type FT;
 

Circular_kernel_3/doc/Circular_kernel_3/Concepts/AlgebraicKernelForSpheres.h

@@ -29,7 +29,7 @@ A model of `RingNumberType`.
 typedef unspecified_type RT;
 
 /*!
-A model of `FieldNumberType``<RT>`.
+A model of `FieldNumberType<RT>`.
 */
 typedef unspecified_type FT;
 

Documentation/doc/Documentation/Usage.txt

@@ -72,7 +72,7 @@ For other distributions or package manager, please consult your respective docum
 You can also obtain the \cgal library sources directly from
 <A HREF="https://www.cgal.org/download.html">https://www.cgal.org/download.html</A>.
 
-Once you have downloaded the file `CGAL-\cgalReleaseNumber``.tar.xz` containing the
+Once you have downloaded the file `CGAL-\cgalReleaseNumber.tar.xz` containing the
 \cgal sources, you have to unpack it. Under a Unix-like shell, use the
 command:
 

Documentation/doc/Documentation/advanced/Installation.txt

@@ -188,8 +188,8 @@ The binary and source directories do not need to be the same. Thus, you can conf
 distinct directory for each configuration and by running CMake from there. This is known in CMake terminology
 as <I>out-of-source configuration</I>, as opposite to an <I>in-source
 configuration</I>, as showed in the previous sections.
-You can, for example, generate subdirectories `CGAL-\cgalReleaseNumber``/build/debug` and
-`CGAL-\cgalReleaseNumber``/build/release` for two configurations, respectively:
+You can, for example, generate subdirectories `CGAL-\cgalReleaseNumber/build/debug` and
+`CGAL-\cgalReleaseNumber/build/release` for two configurations, respectively:
 
     mkdir CGAL-\cgalReleaseNumber/build/debug
     cd CGAL-\cgalReleaseNumber/build/debug

Kernel_23/doc/Kernel_23/CGAL/Direction_2.h

@@ -61,7 +61,7 @@ Direction_2(const Kernel::RT &x, const Kernel::RT &y);
 /// @{
 
 /*!
-returns values, such that `d``== Direction_2<Kernel>(delta(0),delta(1))`.
+returns values, such that `d == Direction_2<Kernel>(delta(0),delta(1))`.
 \pre `0 <= i <= 1`.
 
 \cgalEpicExact

Kernel_23/doc/Kernel_23/CGAL/Direction_3.h

@@ -58,7 +58,7 @@ Direction_3(const Kernel::RT &x, const Kernel::RT &y, const Kernel::RT &z);
 /// @{
 
 /*!
-returns values, such that `d``== Direction_3<Kernel>(delta(0),delta(1),delta(2))`.
+returns values, such that `d == Direction_3<Kernel>(delta(0),delta(1),delta(2))`.
 \pre `0 <= i <= 2`.
 
 \cgalEpicExact

Miscellany/doc/Miscellany/CGAL/Unique_hash_map.h

@@ -28,7 +28,7 @@ of type `Data` specified in the definition of `map`.
 \cgalHeading{Implementation}
 
 `Unique_hash_map` is implemented via a chained hashing scheme. Access
-operations `map``[i]` take expected time \cgalBigO{1}. The `table_size`
+operations `map[i]` take expected time \cgalBigO{1}. The `table_size`
 parameter passed to chained hashing can be used to avoid unnecessary
 rehashing when set to the number of expected elements in the map.
 The design is derived from the \stl `hash_map` and the \leda type
@@ -144,7 +144,7 @@ void clear(const Data& default);
 
 /*!
 
-returns a reference to the variable `map``(key)`. If `key`
+returns a reference to the variable `map(key)`. If `key`
 has not been inserted into `map` before, `key` is inserted and
 initialized with `default_value`.
 */
@@ -152,7 +152,7 @@ Data& operator[](const Key& key);
 
 /*!
 
-returns a const reference to the variable `*this``(key)`. If `key`
+returns a const reference to the variable `*this(key)`. If `key`
 has not been inserted into `*this` before, a const reference to the
 `default_value` is returned. However, `key` is not inserted
 into `*this`.

QP_solver/doc/QP_solver/CGAL/QP_solution.h

@@ -147,7 +147,7 @@ Quadratic_program_solution();
 /*!
 returns `true` iff `sol` is not
 associated to a program. The condition
-!`sol``.is_void()` is a precondition for all access methods below.
+!`sol.is_void()` is a precondition for all access methods below.
 */
 bool is_void() const;
 
@@ -386,9 +386,9 @@ correctness of the solution. Any non-void object of
 /*!
 returns a random access iterator over the optimality certificate
 \f$ \qplambda\f$ as given in Lemma 1, with respect to the solution \f$ \qpx^*\f$
-obtained from `sol``.variable_values_begin()`. The value type
+obtained from `sol.variable_values_begin()`. The value type
 is `Quotient<ET>`, and the valid iterator range has length \f$ m\f$.
-\pre `sol``.is_optimal()`.
+\pre `sol.is_optimal()`.
 
 <B>Lemma 1(optimality certificate):</B> A feasible \f$ n\f$-vector \f$\qpx^*\f$ is an
 optimal solution of (QP) if an \f$ m\f$-vector \f$ \qplambda\f$ with
@@ -467,7 +467,7 @@ optimality_certificate_numerators_end() const;
 returns a random access iterator over the infeasibility certificate
 \f$ \qplambda\f$ as given in Lemma 2. The value type
 is `ET`, and the valid iterator range has length \f$ m\f$.
-\pre `sol``.is_infeasible()`.
+\pre `sol.is_infeasible()`.
 
 
 <B>Lemma 2 (infeasibility certificate):</B> The program (QP) is
@@ -520,9 +520,9 @@ infeasibility_certificate_end() const;
 /*!
 returns a random access iterator over the unbounded direction \f$ \qpw\f$
 as given in Lemma 3,with respect to the solution \f$ \qpx^*\f$
-obtained from `sol``.variable_values_begin()`. The value type
+obtained from `sol.variable_values_begin()`. The value type
 is `ET`, and the valid iterator range has length \f$ n\f$.
-\pre `sol``.is_unbounded()`.
+\pre `sol.is_unbounded()`.
 
 <B>Lemma 3 (unboundedness certificate:)</B> Let \f$\qpx^*\f$ be a feasible
 solution of (QP). The program (QP) is unbounded if an \f$n\f$-vector

Shape_detection/doc/Shape_detection/Shape_detection.txt

@@ -173,28 +173,28 @@ The algorithm aims at detecting the largest shape via many random samples, and t
 More specifically, the functions to be implemented are defined in the base class `Shape_detection::Shape_base`:
 
 - `Shape_detection::Shape_base::minimum_sample_size()` const: Returns the minimum number of required samples.
-- `Shape_detection::Shape_base::create_shape(const std::vector<size_t>& indices)`: The randomly generated samples are provided via a vector of indices. `Shape_detection::Shape_base::point``(std::size_t index)`
-and `Shape_detection::Shape_base::normal``(std::size_t index)` are used to retrieve the actual points and normals (see the example below).
+- `Shape_detection::Shape_base::create_shape(const std::vector<size_t>& indices)`: The randomly generated samples are provided via a vector of indices. `Shape_detection::Shape_base::point(std::size_t index)`
+and `Shape_detection::Shape_base::normal(std::size_t index)` are used to retrieve the actual points and normals (see the example below).
 The provided number of samples might actually be larger than the above minimum number of required samples, depending on the other shape types.
 If the provided samples are not sufficient to define a unique shape, for example in a degenerated case, the shape is considered invalid.
-- `Shape_detection::Shape_base::squared_distance``(const Point& point)` const: This function computes the squared distance from a query point to the shape.
+- `Shape_detection::Shape_base::squared_distance(const Point& point)` const: This function computes the squared distance from a query point to the shape.
 It is used for traversing the hierarchical spatial data structure.
 - `Shape_detection::Shape_base::squared_distance(std::vector<FT>& distances, const std::vector<size_t>& indices)` and
-- `Shape_detection::Shape_base::cos_to_normal``(const std::vector<size_t>& indices, std::vector<FT>& angles)` const.
+- `Shape_detection::Shape_base::cos_to_normal(const std::vector<size_t>& indices, std::vector<FT>& angles)` const.
 
 The last two functions are used to determine the number of inlier points to the shape. They compute respectively the squared distance from a set of points to the shape,
 and the dot product between the point normals and the normals at the shape for the closest points on the shape.
 
-The access to the actual point and normal data is carried out via `Shape_detection::Shape_base::point``(std::size_t index)` and `Shape_detection::Shape_base::normal``(std::size_t index)` (see the example below).
+The access to the actual point and normal data is carried out via `Shape_detection::Shape_base::point(std::size_t index)` and `Shape_detection::Shape_base::normal(std::size_t index)` (see the example below).
 The resulting squared distance/dot product is stored in the vector provided as the first argument.
 
 By default, the connected component is detected via the neighbor graph as mentioned above. However, for shapes that admit a faster approach to detect a connected component,
 the user can provide his/her own implementation to extract the connected component via:
-- `Shape_detection::Shape_base::connected_component``(std::vector<std::size_t>& indices, FT cluster_epsilon)`: The indices of all supporting points are stored in the vector `indices`.
+- `Shape_detection::Shape_base::connected_component(std::vector<std::size_t>& indices, FT cluster_epsilon)`: The indices of all supporting points are stored in the vector `indices`.
 All points that do not belong to the largest cluster of points are removed from the vector `indices`.
 
 Another optional method can be implemented to provide a helper function providing the shape parameters written to a string:
-- `Shape_detection::Shape_base::info``()`: This function returns a string suitable for printing the shape parameters into a log/console.
+- `Shape_detection::Shape_base::info()`: This function returns a string suitable for printing the shape parameters into a log/console.
 The default solution provides an empty string.
 
 The property maps are used to map the indices to the corresponding points and normals. The following header shows an implementation of a planar shape primitive,