mirror of https://github.com/CGAL/cgal
132 lines
5.3 KiB
TeX
132 lines
5.3 KiB
TeX
%OPEN: new name for template argument ROOT ?
|
|
%But this will cause changes in the interface i.e. root() should change too.
|
|
|
|
\begin{ccRefClass}{Polynomial<Coeff>}
|
|
\def\ccTagOperatorLayout{\ccFalse}
|
|
|
|
\ccDefinition
|
|
|
|
An instance of the data type \ccc{Polynomial} represents a
|
|
polynomial $p = a_0 + a_1*x + ...a_i*x^i$ from the ring $Coeff[x]$.
|
|
\ccc{Coeff} can itself be an instance of \ccc{Polynomial}, yielding a form of
|
|
multivariate polynomials.
|
|
|
|
The template argument \ccc{Coeff} must be at
|
|
least a model of \ccc{IntegralDomainWithoutDiv}.
|
|
For all operations naturally involving division, a \ccc{IntegralDomain}
|
|
is required.
|
|
%If more than a \c IntegralDomain is required, this is documented.
|
|
Inexact and limited-precision types can be used as coefficients,
|
|
but at the user's risk. The algorithms implemented were written with
|
|
exact number types in mind.
|
|
\ccc{Polynomial} offers a full set of algebraic operators, i.e.
|
|
binary +, -, *, / as well as +=, -=, *=, /=; not only for polynomials
|
|
but also for a polynomial and a number of the coefficient type.
|
|
(The / operator must only be used for integral divisions, i.e.
|
|
those with remainder zero.)
|
|
The operations are implemented naively: + and - need a number of \ccc{Coeff}
|
|
operations which is linear in the degree while * is quadratic.
|
|
%The advanced algebraic operations are implemented with classical
|
|
%non-modular methods.
|
|
Unary + and - and (in)equality ==, != are provided as well.
|
|
|
|
\ccc{Polynomial} is a model of \ccc{LessThanComparable} if \ccc{Coeff} is a
|
|
model of \ccc{LessThanComparable}. In this case \ccc{Polynomial} provides
|
|
comparison operators <, >, <=, >=, where the comparison amounts to
|
|
lexicographic comparison of the coefficient sequence,
|
|
with the coefficient of the highest power taking precedence over
|
|
those of lower powers.
|
|
|
|
\ccc{Polynomial} is a model of \ccc{Fraction} if \ccc{Coeff} is a
|
|
model of \ccc{Fraction}. In this case Polynomial may be decomposed into a
|
|
(scalar) denominator and a compound numerator with a simpler coefficient type.
|
|
Often operations can be performed faster on these denominator-free multiples.
|
|
%In case a \ccc{Polynomial} is a \ccc{Fraction} the relevant functionality as well as
|
|
%the numerator and denominator type are provided by \ccc{CGAL::Fraction_traits}.
|
|
%In particular \ccc{CGAL::Fraction_traits} provides a tag \ccc{Is_fraction} that can
|
|
%be used for dispatching.
|
|
|
|
\ccc{Polynomial} is a model of \ccc{Modularizable} if \ccc{Coeff} is a
|
|
model of \ccc{Modularizable}, where the homomorphic map on the polynomials
|
|
is simply defined as the canonical extension of the homomorphic map which is
|
|
defined on the coefficient type.
|
|
|
|
This data type is implemented as a handle type with value semantics
|
|
using \ccc{CGAL::Handle_with_policy}, where \ccc{HandlePolicy}
|
|
is \ccc{Handle_policy_no_union}.
|
|
An important invariant to be preserved by all methods is that
|
|
the coefficient sequence does not contain leading zero coefficients
|
|
(where leading means at the high-degree end), with the exception that
|
|
the zero polynomial is represented by a single zero coefficient.
|
|
An empty coefficient sequence denotes an undefined value.
|
|
|
|
|
|
|
|
\ccIsModel
|
|
\begin{tabular}{ll}
|
|
\ccc{Polynomial_d}\\
|
|
\ccc{Assignable}\\
|
|
\ccc{CopyConstructible}\\
|
|
\ccc{DefaultConstructible}\\
|
|
\ccc{EqualityComparable}\\
|
|
\ccc{ImplicitInteroperable} & with int\\
|
|
\ccc{ImplicitInteroperable} & with Coeff\\
|
|
\ccc{Fraction} & if \ccc{Coeff} is model of \ccc{Fraction}\\
|
|
\ccc{LessThanComparable} & if \ccc{Coeff} is model of \ccc{LessThanComparable}\\
|
|
\ccc{Modularizable} & if \ccc{Coeff} is model of \ccc{Modularizable}.
|
|
\end{tabular}
|
|
|
|
\ccCreation
|
|
|
|
\ccCreationVariable{poly}
|
|
\ccConstructor{Polynomial ();}
|
|
{Introduces an variable initialized with 0.}
|
|
\ccGlue
|
|
\ccConstructor{Polynomial (const Polynomial& x);}
|
|
{copy constructor.}
|
|
\ccGlue
|
|
\ccConstructor{Polynomial (const int &i);}
|
|
{Constructor from int.}
|
|
\ccGlue
|
|
\ccConstructor{Polynomial (const Coeff &x);}
|
|
{Constructor from type Coeff.}
|
|
\ccGlue
|
|
\ccConstructor{
|
|
template <class Forward_iterator>
|
|
Polynomial(Forward_iterator first, Forward_iterator last);}
|
|
{Constructor from iterator range with value type Coeff.}
|
|
|
|
\ccTypes
|
|
|
|
\ccOperations
|
|
%\ccMethod{const NT & a0 () const ; }{Const access operator for a0} \ccGlue
|
|
|
|
\ccMethod{const_iterator begin() const;}
|
|
{A const random access iterator pointing to the constant coefficient.} \ccGlue
|
|
\ccMethod{const_iterator end() const;}
|
|
{A const random access iterator pointing beyond the leading coefficient.}\ccGlue
|
|
\ccMethod{int degree() const;}
|
|
{The degree of the polynomial in $x$. The degree of the zero polynomial is 0.}\ccGlue
|
|
\ccMethod{const NT& operator[](unsigned int i) const;}
|
|
{Const access to the coefficient of $x^i$.}\ccGlue
|
|
\ccMethod{const NT& lcoeff() const;}
|
|
{Const access to the leading coefficient.}\ccGlue
|
|
|
|
|
|
\ccFunction{
|
|
std::ostream& operator<<(std::ostream& os, const Polynomial<Coeff> &poly);}
|
|
{Writes \ccc{poly} to ostream \ccc{os}.
|
|
The format depends on the \ccc{CGAL::IO::MODE} of \ccc{os}.
|
|
In case the mode is \ccc{CGAL::IO::ASCII} the format is $P[d,a_0,\dots,a_d]$,
|
|
where $d$ is the degree of the polynomial.
|
|
In case the mode is \ccc{CGAL::IO::PRETTY} the format is human readable.}
|
|
|
|
|
|
\ccFunction{
|
|
std::istream& operator>>(std::istream& is, const Polynomial<Coeff> &poly);}
|
|
{Reads \ccc{poly} from istream \ccc{is} in format $POLY[d,a_0,\dots,a_d]$,
|
|
the output format in mode \ccc{CGAL::IO::ASCII} }
|
|
|
|
|
|
\end{ccRefClass}
|