diff --git a/.gitattributes b/.gitattributes index 039146850c3..1d11b1fd86e 100644 --- a/.gitattributes +++ b/.gitattributes @@ -2684,6 +2684,16 @@ Manual_tools/test/Manual_tools/cgal_test eol=lf Manual_tools/test/Manual_tools/html.orig.tgz -text svneol=unset#application/gzip Matrix_search/demo/Matrix_search/help/index.html svneol=native#text/html Matrix_search/demo/Matrix_search/help/rindex.html svneol=native#text/html +Matrix_search/doc/Matrix_search/CGAL/Dynamic_matrix.h -text +Matrix_search/doc/Matrix_search/CGAL/Sorted_matrix_search_traits_adaptor.h -text +Matrix_search/doc/Matrix_search/CGAL/monotone_matrix_search.h -text +Matrix_search/doc/Matrix_search/CGAL/sorted_matrix_search.h -text +Matrix_search/doc/Matrix_search/Concepts/BasicMatrix.h -text +Matrix_search/doc/Matrix_search/Concepts/MonotoneMatrixSearchTraits.h -text +Matrix_search/doc/Matrix_search/Concepts/SortedMatrixSearchTraits.h -text +Matrix_search/doc/Matrix_search/Matrix_search.txt -text +Matrix_search/doc/Matrix_search/PkgDescription.txt -text +Matrix_search/doc/Matrix_search/fig/matrix.png -text svneol=unset#image/png Matrix_search/doc_tex/Matrix_search/matrix.png -text Matrix_search/test/Matrix_search/rectangular_p_center_2_random1_test.cmd eol=lf Matrix_search/test/Matrix_search/rectangular_p_center_2_random2_test.cmd eol=lf diff --git a/Documentation/doc/Doxyfile b/Documentation/doc/Doxyfile index 30bca79073c..479ea29d3ae 100644 --- a/Documentation/doc/Doxyfile +++ b/Documentation/doc/Doxyfile @@ -31,7 +31,8 @@ STRIP_FROM_PATH = STRIP_FROM_INC_PATH = ../../Algebraic_foundations/doc/Algebraic_foundations \ ../../Number_types/doc/Number_types \ ../../STL_Extension/doc/STL_Extension \ - ../../Modular_arithmetic/doc/Modular_arithmetic + ../../Modular_arithmetic/doc/Modular_arithmetic \ + ../../Matrix_search/doc/Matrix_search SHORT_NAMES = NO JAVADOC_AUTOBRIEF = YES QT_AUTOBRIEF = YES @@ -52,8 +53,9 @@ ALIASES += cgalbib{1}="
BibTeX:
\ ALIASES += license{1}="
License:
\1
" ALIASES += "models=\xrefitem modelss \"Models\" \"Models\"" ALIASES += "refines=\xrefitem refiness \"Refines\" \"Refines\"" +ALIASES += "requires=\xrefitem requiress \"Requirements\" \"Requirements\"" ALIASES += "hasModel=\xrefitem asModelss \"Has Models\" \"Has Models\"" -ALIASES += "advanced=\attention +ALIASES += advanced=\attention ALIASES += "debug=\xrefitem debugs \"Debug\" \"Debug\"" ALIASES += "require=\xrefitem requires \"Requirements\" \"Requirements\"" ALIASES += beginadvanced="" @@ -134,6 +136,7 @@ INPUT = ../../Algebraic_foundations/doc/Algebraic_foundations \ ../../Number_types/doc/Number_types \ ../../STL_Extension/doc/STL_Extension \ ../../Modular_arithmetic/doc/Modular_arithmetic \ + ../../Matrix_search/doc/Matrix_search \ .. \ . # ../../AABB_tree/doc/AABB_tree \ @@ -188,7 +191,6 @@ INPUT = ../../Algebraic_foundations/doc/Algebraic_foundations \ # ../../Min_sphere_d/doc/Min_sphere_d \ # ../../Min_sphere_of_spheres_d/doc/Min_sphere_of_spheres_d \ # ../../Modifier/doc/Modifier \ -# ../../Modular_arithmetic/doc/Modular_arithmetic \ # ../../Nef_2/doc/Nef_2 \ # ../../Nef_3/doc/Nef_3 \ # ../../Nef_S2/doc/Nef_S2 \ @@ -239,13 +241,15 @@ EXAMPLE_PATH = ../../Algebraic_foundations/examples/Algebraic_foundati ../../Number_types/examples/Number_types \ ../../Convex_hull_2/examples/Convex_hull_2 \ ../../STL_Extension/examples/STL_Extension \ - ../../Modular_arithmetic/examples/Modular_arithmetic + ../../Modular_arithmetic/examples/Modular_arithmetic \ + ../../Matrix_search/examples/Matrix_search EXAMPLE_PATTERNS = * EXAMPLE_RECURSIVE = YES IMAGE_PATH = ../../Algebraic_foundations/doc/Algebraic_foundations/fig \ ../../Number_types/doc/Number_types/fig \ ../../STL_Extension/doc/STL_Extension/fig \ - ../../Modular_arithmetic/doc/Modular_arithmetic/fig + ../../Modular_arithmetic/doc/Modular_arithmetic/fig \ + ../../Matrix_search/doc/Matrix_search/fig INPUT_FILTER = FILTER_PATTERNS = FILTER_SOURCE_FILES = NO diff --git a/Matrix_search/doc/Matrix_search/CGAL/Dynamic_matrix.h b/Matrix_search/doc/Matrix_search/CGAL/Dynamic_matrix.h new file mode 100644 index 00000000000..845de979455 --- /dev/null +++ b/Matrix_search/doc/Matrix_search/CGAL/Dynamic_matrix.h @@ -0,0 +1,115 @@ +namespace CGAL { +/// \ingroup PkgMatrixSearch +/// +/// +/// +/// +/// The class `Dynamic_matrix` is an adaptor for an +/// arbitrary matrix class `M` to provide the dynamic operations +/// needed for monotone matrix search. +/// +/// +/// +/// +/// Requirements +/// -------------- +/// `M` is a model for `BasicMatrix`. +/// +/// +/// +/// +/// +/// \models ::BasicMatrix +/// +/// +/// \sa `BasicMatrix` +/// +/// +/// Implementation +/// -------------- +/// All operations take constant time except for +/// `extract_all_even_rows` which needs time linear in the number +/// of rows. +/// +/// +/// +/// +/// +/// +template< M > +class Dynamic_matrix { +public: + + + + + +/// \name Creation +/// @{ +/*! +\advanced initializes `d` to `m`. `m` is not copied, we only store a reference. +*/ +Dynamic_matrix( const M& m); +/// @} + +/// \name Operations +/// @{ +/*! +\advanced returns the number of columns. +*/ +int number_of_columns() const; +/// @} + +/// \name Operations +/// @{ +/*! +\advanced returns the number of rows. +*/ +int number_of_rows() const; +/// @} + +/// \name Operations +/// @{ +/*! +\advanced returns the entry at position (`row`, `column`). + +\pre \f$ 0 \le\f$ `row` \f$ <\f$ `number_of_rows()` +\pre \f$ 0 \le\f$ `column` \f$ <\f$ `number_of_columns()` +*/ +Entry operator()( int row, int column) const; +/// @} + +/// \name Operations +/// @{ +/*! +\advanced replace column `old` with column number `new`. +\pre \f$ 0 \le\f$ `old`, `new` \f$ <\f$ `number_of_columns()` +*/ +void replace_column( int old, int new); +/// @} + +/// \name Operations +/// @{ +/*! +\advanced returns a new Matrix consisting of all rows of `d` with even index, (i.e. first row is row \f$ 0\f$ of `d`, second row is row \f$ 2\f$ of `d` etc.). \pre `number_of_rows()` \f$ > 0\f$. +*/ +Matrix* extract_all_even_rows() const; +/// @} + +/// \name Operations +/// @{ +/*! +\advanced deletes the rightmost columns, such that `d` becomes quadratic. + +\pre `number_of_columns()` \f$ \ge\f$ `number_of_rows()` +\post `number_of_rows()` \f$ ==\f$ `number_of_columns()` +*/ +void shrink_to_quadratic_size(); +/// @} + +}; /* class Dynamic_matrix */ +} /* namespace CGAL */ + + + + diff --git a/Matrix_search/doc/Matrix_search/CGAL/Sorted_matrix_search_traits_adaptor.h b/Matrix_search/doc/Matrix_search/CGAL/Sorted_matrix_search_traits_adaptor.h new file mode 100644 index 00000000000..4ba0dda1150 --- /dev/null +++ b/Matrix_search/doc/Matrix_search/CGAL/Sorted_matrix_search_traits_adaptor.h @@ -0,0 +1,116 @@ +namespace CGAL { +/// \ingroup PkgMatrixSearch +/// +/// +/// +/// +/// The class `Sorted_matrix_search_traits_adaptor` can be used as an +/// adaptor to create sorted matrix search traits classes for +/// arbitrary feasibility test and matrix classes `F` resp. +/// `M`. +/// +/// +/// +/// +/// \models ::SortedMatrixSearchTraits +/// +/// +/// Requirements +/// -------------- +/// +///
    +///
  1. `M` is a model for `BasicMatrix` and +///
  2. `F` defines a copy constructor and a monotone `bool +/// operator()( const Value&)`. +///
+/// +/// +/// +/// +/// +template< F,M > +class Sorted_matrix_search_traits_adaptor { +public: + + + + + +/// \name Creation +/// @{ +/*! +\advanced initializes `t` to use `m` for feasibility testing. +*/ +Sorted_matrix_search_traits_adaptor( const F& + m); +/// @} + +/// \name Types +/// @{ +/*! +\advanced typedef to `M`. +*/ +typedef Hidden_type Matrix; +/// @} + +/// \name Types +/// @{ +/*! +\advanced typedef to `Matrix::Value`. +*/ +typedef Hidden_type Value; +/// @} + +/// \name Types +/// @{ +/*! +\advanced typedef to + `std::less`. +*/ +typedef Hidden_type Compare_strictly; +/// @} + +/// \name Types +/// @{ +/*! +\advanced typedef to + `std::less_equal`. +*/ +typedef Hidden_type Compare_non_strictly; +/// @} + +/// \name Operations +/// @{ +/*! +\advanced returns the `Compare_strictly` object to be used for the search. +*/ +Compare_strictly compare_strictly() + const; +/// @} + +/// \name Operations +/// @{ +/*! +\advanced returns the `Compare_non_strictly` object to be used for the search. +*/ +Compare_non_strictly compare_non_strictly() + const; +/// @} + +/// \name Operations +/// @{ +/*! +\advanced uses the feasibility test given during creation. +*/ +bool is_feasible(const Value& a); +/// @} + + + + +}; /* class Sorted_matrix_search_traits_adaptor */ +} /* namespace CGAL */ + + + + diff --git a/Matrix_search/doc/Matrix_search/CGAL/monotone_matrix_search.h b/Matrix_search/doc/Matrix_search/CGAL/monotone_matrix_search.h new file mode 100644 index 00000000000..5f58ce3b4e1 --- /dev/null +++ b/Matrix_search/doc/Matrix_search/CGAL/monotone_matrix_search.h @@ -0,0 +1,65 @@ +/// +namespace CGAL { +/// \ingroup PkgMatrixSearch +/// +/// +/// +/// +/// +/// The function `monotone_matrix_search` computes the maxima for all +/// rows of a totally monotone matrix. +/// More precisely, monotony for matrices is defined as follows. +/// Let \f$ K\f$ be a totally ordered set, \f$ M \in K^{(n,\, m)}\f$ +/// a matrix over \f$ K\f$ and for \f$ 0 \le i < n\f$: +/// \f[ +/// rmax_M(i) :\in \left\{ \min_{0 \le j < m} j \: \left|\: +/// M[i,\, j] = \max_{0 \le k < m} M[i,\, k] \right.\right\} +/// \f] +/// the (leftmost) column containing the maximum entry in row +/// \f$ i\f$. \f$ M\f$ is called monotone, iff +/// \f[ +/// \forall\, 0 \le i_1 < i_2 < n\: :\: rmax_M(i_1) \le +/// rmax_M(i_2)\; . +/// \f] +/// \f$ M\f$ is totally monotone, iff all of its submatrices are +/// monotone (or equivalently: iff all \f$ 2 \times 2\f$ submatrices are +/// monotone). +/// +/// It computes the maximum (as specified by `compare_strictly`) +/// entry for each row of `m` and writes the corresponding column +/// to `t`, i.e. `t[i]` is set to the index of the column +/// containing the maximum element in row `i`. The maximum \f$ m_r\f$ +/// of a row \f$ r\f$ is the leftmost element for which +/// `compare_strictly`\f$ (m_r,\,x)\f$ is false for all elements \f$ x\f$ in +/// \f$ r\f$. +/// \pre `t` points to a structure of size at least +/// `m.number_of_rows()` +/// \require `Matrix` is a model for `MonotoneMatrixSearchTraits` +/// \require Value type of `RandomAccessIC` is `int`. +/// \require If `compare_strictly` is defined, it is an adaptable binary function: `Matrix::Value` \f$ \times\f$ +/// `Matrix::Value` \f$ \rightarrow\f$ `bool` describing a strict +/// (non-reflexive) total ordering on `Matrix::Value`. +/// +/// +/// \sa `CGAL::extremal_polygon_2` +/// +/// +/// Implementation +/// -------------- +/// The implementation uses an algorithm by Aggarwal +/// et al.\cite akmsw-gamsa-87. The runtime is linear in the number +/// of rows and columns of the matrix. +/// +/// +/// +/// +/// +/// +/// +/// +/// +template < class Matrix, class RandomAccessIC, + class Compare_strictly > void monotone_matrix_search( const + Matrix& m, RandomAccessIC t, const Compare_strictly& + compare_strictly = less< Matrix::Value >()); +} /* namespace CGAL */ diff --git a/Matrix_search/doc/Matrix_search/CGAL/sorted_matrix_search.h b/Matrix_search/doc/Matrix_search/CGAL/sorted_matrix_search.h new file mode 100644 index 00000000000..61c35609a1b --- /dev/null +++ b/Matrix_search/doc/Matrix_search/CGAL/sorted_matrix_search.h @@ -0,0 +1,79 @@ +/// +namespace CGAL { +/// \ingroup PkgMatrixSearch +/// +/// The function `sorted_matrix_search` selects the smallest entry +/// in a set of sorted matrices that fulfills a certain feasibility +/// criterion. +/// More exactly, a matrix \f$ M = (m_{i j}) \in S^{r \times l}\f$ +/// (over a totally ordered set \f$ S\f$) is sorted, iff +/// \f{eqnarray*}{ +/// \forall \, 1 \le i \le r,\; 1 \le j < l\; :\; m_{i j} \le m_{i (j+1)} +/// \;\; {\it and}\\ +/// \forall \, 1 \le i < r,\; 1 \le j \le l\; :\; m_{i j} \le m_{(i+1) j} +/// \;\;. +/// \f} +/// Now let \f$ \mathcal{M}\f$ be a set of \f$ n\f$ sorted matrices over \f$ S\f$ +/// and \f$ f\f$ be a monotone predicate on \f$ S\f$, i.e. +/// +/// \f[ +/// f\: :\: S \longrightarrow\, \textit{bool} \quad{\rm with}\quad f(r) +/// \;\Longrightarrow\; \forall\, t \in S\,,\: t > r \; :\; f(t)\;. +/// \f] +/// +/// If we assume there is any feasible element in one of the matrices +/// in \f$ \mathcal{M}\f$, there certainly is a smallest such element. This is the one +/// we are searching for. +/// The feasibility test as well as some other parameters can (and +/// have to) be customized through a traits class. +/// +/// +/// It returns the element `x` in one of the sorted matrices from the +/// range \f$ \left[ f,\, l \right)\f$, for which `t.is_feasible( x)` +/// is true and `t.compare( x, y)` is true for all other +/// `y` values from any matrix for which `t.is_feasible( +/// y)` is true. +/// \pre All matrices in \f$ \left[f,\, l\right)\f$ are sorted according to `Traits::compare_non_strictly`. +/// \pre There is at least one entry \f$ x\f$ in a matrix \f$ M \in \left[f,\, l\right)\f$ for which `Traits::is_feasible(x)` is true. +/// +/// \require `Traits` is a model for `SortedMatrixSearchTraits`. +/// \require Value type of `RandomAccessIterator` is `Traits::Matrix`. +/// +/// \sa `SortedMatrixSearchTraits` +/// +/// +/// Implementation +/// -------------- +/// The implementation uses an algorithm by +/// Frederickson and Johnson\cite fj-fkppc-83 \cite fj-gsrsm-84 and runs in +/// \f$ \mathcal{O}(n \cdot k + f \cdot \log (n \cdot k))\f$, where \f$ n\f$ is +/// the number of input matrices, \f$ k\f$ denotes the maximal dimension of +/// any input matrix and \f$ f\f$ the time needed for one feasibility test. +/// +/// +/// +/// +/// Example +/// -------------- +/// In the following program we build a random vector \f$ a = +/// (a_i)_{i = 1,\,\ldots,\,5}\f$ (elements drawn uniformly from \f$ \{ +/// 0,\,\ldots,\,99 \}\f$) and construct a Cartesian matrix \f$ M\f$ +/// containing as elements all sums \f$ a_i + a_j,\: i,\,j \in +/// \{1,\,\ldots,\,5\}\f$. If \f$ a\f$ is sorted, \f$ M\f$ is sorted as well. So +/// we can apply `sorted_matrix_search` to compute the upper bound +/// for the maximal entry of \f$ a\f$ in \f$ M\f$. +/// \cgalexample{Matrix_search/sorted_matrix_search.cpp} +/// +/// +/// +/// +/// +/// +/// +/// +/// +template < class RandomAccessIterator, class + Traits > Traits::Value sorted_matrix_search( + RandomAccessIterator f, RandomAccessIterator l, const Traits& + t); +} /* namespace CGAL */ diff --git a/Matrix_search/doc/Matrix_search/Concepts/BasicMatrix.h b/Matrix_search/doc/Matrix_search/Concepts/BasicMatrix.h new file mode 100644 index 00000000000..e2e5cd4391f --- /dev/null +++ b/Matrix_search/doc/Matrix_search/Concepts/BasicMatrix.h @@ -0,0 +1,66 @@ +/// \ingroup PkgMatrixSearchConcepts +/// +/// +/// +/// A class `BasicMatrix` has to provide the following +/// types and operations in order to be a model for +/// `BasicMatrix`. +/// +/// +/// +/// +/// +/// +/// \hasModel CGAL::Dynamic_matrix +/// +/// +/// \sa `SortedMatrixSearchTraits` +/// +class BasicMatrix { +public: + + + + + +/// \name Types +/// @{ +/*! +\advanced The type of a matrix entry. It has to define + a copy constructor. +*/ +typedef Hidden_type Value; +/// @} + +/// \name Operations +/// @{ +/*! +\advanced returns the number of columns. +*/ +int number_of_columns() const; +/// @} + +/// \name Operations +/// @{ +/*! +\advanced returns the number of rows. +*/ +int number_of_rows() const; +/// @} + +/// \name Operations +/// @{ +/*! +\advanced returns the entry at position (`row`, `column`). + +\pre \f$ 0 \le\f$ `row` \f$ <\f$ `number_of_rows()` +\pre \f$ 0 \le\f$ `column` \f$ <\f$ `number_of_columns()` +*/ +Entry operator()( int row, int column) const; +/// @} + +}; /* concept BasicMatrix */ + + + + diff --git a/Matrix_search/doc/Matrix_search/Concepts/MonotoneMatrixSearchTraits.h b/Matrix_search/doc/Matrix_search/Concepts/MonotoneMatrixSearchTraits.h new file mode 100644 index 00000000000..56af5a69c78 --- /dev/null +++ b/Matrix_search/doc/Matrix_search/Concepts/MonotoneMatrixSearchTraits.h @@ -0,0 +1,112 @@ +/// \ingroup PkgMatrixSearchConcepts +/// +/// +/// +/// +/// The concept `MonotoneMatrixSearchTraits` is a refinement of +/// `BasicMatrix` and defines types and operations needed to +/// compute the maxima for all rows of a totally monotone matrix using +/// the function `monotone_matrix_search`. +/// +/// +/// +/// +/// +/// +/// Notes +/// -------------- +/// +///
    +///
  • For the sake of efficiency (and in order to achieve the time +/// bounds claimed for `monotone_matrix_search`), all these +/// operations have to be realized in constant time - except for +/// `extract_all_even_rows` which may take linear time. +///
  • There is an adaptor `Dynamic_matrix` that can be used to +/// add most of the functionality described above to arbitrary +/// matrix classes. +///
+/// +/// +/// +/// +/// \hasModel CGAL::Dynamic_matrix +/// +/// +/// \sa `CGAL::monotone_matrix_search` +/// +class MonotoneMatrixSearchTraits { +public: + + + + + +/// \name Types +/// @{ +/*! +\advanced The type of a matrix entry. +*/ +typedef Hidden_type Value; +/// @} + +/// \name Operations +/// @{ +/*! +\advanced returns the number of columns. +*/ +int number_of_columns() const; +/// @} + +/// \name Operations +/// @{ +/*! +\advanced returns the number of rows. +*/ +int number_of_rows() const; +/// @} + +/// \name Operations +/// @{ +/*! +\advanced returns the entry at position (`row`, `column`). + +\pre \f$ 0 \le\f$ `row` \f$ <\f$ `number_of_rows()` +\pre \f$ 0 \le\f$ `column` \f$ <\f$ `number_of_columns()` +*/ +Entry operator()( int row, int column) const; +/// @} + +/// \name Operations +/// @{ +/*! +\advanced replace column `old` with column number `new`. + +\pre \f$ 0 \le\f$ `old`, `new` \f$ <\f$ `number_of_columns()` +*/ +void replace_column( int old, int new); +/// @} + +/// \name Operations +/// @{ +/*! +\advanced returns a new Matrix consisting of all rows of `m` with even index, (i.e. first row is row \f$ 0\f$ of `m`, second row is row \f$ 2\f$ of `m` etc.). \pre `number_of_rows()` \f$ > 0\f$. +*/ +Matrix* extract_all_even_rows() const; +/// @} + +/// \name Operations +/// @{ +/*! +\advanced deletes the rightmost columns, such that `m` becomes quadratic. + +\pre `number_of_columns()` \f$ \ge\f$ `number_of_rows()` +\post `number_of_rows()` \f$ ==\f$ `number_of_columns()` +*/ +void shrink_to_quadratic_size(); +/// @} + +}; /* concept MonotoneMatrixSearchTraits */ + + + + diff --git a/Matrix_search/doc/Matrix_search/Concepts/SortedMatrixSearchTraits.h b/Matrix_search/doc/Matrix_search/Concepts/SortedMatrixSearchTraits.h new file mode 100644 index 00000000000..555ad050444 --- /dev/null +++ b/Matrix_search/doc/Matrix_search/Concepts/SortedMatrixSearchTraits.h @@ -0,0 +1,97 @@ +/// \ingroup PkgMatrixSearchConcepts +/// +/// +/// +/// +/// The concept `SortedMatrixSearchTraits` defines types and operations +/// needed to compute the smallest entry in a set of sorted matrices +/// that fulfills a certain feasibility criterion using the function +/// `sorted_matrix_search`. +/// +/// +/// +/// +/// +/// +/// \hasModel CGAL::Sorted_matrix_search_traits_adaptor +/// +/// +/// \sa `BasicMatrix` +/// +class SortedMatrixSearchTraits { +public: + + + + + +/// \name Types +/// @{ +/*! +\advanced The class used for representing matrices. + It has to be a model for `BasicMatrix`. +*/ +typedef Hidden_type Matrix; +/// @} + +/// \name Types +/// @{ +/*! +\advanced The class used for representing the matrix elements. +*/ +typedef Matrix::Value Value; +/// @} + +/// \name Types +/// @{ +/*! +\advanced An adaptable binary function + class: `Value` \f$ \times\f$ `Value` \f$ \rightarrow\f$ `bool` + defining a non-reflexive total order on `Value`. This + determines the direction of the search. +*/ +typedef Hidden_type Compare_strictly; +/// @} + +/// \name Types +/// @{ +/*! +\advanced An adaptable binary function + class: `Value` \f$ \times\f$ `Value` \f$ \rightarrow\f$ `bool` + defining the reflexive total order on `Value` corresponding + to `Compare_strictly`. +*/ +typedef Hidden_type Compare_non_strictly; +/// @} + +/// \name Operations +/// @{ +/*! +\advanced returns the `Compare_strictly` object to be used for the search. +*/ +Compare_strictly compare_strictly() + const; +/// @} + +/// \name Operations +/// @{ +/*! +\advanced returns the `Compare_non_strictly` object to be used for the search. +*/ +Compare_non_strictly compare_non_strictly() + const; +/// @} + +/// \name Operations +/// @{ +/*! +\advanced The predicate to determine whether an element `a` is feasible. It has to be monotone in the sense that `compare( a, b)` and `is_feasible( a)` imply `is_feasible( b)`. +*/ +bool is_feasible( const Value& a); +/// @} + +}; /* concept SortedMatrixSearchTraits */ + + + + diff --git a/Matrix_search/doc/Matrix_search/Matrix_search.txt b/Matrix_search/doc/Matrix_search/Matrix_search.txt new file mode 100644 index 00000000000..66cbecd553b --- /dev/null +++ b/Matrix_search/doc/Matrix_search/Matrix_search.txt @@ -0,0 +1,21 @@ + +namespace CGAL { +/*! +\page chap:MatrixSearch Monotone and Sorted Matrix Search +\authors Michael Hoffmann +\par Reference Manual: +\ref PkgMatrixSearch + +`CGAL::monotone_matrix_search` and `CGAL::sorted_matrix_search` +are techniques that deal with the problem of efficiently finding +largest entries in matrices with certain structural properties. Many +concrete problems can be modelled as matrix search problems, and for +some of them we provide explicit solutions that allow you to solve +them without knowing about the matrix search technique. Examples are, +the computation of all furthest neighbors for the vertices of a convex +polygon, maximal \f$ k\f$-gons inscribed into a planar point set, and +computing rectangular \f$ p\f$-centers. + +*/ +} // namespace CGAL + diff --git a/Matrix_search/doc/Matrix_search/PkgDescription.txt b/Matrix_search/doc/Matrix_search/PkgDescription.txt new file mode 100644 index 00000000000..26b71bda8e0 --- /dev/null +++ b/Matrix_search/doc/Matrix_search/PkgDescription.txt @@ -0,0 +1,49 @@ +/// \defgroup PkgMatrixSearch Monotone and Sorted Matrix Search + +/// \defgroup PkgMatrixSearchConcepts Concepts +/// \ingroup PkgMatrixSearch +/*! +\addtogroup PkgMatrixSearch + + + + + + + + +

Monotone and Sorted Matrix Search

\image html matrix.png "" +\par Michael Hoffmann + +\par "" This package provides a matrix search framework, which is the underlying technique for the computation of all furthest neighbors for the vertices of a convex polygon, maximal k-gons inscribed into a planar point set, and computing rectangular p-centers. + +\since \cgal 1.1 + +\cgalbib{cgal:h-msms-12} + +\license{ \ref licensesGPL "GPL" } + +\par Resources: +\ref chap:MatrixSearch "User Manual" +
+ +# Assertions # + +The optimization code uses infix `OPTIMISATION` in the assertions, +e.g. defining the compiler flag +`CGAL_OPTIMISATION_NO_PRECONDITIONS` switches precondition +checking off, cf. Section \ref secchecks . + +# Classified References Pages # + +- `CGAL::monotone_matrix_search` +- `CGAL::Dynamic_matrix` +- `MonotoneMatrixSearchTraits` +- `BasicMatrix` + +- `CGAL::sorted_matrix_search` +- `CGAL::Sorted_matrix_search_traits_adaptor` +- `SortedMatrixSearchTraits` + +*/ + diff --git a/Matrix_search/doc/Matrix_search/fig/matrix.png b/Matrix_search/doc/Matrix_search/fig/matrix.png new file mode 100644 index 00000000000..504d67ce4a5 Binary files /dev/null and b/Matrix_search/doc/Matrix_search/fig/matrix.png differ diff --git a/Modular_arithmetic/doc/Modular_arithmetic/CGAL/Residue.h b/Modular_arithmetic/doc/Modular_arithmetic/CGAL/Residue.h index f1edbd717cd..b86b7a52859 100644 --- a/Modular_arithmetic/doc/Modular_arithmetic/CGAL/Residue.h +++ b/Modular_arithmetic/doc/Modular_arithmetic/CGAL/Residue.h @@ -10,8 +10,8 @@ namespace CGAL { /// However, already existing objects do not lose their value with respect to the /// old prime and can be reused after restoring the old prime. /// Since the type is based on double -/// arithmetic the prime is restricted to values less than \f$2^26\f$. -/// The initial value of \f$p\f$ is 67111067. +/// arithmetic the prime is restricted to values less than \f$2^{26}\f$. +/// The initial value of \f$p\f$ is \f$67111067\f$. /// /// Please note that the implementation of class `CGAL::Residue` requires a mantissa /// precision according to the IEEE Standard for Floating-Point Arithmetic (IEEE 754). @@ -52,7 +52,7 @@ Residue(const Residue& m); /// \name Creation /// @{ /*! - introduces a variable `x`, which is initialized with \f$i % p\f$; + introduces a variable `x`, which is initialized with \f$i \mod p\f$; */ Residue(int i); /// @} @@ -60,7 +60,7 @@ Residue(int i); /// \name Creation /// @{ /*! - introduces a variable `x`, which is initialized with \f$i % p\f$; + introduces a variable `x`, which is initialized with \f$i \mod p\f$; */ Residue(long i); /// @}