mirror of https://github.com/CGAL/cgal
Merge branch '5.6.x-branch' into Triangulation_3-fix_simplex_traverser-GF-CGAL-5.6
# Conflicts: # STL_Extension/include/CGAL/Base_with_time_stamp.h # Triangulation_3/include/CGAL/Triangulation_3/internal/Triangulation_segment_traverser_3_impl.h # Triangulation_3/test/Triangulation_3/CMakeLists.txt
This commit is contained in:
Laurent Rineau
commit
ad9efd0e18
|
|
@ -0,0 +1,6 @@
|
|||
version: 2
|
||||
updates:
|
||||
- package-ecosystem: "github-actions"
|
||||
directory: "/"
|
||||
schedule:
|
||||
interval: "weekly"
|
||||
|
|
@ -160,7 +160,7 @@ jobs:
|
|||
script: |
|
||||
const error = process.env.ERRORMSG
|
||||
const job_url = `${context.serverUrl}/CGAL/cgal/actions/runs/${context.runId}`
|
||||
const msg = "There was an error while building the doc: \n"+error + "\n" + job_url
|
||||
const msg = "There was an error while building the doc: \n```\n"+error + "\n```\n" + job_url
|
||||
github.rest.issues.createComment({
|
||||
owner: "CGAL",
|
||||
repo: "cgal",
|
||||
|
|
|
|||
|
|
@ -2,6 +2,7 @@
|
|||
/*/*/*/build
|
||||
/*/*/*/VC*
|
||||
/*/*/*/GCC
|
||||
.vscode
|
||||
AABB_tree/demo/AABB_tree/AABB_demo
|
||||
AABB_tree/demo/AABB_tree/Makefile
|
||||
AABB_tree/examples/AABB_tree/*.kdev*
|
||||
|
|
@ -1211,3 +1212,4 @@ gmon.*
|
|||
Polygonal_surface_reconstruction/examples/build*
|
||||
Polygonal_surface_reconstruction/test/build*
|
||||
Solver_interface/examples/build*
|
||||
/Mesh_3/examples/Mesh_3/indicator_0.inr.gz
|
||||
|
|
|
|||
|
|
@ -6,12 +6,14 @@ project(AABB_traits_benchmark)
|
|||
|
||||
find_package(CGAL REQUIRED OPTIONAL_COMPONENTS Core)
|
||||
|
||||
# google benchmark
|
||||
find_package(benchmark)
|
||||
|
||||
if (benchmark_FOUND)
|
||||
create_single_source_cgal_program("tree_creation.cpp")
|
||||
target_link_libraries(tree_creation benchmark::benchmark)
|
||||
endif()
|
||||
create_single_source_cgal_program("test.cpp")
|
||||
create_single_source_cgal_program("tree_construction.cpp")
|
||||
|
||||
# google benchmark
|
||||
find_package(benchmark QUIET)
|
||||
if(benchmark_FOUND)
|
||||
create_single_source_cgal_program("tree_creation.cpp")
|
||||
target_link_libraries(tree_creation benchmark::benchmark)
|
||||
else()
|
||||
message(STATUS "NOTICE: The benchmark 'tree_creation.cpp' requires the Google benchmark library, and will not be compiled.")
|
||||
endif()
|
||||
|
|
|
|||
|
|
@ -5,6 +5,7 @@ project(AABB_tree_Demo)
|
|||
|
||||
# Find includes in corresponding build directories
|
||||
set(CMAKE_INCLUDE_CURRENT_DIR ON)
|
||||
|
||||
# Instruct CMake to run moc automatically when needed.
|
||||
set(CMAKE_AUTOMOC ON)
|
||||
if(NOT POLICY CMP0070 AND POLICY CMP0053)
|
||||
|
|
@ -23,7 +24,7 @@ include_directories(BEFORE ./ ./include)
|
|||
find_package(CGAL REQUIRED OPTIONAL_COMPONENTS Qt5)
|
||||
|
||||
# Find Qt5 itself
|
||||
find_package(Qt5 QUIET COMPONENTS Script OpenGL Gui Svg)
|
||||
find_package(Qt5 QUIET COMPONENTS Widgets OpenGL)
|
||||
|
||||
if(CGAL_Qt5_FOUND AND Qt5_FOUND)
|
||||
|
||||
|
|
@ -31,10 +32,8 @@ if(CGAL_Qt5_FOUND AND Qt5_FOUND)
|
|||
|
||||
include(AddFileDependencies)
|
||||
|
||||
qt5_generate_moc("MainWindow.h"
|
||||
"${CMAKE_CURRENT_BINARY_DIR}/MainWindow_moc.cpp")
|
||||
add_file_dependencies(MainWindow_moc.cpp
|
||||
"${CMAKE_CURRENT_SOURCE_DIR}/MainWindow.h")
|
||||
qt5_generate_moc("MainWindow.h" "${CMAKE_CURRENT_BINARY_DIR}/MainWindow_moc.cpp")
|
||||
add_file_dependencies(MainWindow_moc.cpp "${CMAKE_CURRENT_SOURCE_DIR}/MainWindow.h")
|
||||
|
||||
qt5_generate_moc("Viewer.h" "${CMAKE_CURRENT_BINARY_DIR}/Viewer_moc.cpp")
|
||||
add_file_dependencies(Viewer_moc.cpp "${CMAKE_CURRENT_SOURCE_DIR}/Viewer.h")
|
||||
|
|
@ -54,7 +53,7 @@ if(CGAL_Qt5_FOUND AND Qt5_FOUND)
|
|||
#${CGAL_Qt5_MOC_FILES}
|
||||
)
|
||||
# Link with Qt libraries
|
||||
target_link_libraries(AABB_demo PRIVATE Qt5::OpenGL Qt5::Gui
|
||||
target_link_libraries(AABB_demo PRIVATE Qt5::Widgets Qt5::OpenGL
|
||||
CGAL::CGAL CGAL::CGAL_Qt5)
|
||||
|
||||
add_to_cached_list(CGAL_EXECUTABLE_TARGETS AABB_demo)
|
||||
|
|
@ -62,8 +61,7 @@ if(CGAL_Qt5_FOUND AND Qt5_FOUND)
|
|||
include(${CGAL_MODULES_DIR}/CGAL_add_test.cmake)
|
||||
cgal_add_compilation_test(AABB_demo)
|
||||
|
||||
else(CGAL_Qt5_FOUND
|
||||
AND Qt5_FOUND)
|
||||
else(CGAL_Qt5_FOUND AND Qt5_FOUND)
|
||||
|
||||
set(AABB_MISSING_DEPS "")
|
||||
|
||||
|
|
@ -75,11 +73,6 @@ else(CGAL_Qt5_FOUND
|
|||
set(AABB_MISSING_DEPS "Qt5, ${AABB_MISSING_DEPS}")
|
||||
endif()
|
||||
|
||||
message(
|
||||
STATUS
|
||||
"NOTICE: This demo requires ${AABB_MISSING_DEPS}and will not be compiled."
|
||||
)
|
||||
message("NOTICE: This demo requires ${AABB_MISSING_DEPS}, and will not be compiled.")
|
||||
|
||||
endif(
|
||||
CGAL_Qt5_FOUND
|
||||
AND Qt5_FOUND)
|
||||
endif(CGAL_Qt5_FOUND AND Qt5_FOUND)
|
||||
|
|
|
|||
|
|
@ -334,7 +334,7 @@ void Scene::compute_elements(int mode)
|
|||
pos_points.push_back(p.z());
|
||||
}
|
||||
}
|
||||
//The Segements
|
||||
//The segments
|
||||
{
|
||||
std::list<Segment>::iterator sit;
|
||||
for(sit = m_segments.begin(); sit != m_segments.end(); sit++)
|
||||
|
|
|
|||
|
|
@ -2,8 +2,8 @@
|
|||
<body>
|
||||
<h2>AABB Tree Demo</h2>
|
||||
<p>Copyright ©2009
|
||||
<a href="http://www-sop.inria.fr/">INRIA Sophia Antipolis - Mediterranee<a/></p>
|
||||
<p>This application illustrates the AABB tree component
|
||||
<a href="https://www.inria.fr/fr/centre-inria-universite-cote-azur">INRIA Sophia Antipolis - Mediterranee<a/></p>
|
||||
<p>This application illustrates the AABB tree component
|
||||
of <a href="https://www.cgal.org/">CGAL</a>, applied to polyhedron
|
||||
facets and edges.</p>
|
||||
<p>See also the following chapters of the manual:
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@ and compute intersections between query objects and the primitives stored in the
|
|||
In addition, it contains predicates and constructors to compute distances between a point query
|
||||
and the primitives stored in the AABB tree.
|
||||
|
||||
\cgalRefines `SearchGeomTraits_3`
|
||||
\cgalRefines{SearchGeomTraits_3}
|
||||
|
||||
\cgalHasModel All models of the concept `Kernel`
|
||||
|
||||
|
|
@ -74,9 +74,9 @@ typedef unspecified_type Construct_projected_point_3;
|
|||
/*!
|
||||
A functor object to compare the distance of two points wrt a third one. Provides the operator:
|
||||
|
||||
`CGAL::Comparision_result operator()(const Point_3& p1, const Point_3& p2, const Point_3& p3)`,
|
||||
`CGAL::Comparison_result operator()(const Point_3& p1, const Point_3& p2, const Point_3& p3)`,
|
||||
|
||||
which compares the distance between `p1 and `p2`, and between `p2` and `p3`.
|
||||
which compares the distance between `p1` and `p2`, and between `p2` and `p3`.
|
||||
*/
|
||||
typedef unspecified_type Compare_distance_3;
|
||||
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ concept `AABBGeomTraits`. In addition to the types required by
|
|||
`AABBGeomTraits` it also requires types and functors necessary to
|
||||
define the Intersection_distance functor.
|
||||
|
||||
\cgalRefines `AABBGeomTraits`
|
||||
\cgalRefines{AABBGeomTraits}
|
||||
|
||||
\cgalHasModel All models of the concept `Kernel`
|
||||
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ The concept `AABBTraits` provides the geometric primitive types and methods for
|
|||
|
||||
\cgalHasModel `CGAL::AABB_traits<AABBGeomTraits,AABBPrimitive>`
|
||||
|
||||
\cgalRefines `SearchGeomTraits_3`
|
||||
\cgalRefines{SearchGeomTraits_3}
|
||||
|
||||
\sa `CGAL::AABB_traits<AABBGeomTraits,AABBPrimitive>`
|
||||
\sa `CGAL::AABB_tree<AABBTraits>`
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
\cgalPkgDescriptionBegin{3D Fast Intersection and Distance Computation,PkgAABBTree}
|
||||
\cgalPkgPicture{aabb-teaser-thumb.png}
|
||||
\cgalPkgSummaryBegin
|
||||
\cgalPkgAuthors{Pierre Alliez, Stéphane Tayeb, Camille Wormser}
|
||||
\cgalPkgAuthors{Pierre Alliez, Stéphane Tayeb, and Camille Wormser}
|
||||
\cgalPkgDesc{The AABB (axis-aligned bounding box) tree component offers a static data structure and algorithms to perform efficient intersection and distance queries on sets of finite 3D geometric objects.}
|
||||
\cgalPkgManuals{Chapter_3D_Fast_Intersection_and_Distance_Computation,PkgAABBTreeRef}
|
||||
\cgalPkgSummaryEnd
|
||||
|
|
|
|||
|
|
@ -390,7 +390,7 @@ query and location of query in space.
|
|||
number of primitive data (greater than 2M faces in our experiments)
|
||||
however we noticed that it is not necessary (and sometimes even
|
||||
slower) to use all reference points when constructing the
|
||||
KD-tree. In these cases we recommend to specify trough the function
|
||||
KD-tree. In these cases we recommend to specify through the function
|
||||
` AABB_tree::accelerate_distance_queries()` fewer reference
|
||||
points (typically not more than 100K) evenly distributed over the
|
||||
input primitives.
|
||||
|
|
|
|||
|
|
@ -23,9 +23,8 @@
|
|||
|
||||
#include <iterator>
|
||||
#include <boost/mpl/and.hpp>
|
||||
#include <CGAL/is_iterator.h>
|
||||
#include <CGAL/type_traits/is_iterator.h>
|
||||
#include <boost/type_traits/is_convertible.hpp>
|
||||
#include <boost/utility/enable_if.hpp>
|
||||
#include <boost/mpl/if.hpp>
|
||||
|
||||
#include <CGAL/Default.h>
|
||||
|
|
|
|||
|
|
@ -26,8 +26,7 @@
|
|||
#define CGAL_REPLACEMENT_HEADER "<CGAL/AABB_halfedge_graph_segment_primitive.h>"
|
||||
#include <CGAL/Installation/internal/deprecation_warning.h>
|
||||
|
||||
#include <boost/utility/enable_if.hpp>
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
#include <type_traits>
|
||||
|
||||
namespace CGAL {
|
||||
|
||||
|
|
@ -80,9 +79,9 @@ namespace CGAL {
|
|||
: m_halfedge_handle(*ptr) { };
|
||||
template <class Iterator>
|
||||
AABB_polyhedron_segment_primitive( Iterator it,
|
||||
typename boost::enable_if<
|
||||
boost::is_same<Id,typename Iterator::value_type>
|
||||
>::type* =0
|
||||
std::enable_if_t<
|
||||
std::is_same<Id,typename Iterator::value_type>::value
|
||||
>* =0
|
||||
) : m_halfedge_handle(*it) { }
|
||||
|
||||
AABB_polyhedron_segment_primitive(const Self& primitive)
|
||||
|
|
|
|||
|
|
@ -22,8 +22,7 @@
|
|||
#define CGAL_REPLACEMENT_HEADER "<CGAL/AABB_face_graph_triangle_primitive.h>"
|
||||
#include <CGAL/Installation/internal/deprecation_warning.h>
|
||||
|
||||
#include <boost/utility/enable_if.hpp>
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
#include <type_traits>
|
||||
|
||||
namespace CGAL {
|
||||
/// \ingroup PkgAABBTreeRef
|
||||
|
|
@ -76,9 +75,9 @@ namespace CGAL {
|
|||
: m_facet_handle(*ptr) { };
|
||||
template <class Iterator>
|
||||
AABB_polyhedron_triangle_primitive( Iterator it,
|
||||
typename boost::enable_if<
|
||||
boost::is_same<Id,typename Iterator::value_type>
|
||||
>::type* =0
|
||||
std::enable_if_t<
|
||||
std::is_same<Id,typename Iterator::value_type>::value
|
||||
>* =0
|
||||
) : m_facet_handle(*it) { }
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -213,7 +213,7 @@ public:
|
|||
/// Point query type.
|
||||
typedef typename GeomTraits::Point_3 Point_3;
|
||||
|
||||
/// additionnal types for the search tree, required by the RangeSearchTraits concept
|
||||
/// additional types for the search tree, required by the RangeSearchTraits concept
|
||||
/// \bug This is not documented for now in the AABBTraits concept.
|
||||
typedef typename GeomTraits::Iso_cuboid_3 Iso_cuboid_3;
|
||||
|
||||
|
|
@ -254,7 +254,7 @@ public:
|
|||
* @param beyond iterator on beyond element
|
||||
* @param bbox the bounding box of [first,beyond[
|
||||
*
|
||||
* Sorts the range defined by [first,beyond[. Sort is achieved on bbox longuest
|
||||
* Sorts the range defined by [first,beyond[. Sort is achieved on bbox longest
|
||||
* axis, using the comparison function `<dim>_less_than` (dim in {x,y,z})
|
||||
*/
|
||||
class Split_primitives
|
||||
|
|
|
|||
|
|
@ -18,8 +18,8 @@
|
|||
|
||||
|
||||
#include <functional>
|
||||
#include <type_traits>
|
||||
#include <boost/optional.hpp>
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
#include <boost/variant/apply_visitor.hpp>
|
||||
# if defined(BOOST_MSVC)
|
||||
# pragma warning(push)
|
||||
|
|
@ -201,7 +201,7 @@ template<typename Ray, typename SkipFunctor>
|
|||
boost::optional< typename AABB_tree<AABBTraits>::template Intersection_and_primitive_id<Ray>::Type >
|
||||
AABB_tree<AABBTraits>::first_intersection(const Ray& query,
|
||||
const SkipFunctor& skip) const {
|
||||
CGAL_static_assertion_msg((boost::is_same<Ray, typename AABBTraits::Ray_3>::value),
|
||||
CGAL_static_assertion_msg((std::is_same<Ray, typename AABBTraits::Ray_3>::value),
|
||||
"Ray and Ray_3 must be the same type");
|
||||
|
||||
switch(size()) // copy-paste from AABB_tree::traversal
|
||||
|
|
|
|||
|
|
@ -143,18 +143,18 @@ struct AABB_covered_triangle_tree_traits
|
|||
|
||||
// Primitive ID --> box vector pos --> Bounding Box
|
||||
using BPMB = internal::Vector_property_map<CGAL::Bbox_3>;
|
||||
using BPM = CGAL::Property_map_binder<IDPM, BPMB>;
|
||||
using BPM = CGAL::Compose_property_map<IDPM, BPMB>;
|
||||
|
||||
// Primitive ID --> point vector pos --> Reference Point
|
||||
using RPPMB = internal::Vector_property_map<Point>;
|
||||
using RPPM = CGAL::Property_map_binder<IDPM, RPPMB>;
|
||||
using RPPM = CGAL::Compose_property_map<IDPM, RPPMB>;
|
||||
|
||||
// Primitive ID --> Datum pos vector pos --> Datum pos --> Datum
|
||||
// The vector of data has size nf, but the vector of datum pos has size tree.size()
|
||||
using DPPMB = internal::Vector_property_map<std::size_t>; // pos --> Datum pos
|
||||
using DPPM = CGAL::Property_map_binder<IDPM, DPPMB>; // PID --> Datum pos
|
||||
using DPPM = CGAL::Compose_property_map<IDPM, DPPMB>; // PID --> Datum pos
|
||||
using DPMB = internal::Vector_property_map<Triangle_3>; // Datum pos --> Datum
|
||||
using DPM = CGAL::Property_map_binder<DPPM, DPMB>; // PID --> Datum
|
||||
using DPM = CGAL::Compose_property_map<DPPM, DPMB>; // PID --> Datum
|
||||
|
||||
using Primitive = CGAL::AABB_primitive<ID, DPM, RPPM,
|
||||
CGAL::Tag_true /*external pmaps*/,
|
||||
|
|
@ -207,7 +207,7 @@ public:
|
|||
: Base(traits),
|
||||
m_sq_length(square(max_length)),
|
||||
m_dppmb(), m_bpm(), m_rppm(), m_dpmb(),
|
||||
m_dpm(DPPM(m_dppmb/*first binder's value_map*/)/*second binder's key map*/, m_dpmb)
|
||||
m_dpm(DPPM(Default(), m_dppmb/*first binder's value_map*/)/*second binder's key map*/, m_dpmb)
|
||||
{
|
||||
initialize_tree_property_maps();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -18,8 +18,7 @@
|
|||
|
||||
#include <CGAL/disable_warnings.h>
|
||||
|
||||
#include <boost/utility/enable_if.hpp>
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
#include <type_traits>
|
||||
|
||||
namespace CGAL {
|
||||
// \ingroup PkgAABBTreeRef
|
||||
|
|
@ -68,9 +67,9 @@ namespace CGAL {
|
|||
: m_facet(*ptr) { }
|
||||
template <class Iterator>
|
||||
AABB_triangulation_3_triangle_primitive( Iterator it,
|
||||
typename boost::enable_if<
|
||||
boost::is_same<Id,typename Iterator::value_type>
|
||||
>::type* =0
|
||||
std::enable_if_t<
|
||||
std::is_same<Id,typename Iterator::value_type>::value
|
||||
>* =0
|
||||
) : m_facet(*it) { }
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -527,7 +527,6 @@ private:
|
|||
{
|
||||
CGAL::Timer timer;
|
||||
timer.start();
|
||||
int nb_test = 0;
|
||||
while ( timer.time() < duration )
|
||||
{
|
||||
Point a = random_point_in<K>(m_tree.bbox());
|
||||
|
|
@ -539,8 +538,6 @@ private:
|
|||
test(segment, m_polyhedron, m_tree, m_naive);
|
||||
test(ray, m_polyhedron, m_tree, m_naive);
|
||||
test(line, m_polyhedron, m_tree, m_naive);
|
||||
|
||||
++nb_test;
|
||||
}
|
||||
timer.stop();
|
||||
|
||||
|
|
|
|||
|
|
@ -131,7 +131,7 @@ std::tuple<std::size_t, std::size_t, std::size_t, long> test(const char* name) {
|
|||
tu = std::make_tuple(intersect(lines.begin(), lines.end(), tree, counter),
|
||||
intersect(rays.begin(), rays.end(), tree, counter),
|
||||
intersect(segments.begin(), segments.end(), tree, counter),
|
||||
// cant use counter here
|
||||
// can't use counter here
|
||||
0);
|
||||
std::get<3>(tu) = counter;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@ used in the class `CGAL::Advancing_front_surface_reconstruction`.
|
|||
It defines the geometric objects (points, segments...) forming the triangulation
|
||||
together with a few geometric predicates and constructions on these objects.
|
||||
|
||||
\cgalRefines `DelaunayTriangulationTraits_3`
|
||||
\cgalRefines{DelaunayTriangulationTraits_3}
|
||||
|
||||
\cgalHasModel All models of `Kernel`.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@
|
|||
\cgalPkgDescriptionBegin{Advancing Front Surface Reconstruction,PkgAdvancingFrontSurfaceReconstruction}
|
||||
\cgalPkgPicture{afsr-detail.png}
|
||||
\cgalPkgSummaryBegin
|
||||
\cgalPkgAuthors{Tran Kai Frank Da, David Cohen-Steiner}
|
||||
\cgalPkgAuthors{Tran Kai Frank Da and David Cohen-Steiner}
|
||||
\cgalPkgDesc{This package provides a greedy algorithm for surface reconstruction from an
|
||||
unorganized point set. Starting from a seed facet, a piecewise linear
|
||||
surface is grown by adding Delaunay triangles one by one. The most
|
||||
|
|
|
|||
|
|
@ -186,7 +186,7 @@ namespace CGAL {
|
|||
CGAL::Advancing_front_surface_reconstruction_vertex_base_3<
|
||||
CGAL::Exact_predicates_inexact_constructions_kernel>,
|
||||
CGAL::Advancing_front_surface_reconstruction_cell_base_3<
|
||||
CGAL::Exact_predicates_inexact_constructions_kernel> > >`
|
||||
CGAL::Exact_predicates_inexact_constructions_kernel> > >
|
||||
\endcode
|
||||
|
||||
\tparam P must be a functor offering
|
||||
|
|
@ -370,19 +370,19 @@ namespace CGAL {
|
|||
coord_type K, min_K;
|
||||
const coord_type eps;
|
||||
const coord_type inv_eps_2; // 1/(eps^2)
|
||||
const coord_type eps_3; // test de ^3 donc points tel 1e-7 soit petit
|
||||
const coord_type eps_3; // tests using cubed eps so points such that 1e-7 is small
|
||||
const criteria STANDBY_CANDIDATE;
|
||||
const criteria STANDBY_CANDIDATE_BIS;
|
||||
const criteria NOT_VALID_CANDIDATE;
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
//Pour une visu correcte
|
||||
//pour retenir les facettes selectionnees
|
||||
// For a correct visualization
|
||||
// to retain the selected facets
|
||||
int _vh_number;
|
||||
int _facet_number;
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
//Pour le post traitement
|
||||
// For post-processing
|
||||
mutable int _postprocessing_counter;
|
||||
int _size_before_postprocessing;
|
||||
|
||||
|
|
@ -501,9 +501,8 @@ namespace CGAL {
|
|||
}
|
||||
|
||||
//-------------------------------------------------------------------
|
||||
// pour gerer certaines aretes interieures: a savoir celle encore connectee au
|
||||
// bord (en fait seule, les aretes interieures reliant 2 bords nous
|
||||
// interressent...)
|
||||
// to handle certain interior edges, meaning those still connected to the boundary
|
||||
// (actually, only the interior edges linking two boundaries are relevant)
|
||||
|
||||
inline void set_interior_edge(Vertex_handle w, Vertex_handle v)
|
||||
{
|
||||
|
|
@ -806,7 +805,7 @@ namespace CGAL {
|
|||
|
||||
if ((number_of_facets() > static_cast<int>(T.number_of_vertices()))&&
|
||||
(NB_BORDER_MAX > 0))
|
||||
// en principe 2*nb_sommets = nb_facettes: y a encore de la marge!!!
|
||||
// in theory 2*vertices_n = facets_n: plenty of room!!!
|
||||
{
|
||||
while(postprocessing()){
|
||||
extend2_timer.start();
|
||||
|
|
@ -1068,9 +1067,8 @@ namespace CGAL {
|
|||
|
||||
//---------------------------------------------------------------------
|
||||
bool is_interior_edge(const Edge_like& key) const
|
||||
// pour gerer certaines aretes interieures: a savoir celle encore connectee au
|
||||
// bord (en fait seule, les aretes interieures reliant 2 bords nous
|
||||
// interressent...)
|
||||
// to handle certain interior edges, meaning those still connected to the boundary
|
||||
// (actually, only the interior edges linking two boundaries are relevant)
|
||||
{
|
||||
return (is_interior_edge(key.first, key.second)||
|
||||
is_interior_edge(key.second, key.first));
|
||||
|
|
@ -1299,7 +1297,6 @@ namespace CGAL {
|
|||
#ifdef AFSR_LAZY
|
||||
value = lazy_squared_radius(cc);
|
||||
#else
|
||||
// qualified with CGAL, to avoid a compilation error with clang
|
||||
if(volume(pp0, pp1, pp2, pp3) != 0){
|
||||
value = T.geom_traits().compute_squared_radius_3_object()(pp0, pp1, pp2, pp3);
|
||||
} else {
|
||||
|
|
@ -1337,7 +1334,6 @@ namespace CGAL {
|
|||
{
|
||||
value = compute_scalar_product(Vc, Vc) - ac*ac/norm_V;
|
||||
if ((value < 0)||(norm_V > inv_eps_2)){
|
||||
// qualified with CGAL, to avoid a compilation error with clang
|
||||
value = T.geom_traits().compute_squared_radius_3_object()(cp1, cp2, cp3);
|
||||
}
|
||||
}
|
||||
|
|
@ -1365,7 +1361,7 @@ namespace CGAL {
|
|||
/// @}
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
// For a border edge e we determine the incident facet which has the highest
|
||||
// For a border edge e, we determine the incident facet which has the highest
|
||||
// chance to be a natural extension of the surface
|
||||
|
||||
Radius_edge_type
|
||||
|
|
@ -1425,8 +1421,7 @@ namespace CGAL {
|
|||
P2Pn = construct_vector(p2, pn);
|
||||
v2 = construct_cross_product(P2P1,P2Pn);
|
||||
|
||||
//pas necessaire de normer pour un bon echantillon:
|
||||
// on peut alors tester v1*v2 >= 0
|
||||
// no need to normalize for a correct sampling: one can then test v1*v2 >= 0
|
||||
norm = sqrt(norm1 * compute_scalar_product(v2,v2));
|
||||
pscal = v1*v2;
|
||||
// check if the triangle will produce a sliver on the surface
|
||||
|
|
@ -1437,7 +1432,8 @@ namespace CGAL {
|
|||
if (tmp < min_valueA)
|
||||
{
|
||||
PnP1 = p1-pn;
|
||||
// DELTA represente la qualite d'echantillonnage du bord
|
||||
// DELTA encodes the quality of the border sampling
|
||||
//
|
||||
// We skip triangles having an internal angle along e
|
||||
// whose cosinus is smaller than -DELTA
|
||||
// that is the angle is larger than arcos(-DELTA)
|
||||
|
|
@ -1462,37 +1458,36 @@ namespace CGAL {
|
|||
|
||||
if ((min_valueA == infinity()) || border_facet) // bad facets case
|
||||
{
|
||||
min_facet = Facet(c, i); // !!! sans aucune signification....
|
||||
value = NOT_VALID_CANDIDATE; // Attention a ne pas inserer dans PQ
|
||||
min_facet = Facet(c, i); // !!! without any meaning....
|
||||
value = NOT_VALID_CANDIDATE; // Do not insert in the PQ
|
||||
}
|
||||
else
|
||||
{
|
||||
min_facet = min_facetA;
|
||||
|
||||
//si on considere seulement la pliure value appartient a [0, 2]
|
||||
//value = coord_type(1) - min_valueP;
|
||||
|
||||
// si la pliure est bonne on note suivant le alpha sinon on prend en compte la
|
||||
// pliure seule... pour discriminer entre les bons slivers...
|
||||
// si on veut discriminer les facettes de bonnes pliures plus finement
|
||||
// alors -(1+1/min_valueA) app a [-inf, -1]
|
||||
// -min_valueP app a [-1, 1]
|
||||
// If we only consider the fold value belongs to [0, 2]
|
||||
// value = coord_type(1) - min_valueP;
|
||||
|
||||
// If the fold is OK, we rate based on the alpha value. Otherwise, take only the fold into account
|
||||
// to discriminate between good slivers.
|
||||
//
|
||||
// If we wish to discriminate the facets with good folds more finely,
|
||||
// then:
|
||||
// -(1+1/min_valueA) is within [-inf, -1]
|
||||
// -min_valueP is within [-1, 1]
|
||||
//
|
||||
if (min_valueP > COS_BETA)
|
||||
value = -(coord_type(1) + coord_type(1)/min_valueA);
|
||||
else
|
||||
{
|
||||
//on refuse une trop grande non-uniformite
|
||||
// reject overly non-uniform values
|
||||
coord_type tmp = priority (*this, c, i);
|
||||
if (min_valueA <= K * tmp)
|
||||
value = - min_valueP;
|
||||
else
|
||||
{
|
||||
value = STANDBY_CANDIDATE; // tres mauvais candidat mauvaise pliure
|
||||
// + grand alpha... a traiter plus tard....
|
||||
min_K =
|
||||
(std::min)(min_K,
|
||||
min_valueA/tmp);
|
||||
value = STANDBY_CANDIDATE; // extremely bad candidate, bad fold + large alpha; handle later
|
||||
min_K = (std::min)(min_K, min_valueA/tmp);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1597,7 +1592,7 @@ namespace CGAL {
|
|||
}
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
// test de reciprocite avant de recoller une oreille anti-singularite
|
||||
// reciprocity test before glueing anti-singularity ear
|
||||
int
|
||||
test_merge(const Edge_like& ordered_key, const Border_elt& result,
|
||||
const Vertex_handle& v, const coord_type& ear_alpha)
|
||||
|
|
@ -1622,12 +1617,12 @@ namespace CGAL {
|
|||
coord_type norm = sqrt(compute_scalar_product(v1, v1) * compute_scalar_product(v2, v2));
|
||||
|
||||
if (v1*v2 > COS_BETA*norm)
|
||||
return 1; // label bonne pliure sinon:
|
||||
return 1; // mark as good fold
|
||||
|
||||
if (ear_alpha <= K * priority(*this, neigh, n_ind))
|
||||
return 2; // label alpha coherent...
|
||||
return 2; // mark alpha consistent
|
||||
|
||||
return 0; //sinon oreille a rejeter...
|
||||
return 0; // ear to be rejected
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1753,7 +1748,7 @@ namespace CGAL {
|
|||
Edge_like ordered_key(v1,v2);
|
||||
|
||||
if (!is_border_elt(ordered_key, result12))
|
||||
std::cerr << "+++probleme coherence bord <validate>" << std::endl;
|
||||
std::cerr << "+++issue with border consistency <validate>" << std::endl;
|
||||
|
||||
bool is_border_el1 = is_border_elt(ordered_el1, result1),
|
||||
is_border_el2 = is_border_elt(ordered_el2, result2);
|
||||
|
|
@ -1782,8 +1777,7 @@ namespace CGAL {
|
|||
return FINAL_CASE;
|
||||
}
|
||||
//---------------------------------------------------------------------
|
||||
//on peut alors marquer v1 et on pourrait essayer de merger
|
||||
//sans faire de calcul inutile???
|
||||
// we can then mark v1 and could try to merge without any useless computation???
|
||||
if (is_border_el1)
|
||||
{
|
||||
Edge_incident_facet edge_Ifacet_2(Edge(c, i, edge_Efacet.first.third),
|
||||
|
|
@ -1796,7 +1790,7 @@ namespace CGAL {
|
|||
return EAR_CASE;
|
||||
}
|
||||
//---------------------------------------------------------------------
|
||||
//idem pour v2
|
||||
//idem for v2
|
||||
if (is_border_el2)
|
||||
{
|
||||
Edge_incident_facet edge_Ifacet_1(Edge(c, i, edge_Efacet.first.second),
|
||||
|
|
@ -1852,9 +1846,9 @@ namespace CGAL {
|
|||
// border incident to a point... _mark<1 even if th orientation
|
||||
// may be such as one vh has 2 successorson the same border...
|
||||
{
|
||||
// a ce niveau on peut tester si le recollement se fait en
|
||||
// maintenant la compatibilite d'orientation des bords (pour
|
||||
// surface orientable...) ou si elle est brisee...
|
||||
// at this level, we can test if glueing can be done while keeping
|
||||
// compatible orientations for the borders (for an orientable surface...)
|
||||
// or if it is broken
|
||||
Edge_incident_facet edge_Ifacet_1(Edge(c, i, edge_Efacet.first.second),
|
||||
edge_Efacet.second);
|
||||
Edge_incident_facet edge_Ifacet_2(Edge(c, i, edge_Efacet.first.third),
|
||||
|
|
@ -1884,8 +1878,8 @@ namespace CGAL {
|
|||
Border_elt result_ear2;
|
||||
|
||||
Edge_like ear1_e, ear2_e;
|
||||
// pour maintenir la reconstruction d'une surface orientable :
|
||||
// on verifie que les bords se recollent dans des sens opposes
|
||||
// to preserve the reconstruction of an orientable surface, we check that
|
||||
// borders glue to one another in opposite directions
|
||||
if (ordered_key.first==v1)
|
||||
{
|
||||
ear1_e = Edge_like(c->vertex(i), ear1_c ->vertex(ear1_i));
|
||||
|
|
@ -1897,7 +1891,7 @@ namespace CGAL {
|
|||
ear2_e = Edge_like(c->vertex(i), ear2_c ->vertex(ear2_i));
|
||||
}
|
||||
|
||||
//maintient la surface orientable
|
||||
// preserves orientability of the surface
|
||||
bool is_border_ear1 = is_ordered_border_elt(ear1_e, result_ear1);
|
||||
bool is_border_ear2 = is_ordered_border_elt(ear2_e, result_ear2);
|
||||
bool ear1_valid(false), ear2_valid(false);
|
||||
|
|
@ -1931,8 +1925,7 @@ namespace CGAL {
|
|||
{
|
||||
Validation_case res = validate(ear1, e1.first);
|
||||
if (!((res == EAR_CASE)||(res == FINAL_CASE)))
|
||||
std::cerr << "+++probleme de recollement : cas "
|
||||
<< res << std::endl;
|
||||
std::cerr << "+++issue in glueing: case " << res << std::endl;
|
||||
e2 = compute_value(edge_Ifacet_2);
|
||||
|
||||
if (ordered_key.first == v1)
|
||||
|
|
@ -1948,8 +1941,7 @@ namespace CGAL {
|
|||
{
|
||||
Validation_case res = validate(ear2, e2.first);
|
||||
if (!((res == EAR_CASE)||(res == FINAL_CASE)))
|
||||
std::cerr << "+++probleme de recollement : cas "
|
||||
<< res << std::endl;
|
||||
std::cerr << "+++issue in glueing : case " << res << std::endl;
|
||||
e1 = compute_value(edge_Ifacet_1);
|
||||
|
||||
if (ordered_key.first == v1)
|
||||
|
|
@ -1962,25 +1954,23 @@ namespace CGAL {
|
|||
_ordered_border.insert(Radius_ptr_type(e1.first, p1));
|
||||
}
|
||||
}
|
||||
else// les deux oreilles ne se recollent pas sur la meme arete...
|
||||
else // both ears do not glue on the same edge
|
||||
{
|
||||
// on resoud la singularite.
|
||||
// resolve the singularity
|
||||
if (ear1_valid)
|
||||
{
|
||||
Validation_case res = validate(ear1, e1.first);
|
||||
if (!((res == EAR_CASE)||(res == FINAL_CASE)))
|
||||
std::cerr << "+++probleme de recollement : cas "
|
||||
<< res << std::endl;
|
||||
std::cerr << "+++issue in glueing: case " << res << std::endl;
|
||||
}
|
||||
if (ear2_valid)
|
||||
{
|
||||
Validation_case res = validate(ear2, e2.first);
|
||||
if (!((res == EAR_CASE)||(res == FINAL_CASE)))
|
||||
std::cerr << "+++probleme de recollement : cas "
|
||||
<< res << std::endl;
|
||||
std::cerr << "+++issue in glueing : case " << res << std::endl;
|
||||
}
|
||||
// on met a jour la PQ s'il y a lieu... mais surtout pas
|
||||
// avant la resolution de la singularite
|
||||
|
||||
// Update the PQ if needed, but not before resolving the singularity
|
||||
if (!ear1_valid)
|
||||
{
|
||||
_ordered_border.insert(Radius_ptr_type(e1.first, p1));
|
||||
|
|
@ -2020,7 +2010,7 @@ namespace CGAL {
|
|||
|
||||
if (new_candidate.first == STANDBY_CANDIDATE)
|
||||
{
|
||||
// a garder pour un K un peu plus grand...
|
||||
// put aside for a slightly larger K
|
||||
new_candidate.first = STANDBY_CANDIDATE_BIS;
|
||||
}
|
||||
|
||||
|
|
@ -2042,8 +2032,8 @@ namespace CGAL {
|
|||
void
|
||||
extend()
|
||||
{
|
||||
// initilisation de la variable globale K: qualite d'echantillonnage requise
|
||||
K = K_init; // valeur d'initialisation de K pour commencer prudemment...
|
||||
// Initialize the global variable K: required sampling quality
|
||||
K = K_init; // initial value of K to start carefully
|
||||
coord_type K_prev = K;
|
||||
|
||||
Vertex_handle v1, v2;
|
||||
|
|
@ -2052,7 +2042,7 @@ namespace CGAL {
|
|||
}
|
||||
do
|
||||
{
|
||||
min_K = infinity(); // pour retenir le prochain K necessaire pour progresser...
|
||||
min_K = infinity(); // to store the next K required to progress
|
||||
do
|
||||
{
|
||||
|
||||
|
|
@ -2095,7 +2085,7 @@ namespace CGAL {
|
|||
{
|
||||
new_candidate = compute_value(mem_Ifacet);
|
||||
if ((new_candidate != mem_e_it))
|
||||
// &&(new_candidate.first < NOT_VALID_CANDIDATE))
|
||||
// &&(new_candidate.first < NOT_VALID_CANDIDATE))
|
||||
{
|
||||
IO_edge_type* pnew =
|
||||
set_again_border_elt(key_tmp.first, key_tmp.second,
|
||||
|
|
@ -2111,8 +2101,7 @@ namespace CGAL {
|
|||
(_ordered_border.begin()->first < STANDBY_CANDIDATE_BIS));
|
||||
K_prev = K;
|
||||
K += (std::max)(K_step, min_K - K + eps);
|
||||
// on augmente progressivement le K mais on a deja rempli sans
|
||||
// faire des betises auparavant...
|
||||
// Progressively increase K, but having already filled without issue beforehand
|
||||
}
|
||||
while((!_ordered_border.empty())&&(K <= K)&&(min_K != infinity())&&(K!=K_prev));
|
||||
|
||||
|
|
@ -2125,9 +2114,8 @@ namespace CGAL {
|
|||
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
// En principe, si l'allocateur de cellules etait bien fait on aurait pas besoin
|
||||
// de mettre a jour les valeurs rajoutees pour les cellules a la main...
|
||||
|
||||
// In theory, if the cell allocator were properly made, one would not need to manually update
|
||||
// the values added for the cells
|
||||
void
|
||||
re_init_for_free_cells_cache(const Vertex_handle& vh)
|
||||
{
|
||||
|
|
@ -2152,9 +2140,8 @@ namespace CGAL {
|
|||
int index = c->index(vh);
|
||||
Cell_handle neigh = c->neighbor(index);
|
||||
int n_ind = neigh->index(c);
|
||||
neigh->set_smallest_radius(n_ind, -1); // pour obliger le recalcul
|
||||
// si c est selectionnee c'est qu'elle est aussi le mem_IFacet renvoye par
|
||||
// compute_value... donc a swapper aussi
|
||||
neigh->set_smallest_radius(n_ind, -1); // forces recomputation
|
||||
// if c is selected, then it is also the mem_IFacet returned by compute_value... so to be swapped too
|
||||
if (c->is_selected_facet(index))
|
||||
{
|
||||
int fn = c->facet_number(index);
|
||||
|
|
@ -2214,8 +2201,8 @@ namespace CGAL {
|
|||
circ = next(circ);
|
||||
}
|
||||
while(circ.first.first != c);
|
||||
// si on passe par la, alors y a eu un probleme....
|
||||
std::cerr << "+++probleme dans la MAJ avant remove..." << std::endl;
|
||||
// if we are here, something went wrong
|
||||
std::cerr << "+++issue in the update before removal..." << std::endl;
|
||||
return Facet(c, start.second);
|
||||
}
|
||||
|
||||
|
|
@ -2237,7 +2224,7 @@ namespace CGAL {
|
|||
ordered_map_erase(border_elt.second.first.first,
|
||||
border_IO_elt(vh, vh_succ));
|
||||
remove_border_edge(vh, vh_succ);
|
||||
// 1- a virer au cas ou car vh va etre detruit
|
||||
// 1- remove just in case since vh is about to be destroyed
|
||||
remove_interior_edge(vh_succ, vh);
|
||||
bool while_cond(true);
|
||||
do
|
||||
|
|
@ -2266,14 +2253,14 @@ namespace CGAL {
|
|||
{
|
||||
ordered_map_erase(result.first.first, border_IO_elt(vh_int, vh));
|
||||
remove_border_edge(vh_int, vh);
|
||||
// 1- a virer au cas ou car vh va etre detruit
|
||||
// 1- remove just in case since vh is about to be destroyed
|
||||
remove_interior_edge(vh_int, vh);
|
||||
while_cond = false;
|
||||
}
|
||||
// a titre preventif... on essaye de s'assurer de marquer les aretes
|
||||
// interieures au sens large...
|
||||
|
||||
// 2- a virer a tout pris pour que maintenir le sens de interior edge
|
||||
// As a preventive measure, we try to ensure marking the interior edges in a broad sense
|
||||
|
||||
// 2- remove to preserve the interior edge
|
||||
remove_interior_edge(vh_int, vh_succ);
|
||||
remove_interior_edge(vh_succ, vh_int);
|
||||
|
||||
|
|
@ -2304,16 +2291,16 @@ namespace CGAL {
|
|||
bool
|
||||
create_singularity(const Vertex_handle& vh)
|
||||
{
|
||||
// Pour reperer le cas de triangle isole
|
||||
// To detect the isolated triangle case
|
||||
if (vh->is_on_border())
|
||||
{
|
||||
// vh sommet 0
|
||||
// vh vertex 0
|
||||
Next_border_elt border_elt = *(vh->first_incident());
|
||||
Vertex_handle vh_1 = border_elt.first;// sommet 1
|
||||
Vertex_handle vh_1 = border_elt.first;// vertex 1
|
||||
border_elt = *(vh_1->first_incident());
|
||||
Vertex_handle vh_2 = border_elt.first;// sommet 2
|
||||
Vertex_handle vh_2 = border_elt.first;// vertex 2
|
||||
border_elt = *(vh_2->first_incident());
|
||||
Vertex_handle vh_3 = border_elt.first;// sommet 0 ???
|
||||
Vertex_handle vh_3 = border_elt.first;// vertex 0 ???
|
||||
Cell_handle c;
|
||||
int i, j, k;
|
||||
if ((vh_3 == vh)&&(T.is_facet(vh, vh_1, vh_2, c, i ,j ,k)))
|
||||
|
|
@ -2328,7 +2315,7 @@ namespace CGAL {
|
|||
}
|
||||
|
||||
|
||||
// Reperer le cas d'aretes interieures...
|
||||
// Detect the interior edges case
|
||||
std::list<Vertex_handle> vh_list;
|
||||
T.incident_vertices(vh, std::back_inserter(vh_list));
|
||||
|
||||
|
|
@ -2402,9 +2389,9 @@ namespace CGAL {
|
|||
|
||||
std::list<Vertex_handle> L_v;
|
||||
|
||||
// Pour controler les sommets choisis sur le bord...
|
||||
// To control vertices chosen on the boundary
|
||||
|
||||
// nombre d'aretes a partir duquel on considere que c'est irrecuperable NB_BORDER_MAX
|
||||
// NB_BORDER_MAX: number of edges from which we consider that things are irrecoverable
|
||||
|
||||
int vh_on_border_inserted(0);
|
||||
for(Finite_vertices_iterator v_it = T.finite_vertices_begin();
|
||||
|
|
@ -2445,7 +2432,7 @@ namespace CGAL {
|
|||
|
||||
std::size_t itmp, L_v_size_mem;
|
||||
L_v_size_mem = L_v.size();
|
||||
if ((vh_on_border_inserted != 0)&& // pour ne post-traiter que les bords
|
||||
if ((vh_on_border_inserted != 0)&& // to post-process only the borders
|
||||
(L_v.size() < .1 * _size_before_postprocessing))
|
||||
{
|
||||
{
|
||||
|
|
@ -2460,7 +2447,7 @@ namespace CGAL {
|
|||
}
|
||||
#ifdef VERBOSE
|
||||
if(L_v.size() > 0){
|
||||
std::cout << " " << L_v.size() << " non regular points." << std::endl;
|
||||
std::cout << " " << L_v.size() << " non-regular points." << std::endl;
|
||||
}
|
||||
#endif // VERBOSE
|
||||
re_compute_values();
|
||||
|
|
@ -2469,7 +2456,7 @@ namespace CGAL {
|
|||
postprocess_timer.stop();
|
||||
return false;
|
||||
}
|
||||
// we stop if we removed more than 10% of points or after 20 rounds
|
||||
// we stop if we removed more than 10% of points, or after 20 rounds
|
||||
if ((L_v_size_mem == L_v.size())||
|
||||
((_size_before_postprocessing - T.number_of_vertices()) >
|
||||
.1 * _size_before_postprocessing)||
|
||||
|
|
@ -2479,7 +2466,6 @@ namespace CGAL {
|
|||
}
|
||||
|
||||
min_K = infinity();
|
||||
// fin--
|
||||
// if (_postprocessing_counter < 5)
|
||||
// return true;
|
||||
postprocess_timer.stop();
|
||||
|
|
|
|||
|
|
@ -220,7 +220,7 @@ namespace CGAL {
|
|||
else
|
||||
{
|
||||
if (m_incident_border->second->first != nullptr)
|
||||
std::cerr << "+++probleme de MAJ du bord <Vertex_base>" << std::endl;
|
||||
std::cerr << "+++issue while updating border <Vertex_base>" << std::endl;
|
||||
*m_incident_border->second = elt;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ namespace AlgebraicStructureTraits_{
|
|||
`AdaptableBinaryFunction` computes the integral quotient of division
|
||||
with remainder.
|
||||
|
||||
\cgalRefines `AdaptableBinaryFunction`
|
||||
\cgalRefines{AdaptableBinaryFunction}
|
||||
|
||||
\sa `AlgebraicStructureTraits`
|
||||
\sa `AlgebraicStructureTraits_::Mod`
|
||||
|
|
@ -58,4 +58,4 @@ template <class NT1, class NT2> result_type operator()(NT1 x, NT2 y);
|
|||
|
||||
}; /* end Div */
|
||||
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -189,7 +189,7 @@ r
|
|||
|
||||
</TABLE>
|
||||
|
||||
\cgalRefines `AdaptableFunctor`
|
||||
\cgalRefines{AdaptableFunctor}
|
||||
|
||||
\sa `AlgebraicStructureTraits`
|
||||
\sa `AlgebraicStructureTraits_::Mod`
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ This functor is required to provide two operators. The first operator takes two
|
|||
arguments and returns true if the first argument divides the second argument.
|
||||
The second operator returns \f$ c\f$ via the additional third argument.
|
||||
|
||||
\cgalRefines `AdaptableBinaryFunction`
|
||||
\cgalRefines{AdaptableBinaryFunction}
|
||||
|
||||
\sa `AlgebraicStructureTraits`
|
||||
\sa `AlgebraicStructureTraits_::IntegralDivision`
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ unit-normal (i.e.\ have unit part 1).
|
|||
to the partial order of divisibility. This is because an element \f$ a \in R\f$ is said to divide \f$ b \in R\f$, iff \f$ \exists r \in R\f$ such that \f$ a \cdot r = b\f$.
|
||||
Thus, \f$ 0\f$ is divided by every element of the Ring, in particular by itself.
|
||||
|
||||
\cgalRefines `AdaptableBinaryFunction`
|
||||
\cgalRefines{AdaptableBinaryFunction}
|
||||
|
||||
\sa `AlgebraicStructureTraits`
|
||||
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ exists (i.e.\ if \f$ x\f$ is divisible by \f$ y\f$). Otherwise the effect of inv
|
|||
this operation is undefined. Since the ring represented is an integral domain,
|
||||
\f$ z\f$ is uniquely defined if it exists.
|
||||
|
||||
\cgalRefines `AdaptableBinaryFunction`
|
||||
\cgalRefines{AdaptableBinaryFunction}
|
||||
|
||||
\sa `AlgebraicStructureTraits`
|
||||
\sa `AlgebraicStructureTraits_::Divides`
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ namespace AlgebraicStructureTraits_{
|
|||
`AdaptableUnaryFunction` providing the inverse element with
|
||||
respect to multiplication of a `Field`.
|
||||
|
||||
\cgalRefines `AdaptableUnaryFunction`
|
||||
\cgalRefines{AdaptableUnaryFunction}
|
||||
|
||||
\sa `AlgebraicStructureTraits`
|
||||
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ namespace AlgebraicStructureTraits_{
|
|||
`AdaptableUnaryFunction`,
|
||||
returns true in case the argument is the one of the ring.
|
||||
|
||||
\cgalRefines `AdaptableUnaryFunction`
|
||||
\cgalRefines{AdaptableUnaryFunction}
|
||||
|
||||
\sa `AlgebraicStructureTraits`
|
||||
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ A ring element \f$ x\f$ is said to be a square iff there exists a ring element \
|
|||
that \f$ x= y*y\f$. In case the ring is a `UniqueFactorizationDomain`,
|
||||
\f$ y\f$ is uniquely defined up to multiplication by units.
|
||||
|
||||
\cgalRefines `AdaptableBinaryFunction`
|
||||
\cgalRefines{AdaptableBinaryFunction}
|
||||
|
||||
\sa `AlgebraicStructureTraits`
|
||||
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ namespace AlgebraicStructureTraits_{
|
|||
|
||||
`AdaptableUnaryFunction`, returns true in case the argument is the zero element of the ring.
|
||||
|
||||
\cgalRefines `AdaptableUnaryFunction`
|
||||
\cgalRefines{AdaptableUnaryFunction}
|
||||
|
||||
\sa `AlgebraicStructureTraits`
|
||||
\sa `RealEmbeddableTraits_::IsZero`
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ namespace AlgebraicStructureTraits_{
|
|||
|
||||
`AdaptableBinaryFunction` providing the k-th root.
|
||||
|
||||
\cgalRefines `AdaptableBinaryFunction`
|
||||
\cgalRefines{AdaptableBinaryFunction}
|
||||
|
||||
\sa `FieldWithRootOf`
|
||||
\sa `AlgebraicStructureTraits`
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ namespace AlgebraicStructureTraits_ {
|
|||
|
||||
`AdaptableBinaryFunction` computes the remainder of division with remainder.
|
||||
|
||||
\cgalRefines `AdaptableBinaryFunction`
|
||||
\cgalRefines{AdaptableBinaryFunction}
|
||||
|
||||
\sa `AlgebraicStructureTraits`
|
||||
\sa `AlgebraicStructureTraits_::Div`
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ namespace AlgebraicStructureTraits_{
|
|||
`AdaptableFunctor` computes a real root of a square-free univariate
|
||||
polynomial.
|
||||
|
||||
\cgalRefines `AdaptableFunctor`
|
||||
\cgalRefines{AdaptableFunctor}
|
||||
|
||||
\sa `FieldWithRootOf`
|
||||
\sa `AlgebraicStructureTraits`
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ namespace AlgebraicStructureTraits_{
|
|||
|
||||
This `AdaptableUnaryFunction` may simplify a given object.
|
||||
|
||||
\cgalRefines `AdaptableUnaryFunction`
|
||||
\cgalRefines{AdaptableUnaryFunction}
|
||||
|
||||
\sa `AlgebraicStructureTraits`
|
||||
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ namespace AlgebraicStructureTraits_{
|
|||
|
||||
`AdaptableUnaryFunction` providing the square root.
|
||||
|
||||
\cgalRefines `AdaptableUnaryFunction`
|
||||
\cgalRefines{AdaptableUnaryFunction}
|
||||
|
||||
\sa `AlgebraicStructureTraits`
|
||||
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ namespace AlgebraicStructureTraits_{
|
|||
|
||||
`AdaptableUnaryFunction`, computing the square of the argument.
|
||||
|
||||
\cgalRefines `AdaptableUnaryFunction`
|
||||
\cgalRefines{AdaptableUnaryFunction}
|
||||
|
||||
\sa `AlgebraicStructureTraits`
|
||||
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ hence the unit-part of a non-zero integer is its sign. For a `Field`, every
|
|||
non-zero element is a unit and is its own unit part, its unit normal
|
||||
associate being one. The unit part of zero is, by convention, one.
|
||||
|
||||
\cgalRefines `AdaptableUnaryFunction`
|
||||
\cgalRefines{AdaptableUnaryFunction}
|
||||
|
||||
\sa `AlgebraicStructureTraits`
|
||||
|
||||
|
|
|
|||
|
|
@ -139,7 +139,7 @@ typedef unspecified_type Is_numerical_sensitive;
|
|||
This type specifies the return type of the predicates provided
|
||||
by this traits. The type must be convertible to `bool` and
|
||||
typically the type indeed maps to `bool`. However, there are also
|
||||
cases such as interval arithmetic, in which it is `Uncertain<bool>`
|
||||
cases such as interval arithmetic, in which it is `CGAL::Uncertain<bool>`
|
||||
or some similar type.
|
||||
|
||||
*/
|
||||
|
|
@ -300,4 +300,3 @@ typedef unspecified_type Root_of;
|
|||
/// @}
|
||||
|
||||
}; /* end AlgebraicStructureTraits */
|
||||
|
||||
|
|
|
|||
|
|
@ -25,7 +25,7 @@ The most prominent example of a Euclidean ring are the integers.
|
|||
Whenever both \f$ x\f$ and \f$ y\f$ are positive, then it is conventional to choose
|
||||
the smallest positive remainder \f$ r\f$.
|
||||
|
||||
\cgalRefines `UniqueFactorizationDomain`
|
||||
\cgalRefines{UniqueFactorizationDomain}
|
||||
|
||||
\sa `IntegralDomainWithoutDivision`
|
||||
\sa `IntegralDomain`
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ Moreover, `CGAL::Algebraic_structure_traits< Field >` is a model of
|
|||
- \link AlgebraicStructureTraits::Algebraic_category `CGAL::Algebraic_structure_traits< Field >::Algebraic_category` \endlink derived from `CGAL::Field_tag`
|
||||
- \link AlgebraicStructureTraits::Inverse `CGAL::Algebraic_structure_traits< FieldWithSqrt >::Inverse` \endlink which is a model of `AlgebraicStructureTraits_::Inverse`
|
||||
|
||||
\cgalRefines `IntegralDomain`
|
||||
\cgalRefines{IntegralDomain}
|
||||
|
||||
\sa `IntegralDomainWithoutDivision`
|
||||
\sa `IntegralDomain`
|
||||
|
|
|
|||
|
|
@ -7,8 +7,7 @@ The concept `FieldNumberType` combines the requirements of the concepts
|
|||
A model of `FieldNumberType` can be used as a template parameter
|
||||
for Cartesian kernels.
|
||||
|
||||
\cgalRefines `Field`
|
||||
\cgalRefines `RealEmbeddable`
|
||||
\cgalRefines{Field,RealEmbeddable}
|
||||
|
||||
\cgalHasModel float
|
||||
\cgalHasModel double
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ Moreover, `CGAL::Algebraic_structure_traits< FieldWithKthRoot >` is a model of `
|
|||
- \link AlgebraicStructureTraits::Algebraic_category `CGAL::Algebraic_structure_traits< FieldWithKthRoot >::Algebraic_category` \endlink derived from `CGAL::Field_with_kth_root_tag`
|
||||
- \link AlgebraicStructureTraits::Kth_root `CGAL::Algebraic_structure_traits< FieldWithKthRoot >::Kth_root` \endlink which is a model of `AlgebraicStructureTraits_::KthRoot`
|
||||
|
||||
\cgalRefines `FieldWithSqrt`
|
||||
\cgalRefines{FieldWithSqrt}
|
||||
|
||||
\sa `IntegralDomainWithoutDivision`
|
||||
\sa `IntegralDomain`
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ Moreover, `CGAL::Algebraic_structure_traits< FieldWithRootOf >` is a model of `A
|
|||
- \link AlgebraicStructureTraits::Algebraic_category `CGAL::Algebraic_structure_traits< FieldWithRootOf >::Algebraic_category` \endlink derived from `CGAL::Field_with_kth_root_tag`
|
||||
- \link AlgebraicStructureTraits::Root_of `CGAL::Algebraic_structure_traits< FieldWithRootOf >::Root_of` \endlink which is a model of `AlgebraicStructureTraits_::RootOf`
|
||||
|
||||
\cgalRefines `FieldWithKthRoot`
|
||||
\cgalRefines{FieldWithKthRoot}
|
||||
|
||||
\sa `IntegralDomainWithoutDivision`
|
||||
\sa `IntegralDomain`
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ Moreover, `CGAL::Algebraic_structure_traits< FieldWithSqrt >` is a model of `Alg
|
|||
- \link AlgebraicStructureTraits::Algebraic_category `CGAL::Algebraic_structure_traits< FieldWithSqrt >::Algebraic_category` \endlink derived from `CGAL::Field_with_sqrt_tag`
|
||||
- \link AlgebraicStructureTraits::Sqrt `CGAL::Algebraic_structure_traits< FieldWithSqrt >::Sqrt` \endlink which is a model of `AlgebraicStructureTraits_::Sqrt`
|
||||
|
||||
\cgalRefines `Field`
|
||||
\cgalRefines{Field}
|
||||
|
||||
\sa `IntegralDomainWithoutDivision`
|
||||
\sa `IntegralDomain`
|
||||
|
|
|
|||
|
|
@ -113,7 +113,7 @@ FractionTraits::Denominator_type & d);
|
|||
|
||||
`AdaptableBinaryFunction`, returns the fraction of its arguments.
|
||||
|
||||
\cgalRefines `AdaptableBinaryFunction`
|
||||
\cgalRefines{AdaptableBinaryFunction}
|
||||
|
||||
\sa `Fraction`
|
||||
\sa `FractionTraits`
|
||||
|
|
@ -168,7 +168,7 @@ This can be considered as a relaxed version of `AlgebraicStructureTraits_::Gcd`,
|
|||
this is needed because it is not guaranteed that `FractionTraits::Denominator_type` is a model of
|
||||
`UniqueFactorizationDomain`.
|
||||
|
||||
\cgalRefines `AdaptableBinaryFunction`
|
||||
\cgalRefines{AdaptableBinaryFunction}
|
||||
|
||||
\sa `Fraction`
|
||||
\sa `FractionTraits`
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ In this case
|
|||
\link CGAL::Coercion_traits::Are_implicit_interoperable `CGAL::Coercion_traits<A,B>::Are_implicit_interoperable`\endlink
|
||||
is `CGAL::Tag_true`.
|
||||
|
||||
\cgalRefines `ExplicitInteroperable`
|
||||
\cgalRefines{ExplicitInteroperable}
|
||||
|
||||
\sa `CGAL::Coercion_traits<A,B>`
|
||||
\sa `ExplicitInteroperable`
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ Moreover, `CGAL::Algebraic_structure_traits< IntegralDomain >` is a model of
|
|||
- \link AlgebraicStructureTraits::Integral_division `CGAL::Algebraic_structure_traits< IntegralDomain >::Integral_division` \endlink which is a model of `AlgebraicStructureTraits_::IntegralDivision`
|
||||
- \link AlgebraicStructureTraits::Divides `CGAL::Algebraic_structure_traits< IntegralDomain >::Divides` \endlink which is a model of `AlgebraicStructureTraits_::Divides`
|
||||
|
||||
\cgalRefines `IntegralDomainWithoutDivision`
|
||||
\cgalRefines{IntegralDomainWithoutDivision}
|
||||
|
||||
\sa `IntegralDomainWithoutDivision`
|
||||
\sa `IntegralDomain`
|
||||
|
|
|
|||
|
|
@ -29,11 +29,7 @@ Moreover, `CGAL::Algebraic_structure_traits< IntegralDomainWithoutDivision >` is
|
|||
- \link AlgebraicStructureTraits::Simplify `CGAL::Algebraic_structure_traits< IntegralDomainWithoutDivision >::Simplify` \endlink which is a model of `AlgebraicStructureTraits_::Simplify`
|
||||
- \link AlgebraicStructureTraits::Unit_part `CGAL::Algebraic_structure_traits< IntegralDomainWithoutDivision >::Unit_part` \endlink which is a model of `AlgebraicStructureTraits_::UnitPart`
|
||||
|
||||
\cgalRefines `Assignable`
|
||||
\cgalRefines `CopyConstructible`
|
||||
\cgalRefines `DefaultConstructible`
|
||||
\cgalRefines `EqualityComparable`
|
||||
\cgalRefines `FromIntConstructible`
|
||||
\cgalRefines{Assignable,CopyConstructible,DefaultConstructible,EqualityComparable,FromIntConstructible}
|
||||
|
||||
\sa `IntegralDomainWithoutDivision`
|
||||
\sa `IntegralDomain`
|
||||
|
|
|
|||
|
|
@ -38,8 +38,7 @@ If a number type is a model of both `IntegralDomainWithoutDivision` and
|
|||
`RealEmbeddable`, it follows that the ring represented by such a number type
|
||||
is a sub-ring of the real numbers and hence has characteristic zero.
|
||||
|
||||
\cgalRefines `EqualityComparable`
|
||||
\cgalRefines `LessThanComparable`
|
||||
\cgalRefines{EqualityComparable,LessThanComparable}
|
||||
|
||||
\sa `RealEmbeddableTraits`
|
||||
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ namespace RealEmbeddableTraits_ {
|
|||
|
||||
`AdaptableUnaryFunction` computes the absolute value of a number.
|
||||
|
||||
\cgalRefines `AdaptableUnaryFunction`
|
||||
\cgalRefines{AdaptableUnaryFunction}
|
||||
|
||||
\sa `RealEmbeddableTraits`
|
||||
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ namespace RealEmbeddableTraits_ {
|
|||
|
||||
`AdaptableBinaryFunction` compares two real embeddable numbers.
|
||||
|
||||
\cgalRefines `AdaptableBinaryFunction`
|
||||
\cgalRefines{AdaptableBinaryFunction}
|
||||
|
||||
\sa `RealEmbeddableTraits`
|
||||
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ namespace RealEmbeddableTraits_ {
|
|||
|
||||
`AdaptableUnaryFunction`, returns true in case the argument is negative.
|
||||
|
||||
\cgalRefines `AdaptableUnaryFunction`
|
||||
\cgalRefines{AdaptableUnaryFunction}
|
||||
|
||||
\sa `RealEmbeddableTraits`
|
||||
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ namespace RealEmbeddableTraits_ {
|
|||
|
||||
`AdaptableUnaryFunction`, returns true in case the argument is positive.
|
||||
|
||||
\cgalRefines `AdaptableUnaryFunction`
|
||||
\cgalRefines{AdaptableUnaryFunction}
|
||||
|
||||
\sa `RealEmbeddableTraits`
|
||||
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ namespace RealEmbeddableTraits_ {
|
|||
|
||||
`AdaptableUnaryFunction`, returns true in case the argument is 0.
|
||||
|
||||
\cgalRefines `AdaptableUnaryFunction`
|
||||
\cgalRefines{AdaptableUnaryFunction}
|
||||
|
||||
\sa `RealEmbeddableTraits`
|
||||
\sa `AlgebraicStructureTraits_::IsZero`
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ namespace RealEmbeddableTraits_ {
|
|||
|
||||
This `AdaptableUnaryFunction` computes the sign of a real embeddable number.
|
||||
|
||||
\cgalRefines `AdaptableUnaryFunction`
|
||||
\cgalRefines{AdaptableUnaryFunction}
|
||||
|
||||
\sa `RealEmbeddableTraits`
|
||||
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ embeddable number.
|
|||
Remark: In order to control the quality of approximation one has to resort
|
||||
to methods that are specific to NT. There are no general guarantees whatsoever.
|
||||
|
||||
\cgalRefines `AdaptableUnaryFunction`
|
||||
\cgalRefines{AdaptableUnaryFunction}
|
||||
|
||||
\sa `RealEmbeddableTraits`
|
||||
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@ namespace RealEmbeddableTraits_ {
|
|||
number \f$ x\f$ a double interval containing \f$ x\f$.
|
||||
This interval is represented by `std::pair<double,double>`.
|
||||
|
||||
\cgalRefines `AdaptableUnaryFunction`
|
||||
\cgalRefines{AdaptableUnaryFunction}
|
||||
|
||||
\sa `RealEmbeddableTraits`
|
||||
|
||||
|
|
|
|||
|
|
@ -25,7 +25,7 @@ typedef unspecified_type Type;
|
|||
/*!
|
||||
Tag indicating whether the associated type is real embeddable.
|
||||
|
||||
This is either \link Tag_true `Tag_true`\endlink or \link Tag_false `Tag_false`\endlink.
|
||||
This is either \link CGAL::Tag_true `Tag_true`\endlink or \link CGAL::Tag_false `Tag_false`\endlink.
|
||||
*/
|
||||
typedef unspecified_type Is_real_embeddable;
|
||||
|
||||
|
|
|
|||
|
|
@ -8,8 +8,7 @@ The concept `RingNumberType` combines the requirements of the concepts
|
|||
A model of `RingNumberType` can be used as a template parameter
|
||||
for Homogeneous kernels.
|
||||
|
||||
\cgalRefines `IntegralDomainWithoutDivision`
|
||||
\cgalRefines `RealEmbeddable`
|
||||
\cgalRefines{IntegralDomainWithoutDivision,RealEmbeddable}
|
||||
|
||||
\cgalHasModel \cpp built-in number types
|
||||
\cgalHasModel `CGAL::Gmpq`
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@ is a model of `AlgebraicStructureTraits` providing:
|
|||
derived from `CGAL::Unique_factorization_domain_tag`
|
||||
- \link AlgebraicStructureTraits::Gcd `CGAL::Algebraic_structure_traits< UniqueFactorizationDomain >::Gcd` \endlink which is a model of `AlgebraicStructureTraits_::Gcd`
|
||||
|
||||
\cgalRefines `IntegralDomain`
|
||||
\cgalRefines{IntegralDomain}
|
||||
|
||||
\sa `IntegralDomainWithoutDivision`
|
||||
\sa `IntegralDomain`
|
||||
|
|
|
|||
|
|
@ -9,8 +9,8 @@ int main(){
|
|||
typedef FT::Numerator_type Numerator_type;
|
||||
typedef FT::Denominator_type Denominator_type;
|
||||
|
||||
CGAL_static_assertion((boost::is_same<Numerator_type,CGAL::Gmpz>::value));
|
||||
CGAL_static_assertion((boost::is_same<Denominator_type,CGAL::Gmpz>::value));
|
||||
CGAL_static_assertion((std::is_same<Numerator_type,CGAL::Gmpz>::value));
|
||||
CGAL_static_assertion((std::is_same<Denominator_type,CGAL::Gmpz>::value));
|
||||
|
||||
Numerator_type numerator;
|
||||
Denominator_type denominator;
|
||||
|
|
|
|||
|
|
@ -354,7 +354,7 @@ class Algebraic_structure_traits_base< Type_,
|
|||
typedef typename CT::Type Coercion_type_NT1_NT2;
|
||||
CGAL_USE_TYPE(Coercion_type_NT1_NT2);
|
||||
CGAL_static_assertion((
|
||||
::boost::is_same<Coercion_type_NT1_NT2 , Type >::value));
|
||||
::std::is_same<Coercion_type_NT1_NT2 , Type >::value));
|
||||
|
||||
typename Coercion_traits< NT1, NT2 >::Cast cast;
|
||||
operator()( cast(x), cast(y), q, r );
|
||||
|
|
|
|||
|
|
@ -23,19 +23,19 @@
|
|||
#define CGAL_COERCION_TRAITS_H 1
|
||||
|
||||
#include <iterator>
|
||||
#include <type_traits>
|
||||
|
||||
#include <CGAL/boost/iterator/transform_iterator.hpp>
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
|
||||
#include <CGAL/tags.h>
|
||||
|
||||
// Makro to define an additional operator for binary functors which takes
|
||||
// Macro to define an additional operator for binary functors which takes
|
||||
// two number types as parameters that are interoperable with the
|
||||
// number type
|
||||
#define CGAL_IMPLICIT_INTEROPERABLE_BINARY_OPERATOR_WITH_RT( NT, Result_type ) \
|
||||
template < class CT_Type_1, class CT_Type_2 > \
|
||||
Result_type operator()( const CT_Type_1& x, const CT_Type_2& y ) const { \
|
||||
CGAL_static_assertion((::boost::is_same< \
|
||||
CGAL_static_assertion((::std::is_same< \
|
||||
typename Coercion_traits< CT_Type_1, CT_Type_2 >::Type, NT \
|
||||
>::value)); \
|
||||
\
|
||||
|
|
|
|||
|
|
@ -28,7 +28,7 @@ class Parens_as_product_tag {};
|
|||
|
||||
/*! \ingroup NiX_io_parens
|
||||
* \brief decides whether this number requires parentheses
|
||||
* in case it appears within a produkt.
|
||||
* in case it appears within a product.
|
||||
*/
|
||||
template <class NT>
|
||||
struct Needs_parens_as_product{
|
||||
|
|
@ -37,7 +37,7 @@ struct Needs_parens_as_product{
|
|||
|
||||
/*! \ingroup NiX_io_parens
|
||||
* \brief decides whether this number requires parentheses
|
||||
* in case it appears within a produkt.
|
||||
* in case it appears within a product.
|
||||
*/
|
||||
template <class NT>
|
||||
inline bool needs_parens_as_product(const NT& x){
|
||||
|
|
|
|||
|
|
@ -21,7 +21,8 @@
|
|||
#include <CGAL/number_type_basic.h>
|
||||
#include <CGAL/Fraction_traits.h>
|
||||
#include <CGAL/is_convertible.h>
|
||||
#include <boost/utility/enable_if.hpp>
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
namespace CGAL {
|
||||
|
||||
|
|
@ -79,11 +80,11 @@ public:
|
|||
{ return make_rational(x.first, x.second); }
|
||||
|
||||
template<class N,class D>
|
||||
Rational make_rational(const N& n, const D& d,typename boost::enable_if_c<is_implicit_convertible<N,RT>::value&&is_implicit_convertible<D,RT>::value,int>::type=0) const
|
||||
Rational make_rational(const N& n, const D& d,std::enable_if_t<is_implicit_convertible<N,RT>::value&&is_implicit_convertible<D,RT>::value,int> = 0) const
|
||||
{ return Compose()(n,d); }
|
||||
|
||||
template<class N,class D>
|
||||
Rational make_rational(const N& n, const D& d,typename boost::enable_if_c<!is_implicit_convertible<N,RT>::value||!is_implicit_convertible<D,RT>::value,int>::type=0) const
|
||||
Rational make_rational(const N& n, const D& d,std::enable_if_t<!is_implicit_convertible<N,RT>::value||!is_implicit_convertible<D,RT>::value,int> = 0) const
|
||||
{ return n/d; } // Assume that n or d is already a fraction
|
||||
};
|
||||
}// namespace internal
|
||||
|
|
@ -92,9 +93,9 @@ public:
|
|||
template <class T>
|
||||
class Rational_traits
|
||||
: public internal::Rational_traits_base<T,
|
||||
::boost::is_same<typename Fraction_traits<T>::Is_fraction,Tag_true>::value
|
||||
::std::is_same<typename Fraction_traits<T>::Is_fraction,Tag_true>::value
|
||||
&&
|
||||
::boost::is_same<
|
||||
::std::is_same<
|
||||
typename Fraction_traits<T>::Numerator_type,
|
||||
typename Fraction_traits<T>::Denominator_type
|
||||
>::value >
|
||||
|
|
|
|||
|
|
@ -85,13 +85,13 @@ public:
|
|||
|
||||
// determine extractable scalar factor
|
||||
Scalar operator () (const NT& a) {
|
||||
CGAL_static_assertion(( ::boost::is_same< NT,Scalar >::value));
|
||||
CGAL_static_assertion(( ::std::is_same< NT,Scalar >::value));
|
||||
typedef typename Algebraic_structure_traits<NT>::Algebraic_category SAT;
|
||||
return scalar_factor(a, SAT());
|
||||
}
|
||||
// determine extractable scalar factor
|
||||
Scalar operator () (const NT& a, const Scalar& d) {
|
||||
CGAL_static_assertion(( ::boost::is_same< NT,Scalar >::value));
|
||||
CGAL_static_assertion(( ::std::is_same< NT,Scalar >::value));
|
||||
typedef typename Algebraic_structure_traits<NT>::Algebraic_category SAT;
|
||||
return scalar_factor(a,d,SAT());
|
||||
}
|
||||
|
|
|
|||
|
|
@ -44,7 +44,7 @@
|
|||
template <typename AdaptableFunctor, typename ResultType>
|
||||
void check_result_type(AdaptableFunctor, ResultType){
|
||||
typedef typename AdaptableFunctor::result_type result_type;
|
||||
CGAL_static_assertion((::boost::is_same<result_type,ResultType>::value));
|
||||
CGAL_static_assertion((::std::is_same<result_type,ResultType>::value));
|
||||
CGAL_USE_TYPE(result_type);
|
||||
}
|
||||
// check nothing for CGAL::Null_functor
|
||||
|
|
@ -123,11 +123,11 @@ void test_algebraic_structure_intern( const CGAL::Integral_domain_tag& ) {
|
|||
|
||||
using CGAL::Null_functor;
|
||||
CGAL_static_assertion(
|
||||
(!::boost::is_same< Integral_division, Null_functor >::value));
|
||||
CGAL_static_assertion((!::boost::is_same< Divides, Null_functor >::value));
|
||||
CGAL_static_assertion((!::boost::is_same< Is_zero, Null_functor >::value));
|
||||
CGAL_static_assertion((!::boost::is_same< Is_one, Null_functor >::value));
|
||||
CGAL_static_assertion((!::boost::is_same< Square, Null_functor >::value));
|
||||
(!::std::is_same< Integral_division, Null_functor >::value));
|
||||
CGAL_static_assertion((!::std::is_same< Divides, Null_functor >::value));
|
||||
CGAL_static_assertion((!::std::is_same< Is_zero, Null_functor >::value));
|
||||
CGAL_static_assertion((!::std::is_same< Is_one, Null_functor >::value));
|
||||
CGAL_static_assertion((!::std::is_same< Square, Null_functor >::value));
|
||||
|
||||
// functor
|
||||
const Is_zero is_zero = Is_zero();
|
||||
|
|
@ -206,7 +206,7 @@ void test_algebraic_structure_intern(
|
|||
CGAL_SNAP_AST_FUNCTORS(AST);
|
||||
|
||||
using CGAL::Null_functor;
|
||||
CGAL_static_assertion((!::boost::is_same< Gcd, Null_functor>::value));
|
||||
CGAL_static_assertion((!::std::is_same< Gcd, Null_functor>::value));
|
||||
|
||||
const Gcd gcd = Gcd();
|
||||
assert( gcd( AS ( 0), AS ( 0)) == unit_normal( AS (0) ) );
|
||||
|
|
@ -268,9 +268,9 @@ void test_algebraic_structure_intern( const CGAL::Euclidean_ring_tag&) {
|
|||
CGAL_SNAP_AST_FUNCTORS(AST);
|
||||
|
||||
using CGAL::Null_functor;
|
||||
CGAL_static_assertion((!::boost::is_same< Div, Null_functor>::value));
|
||||
CGAL_static_assertion((!::boost::is_same< Mod, Null_functor>::value));
|
||||
CGAL_static_assertion((!::boost::is_same< Div_mod, Null_functor>::value));
|
||||
CGAL_static_assertion((!::std::is_same< Div, Null_functor>::value));
|
||||
CGAL_static_assertion((!::std::is_same< Mod, Null_functor>::value));
|
||||
CGAL_static_assertion((!::std::is_same< Div_mod, Null_functor>::value));
|
||||
|
||||
const Div div=Div();
|
||||
const Mod mod=Mod();
|
||||
|
|
@ -387,7 +387,7 @@ void test_algebraic_structure_intern( const CGAL::Field_with_sqrt_tag& ) {
|
|||
|
||||
CGAL_SNAP_AST_FUNCTORS(AST);
|
||||
|
||||
CGAL_static_assertion((!::boost::is_same< Sqrt, Null_functor>::value));
|
||||
CGAL_static_assertion((!::std::is_same< Sqrt, Null_functor>::value));
|
||||
const Sqrt sqrt =Sqrt();
|
||||
AS a(4);
|
||||
|
||||
|
|
@ -614,10 +614,10 @@ class Test_is_square {
|
|||
CGAL_USE_TYPE(Second_argument_type);
|
||||
|
||||
CGAL_static_assertion(
|
||||
( ::boost::is_same< AS , First_argument_type>::value));
|
||||
( ::std::is_same< AS , First_argument_type>::value));
|
||||
CGAL_static_assertion(
|
||||
( ::boost::is_same< AS& , Second_argument_type>::value));
|
||||
//CGAL_static_assertion(( ::boost::is_same< bool , Result_type>::value));
|
||||
( ::std::is_same< AS& , Second_argument_type>::value));
|
||||
//CGAL_static_assertion(( ::std::is_same< bool , Result_type>::value));
|
||||
bool b = Result_type(true); CGAL_USE(b);
|
||||
|
||||
AS test_number = AS(3)*AS(3);
|
||||
|
|
@ -649,8 +649,8 @@ public:
|
|||
typedef typename Sqrt::result_type Result_type;
|
||||
CGAL_USE_TYPE(Argument_type);
|
||||
CGAL_USE_TYPE(Result_type);
|
||||
CGAL_static_assertion(( ::boost::is_same< AS , Argument_type>::value));
|
||||
CGAL_static_assertion(( ::boost::is_same< AS , Result_type>::value));
|
||||
CGAL_static_assertion(( ::std::is_same< AS , Argument_type>::value));
|
||||
CGAL_static_assertion(( ::std::is_same< AS , Result_type>::value));
|
||||
typedef Algebraic_structure_traits<AS> AST;
|
||||
typedef typename AST::Is_exact Is_exact;
|
||||
assert( !Is_exact::value || AS (3) == sqrt( AS (9)));
|
||||
|
|
@ -676,11 +676,11 @@ public:
|
|||
CGAL_USE_TYPE(Second_argument_type);
|
||||
CGAL_USE_TYPE(Result_type);
|
||||
CGAL_static_assertion(
|
||||
( ::boost::is_same<int, First_argument_type>::value));
|
||||
( ::std::is_same<int, First_argument_type>::value));
|
||||
CGAL_static_assertion(
|
||||
( ::boost::is_same< AS , Second_argument_type>::value));
|
||||
( ::std::is_same< AS , Second_argument_type>::value));
|
||||
CGAL_static_assertion(
|
||||
( ::boost::is_same< AS , Result_type>::value));
|
||||
( ::std::is_same< AS , Result_type>::value));
|
||||
AS epsilon(1);
|
||||
assert( test_equality_epsilon( AS (2),
|
||||
root( 4, AS (16) ), epsilon ) );
|
||||
|
|
@ -803,7 +803,7 @@ void test_algebraic_structure(){
|
|||
typedef CGAL::Algebraic_structure_traits< AS > AST;
|
||||
CGAL_SNAP_AST_FUNCTORS(AST);
|
||||
|
||||
CGAL_static_assertion((::boost::is_same<AS,typename AST::Type>::value));
|
||||
CGAL_static_assertion((::std::is_same<AS,typename AST::Type>::value));
|
||||
|
||||
typedef typename AST::Boolean Boolean;
|
||||
assert(!Boolean());
|
||||
|
|
@ -817,13 +817,13 @@ void test_algebraic_structure(){
|
|||
using CGAL::Null_functor;
|
||||
// Test for desired exactness
|
||||
CGAL_static_assertion(
|
||||
( ::boost::is_same< typename AST::Is_exact, Is_exact >::value));
|
||||
( ::std::is_same< typename AST::Is_exact, Is_exact >::value));
|
||||
|
||||
CGAL_static_assertion(( ::boost::is_convertible< Tag,
|
||||
Integral_domain_without_division_tag >::value ));
|
||||
CGAL_static_assertion(( ::boost::is_same< Tag, Algebraic_category>::value));
|
||||
CGAL_static_assertion((!::boost::is_same< Simplify, Null_functor>::value));
|
||||
CGAL_static_assertion((!::boost::is_same< Unit_part, Null_functor>::value));
|
||||
CGAL_static_assertion(( ::std::is_same< Tag, Algebraic_category>::value));
|
||||
CGAL_static_assertion((!::std::is_same< Simplify, Null_functor>::value));
|
||||
CGAL_static_assertion((!::std::is_same< Unit_part, Null_functor>::value));
|
||||
const Simplify simplify=Simplify();;
|
||||
const Unit_part unit_part= Unit_part();
|
||||
|
||||
|
|
@ -944,7 +944,7 @@ void test_algebraic_structure( const AS & a, const AS & b, const AS & c) {
|
|||
typedef CGAL::Algebraic_structure_traits<AS> AST;
|
||||
typedef typename AST::Is_numerical_sensitive Is_numerical_sensitive;
|
||||
CGAL_static_assertion(
|
||||
!(::boost::is_same<Is_numerical_sensitive, CGAL::Null_tag>::value));
|
||||
!(::std::is_same<Is_numerical_sensitive, CGAL::Null_tag>::value));
|
||||
CGAL_USE_TYPE(Is_numerical_sensitive);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -327,8 +327,8 @@ void test_implicit_interoperable_one_way() {
|
|||
typedef typename CT::Are_implicit_interoperable Are_implicit_interoperable;
|
||||
|
||||
CGAL_static_assertion(
|
||||
(::boost::is_same<Are_implicit_interoperable, CGAL::Tag_true>::value));
|
||||
assert((::boost::is_same<Are_implicit_interoperable, CGAL::Tag_true>::value));
|
||||
(::std::is_same<Are_implicit_interoperable, CGAL::Tag_true>::value));
|
||||
assert((::std::is_same<Are_implicit_interoperable, CGAL::Tag_true>::value));
|
||||
|
||||
typename CGAL::Real_embeddable_traits<C>::Is_real_embeddable is_real_embeddable;
|
||||
test_implicit_interoperable_for_real_embeddable<A,B>(is_real_embeddable);
|
||||
|
|
@ -346,9 +346,9 @@ void test_explicit_interoperable_one_way(){
|
|||
typedef typename CT::Cast Cast;
|
||||
typedef typename Cast::result_type result_type;
|
||||
CGAL_USE_TYPE(result_type);
|
||||
CGAL_static_assertion((::boost::is_same<result_type,Type>::value));
|
||||
CGAL_static_assertion((::boost::is_same< typename CT::Are_explicit_interoperable,CGAL::Tag_true>::value));
|
||||
CGAL_static_assertion((::boost::is_same<Type,RT>::value));
|
||||
CGAL_static_assertion((::std::is_same<result_type,Type>::value));
|
||||
CGAL_static_assertion((::std::is_same< typename CT::Are_explicit_interoperable,CGAL::Tag_true>::value));
|
||||
CGAL_static_assertion((::std::is_same<Type,RT>::value));
|
||||
typename CT::Cast cast;
|
||||
|
||||
A a(3);
|
||||
|
|
|
|||
|
|
@ -37,11 +37,11 @@ void test_fraction_traits(){
|
|||
typedef typename FT::Compose Compose;
|
||||
|
||||
CGAL_USE_TYPE(Is_fraction);
|
||||
CGAL_static_assertion( (::boost::is_same<Type,T>::value));
|
||||
CGAL_static_assertion( (::boost::is_same<Is_fraction,Tag_true>::value));
|
||||
CGAL_static_assertion(!(::boost::is_same<Common_factor,Null_functor>::value));
|
||||
CGAL_static_assertion(!(::boost::is_same<Decompose,Null_functor>::value));
|
||||
CGAL_static_assertion(!(::boost::is_same<Compose,Null_functor>::value));
|
||||
CGAL_static_assertion( (::std::is_same<Type,T>::value));
|
||||
CGAL_static_assertion( (::std::is_same<Is_fraction,Tag_true>::value));
|
||||
CGAL_static_assertion(!(::std::is_same<Common_factor,Null_functor>::value));
|
||||
CGAL_static_assertion(!(::std::is_same<Decompose,Null_functor>::value));
|
||||
CGAL_static_assertion(!(::std::is_same<Compose,Null_functor>::value));
|
||||
|
||||
|
||||
// Decompose
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@ void test_rational_traits(){
|
|||
|
||||
typedef Rational_traits<Rational> Rational_traits;
|
||||
typedef typename Rational_traits::RT RT;
|
||||
CGAL_static_assertion((::boost::is_same<RT,RT>::value));
|
||||
CGAL_static_assertion((::std::is_same<RT,RT>::value));
|
||||
|
||||
assert( Rational_traits().numerator(x) == RT(7));
|
||||
assert( Rational_traits().denominator(x) == RT(2));
|
||||
|
|
@ -39,7 +39,7 @@ void test_rational_traits(){
|
|||
assert( Rational_traits().make_rational(std::make_pair(x,x)) == Rational(1));
|
||||
assert( Rational_traits().make_rational(std::make_pair(7,RT(2))) == x);
|
||||
|
||||
// gloabal function to_rational
|
||||
// global function to_rational
|
||||
x = CGAL::to_rational<Rational>(3.5);
|
||||
assert( x == Rational(7)/Rational(2));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -48,9 +48,9 @@ namespace CGAL {
|
|||
void operator() (const ToDouble& to_double) {
|
||||
typedef typename ToDouble::argument_type Argument_type;
|
||||
typedef typename ToDouble::result_type Result_type;
|
||||
CGAL_static_assertion(( ::boost::is_same<Type, Argument_type>::value));
|
||||
CGAL_static_assertion(( ::std::is_same<Type, Argument_type>::value));
|
||||
CGAL_USE_TYPE(Argument_type);
|
||||
CGAL_static_assertion(( ::boost::is_same<double, Result_type>::value));
|
||||
CGAL_static_assertion(( ::std::is_same<double, Result_type>::value));
|
||||
CGAL_USE_TYPE(Result_type);
|
||||
assert(42.0 == to_double(Type(42)));
|
||||
}
|
||||
|
|
@ -71,9 +71,9 @@ namespace CGAL {
|
|||
typedef typename To_interval::argument_type Argument_type;
|
||||
typedef typename To_interval::result_type Result_type;
|
||||
typedef std::pair<double,double> Interval_type;
|
||||
CGAL_static_assertion(( ::boost::is_same<Type, Argument_type>::value));
|
||||
CGAL_static_assertion(( ::std::is_same<Type, Argument_type>::value));
|
||||
CGAL_USE_TYPE(Argument_type);
|
||||
CGAL_static_assertion(( ::boost::is_same<Interval_type, Result_type>::value));
|
||||
CGAL_static_assertion(( ::std::is_same<Interval_type, Result_type>::value));
|
||||
CGAL_USE_TYPE(Result_type); CGAL_USE_TYPE(Interval_type);
|
||||
|
||||
// assert(NiX::in(42.0,to_Interval(Type(42))));
|
||||
|
|
@ -84,7 +84,7 @@ namespace CGAL {
|
|||
assert(to_interval(Type(42)).first > 41.99);
|
||||
assert(to_interval(Type(42)).second < 42.01);
|
||||
|
||||
// test neagtive numbers as well to catch obvious sign
|
||||
// test negative numbers as well to catch obvious sign
|
||||
// errors
|
||||
assert( -42.0 >= to_interval( -Type(42) ).first );
|
||||
assert( -42.0 <= to_interval( -Type(42) ).second );
|
||||
|
|
@ -139,7 +139,7 @@ void test_real_embeddable() {
|
|||
CGAL_SNAP_RET_FUNCTORS(RET);
|
||||
typedef typename RET::Is_real_embeddable Is_real_embeddable;
|
||||
using CGAL::Tag_true;
|
||||
CGAL_static_assertion(( ::boost::is_same< Is_real_embeddable, Tag_true>::value));
|
||||
CGAL_static_assertion(( ::std::is_same< Is_real_embeddable, Tag_true>::value));
|
||||
CGAL_USE_TYPE(Is_real_embeddable);
|
||||
|
||||
typedef typename RET::Boolean Boolean;
|
||||
|
|
@ -246,7 +246,7 @@ void test_not_real_embeddable() {
|
|||
typedef CGAL::Real_embeddable_traits<Type> RET;
|
||||
typedef typename RET::Is_real_embeddable Is_real_embeddable;
|
||||
using CGAL::Tag_false;
|
||||
CGAL_static_assertion(( ::boost::is_same< Is_real_embeddable, Tag_false>::value));
|
||||
CGAL_static_assertion(( ::std::is_same< Is_real_embeddable, Tag_false>::value));
|
||||
CGAL_USE_TYPE(Is_real_embeddable);
|
||||
}
|
||||
|
||||
|
|
@ -254,13 +254,13 @@ void test_not_real_embeddable() {
|
|||
//template <class Type, class CeilLog2Abs>
|
||||
//void test_rounded_log2_abs(Type zero, CGAL::Null_functor, CeilLog2Abs) {
|
||||
// typedef CGAL::Null_functor Null_functor;
|
||||
// CGAL_static_assertion(( ::boost::is_same< CeilLog2Abs, Null_functor>::value));
|
||||
// CGAL_static_assertion(( ::std::is_same< CeilLog2Abs, Null_functor>::value));
|
||||
//}
|
||||
//
|
||||
//template <class Type, class FloorLog2Abs, class CeilLog2Abs>
|
||||
//void test_rounded_log2_abs(Type zero, FloorLog2Abs fl_log, CeilLog2Abs cl_log) {
|
||||
// typedef CGAL::Null_functor Null_functor;
|
||||
// CGAL_static_assertion((!::boost::is_same< CeilLog2Abs, Null_functor>::value));
|
||||
// CGAL_static_assertion((!::std::is_same< CeilLog2Abs, Null_functor>::value));
|
||||
//
|
||||
// assert( fl_log(Type( 7)) == 2 );
|
||||
// assert( cl_log(Type( 7)) == 3 );
|
||||
|
|
|
|||
|
|
@ -195,7 +195,7 @@ template< class Number_type >
|
|||
inline
|
||||
// select a Is_zero functor
|
||||
typename boost::mpl::if_c<
|
||||
::boost::is_same< typename Algebraic_structure_traits< Number_type >::Is_zero,
|
||||
::std::is_same< typename Algebraic_structure_traits< Number_type >::Is_zero,
|
||||
Null_functor >::value ,
|
||||
typename Real_embeddable_traits< Number_type >::Is_zero,
|
||||
typename Algebraic_structure_traits< Number_type >::Is_zero
|
||||
|
|
@ -204,7 +204,7 @@ is_zero( const Number_type& x ) {
|
|||
// We take the Algebraic_structure_traits<>::Is_zero functor by default. If it
|
||||
// is not available, we take the Real_embeddable_traits functor
|
||||
typename ::boost::mpl::if_c<
|
||||
::boost::is_same<
|
||||
::std::is_same<
|
||||
typename Algebraic_structure_traits< Number_type >::Is_zero,
|
||||
Null_functor >::value ,
|
||||
typename Real_embeddable_traits< Number_type >::Is_zero,
|
||||
|
|
|
|||
|
|
@ -9,21 +9,21 @@ int main(){
|
|||
|
||||
typedef AET::Type Type;
|
||||
CGAL_USE_TYPE(Type);
|
||||
CGAL_static_assertion((::boost::is_same<int,Type>::value));
|
||||
CGAL_static_assertion((::std::is_same<int,Type>::value));
|
||||
|
||||
typedef AET::Is_extended Is_extended;
|
||||
CGAL_USE_TYPE(Is_extended);
|
||||
CGAL_static_assertion(
|
||||
(::boost::is_same<CGAL::Tag_false,Is_extended>::value));
|
||||
(::std::is_same<CGAL::Tag_false,Is_extended>::value));
|
||||
|
||||
typedef AET::Normalization_factor Normalization_factor;
|
||||
{
|
||||
typedef Normalization_factor::argument_type argument_type;
|
||||
CGAL_USE_TYPE(argument_type);
|
||||
CGAL_static_assertion((::boost::is_same<argument_type,int>::value));
|
||||
CGAL_static_assertion((::std::is_same<argument_type,int>::value));
|
||||
typedef Normalization_factor::result_type result_type;
|
||||
CGAL_USE_TYPE(result_type);
|
||||
CGAL_static_assertion((::boost::is_same<result_type,int>::value));
|
||||
CGAL_static_assertion((::std::is_same<result_type,int>::value));
|
||||
Normalization_factor nfac;
|
||||
assert(nfac(3)==1);
|
||||
}
|
||||
|
|
@ -31,10 +31,10 @@ int main(){
|
|||
{
|
||||
typedef DFAI::argument_type argument_type;
|
||||
CGAL_USE_TYPE(argument_type);
|
||||
CGAL_static_assertion((::boost::is_same<argument_type,int>::value));
|
||||
CGAL_static_assertion((::std::is_same<argument_type,int>::value));
|
||||
typedef DFAI::result_type result_type;
|
||||
CGAL_USE_TYPE(result_type);
|
||||
CGAL_static_assertion((::boost::is_same<result_type,int>::value));
|
||||
CGAL_static_assertion((::std::is_same<result_type,int>::value));
|
||||
DFAI dfai;
|
||||
assert(dfai(3)==1);
|
||||
}
|
||||
|
|
@ -45,21 +45,21 @@ int main(){
|
|||
|
||||
typedef AET::Type Type;
|
||||
CGAL_USE_TYPE(Type);
|
||||
CGAL_static_assertion((::boost::is_same<EXT,Type>::value));
|
||||
CGAL_static_assertion((::std::is_same<EXT,Type>::value));
|
||||
|
||||
typedef AET::Is_extended Is_extended;
|
||||
CGAL_USE_TYPE(Is_extended);
|
||||
CGAL_static_assertion(
|
||||
(::boost::is_same<CGAL::Tag_true,Is_extended>::value));
|
||||
(::std::is_same<CGAL::Tag_true,Is_extended>::value));
|
||||
|
||||
typedef AET::Normalization_factor Normalization_factor;
|
||||
{
|
||||
typedef Normalization_factor::argument_type argument_type;
|
||||
CGAL_USE_TYPE(argument_type);
|
||||
CGAL_static_assertion((::boost::is_same<argument_type,EXT>::value));
|
||||
CGAL_static_assertion((::std::is_same<argument_type,EXT>::value));
|
||||
typedef Normalization_factor::result_type result_type;
|
||||
CGAL_USE_TYPE(result_type);
|
||||
CGAL_static_assertion((::boost::is_same<result_type,EXT>::value));
|
||||
CGAL_static_assertion((::std::is_same<result_type,EXT>::value));
|
||||
Normalization_factor nfac;
|
||||
assert(nfac(EXT(3))==1);
|
||||
assert(nfac(EXT(3,0,5))==1);
|
||||
|
|
@ -69,10 +69,10 @@ int main(){
|
|||
{
|
||||
typedef DFAI::argument_type argument_type;
|
||||
CGAL_USE_TYPE(argument_type);
|
||||
CGAL_static_assertion((::boost::is_same<argument_type,EXT>::value));
|
||||
CGAL_static_assertion((::std::is_same<argument_type,EXT>::value));
|
||||
typedef DFAI::result_type result_type;
|
||||
CGAL_USE_TYPE(result_type);
|
||||
CGAL_static_assertion((::boost::is_same<result_type,EXT>::value));
|
||||
CGAL_static_assertion((::std::is_same<result_type,EXT>::value));
|
||||
DFAI dfai;
|
||||
assert(dfai(EXT(3))==1);
|
||||
assert(dfai(EXT(3,0,5))==1);
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
typedef AST::NAME NAME; \
|
||||
CGAL_USE_TYPE(NAME); \
|
||||
CGAL_static_assertion( \
|
||||
(::boost::is_same<CGAL::Null_functor,NAME>::value)); \
|
||||
(::std::is_same<CGAL::Null_functor,NAME>::value)); \
|
||||
}
|
||||
|
||||
int main(){
|
||||
|
|
@ -16,19 +16,19 @@ int main(){
|
|||
|
||||
typedef AST::Type Type;
|
||||
CGAL_USE_TYPE(Type);
|
||||
CGAL_static_assertion((::boost::is_same<void,Type>::value));
|
||||
CGAL_static_assertion((::std::is_same<void,Type>::value));
|
||||
|
||||
typedef AST::Algebraic_category Algebraic_category;
|
||||
CGAL_USE_TYPE(Algebraic_category);
|
||||
CGAL_static_assertion(
|
||||
(::boost::is_same<CGAL::Null_tag,Algebraic_category>::value));
|
||||
(::std::is_same<CGAL::Null_tag,Algebraic_category>::value));
|
||||
|
||||
typedef AST::Is_exact Is_exact;
|
||||
CGAL_USE_TYPE(Is_exact);
|
||||
CGAL_static_assertion((::boost::is_same<CGAL::Null_tag,Is_exact>::value));
|
||||
CGAL_static_assertion((::std::is_same<CGAL::Null_tag,Is_exact>::value));
|
||||
typedef AST::Is_numerical_sensitive Is_sensitive;
|
||||
CGAL_USE_TYPE(Is_sensitive);
|
||||
CGAL_static_assertion((::boost::is_same<CGAL::Null_tag,Is_sensitive>::value));
|
||||
CGAL_static_assertion((::std::is_same<CGAL::Null_tag,Is_sensitive>::value));
|
||||
|
||||
CGAL_IS_AST_NULL_FUNCTOR ( Simplify);
|
||||
CGAL_IS_AST_NULL_FUNCTOR ( Unit_part);
|
||||
|
|
|
|||
|
|
@ -6,22 +6,22 @@ int main(){
|
|||
{
|
||||
typedef CGAL::Coercion_traits<int,int> CT;
|
||||
CGAL_USE_TYPE(CT);
|
||||
CGAL_static_assertion(( boost::is_same<CT::Type,int>::value));
|
||||
CGAL_static_assertion(( std::is_same<CT::Type,int>::value));
|
||||
CGAL_static_assertion(
|
||||
( boost::is_same<CT::Are_implicit_interoperable,CGAL::Tag_true>::value));
|
||||
( std::is_same<CT::Are_implicit_interoperable,CGAL::Tag_true>::value));
|
||||
CGAL_static_assertion(
|
||||
( boost::is_same<CT::Are_explicit_interoperable,CGAL::Tag_true>::value));
|
||||
( std::is_same<CT::Are_explicit_interoperable,CGAL::Tag_true>::value));
|
||||
assert( 5 == CT::Cast()(5));
|
||||
}
|
||||
{
|
||||
typedef CGAL::Coercion_traits<CGAL::Tag_true,CGAL::Tag_false> CT;
|
||||
CGAL_USE_TYPE(CT);
|
||||
// CGAL_static_assertion(( boost::is_same<CT::Type,CGAL::Null_type>::value));
|
||||
// CGAL_static_assertion(( std::is_same<CT::Type,CGAL::Null_type>::value));
|
||||
CGAL_static_assertion(
|
||||
( boost::is_same<CT::Are_implicit_interoperable,CGAL::Tag_false>::value));
|
||||
( std::is_same<CT::Are_implicit_interoperable,CGAL::Tag_false>::value));
|
||||
CGAL_static_assertion(
|
||||
( boost::is_same<CT::Are_explicit_interoperable,CGAL::Tag_false>::value));
|
||||
( std::is_same<CT::Are_explicit_interoperable,CGAL::Tag_false>::value));
|
||||
CGAL_static_assertion(
|
||||
( boost::is_same<CT::Cast,CGAL::Null_functor>::value));
|
||||
( std::is_same<CT::Cast,CGAL::Null_functor>::value));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
typedef RET::NAME NAME; \
|
||||
CGAL_USE_TYPE(NAME); \
|
||||
CGAL_static_assertion( \
|
||||
(::boost::is_same<CGAL::Null_functor,NAME>::value)); \
|
||||
(::std::is_same<CGAL::Null_functor,NAME>::value)); \
|
||||
}
|
||||
|
||||
int main(){
|
||||
|
|
@ -16,11 +16,11 @@ int main(){
|
|||
|
||||
typedef RET::Type Type;
|
||||
CGAL_USE_TYPE(Type);
|
||||
CGAL_static_assertion((::boost::is_same<void,Type>::value));
|
||||
CGAL_static_assertion((::std::is_same<void,Type>::value));
|
||||
|
||||
typedef RET::Is_real_embeddable Is_real_embeddable;
|
||||
CGAL_USE_TYPE(Is_real_embeddable);
|
||||
CGAL_static_assertion((::boost::is_same<CGAL::Tag_false,Is_real_embeddable>::value));
|
||||
CGAL_static_assertion((::std::is_same<CGAL::Tag_false,Is_real_embeddable>::value));
|
||||
|
||||
CGAL_IS_RET_NULL_FUNCTOR(Abs);
|
||||
CGAL_IS_RET_NULL_FUNCTOR(Sgn);
|
||||
|
|
|
|||
|
|
@ -7,33 +7,33 @@
|
|||
int main(){
|
||||
typedef CGAL::Scalar_factor_traits<int> SFT;
|
||||
CGAL_USE_TYPE(SFT);
|
||||
CGAL_static_assertion((::boost::is_same<int, SFT::Type>::value));
|
||||
CGAL_static_assertion((::boost::is_same<int, SFT::Scalar>::value));
|
||||
CGAL_static_assertion((::std::is_same<int, SFT::Type>::value));
|
||||
CGAL_static_assertion((::std::is_same<int, SFT::Scalar>::value));
|
||||
|
||||
typedef SFT::Scalar_factor Scalar_factor;
|
||||
{
|
||||
typedef Scalar_factor::result_type result_type;
|
||||
CGAL_USE_TYPE(result_type);
|
||||
CGAL_static_assertion((::boost::is_same<int, result_type>::value));
|
||||
CGAL_static_assertion((::std::is_same<int, result_type>::value));
|
||||
|
||||
typedef Scalar_factor::argument_type argument_type;
|
||||
CGAL_USE_TYPE(argument_type);
|
||||
CGAL_static_assertion((::boost::is_same<int, argument_type>::value));
|
||||
CGAL_static_assertion((::std::is_same<int, argument_type>::value));
|
||||
}
|
||||
typedef SFT::Scalar_div Scalar_div;
|
||||
{
|
||||
typedef Scalar_div::result_type result_type;
|
||||
CGAL_USE_TYPE(result_type);
|
||||
CGAL_static_assertion((::boost::is_same<void, result_type>::value));
|
||||
CGAL_static_assertion((::std::is_same<void, result_type>::value));
|
||||
|
||||
typedef Scalar_div::first_argument_type first_argument_type;
|
||||
CGAL_USE_TYPE(first_argument_type);
|
||||
CGAL_static_assertion(
|
||||
(::boost::is_same<int&, first_argument_type>::value));
|
||||
(::std::is_same<int&, first_argument_type>::value));
|
||||
typedef Scalar_div::second_argument_type second_argument_type;
|
||||
CGAL_USE_TYPE(second_argument_type);
|
||||
CGAL_static_assertion(
|
||||
(::boost::is_same<int, second_argument_type>::value));
|
||||
(::std::is_same<int, second_argument_type>::value));
|
||||
}
|
||||
|
||||
int i;
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ A model of `AlgebraicKernel_d_1::ApproximateAbsolute_1` is an `AdaptableBinaryFu
|
|||
approximation of an `AlgebraicKernel_d_1::Algebraic_real_1` value with
|
||||
respect to a given absolute precision.
|
||||
|
||||
\cgalRefines `AdaptableBinaryFunction`
|
||||
\cgalRefines{AdaptableBinaryFunction}
|
||||
|
||||
\sa `AlgebraicKernel_d_1::ApproximateRelative_1`
|
||||
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ A model of `AlgebraicKernel_d_1::ApproximateRelative_1` is an `AdaptableBinaryFu
|
|||
approximation of an `AlgebraicKernel_d_1::Algebraic_real_1` value with
|
||||
respect to a given relative precision.
|
||||
|
||||
\cgalRefines `AdaptableBinaryFunction`
|
||||
\cgalRefines{AdaptableBinaryFunction}
|
||||
|
||||
\sa `AlgebraicKernel_d_1::ApproximateAbsolute_1`
|
||||
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ Computes a number of type
|
|||
`AlgebraicKernel_d_1::Bound` in-between two
|
||||
`AlgebraicKernel_d_1::Algebraic_real_1` values.
|
||||
|
||||
\cgalRefines `AdaptableBinaryFunction`
|
||||
\cgalRefines{AdaptableBinaryFunction}
|
||||
|
||||
*/
|
||||
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@
|
|||
|
||||
Compares `AlgebraicKernel_d_1::Algebraic_real_1` values.
|
||||
|
||||
\cgalRefines `AdaptableBinaryFunction`
|
||||
\cgalRefines{AdaptableBinaryFunction}
|
||||
|
||||
*/
|
||||
class AlgebraicKernel_d_1::Compare_1 {
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
Computes a square free univariate polynomial \f$ p\f$, such that the given
|
||||
`AlgebraicKernel_d_1::Algebraic_real_1` is a root of \f$ p\f$.
|
||||
|
||||
\cgalRefines `AdaptableUnaryFunction`
|
||||
\cgalRefines{AdaptableUnaryFunction}
|
||||
|
||||
\sa `AlgebraicKernel_d_1::Isolate_1`
|
||||
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@
|
|||
|
||||
Constructs `AlgebraicKernel_d_1::Algebraic_real_1`.
|
||||
|
||||
\cgalRefines `AdaptableFunctor`
|
||||
\cgalRefines{AdaptableFunctor}
|
||||
|
||||
\sa `AlgebraicKernel_d_2::ConstructAlgebraicReal_2`
|
||||
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
Determines whether a given pair of univariate polynomials \f$ p_1, p_2\f$ is coprime,
|
||||
namely if \f$ \deg({\rm gcd}(p_1 ,p_2)) = 0\f$.
|
||||
|
||||
\cgalRefines `AdaptableBinaryFunction`
|
||||
\cgalRefines{AdaptableBinaryFunction}
|
||||
|
||||
\sa `AlgebraicKernel_d_1::MakeCoprime_1`
|
||||
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@
|
|||
|
||||
Computes whether the given univariate polynomial is square free.
|
||||
|
||||
\cgalRefines `AdaptableUnaryFunction`
|
||||
\cgalRefines{AdaptableUnaryFunction}
|
||||
|
||||
\sa `AlgebraicKernel_d_1::MakeSquareFree_1`
|
||||
\sa `AlgebraicKernel_d_1::SquareFreeFactorize_1`
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
Computes whether an `AlgebraicKernel_d_1::Polynomial_1`
|
||||
is zero at a given `AlgebraicKernel_d_1::Algebraic_real_1`.
|
||||
|
||||
\cgalRefines `AdaptableBinaryFunction`
|
||||
\cgalRefines{AdaptableBinaryFunction}
|
||||
|
||||
\sa `AlgebraicKernel_d_1::SignAt_1`
|
||||
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
Computes an open isolating interval for an `AlgebraicKernel_d_1::Algebraic_real_1`
|
||||
with respect to the real roots of a given univariate polynomial.
|
||||
|
||||
\cgalRefines `AdaptableBinaryFunction`
|
||||
\cgalRefines{AdaptableBinaryFunction}
|
||||
|
||||
\sa `AlgebraicKernel_d_1::ComputePolynomial_1`
|
||||
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ such that \f$ q_1\f$ and \f$ q_2\f$ are coprime.
|
|||
|
||||
It returns true if \f$ p_1\f$ and \f$ p_2\f$ are already coprime.
|
||||
|
||||
\cgalRefines `AdaptableFunctor` with five arguments
|
||||
\cgalRefines{AdaptableQuinaryFunction}
|
||||
|
||||
\sa `AlgebraicKernel_d_1::IsCoprime_1`
|
||||
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@
|
|||
|
||||
Returns a square free part of a univariate polynomial.
|
||||
|
||||
\cgalRefines `AdaptableUnaryFunction`
|
||||
\cgalRefines{AdaptableUnaryFunction}
|
||||
|
||||
\sa `AlgebraicKernel_d_1::IsSquareFree_1`
|
||||
\sa `AlgebraicKernel_d_1::SquareFreeFactorize_1`
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@
|
|||
|
||||
Computes the number of real solutions of the given univariate polynomial.
|
||||
|
||||
\cgalRefines `AdaptableUnaryFunction`
|
||||
\cgalRefines{AdaptableUnaryFunction}
|
||||
|
||||
\sa `AlgebraicKernel_d_1::ConstructAlgebraicReal_1`
|
||||
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ Computes the sign of a univariate polynomial
|
|||
`AlgebraicKernel_d_1::Polynomial_1` at a real value of type
|
||||
`AlgebraicKernel_d_1::Algebraic_real_1`.
|
||||
|
||||
\cgalRefines `AdaptableBinaryFunction`
|
||||
\cgalRefines{AdaptableBinaryFunction}
|
||||
|
||||
\sa `AlgebraicKernel_d_1::IsZeroAt_1`
|
||||
|
||||
|
|
|
|||
|
|
@ -5,8 +5,7 @@
|
|||
|
||||
Computes the real roots of a univariate polynomial.
|
||||
|
||||
\cgalRefines `Assignable`
|
||||
\cgalRefines `CopyConstructible`
|
||||
\cgalRefines{Assignable,CopyConstructible}
|
||||
|
||||
*/
|
||||
|
||||
|
|
|
|||
|
|
@ -14,8 +14,7 @@ and a constant factor \f$ c\f$, such that
|
|||
The factor multiplicity pairs \f$ <q_i,m_i>\f$ are written to the
|
||||
given output iterator. The constant factor \f$ c\f$ is not computed.
|
||||
|
||||
\cgalRefines `Assignable`
|
||||
\cgalRefines `CopyConstructible`
|
||||
\cgalRefines{Assignable,CopyConstructible}
|
||||
|
||||
\sa `AlgebraicKernel_d_1::IsSquareFree_1`
|
||||
\sa `AlgebraicKernel_d_1::MakeSquareFree_1`
|
||||
|
|
|
|||
|
|
@ -6,8 +6,7 @@
|
|||
A model of the `AlgebraicKernel_d_1` concept is meant to provide the
|
||||
algebraic functionalities on univariate polynomials of general degree \f$ d\f$.
|
||||
|
||||
\cgalRefines `CopyConstructible`
|
||||
\cgalRefines `Assignable`
|
||||
\cgalRefines{CopyConstructible,Assignable}
|
||||
|
||||
\cgalHasModel `CGAL::Algebraic_kernel_rs_gmpz_d_1`
|
||||
\cgalHasModel `CGAL::Algebraic_kernel_rs_gmpq_d_1`
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ A model of `AlgebraicKernel_d_2::ApproximateAbsoluteX_2` is an `AdaptableBinaryF
|
|||
approximation of the \f$ x\f$-coordinate of an `AlgebraicKernel_d_2::Algebraic_real_2` value
|
||||
with respect to a given absolute precision.
|
||||
|
||||
\cgalRefines `AdaptableBinaryFunction`
|
||||
\cgalRefines{AdaptableBinaryFunction}
|
||||
|
||||
\sa `AlgebraicKernel_d_2::ApproximateRelativeX_2`
|
||||
\sa `AlgebraicKernel_d_1::ApproximateAbsolute_1`
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ A model of `AlgebraicKernel_d_2::ApproximateAbsoluteY_2` is an `AdaptableBinaryF
|
|||
approximation of the \f$ y\f$-coordinate of an `AlgebraicKernel_d_2::Algebraic_real_2` value
|
||||
with respect to a given absolute precision.
|
||||
|
||||
\cgalRefines `AdaptableBinaryFunction`
|
||||
\cgalRefines{AdaptableBinaryFunction}
|
||||
|
||||
\sa `AlgebraicKernel_d_2::ApproximateRelativeY_2`
|
||||
\sa `AlgebraicKernel_d_1::ApproximateAbsolute_1`
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue