/usr/include/CGAL/Polynomial/polynomial_converters.h is in libcgal-dev 4.7-4.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 | // Copyright (c) 2005 Stanford University (USA).
// All rights reserved.
//
// This file is part of CGAL (www.cgal.org); you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 3 of the License,
// or (at your option) any later version.
//
// Licensees holding a valid commercial license may use this file in
// accordance with the commercial license agreement provided with the software.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//
// $URL$
// $Id$
//
//
// Author(s) : Daniel Russel <drussel@alumni.princeton.edu>
#ifndef CGAL_POLYNOMIAL_CONVERTERS_H
#define CGAL_POLYNOMIAL_CONVERTERS_H
#include <CGAL/Polynomial/basic.h>
#include <CGAL/Polynomial/internal/nt_converters.h>
#include <iterator>
namespace CGAL { namespace POLYNOMIAL {
//! from P1 to P2
template<class P1, class P2, class Converter_t =
CGAL_POLYNOMIAL_NS::NT_converter<typename P1::NT,typename P2::NT> >
class Polynomial_converter
{
class Iterator
{
public:
Iterator(typename P1::iterator it, const Converter_t& fun): fun_(fun), it_(it){}
Iterator(){}
typedef typename std::iterator_traits<typename P1::iterator> Traits;
typedef typename Traits::iterator_category iterator_category;
typedef typename Traits::difference_type difference_type;
typedef typename Converter_t::result_type value_type;
typedef value_type reference;
typedef const value_type *pointer;
value_type operator*() const
{
return fun_(*it_);
}
/*pointer_type operator->() const {
return fun_(P1::iterator::operator*());
}*/
difference_type operator-(Iterator o) const
{
return it_-o.it_;
}
bool operator<(const Iterator& o) const
{
return ( it_-o.it_ ) < 0;
}
bool operator==(const Iterator &o) const
{
return it_==o.it_;
}
bool operator!=(const Iterator &o) const
{
return it_!=o.it_;
}
Iterator operator++() {
++it_;
return *this;
}
Iterator operator++(int) {
Iterator t= *this;
++it_;
return t;
}
Iterator operator+=(difference_type i) {
it_+=i;
return *this;
}
protected:
Converter_t fun_;
typename P1::iterator it_;
};
public:
typedef P1 argument_type;
typedef P2 result_type;
typedef Converter_t NT_converter;
explicit Polynomial_converter(NT_converter cv = NT_converter()) : cv_(cv) {}
P2 operator()(const P1& p1) const
{
Iterator b(p1.begin(), cv_);
Iterator e(p1.end(), cv_);
return P2(b,e);
}
/*typename P2::NT operator()(const typename P1::NT &p) const {
return cv_(p);
}*/
const NT_converter& nt_converter() const
{
return cv_;
}
protected:
NT_converter cv_;
};
template <class F>
class Polynomial_identity_converter
{
public:
Polynomial_identity_converter(){}
typedef F argument_type;
typedef F result_type;
typedef Identity_converter<typename argument_type::NT> NT_converter;
const F& operator()(const F&f) const
{
return f;
}
NT_converter nt_converter() const
{
return NT_converter();
}
};
} } //namespace CGAL::POLYNOMIAL
#endif // CGAL_POLYNOMIAL_CONVERTER_H
|