songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

first version of concept Polynomial_traits_d

This commit is contained in:
Michael Hemmer 2006-12-07 17:51:15 +00:00
parent 9bde28874f
commit 164527701b
40 changed files with 1931 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
.gitattributes vendored
View File

@ -1791,6 +1791,45 @@ Polyhedron/examples/Polyhedron/corner.off -text svneol=unset#application/octet-s
Polyhedron/examples/Polyhedron/corner_with_hole.off -text svneol=unset#application/octet-stream
Polyhedron/examples/Polyhedron/corner_with_sharp_edge.off -text svneol=unset#application/octet-stream
Polyhedron/examples/Polyhedron/cross.off -text svneol=unset#application/octet-stream
Polynomial/doc_tex/Polynomial_ref/Exponent_vector.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_Canonicalize.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_Compare.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_ConstructPolynomial_d.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_Degree.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_Differentiate.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_Evaluate.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_EvaluateHomogeneous.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_GcdUpToConstantFactor.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_GcdUtcf.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_IntegralDivisionUpToConstantFactor.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_IntegralDivisionUtcf.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_Invert.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_LeadingCoefficient.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_MakeSquareFree.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_MakeSquareFreeUtcf.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_MultivariateContent.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_Negate.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_PseudoDivision.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_PseudoDivisionQuotient.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_PseudoDivisionRemainder.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_Resultant.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_Scale.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_ScaleHomogeneous.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_Shift.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_SquareFreeFactorization.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_SquareFreeFactorizationUpToConstantFactor.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_SquareFreeFactorizationUtcf.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_Swap.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_TotalDegree.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_Translate.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_TranslateHomogeneous.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_UnivariateContent.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_UnivariateContentUpToConstantFactor.tex -text
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_UnivariateContentUtcf.tex -text
Polynomial/doc_tex/Polynomial_ref/Polynomial_d.tex -text
Polynomial/doc_tex/Polynomial_ref/intro.tex -text
Polynomial/doc_tex/Polynomial_ref/main.tex -text
Polynomial/include/CGAL/Exponent_vector.h -text
Polynomial/include/CGAL/Polynomial.h -text
Polynomial/include/CGAL/Polynomial/Algebraic_structure_traits.h -text

132
Polynomial/doc_tex/Polynomial_ref/Exponent_vector.tex Normal file
View File

@ -0,0 +1,132 @@
\begin{ccRefClass}{Exponent_vector}
\ccDefinition
For a given monomial the vector of its exponents is called the
exponent vector. The class \ccClassName\ is meant to represent
such a vector.
A vector is considered as valid, in case it represents a valid monomial.
In particular, it should not contain negative exponents.
\footnote{We choose value type int, since negative exponents may appear in intermediate results. }
Note that the set of exponent vectors with element vise
addition forms an {\em Abelian Group}.
\footnote{Should we add a scalar multiplication? }
\ccInclude{CGAL/Exponent_vector.h}
\ccInheritsFrom
\ccc{std::vector<int>}
\ccIsModel
\ccc{Random Access Container}\\
\ccc{Back Insertion Sequence}\\
\ccc{DefaultConstructible}\\
\ccc{Assignable}\\
\ccc{CopyConstructible}\\
\ccc{EqualityComparable}\\
\ccc{LessThanComparable}\\
\ccCreation
\ccCreationVariable{ev}
%\ccc{DefaultConstructible}\\
\ccConstructor{Exponent_vector();}
{introduces an uninitialized variable \ccVar.
}\ccGlue
%\ccc{CopyConstructible}\\
\ccConstructor{Exponent_vector(const Exponent_vector & ev_);}
{The copy constructor
}\ccGlue
\ccConstructor{Exponent_vector(size_type n);}
{Creates a vector with \ccc{n} elements.
}\ccGlue
\ccConstructor{Exponent_vector(size_type n, int i);}
{Creates a vector with \ccc{n} copies of \ccc{i}.
}\ccGlue
\ccConstructor{
template < class InputIterator >
Exponent_vector(InputIterator begin, InputIterator end);}{
Creates a vector with a copy of the given range.
\ccPrecond \ccc{InputIterator} must allow the value type \ccc{int}. \\
}\ccGlue
\ccOperations
\ccMethod{void swap(const size_type& i, const size_type& j) const;}{
Swap exponent at position i with exponent at position j.
\ccPrecond { i <= \ccVar.size()}
\ccPrecond { j <= \ccVar.size()}
}
\ccGlue
\ccFunction{bool is_valid(const Exponent_vector & ev_);}
{ Returns true if all entries are not negative. }
\ccOperations
Group Operation:
\ccFunction{Exponent_vector operator+(const Exponent_vector &ev1);}{}\ccGlue
\ccFunction{Exponent_vector operator-(const Exponent_vector &ev1);}{}\ccGlue
\ccFunction{Exponent_vector
operator+(const Exponent_vector &ev1,
const Exponent_vector &ev2);}{
\ccPrecond ev1.size() == ev2.size()
}
\ccGlue
\ccFunction{Exponent_vector
operator-(const Exponent_vector &ev1,
const Exponent_vector &ev2);}{
\ccPrecond ev1.size() == ev2.size()
}
\ccGlue
\ccMethod{Exponent_vector
operator+=(const Exponent_vector &ev2);}{
\ccPrecond \ccVar.size() == ev2.size()
}
\ccGlue
\ccMethod{Exponent_vector
operator-=(const Exponent_vector &ev2);}{
\ccPrecond \ccVar.size() == ev2.size()
}
\begin{ccAdvanced}
TODO: Should we add these functions? what about operator $/$ ?
\ccMethod{Exponent_vector operator*=(int i);}{}
\ccGlue
\ccFunction{Exponent_vector operator*(const Exponent_vector &ev, int i);}{}
\ccGlue
\ccFunction{Exponent_vector operator*(int i ,const Exponent_vector &ev);}{}
\end{ccAdvanced}
\ccc{EqualityComparable}:
\ccFunction{bool
operator==(const Exponent_vector &ev1,
const Exponent_vector &ev2);}{}
\ccGlue
\ccFunction{bool
operator!=(const Exponent_vector &ev1,
const Exponent_vector &ev2);}{}
\ccc{LessThanComparable}:
\ccFunction{bool
operator<(const Exponent_vector &ev1,
const Exponent_vector &ev2);}{
Lexicographic compare, starting with the {\em last} variable. }
\ccGlue
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}\\
\end{ccRefClass}

122
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d.tex Normal file
View File

@ -0,0 +1,122 @@
\begin{ccRefConcept}{PolynomialTraits_d}
\ccDefinition
A model of \ccc{PolynomialTraits_d} is associated to an type
\ccc{Polynomial_d}, representing a multivariate polynomial.
The number of variables is denoted as the dimension of the polynomial,
it is arbitrary but fixed for a certain model of this concept.
Note: That this concept does not exclude univariate polynomial.
\ccc{PolynomialTraits_d} provides two different views on the
multivariate polynomial.
\begin{itemize}
\item A recursive view, that sees the polynomial as an element of
$R[x_1,\dots,x_{d-1}][x_d]$. In this view, the polynomial is handled as
an univariate polynomial over the ring $R[x_1,\dots,x_{d-1}]$.
\item A symmetric view, which is symmetric with respect to all variables,
seeing the polynomials as element of $R[x_1,\dots,x_d]$.
\end{itemize}
The default view is the recursive view, therefore all functors are
designed such that there default version performs the operation
with respect to this view.
\ccRefines
\ccConstants
\ccVariable{const int d;}{The dimension and the number of variables respectively.}
\ccTypes
\ccNestedType{Polynomial_d}{ Type representing $R[x_1,\dots,x_{d}]$.}\ccGlue
\ccNestedType{Coefficient }{ Type representing $R[x_1,\dots,x_{d-1}]$.}\ccGlue
\ccNestedType{Innermost_coefficient}{ Type representing the base ring $R$.}
\ccHeading{Functors}
\ccSetTwoColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{}
\ccNestedType{Construct_polynomial_d}{ A model of \ccc{PolynomialTraits_d::ConstructPolynomial_d}}
%Properties
\ccNestedType{Degree}{ A model of \ccc{PolynomialTraits_d::Degree}}
\ccNestedType{Total_degree}{ A model of \ccc{PolynomialTraits_d::TotalDegree}}
\ccNestedType{Leading_coefficient}{ A model of \ccc{PolynomialTraits_d::LeadingCoefficient}}
\ccNestedType{Univariate_content}{
In case \ccc{PolynomialTraits_d::Coefficient} is {\bf not} a model of
\ccc{UFDomain}, this is \ccc{CGAL::Null_type}, otherwise this is
a model of \ccc{PolynomialTraits_d::UnivariateContent}}
\begin{ccAdvanced}
\ccNestedType{Multivariate_content}{
In case \ccc{PolynomialTraits_d::Innermost_coefficient} is {\bf not}
a model of \ccc{UFDomain}, this is \ccc{CGAL::Null_type},
otherwise this is a model of
\ccc{PolynomialTraits_d::MultivariateContent}}
\end{ccAdvanced}
%Manipulation
\ccNestedType{Shift}{ A model of \ccc{PolynomialTraits_d::Shift}}
\ccNestedType{Negate}{ A model of \ccc{PolynomialTraits_d::Negate}}
\ccNestedType{Invert}{ A model of \ccc{PolynomialTraits_d::Invert}}
\ccNestedType{Translate}{ A model of \ccc{PolynomialTraits_d::Translate}}
\ccNestedType{Translate_homogeneous}{ A model of \ccc{PolynomialTraits_d::TranslateHomogeneous}}
\ccNestedType{Scale}{ A model of \ccc{PolynomialTraits_d::Scale}}
\ccNestedType{Scale_homogeneous}{ A model of \ccc{PolynomialTraits_d::ScaleHomogeneous}}
\begin{ccAdvanced}
//\ccNestedType{Scale_up}{ A model of \ccc{PolynomialTraits_d::ScaleUp, return $p(a*x)$}}
//\ccNestedType{Scale_down}{ A model of \ccc{PolynomialTraits_d::ScaleDown, return $b^{degree}*p(x/b)$}}
\end{ccAdvanced}
%unary operations
\ccNestedType{Differentiate}{ A model of \ccc{PolynomialTraits_d::Differentiate}}
\ccNestedType{Make_square_free}{ A model of \ccc{PolynomialTraits_d::MakeSquareFree}}
\ccNestedType{Square_free_factorization}{ In case \ccc{PolynomialTraits::Polynomial_d}
is not a model of \ccc{UFDomain}, this is of type \ccc{CGAL::Null_type},
otherwise this is a model of \ccc{PolynomialTraits_d::SquareFreeFactorization}}
%pseudo division
\ccNestedType{Pseudo_division }{ A model of \ccc{PolynomialTraits_d::Pseudo_division}}
\ccNestedType{Pseudo_division_remainder}{ A model of \ccc{PolynomialTraits_d::Pseudo_division_remainder}}
\ccNestedType{Pseudo_division_quotient }{ A model of \ccc{PolynomialTraits_d::Pseudo_division_quotient}}
%utcf
\ccNestedType{Gcd_up_to_constant_factor}{ A model of \ccc{PolynomialTraits_d::GcdUpToConstantFactor}}
\ccNestedType{Integral_division_up_to_constant_factor}{ A model of \ccc{PolynomialTraits_d::IntegralDivisionUpToConstantFactor}}
\ccNestedType{Content_up_to_constant_factor}{ A model of \ccc{PolynomialTraits_d::ContentUpToConstantFactor}}
\ccNestedType{Square_free_factorization_up_to_constant_factor}{ A model of \ccc{PolynomialTraits_d::SquareFreeFactorizationUpToConstantFactor}}
%Evaluation
\ccNestedType{Evaluate}{ A model of \ccc{PolynomialTraits_d::Evaluate}}
\ccNestedType{Evaluate_homogeneous}{ A model of \ccc{PolynomialTraits_d::EvaluateHomogeneous}}
%\ccNestedType{Sign_at}{ A model of \ccc{PolynomialTraits_d::SignAt}}
%resultant
\ccNestedType{Resultant}{ A model of \ccc{PolynomialTraits_d::Resultant}}
\ccNestedType{Swap}{ A model of \ccc{PolynomialTraits_d::Swap}}
\ccNestedType{Compare}{ A model of \ccc{PolynomialTraits_d::Compare}.
In case \ccc{Innermost_coefficient} is not \ccc{LessThanComparable} this
is \ccc{CGAL::Null_functor}. }
\ccNestedType{Canonicalize}{ A model of \ccc{PolynomialTraits_d::Canonicalize}}
\ccSeeAlso
\ccRefIdfierPage{AlgebraicStructureTraits}\\
\ccRefIdfierPage{Polynomial_d}\\
\end{ccRefConcept}

38
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_Canonicalize.tex Normal file
View File

@ -0,0 +1,38 @@
\begin{ccRefConcept}{PolynomialTraits_d::Canonicalize}
\ccDefinition
This \ccc{AdaptableUnaryFunction} computes a unique representative from the set:
$\{ q | \lambda * q = p with \lambda \in R \}$, where $p$ is the given polynomial and
$R$ the base of the polynomial ring.
In particular, the computed polynomial has the same zero set as the given one.
\footnote{In case \ccc{PolynomialTraits::Innermost_coefficient} is a model of \ccc{Field},
the computed polynomial is {\em monic}. (Innermost leading coefficient is one.)}
\ccRefines
\ccc{AdaptableUnaryFunction}
\ccTypes
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{xxx}{}
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d result_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d argument_type;}{}
\ccOperations
\ccCreationVariable{canonicalize}
\ccMethod{result_type operator()(first_argument_type f);}{}
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}\\
\end{ccRefConcept}

35
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_Compare.tex Normal file
View File

@ -0,0 +1,35 @@
\begin{ccRefConcept}{PolynomialTraits_d::Compare}
\ccDefinition
This \ccc{AdaptableBinaryFunction} compares two polynomials.
\ccRefines
\ccc{AdaptableBinaryFunction}
\ccTypes
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{xxx}{}
\ccTypedef{typedef CGAL::Comparison_result result_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d first_argument_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d second_argument_type;}{}
\ccOperations
\ccCreationVariable{compare}
\ccMethod{result_type operator()(first_argument_type f,
second_argument_type g);}
{Compare two polynomials.}
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}\\
\end{ccRefConcept}

58
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_ConstructPolynomial_d.tex Normal file
View File

@ -0,0 +1,58 @@
\begin{ccRefConcept}{PolynomialTraits_d::ConstructPolynomial_d}
\ccDefinition
This \ccc{Functor} provides several operators
to construct objects of type \ccc{PolynomialTraits_d::Polynomial_d}.
\ccRefines
\ccTypes
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{xxx}{}
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d result_type;}{}
\ccCreationVariable{poly}
\ccOperations
\ccMethod{result_type operator()();}
{Construct the zero polynomial.}
\ccMethod{result_type operator()(int i);}
{Construct the constant polynomial equal to $i$. }
\ccMethod{template < class InputIterator >
result_type operator()(InputIterator begin, InputIterator end);}
{\ccPrecond \ccc{InputIterator} must allow the value type
\ccc{PolynomialTraits_d::Coefficient}. \\
The operator constructs the a polynomial from the iterator range,
with respect to the outermost variable, $x_d$. \\
The range starts with the coefficient for $x_d^0$. \\
In case the range is empty, the zero polynomial is constructed.
}
\ccMethod{template < class InputIterator >
result_type operator()(InputIterator begin, InputIterator end, bool is_sorted= false);}{
%result_type operator()(InputIterator begin, InputIterator end, bool is_sorted = false);}{
Constructs a \ccc{Polynomial_d} from a given iterator range of
\ccc{std::pair<Exponent_vector, PolynomialTraits_d::Innermost_coefficient>}.
\ccPrecond value type of \ccc{InputIterator} is
\ccc{std::pair<Exponent_vector,
PolynomialTraits_d::Innermost_coefficient>}.
\ccPrecond Each \ccc{Exponent_vector} must have size $d$.
\ccPrecond All appearing \ccc{Exponent_vector}s are different.
}
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}\\
\ccRefIdfierPage{PolynomialTraits_d::TotalDegree}
\end{ccRefConcept}

35
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_Degree.tex Normal file
View File

@ -0,0 +1,35 @@
\begin{ccRefConcept}{PolynomialTraits_d::Degree}
\ccDefinition
This \ccc{AdaptableFunctor} computes the degree
of a \ccc{PolynomialTraits_d::Polynomial_d}.
\ccRefines
\ccc{AdaptableFunctor}
\ccTypes
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{xxx}{}
\ccTypedef{typedef int result_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d first_argument_type;}{}\ccGlue
\ccTypedef{typedef int second_argument_type;}{}
\ccOperations
\ccMethod{result_type operator()(first_argument_type p);}
{Computes the degree of $p$ with respect to the outermost variable $x_d$.}
\ccMethod{result_type operator()(first_argument_type p, int i);}
{Computes the degree of $p$ with respect to variable $x_i$.
\ccPrecond $0<i \leq d$
}
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}\\
\ccRefIdfierPage{PolynomialTraits_d::TotalDegree}
\end{ccRefConcept}

32
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_Differentiate.tex Normal file
View File

@ -0,0 +1,32 @@
\begin{ccRefConcept}{PolynomialTraits_d::Differentiate}
\ccDefinition
This \ccc{AdaptableFunctor} differentiates a
\ccc{PolynomialTraits_d::Polynomial_d} with respect to one variable.
\ccRefines
\ccc{AdaptableFunctor}
\ccTypes
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{xxx}{}
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d result_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d first_argument_type;}{}\ccGlue
\ccTypedef{typedef int second_argument_type;}{}
\ccOperations
\ccMethod{result_type operator()(first_argument_type p);}
{ return $p'$, with respect to the outermost variable. }
\ccMethod{result_type operator()(first_argument_type p,
second_argument_type i);}
{ return $p'$, with respect to variable $x_i$.
\ccPrecond $0<i \leq d$
}
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}
\end{ccRefConcept}

36
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_Evaluate.tex Normal file
View File

@ -0,0 +1,36 @@
\begin{ccRefConcept}{PolynomialTraits_d::Evaluate}
\ccDefinition
This \ccc{AdaptableFunctor} evaluates
\ccc{PolynomialTraits_d::Polynomial_d} with respect to one variable.
\ccRefines
\ccc{AdaptableFunctor}
\ccTypes
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{xxx}{}
\ccTypedef{typedef PolynomialTraits_d::Coefficient result_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d first_argument_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Innermost_coefficient second_argument_type;}{}\ccGlue
\ccTypedef{typedef int third_argument_type;}{}
\ccOperations
\ccMethod{result_type operator()(first_argument_type p,
second_argument_type x);}
{ return $p(x)$, with respect to the outermost variable. }
\ccMethod{result_type operator()(first_argument_type p,
second_argument_type c,
third_argument_type i);}
{ return $p(x)$, with respect to variable $x_i$.
\ccPrecond $0<i \leq d$
}
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}\\
\end{ccRefConcept}

51
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_EvaluateHomogeneous.tex Normal file
View File

@ -0,0 +1,51 @@
\begin{ccRefConcept}{PolynomialTraits_d::EvaluateHomogeneous}
\ccDefinition
This \ccc{AdaptableFunctor} interprets a \ccc{PolynomialTraits_d::Polynomial_d}
as a homogeneous polynomial with respect to one variable, an provides respective evaluation.
\ccRefines
\ccc{AdaptableFunctor}
\ccTypes
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{xxx}{}
\ccTypedef{typedef PolynomialTraits_d::Coefficient result_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d first_argument_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Innermost_coefficient second_argument_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Innermost_coefficient third_argument_type;}{}\ccGlue
\ccTypedef{typedef int fourth_argument_type;}{}\ccGlue
\ccTypedef{typedef int fifth_argument_type;}{}
\ccOperations
\ccMethod{result_type operator()(first_argument_type p,
second_argument_type u,
third_argument_type v);}
{ return $p(u,v)$, with respect to the outermost variable. \\
The homogeneous degree is considered as equal to the degree of $p$. }
\ccMethod{result_type operator()(first_argument_type p,
second_argument_type u,
third_argument_type v,
fourth_argument_type h);}
{ return $p(u,v)$, with respect to the outermost variable. \\
The homogeneous degree is $h$.
\ccPrecond: $h \geq degree(p)$ }
\ccMethod{result_type operator()(first_argument_type p,
second_argument_type u,
third_argument_type v,
fourth_argument_type h,
fifth_argument_type i);}
{ return $p(u,v)$, with respect to the variable $x_i$. \\
The homogeneous degree is $h$.
\ccPrecond $h \geq degree_i(p)$
\ccPrecond $0 < i \leq d$}
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}\\
\end{ccRefConcept}

49
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_GcdUpToConstantFactor.tex Normal file
View File

@ -0,0 +1,49 @@
\begin{ccRefConcept}{PolynomialTraits_d::GcdUpToConstantFactor}
\ccDefinition
This \ccc{AdaptableBinaryFunction} computes the $gcd$
{\em up to a constant factor (utcf)} of two polynomials of type
\ccc{PolynomialTraits_d::Polynomial_d}.
In case the base ring $R$, \ccc{PolynomialTraits_d::Innermost_coefficient},
is not a \ccc{UFDomain} or not a \ccc{Field} the polynomial ring
$R[x_1,\dots,x_d]$ ,\ccc{PolynomialTraits_d::Polynomial_d}, may not
possess greatest common divisor. However, since the $R$ is an integral
domain one can consider its quotient field $Q(R)$ for which gcds of
polynomials exist. A $gcd\_up_to_constant_factor(f,g)$ is a denominator-free
constant multiple of $gcd(f,g)$ in $Q(R)[x_1,\dots,x_d]$.
{\bf Note:} It may not be a divisor of $f$ and $g$ in $R[x_1,\dots,x_d]$.
\ccRefines
\ccc{AdaptableBinaryFunction}
\ccTypes
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{xxx}{}
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d result_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d first_argument_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d second_argument_type;}{}
\ccOperations
\ccMethod{result_type operator()(first_argument_type f,
second_argument_type g);}
{return a denominator-free, constant multiple of $gcd(f,g)$}
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}\\
\ccRefIdfierPage{PolynomialTraits_d::IntegralDivisionUpToConstantFactor}\\
\ccRefIdfierPage{PolynomialTraits_d::UnivariateContentUpToConstantFactor}\\
\ccRefIdfierPage{PolynomialTraits_d::SquareFreeFactorizationUpToConstantFactor}\\
\end{ccRefConcept}

49
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_GcdUtcf.tex Normal file
View File

@ -0,0 +1,49 @@
\begin{ccRefConcept}{PolynomialTraits_d::GcdUpToConstantFactor}
\ccDefinition
This \ccc{AdaptableBinaryFunction} computes the $gcd$
{\em up to a constant factor (utcf)} of two polynomials of type
\ccc{PolynomialTraits_d::Polynomial_d}.
In case the base ring $R$, \ccc{PolynomialTraits_d::Innermost_coefficient},
is not a \ccc{UFDomain} or not a \ccc{Field} the polynomial ring
$R[x_1,\dots,x_d]$ ,\ccc{PolynomialTraits_d::Polynomial_d}, may not
possess greatest common divisor. However, since the $R$ is an integral
domain one can consider its quotient field $Q(R)$ for which gcds of
polynomials exist. A $gcd\_up_to_constant_factor(f,g)$ is a denominator-free
constant multiple of $gcd(f,g)$ in $Q(R)[x_1,\dots,x_d]$.
{\bf Note:} It may not be a divisor of $f$ and $g$ in $R[x_1,\dots,x_d]$.
\ccRefines
\ccc{AdaptableBinaryFunction}
\ccTypes
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{xxx}{}
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d result_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d first_argument_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d second_argument_type;}{}
\ccOperations
\ccMethod{result_type operator()(first_argument_type f,
second_argument_type g);}
{return a denominator-free, constant multiple of $gcd(f,g)$}
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}\\
\ccRefIdfierPage{PolynomialTraits_d::IntegralDivisionUpToConstantFactor}\\
\ccRefIdfierPage{PolynomialTraits_d::UnivariateContentUpToConstantFactor}\\
\ccRefIdfierPage{PolynomialTraits_d::SquareFreeFactorizationUpToConstantFactor}\\
\end{ccRefConcept}

41
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_IntegralDivisionUpToConstantFactor.tex Normal file
View File

@ -0,0 +1,41 @@
\begin{ccRefConcept}{PolynomialTraits_d::IntegralDivisionUpToConstantFactor}
\ccDefinition
This \ccc{AdaptableBinaryFunction} computes the integral division
of two polynomials of type \ccc{PolynomialTraits_d::Polynomial_d}
{\em up to a constant factor (utcf)} .
\ccPrecond $g$ divides $f$ in $Q(R)[x_1,\dots,x_d]$, where $Q(R)$ is the quotient
field of the base ring $R$, \ccc{PolynomialTraits_d::Innermost_coefficient}.
\ccRefines
\ccc{AdaptableBinaryFunction}
\ccTypes
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{xxx}{}
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d result_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d first_argument_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d second_argument_type;}{}
\ccOperations
\ccMethod{result_type operator()(first_argument_type f,
second_argument_type g);}
{return a denominator-free, constant multiple of $f/g$}
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}\\
\ccRefIdfierPage{PolynomialTraits_d::GcdUpToConstantFactor}\\
\end{ccRefConcept}

41
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_IntegralDivisionUtcf.tex Normal file
View File

@ -0,0 +1,41 @@
\begin{ccRefConcept}{PolynomialTraits_d::IntegralDivisionUpToConstantFactor}
\ccDefinition
This \ccc{AdaptableBinaryFunction} computes the integral division
of two polynomials of type \ccc{PolynomialTraits_d::Polynomial_d}
{\em up to a constant factor (utcf)} .
\ccPrecond $g$ divides $f$ in $Q(R)[x_1,\dots,x_d]$, where $Q(R)$ is the quotient
field of the base ring $R$, \ccc{PolynomialTraits_d::Innermost_coefficient}.
\ccRefines
\ccc{AdaptableBinaryFunction}
\ccTypes
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{xxx}{}
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d result_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d first_argument_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d second_argument_type;}{}
\ccOperations
\ccMethod{result_type operator()(first_argument_type f,
second_argument_type g);}
{return a denominator-free, constant multiple of $f/g$}
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}\\
\ccRefIdfierPage{PolynomialTraits_d::GcdUpToConstantFactor}\\
\end{ccRefConcept}

32
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_Invert.tex Normal file
View File

@ -0,0 +1,32 @@
\begin{ccRefConcept}{PolynomialTraits_d::Invert}
\ccDefinition
This \ccc{AdaptableFunctor} inverts (reverse) a
\ccc{PolynomialTraits_d::Polynomial_d} with respect to one variable.
\ccRefines
\ccc{AdaptableFunctor}
\ccTypes
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{xxx}{}
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d result_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d first_argument_type;}{}\ccGlue
\ccTypedef{typedef int second_argument_type;}{}
\ccOperations
\ccMethod{result_type operator()(first_argument_type p);}
{ return $x^{degree}\cdot p(1/x)$, with respect to the outermost variable. }
\ccMethod{result_type operator()(first_argument_type p,
second_argument_type i);}
{ return $x^{degree}\cdot p(1/x)$, with respect to variable $x_i$.
\ccPrecond $0<i \leq d$
}
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}
\end{ccRefConcept}

33
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_LeadingCoefficient.tex Normal file
View File

@ -0,0 +1,33 @@
\begin{ccRefConcept}{PolynomialTraits_d::LeadingCoefficient}
\ccDefinition
This \ccc{AdaptableFunctor} computes the leading coefficient
of a \ccc{PolynomialTraits_d::Polynomial_d}.
\ccRefines
\ccc{AdaptableFunctor}
\ccTypes
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{xxx}{}
\ccTypedef{typedef PolynomialTraits_d::Coefficient result_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d first_argument_type;}{}\ccGlue
\ccTypedef{typedef int second_argument_type;}{}
\ccOperations
\ccMethod{result_type operator()(first_argument_type p);}
{Computes the leading coefficient of $p$ with respect to the outermost variable $x_d$. }
\ccMethod{result_type operator()(first_argument_type p, int i);}
{Computes the leading coefficient of $p$ with respect to variable $x_i$.
\ccPrecond $0<i \leq d$
}
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}
\end{ccRefConcept}

35
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_MakeSquareFree.tex Normal file
View File

@ -0,0 +1,35 @@
\begin{ccRefConcept}{PolynomialTraits_d::MakeSquareFree}
\ccDefinition
This \ccc{AdaptableFunctor} computes the square-free part of
a polynomial of type \ccc{PolynomialTraits_d::Polynomial_d}
{\em up to a constant factor}.
A polynomial $p$ can be factored into square-free and pairwise coprime
non-constant factors $g_i$ with multiplicities $m_i$ and a constant factor $a$,
such that $p = a \cdot g_1m_1 \cdot ... \cdot g_nm_n$.
This functor computes $g_1 \cdot ... \cdot g_n$ {\em up to a constant factor}.
\ccRefines
\ccc{AdaptableFunctor}
\ccTypes
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{xxx}{}
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d result_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d first_argument_type;}{}
\ccOperations
\ccMethod{result_type operator()(first_argument_type p);}
{ return the square-free part of $p$ {\em up to a constant factor.} }
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}
\end{ccRefConcept}

39
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_MakeSquareFreeUtcf.tex Normal file
View File

@ -0,0 +1,39 @@
\begin{ccRefConcept}{PolynomialTraits_d::MakeSquareFreeUpToConstantFactor}
\ccDefinition
This \ccc{AdaptableFunctor} computes the square-free part of
a polynomial of type \ccc{PolynomialTraits_d::Polynomial_d}.
A polynomial $p$ can be factored into square-free and pairwise coprime
non-constant factors $g_i$ with multiplicities $m_i$ and a constant factor $a$,
such that $p = a \cdot g_1m_1 \cdot ... \cdot g_nm_n$.
This functor computes $g_1 \cdot ... \cdot g_n$.
\ccRefines
\ccc{AdaptableFunctor}
\ccTypes
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{xxx}{}
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d result_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d first_argument_type;}{}
\ccOperations
\ccMethod{result_type operator()(first_argument_type p);}
{ return the square-free part of $p$.
\ccPostcond $multivriat_content(result) = 1$
}
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}\\
\ccRefIdfierPage{PolynomialTraits_d::MakeSquareFree}\\
\ccRefIdfierPage{PolynomialTraits_d::SquareFreeFactorization}\\
\ccRefIdfierPage{PolynomialTraits_d::SquareFreeFactorizationUpToConstantFactor}\\
\end{ccRefConcept}

31
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_MultivariateContent.tex Normal file
View File

@ -0,0 +1,31 @@
\begin{ccRefConcept}{PolynomialTraits_d::MultivariateContent}
\begin{ccAdvanced}
\ccDefinition
This \ccc{AdaptableFunctor} computes the content of a \ccc{PolynomialTraits_d::Polynomial_d}
with respect to the symmetric view on the polynomial.
In particular it computes the gcd of all innermost coefficients.
\ccRefines
\ccc{AdaptableFunctor}
\ccTypes
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx xxxxxx}{xxx}{}
\ccTypedef{typedef PolynomialTraits_d::Innermost_coefficient result_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d first_argument_type;}{}
\ccOperations
\ccMethod{result_type operator()(first_argument_type p);}
{Computes the $gcd$ of all innermost coefficients of $p$. }
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}\\
\end{ccAdvanced}
\end{ccRefConcept}

31
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_Negate.tex Normal file
View File

@ -0,0 +1,31 @@
\begin{ccRefConcept}{PolynomialTraits_d::Negate}
\ccDefinition
This \ccc{AdaptableFunctor} negates a \ccc{PolynomialTraits_d::Polynomial_d} with
respect to one variable.
\ccRefines
\ccc{AdaptableFunctor}
\ccTypes
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{xxx}{}
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d result_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d first_argument_type;}{}\ccGlue
\ccTypedef{typedef int second_argument_type;}{}
\ccOperations
\ccMethod{result_type operator()(first_argument_type p);}
{ return $p(-x)$, with respect to the outermost variable. }
\ccMethod{result_type operator()(first_argument_type p,
second_argument_type i);}
{ return $p(-x)$, with respect to variable $x_i$.
\ccPrecond $0<i \leq d$
}
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}\\
\end{ccRefConcept}

60
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_PseudoDivision.tex Normal file
View File

@ -0,0 +1,60 @@
\begin{ccRefConcept}{PolynomialTraits_d::PseudoDivision}
\ccDefinition
This \ccc{AdaptableFunctor} computes the so called {\em pseudo division}
of to polynomials $f$ and $g$.
Given $f$ and $g != 0$, compute quotient $q$ and remainder $r$
such that $D \cdot f = g \cdot q + r$ and $degree(r) < degree(g)$,
where $ D = leading\_coefficient(g)^{max(0, degree(f)-degree(g)+1)}$
\ccRefines
\ccTypes
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{xxx}{}
\ccTypedef{typedef void result_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d first_argument_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d second_argument_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d third_argument_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d fourth_argument_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Coefficient fifth_argument_type;}{}\ccGlue
\ccTypedef{typedef int sixth_argument_type;}{}
\ccOperations
\ccMethod{result_type operator()(first_argument_type f,
second_argument_type g,
third_argument_type q,
fourth_argument_type r,
fifth_argument_type D);}{ Computes
the pseudo division with respect to the outermost variable $x_d$.}
\begin{ccAdvanced}
\ccMethod{result_type operator()(first_argument_type f,
second_argument_type g,
third_argument_type q,
fourth_argument_type r,
fifth_argument_type D,
int i);}{ Computes
the pseudo division with respect to variable $x_i$.
\ccPrecond $0<i \leq d$ }
\end{ccAdvanced}
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}\\
\ccRefIdfierPage{PolynomialTraits_d::PseudoDivision}\\
\ccRefIdfierPage{PolynomialTraits_d::PseudoDivisionRemainder}\\
\ccRefIdfierPage{PolynomialTraits_d::PseudoDivisionQuotient}\\
\end{ccRefConcept}

49
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_PseudoDivisionQuotient.tex Normal file
View File

@ -0,0 +1,49 @@
\begin{ccRefConcept}{PolynomialTraits_d::PseudoDivisionQuotient}
\ccDefinition
This \ccc{AdaptableFunctor} computes the quotient of the so called {\em pseudo division}
of to polynomials $f$ and $g$.
Given $f$ and $g != 0$, compute quotient $q$ and remainder $r$
such that $D \cdot f = g \cdot q + r$ and $degree(r) < degree(g)$,
where $ D = leading\_coefficient(g)^{max(0, degree(f)-degree(g)+1)}$
\ccRefines
\ccTypes
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{xxx}{}
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d result_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d first_argument_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d second_argument_type;}{}\ccGlue
\ccTypedef{typedef int third_argument_type;}{}
\ccOperations
\ccMethod{result_type operator()(first_argument_type f,
second_argument_type g);}{ Returns the quotient $q$
of the pseudo division of $f$ and $g$ with respect to the outermost variable $x_d$.}
\begin{ccAdvanced}
\ccMethod{result_type operator()(first_argument_type f,
second_argument_type g,
int i);}{ Returns the quotient $q$
of the pseudo division of $f$ and $g$ with respect to variable $x_i$.
\ccPrecond $0<i \leq d$ }
\end{ccAdvanced}
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}\\
\ccRefIdfierPage{PolynomialTraits_d::PseudoDivision}\\
\ccRefIdfierPage{PolynomialTraits_d::PseudoDivisionRemainder}\\
\ccRefIdfierPage{PolynomialTraits_d::PseudoDivisionQuotient}\\
\end{ccRefConcept}

51
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_PseudoDivisionRemainder.tex Normal file
View File

@ -0,0 +1,51 @@
\begin{ccRefConcept}{PolynomialTraits_d::PseudoDivisionRemainder}
\ccDefinition
This \ccc{AdaptableFunctor} computes the remainder of the so called {\em pseudo division}
of to polynomials $f$ and $g$.
Given $f$ and $g != 0$, compute quotient $q$ and remainder $r$
such that $D \cdot f = g \cdot q + r$ and $degree(r) < degree(g)$,
where $ D = leading\_coefficient(g)^{max(0, degree(f)-degree(g)+1)}$
\ccRefines
\ccTypes
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{xxx}{}
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d result_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d first_argument_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d second_argument_type;}{}\ccGlue
\ccTypedef{typedef int third_argument_type;}{}
\ccOperations
\ccMethod{result_type operator()(first_argument_type f,
second_argument_type g);}{ Returns the remainder $r$
of the pseudo division of $f$ and $g$ with respect to the outermost variable $x_d$.}
\begin{ccAdvanced}
\ccMethod{result_type operator()(first_argument_type f,
second_argument_type g,
int i);}{ Returns the remainder $r$
of the pseudo division of $f$ and $g$ with respect to variable $x_i$.
\ccPrecond $0<i \leq d$}
\end{ccAdvanced}
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}\\
\ccRefIdfierPage{PolynomialTraits_d::PseudoDivision}\\
\ccRefIdfierPage{PolynomialTraits_d::PseudoDivisionRemainder}\\
\ccRefIdfierPage{PolynomialTraits_d::PseudoDivisionQuotient}\\
\end{ccRefConcept}

38
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_Resultant.tex Normal file
View File

@ -0,0 +1,38 @@
\begin{ccRefConcept}{PolynomialTraits_d::Resultant}
\ccDefinition
This \ccc{AdaptableFunctor} computes the resultant of two polynomials $f$ and $g$ of
type \ccc{PolynomialTraits_d::Polynomial_d} with respect a certain variable.
\ccRefines
\ccc{AdaptableFunctor}
\ccTypes
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{xxx}{}
\ccTypedef{typedef PolynomialTraits_d::Coefficient result_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d first_argument_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d second_argument_type;}{}\ccGlue
\ccTypedef{typedef int third_argument_type;}{}
\ccOperations
\ccMethod{result_type operator()(first_argument_type f,
second_argument_type g);}
{ computes the resultant of $f$ and $g$,
with respect to the outermost variable.}
\ccMethod{result_type operator()(first_argument_type f,
second_argument_type g,
third_argument_type i);}
{ computes the resultant of $f$ and $g$,
with respect to variable $x_i$.
\ccPrecond $0<i \leq d$
}
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}\\
\end{ccRefConcept}

37
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_Scale.tex Normal file
View File

@ -0,0 +1,37 @@
\begin{ccRefConcept}{PolynomialTraits_d::Scale}
\ccDefinition
This \ccc{AdaptableFunctor} scale a
\ccc{PolynomialTraits_d::Polynomial_d} with respect to one variable.
\ccRefines
\ccc{AdaptableFunctor}
\ccTypes
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{xxx}{}
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d result_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d first_argument_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Coefficient second_argument_type;}{}\ccGlue
\ccTypedef{typedef int third_argument_type;}{}
\ccOperations
\ccMethod{result_type operator()(first_argument_type p,
second_argument_type c);}
{ return $p(c\cdot x)$, with respect to the outermost variable. }
\ccMethod{result_type operator()(first_argument_type p,
second_argument_type c,
third_argument_type i);}
{ return $p(c\cdot x)$, with respect to variable $x_i$.
\ccPrecond $0<i \leq d$
}
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}\\
\end{ccRefConcept}

38
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_ScaleHomogeneous.tex Normal file
View File

@ -0,0 +1,38 @@
\begin{ccRefConcept}{PolynomialTraits_d::ScaleHomogeneous}
\ccDefinition
This \ccc{AdaptableFunctor} scale a
\ccc{PolynomialTraits_d::Polynomial_d} with respect to one variable.
\ccRefines
\ccc{AdaptableFunctor}
\ccTypes
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{xxx}{}
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d result_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d first_argument_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Coefficient second_argument_type;}{}\ccGlue
\ccTypedef{typedef int third_argument_type;}{}
\ccOperations
\ccMethod{result_type operator()(first_argument_type p,
second_argument_type a,
third_argument_type b);}
{ return $b^{degree}\cdot p(a\cdot x/b)$, with respect to the outermost variable. }
\ccMethod{result_type operator()(first_argument_type p,
second_argument_type a,
third_argument_type b,
fourth_argument_type i);}
{ return $b^{degree}\cdot p(a\cdot x/b) $, with respect to variable $x_i$.
\ccPrecond $0<i \leq d$
}
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}\\
\end{ccRefConcept}

38
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_Shift.tex Normal file
View File

@ -0,0 +1,38 @@
\begin{ccRefConcept}{PolynomialTraits_d::Shift}
\ccDefinition
This \ccc{AdaptableFunctor} shifts a \ccc{PolynomialTraits_d::Polynomial_d} by
some power of a variable.
\ccRefines
\ccc{AdaptableFunctor}
\ccTypes
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{xxx}{}
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d result_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d first_argument_type;}{}\ccGlue
\ccTypedef{typedef int second_argument_type;}{}\ccGlue
\ccTypedef{typedef int third_argument_type;}{}
\ccOperations
\ccMethod{result_type operator()(first_argument_type p,
second_argument_type e);}
{ return $p * x_d^e$
\ccPrecond $0 \leq e$ }
\ccMethod{result_type operator()(first_argument_type p,
second_argument_type e,
third_argument_type i);}
{ return $p * x_i^e$
\ccPrecond $0 \leq e$
\ccPrecond $0 < i \leq d$
}
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}\\
\end{ccRefConcept}

64
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_SquareFreeFactorization.tex Normal file
View File

@ -0,0 +1,64 @@
\begin{ccRefConcept}{PolynomialTraits_d::SquareFreeFactorization}
\ccDefinition
This \ccc{AdaptableFunctor} computes a square-free factorization
of a \ccc{PolynomialTraits_d::Polynomial_d}.
A polynomial $p$ is factored into square-free and pairwise coprime non-constant
factors $g_i$ with multiplicities $m_i$ and a constant factor $a$, such that
$p = a \cdot g_1m_1 \cdot ... \cdot g_nm_n$.
The provided operators return the number $n$, the factors $g_i$ and
multiplicities $m_i$ are written through the respective output iterators,
$a$ is a constant factor of type \ccc{PolynomialTraits_d::Innermost_coefficient}
\ccRefines
\ccTypes
\ccOperations
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{xxx}{}
\ccMethod{template<class OutputIterator_1, class OutputIterator_2>
int operator()(PolynomialTraits_d::Polynomial_d p,
OutputIterator_1 it_1,
OutputIterator_2 it_2,
PolynomialTraits_d::Innermost_coefficient& a);}{computes square-free
factorization of $p$.\\
\ccPrecond \ccc{OutputIterator_1} must allow the value type
\ccc{PolynomialTraits_d:.Polynomial_d}.
\ccPrecond \ccc{OutputIterator_2} must allow the value type int.}
% This is the original documentation, but the manual tools are not able to handle this part:
%\ccMethod{template<class OutputIterator_1, class OutputIterator_2>
% int
% operator()(PolynomialTraits_d::Polynomial_d p,
% OutputIterator_1 it_1,
% OutputIterator_2 it_2,
% PolynomialTraits_d::Innermost_coefficient& a);}
% { factor the polynomial $p$ by multiplicities.
% That means: factor it into square-free and pairwise coprime non-constant factors $g_i$
% with multiplicities $m_i$ such that $p = a \cdot g_1m_1 \cdot ... \cdot g_nm_n$.
%
% This is known as square-free factorization in the literature.
% The number n is returned. The factors $g_i$ and multiplicities $m_i$ are written through
% the respective output iterators.\\
%
% \ccPrecond \ccc{OutputIterator_1} must allow the value type \ccc{PolynomialTraits_d:.Polynomial_d}. \\
% \ccPrecond \ccc{OutputIterator_1} must allow the value type int.
% }
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}\\
\ccRefIdfierPage{PolynomialTraits_d::SquareFreeFactorizationUpToConstantFactor}\\
\ccRefIdfierPage{PolynomialTraits_d::MakeSquareFree}\\
\end{ccRefConcept}

63
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_SquareFreeFactorizationUpToConstantFactor.tex Normal file
View File

@ -0,0 +1,63 @@
\begin{ccRefConcept}{PolynomialTraits_d::SquareFreeFactorizationUpToConstantFactor}
\ccDefinition
This \ccc{AdaptableFunctor} computes a square-free factorization
{\em up to a constant factor (utcf)} of a
\ccc{PolynomialTraits_d::Polynomial_d}.
A polynomial $p$ is factored into square-free and pairwise coprime non-constant
factors $g_i$ with multiplicities $m_i$, such that
$a \cdot p = g_1m_1 \cdot ... \cdot g_nm_n$, where $a$ is some constant factor.
The provided operators return the number $n$, the factors $g_i$ and
multiplicities $m_i$ are written through the respective output iterators.
The constant factor $a$ is not computed.
\ccRefines
\ccTypes
\ccOperations
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{xxx}{}
\ccMethod{template<class OutputIterator_1, class OutputIterator_2>
int operator()(PolynomialTraits_d::PolynomialTraits_d p,
OutputIterator_1 it_1,
OutputIterator_2 it_2);}{computes square-free
factorization of $p$ up to a constant factor.\\
\ccPrecond \ccc{OutputIterator_1} must allow the value type
\ccc{PolynomialTraits_d::Polynomial_d}.
\ccPrecond \ccc{OutputIterator_2} must allow the value type int.}
% This is the original documentation, but the manual tools are not able to handle this part:
%\ccMethod{template<class OutputIterator_1, class OutputIterator_2>
% int
% operator()(PolynomialTraits_d::Polynomial_d p,
% OutputIterator_1 it_1,
% OutputIterator_2 it_2,
% PolynomialTraits_d::Innermost_coefficient& a);}
% { factor the polynomial $p$ by multiplicities.
% That means: factor it into square-free and pairwise coprime non-constant factors $g_i$
% with multiplicities $m_i$ such that $p = a \cdot g_1m_1 \cdot ... \cdot g_nm_n$.
%
% This is known as square-free factorization in the literature.
% The number n is returned. The factors $g_i$ and multiplicities $m_i$ are written through
% the respective output iterators.\\
%
% \ccPrecond \ccc{OutputIterator_1} must allow the value type \ccc{PolynomialTraits_d:.Polynomial_d}. \\
% \ccPrecond \ccc{OutputIterator_1} must allow the value type int.
% }
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}\\
\ccRefIdfierPage{PolynomialTraits_d::SquareFreeFactorization}\\
\end{ccRefConcept}

63
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_SquareFreeFactorizationUtcf.tex Normal file
View File

@ -0,0 +1,63 @@
\begin{ccRefConcept}{PolynomialTraits_d::SquareFreeFactorizationUpToConstantFactor}
\ccDefinition
This \ccc{AdaptableFunctor} computes a square-free factorization
{\em up to a constant factor (utcf)} of a
\ccc{PolynomialTraits_d::Polynomial_d}.
A polynomial $p$ is factored into square-free and pairwise coprime non-constant
factors $g_i$ with multiplicities $m_i$, such that
$a \cdot p = g_1m_1 \cdot ... \cdot g_nm_n$, where $a$ is some constant factor.
The provided operators return the number $n$, the factors $g_i$ and
multiplicities $m_i$ are written through the respective output iterators.
The constant factor $a$ is not computed.
\ccRefines
\ccTypes
\ccOperations
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{xxx}{}
\ccMethod{template<class OutputIterator_1, class OutputIterator_2>
int operator()(PolynomialTraits_d::PolynomialTraits_d p,
OutputIterator_1 it_1,
OutputIterator_2 it_2);}{computes square-free
factorization of $p$ up to a constant factor.\\
\ccPrecond \ccc{OutputIterator_1} must allow the value type
\ccc{PolynomialTraits_d::Polynomial_d}.
\ccPrecond \ccc{OutputIterator_2} must allow the value type int.}
% This is the original documentation, but the manual tools are not able to handle this part:
%\ccMethod{template<class OutputIterator_1, class OutputIterator_2>
% int
% operator()(PolynomialTraits_d::Polynomial_d p,
% OutputIterator_1 it_1,
% OutputIterator_2 it_2,
% PolynomialTraits_d::Innermost_coefficient& a);}
% { factor the polynomial $p$ by multiplicities.
% That means: factor it into square-free and pairwise coprime non-constant factors $g_i$
% with multiplicities $m_i$ such that $p = a \cdot g_1m_1 \cdot ... \cdot g_nm_n$.
%
% This is known as square-free factorization in the literature.
% The number n is returned. The factors $g_i$ and multiplicities $m_i$ are written through
% the respective output iterators.\\
%
% \ccPrecond \ccc{OutputIterator_1} must allow the value type \ccc{PolynomialTraits_d:.Polynomial_d}. \\
% \ccPrecond \ccc{OutputIterator_1} must allow the value type int.
% }
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}\\
\ccRefIdfierPage{PolynomialTraits_d::SquareFreeFactorization}\\
\end{ccRefConcept}

34
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_Swap.tex Normal file
View File

@ -0,0 +1,34 @@
\begin{ccRefConcept}{PolynomialTraits_d::Swap}
\ccDefinition
\ccRefines
\ccc{AdaptableFunctor}
\ccTypes
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{xxx}{}
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d result_type;}{}\ccGlue
\ccOperations
\ccMethod{result_type operator()(PolynomialTraits_d::Polynomial_d,
int i, int j);}
{ return polynomial with interchanged variables $x_i$,$x_j$.
\ccPrecond 0 < i <= d
\ccPrecond 0 < j <= d
}
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}\\
\end{ccRefConcept}

31
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_TotalDegree.tex Normal file
View File

@ -0,0 +1,31 @@
\begin{ccRefConcept}{PolynomialTraits_d::TotalDegree}
\ccDefinition
This \ccc{AdaptableUnaryFunction} computes the total degree
of a \ccc{PolynomialTraits_d::Polynomial_d}.
\ccRefines
\ccc{AdaptableFunctor}
\ccTypes
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{xxx}{}
\ccTypedef{typedef int result_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d first_argument_type;}{}
\ccOperations
\ccMethod{result_type operator()(first_argument_type p);}
{Computes the total degree of $p$.}
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}\\
\ccRefIdfierPage{PolynomialTraits_d::Degree}
\end{ccRefConcept}

37
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_Translate.tex Normal file
View File

@ -0,0 +1,37 @@
\begin{ccRefConcept}{PolynomialTraits_d::Translate}
\ccDefinition
This \ccc{AdaptableFunctor} translate a
\ccc{PolynomialTraits_d::Polynomial_d} with respect to one variable.
\ccRefines
\ccc{AdaptableFunctor}
\ccTypes
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{xxx}{}
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d result_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d first_argument_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Coefficient second_argument_type;}{}\ccGlue
\ccTypedef{typedef int third_argument_type;}{}
\ccOperations
\ccMethod{result_type operator()(first_argument_type p,
second_argument_type c);}
{ return $p(x+c)$, with respect to the outermost variable. }
\ccMethod{result_type operator()(first_argument_type p,
second_argument_type c,
third_argument_type i);}
{ return $p(x+c)$, with respect to variable $x_i$.
\ccPrecond $0<i \leq d$
}
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}\\
\end{ccRefConcept}

39
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_TranslateHomogeneous.tex Normal file
View File

@ -0,0 +1,39 @@
\begin{ccRefConcept}{PolynomialTraits_d::TranslateHomogeneous}
\ccDefinition
This \ccc{AdaptableFunctor} translate a
\ccc{PolynomialTraits_d::Polynomial_d} with respect to one variable.
\ccRefines
\ccc{AdaptableFunctor}
\ccTypes
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{xxx}{}
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d result_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d first_argument_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Coefficient second_argument_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Coefficient third_argument_type;}{}\ccGlue
\ccTypedef{typedef int fourth_argument_type;}{}
\ccOperations
\ccMethod{result_type operator()(first_argument_type p,
second_argument_type a,
third_argument_type b);}
{ return $b^{degree}\cdot p(x+a)/b$, with respect to the outermost variable. }
\ccMethod{result_type operator()(first_argument_type p,
second_argument_type a,
third_argument_type b,
fourth_argument_type i);}
{ return $b^{degree}\cdot p(x+a)/b$, with respect to variable $x_i$.
\ccPrecond $0<i \leq d$
}
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}\\
\end{ccRefConcept}

36
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_UnivariateContent.tex Normal file
View File

@ -0,0 +1,36 @@
\begin{ccRefConcept}{PolynomialTraits_d::UnivariateContent}
\ccDefinition
This \ccc{AdaptableFunctor} computes the content of a
\ccc{PolynomialTraits_d::Polynomial_d}
with respect to the univariate (recursive) view on the
polynomial. In particular it computes the gcd of all
coefficients with respect to one variable.
\ccRefines
\ccc{AdaptableFunctor}
\ccTypes
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{xxx}{}
\ccTypedef{typedef PolynomialTraits_d::Coefficient result_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d first_argument_type;}{}\ccGlue
\ccTypedef{typedef int second_argument_type;}{}
\ccOperations
\ccMethod{result_type operator()(first_argument_type p);}
{Computes the content of $p$ with respect to the outermost variable $x_d$. }
\ccMethod{result_type operator()(first_argument_type p, int i);}
{Computes the content of $p$ with respect to variable $x_i$.
\ccPrecond $0<i \leq d$
}
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}
\end{ccRefConcept}

46
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_UnivariateContentUpToConstantFactor.tex Normal file
View File

@ -0,0 +1,46 @@
\begin{ccRefConcept}{PolynomialTraits_d::UnivariateContentUpToConstantFactor}
\ccDefinition
This \ccc{AdaptableFunctor} computes the content of a
\ccc{PolynomialTraits_d::Polynomial_d}
with respect to the univariate (recursive) view on the
polynomial {\em up to a constant factor}.
In particular it computes the $gcd_up_to_constant_factor$ of all
coefficients with respect to one variable.
Remark: This is called \ccc{UnivariateContentUpToConstantFactor} for
symmetric reasons with respect to \ccc{PolynomialTraits_d::UnivariateContent}
and \ccc{PolynomialTraits_d::MultivariateContent}.
However, a concept \ccc{PolynomialTraits_d::MultivariateContentUpToConstantFactor} does not exist
since the result is trivial.
\ccRefines
\ccc{AdaptableFunctor}
\ccTypes
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{xxx}{}
\ccTypedef{typedef PolynomialTraits_d::Coefficient result_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d first_argument_type;}{}\ccGlue
\ccTypedef{typedef int second_argument_type;}{}
\ccOperations
\ccMethod{result_type operator()(first_argument_type p);}
{Computes the content {\em up to a constant factor} of $p$ with
respect to the outermost variable $x_d$. }
\ccMethod{result_type operator()(first_argument_type p, int i);}
{Computes the content {\em up to a constant factor} of $p$ with
respect to variable $x_i$.
\ccPrecond $0<i \leq d$
}
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}
\ccRefIdfierPage{PolynomialTraits_d::GcdUpToConstantFactor}\\
\end{ccRefConcept}

46
Polynomial/doc_tex/Polynomial_ref/PolynomialTraits_d_UnivariateContentUtcf.tex Normal file
View File

@ -0,0 +1,46 @@
\begin{ccRefConcept}{PolynomialTraits_d::UnivariateContentUpToConstantFactor}
\ccDefinition
This \ccc{AdaptableFunctor} computes the content of a
\ccc{PolynomialTraits_d::Polynomial_d}
with respect to the univariate (recursive) view on the
polynomial {\em up to a constant factor}.
In particular it computes the $gcd_up_to_constant_factor$ of all
coefficients with respect to one variable.
Remark: This is called \ccc{UnivariateContentUpToConstantFactor} for
symmetric reasons with respect to \ccc{PolynomialTraits_d::UnivariateContent}
and \ccc{PolynomialTraits_d::MultivariateContent}.
However, a concept \ccc{PolynomialTraits_d::MultivariateContentUpToConstantFactor} does not exist
since the result is trivial.
\ccRefines
\ccc{AdaptableFunctor}
\ccTypes
\ccSetThreeColumns{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}{xxx}{}
\ccTypedef{typedef PolynomialTraits_d::Coefficient result_type;}{}\ccGlue
\ccTypedef{typedef PolynomialTraits_d::Polynomial_d first_argument_type;}{}\ccGlue
\ccTypedef{typedef int second_argument_type;}{}
\ccOperations
\ccMethod{result_type operator()(first_argument_type p);}
{Computes the content {\em up to a constant factor} of $p$ with
respect to the outermost variable $x_d$. }
\ccMethod{result_type operator()(first_argument_type p, int i);}
{Computes the content {\em up to a constant factor} of $p$ with
respect to variable $x_i$.
\ccPrecond $0<i \leq d$
}
%\ccHasModels
\ccSeeAlso
\ccRefIdfierPage{Polynomial_d}\\
\ccRefIdfierPage{PolynomialTraits_d}
\ccRefIdfierPage{PolynomialTraits_d::GcdUpToConstantFactor}\\
\end{ccRefConcept}

44
Polynomial/doc_tex/Polynomial_ref/Polynomial_d.tex Normal file
View File

@ -0,0 +1,44 @@
\begin{ccRefConcept}{Polynomial_d}
\ccDefinition
A model \ccc{Polynomial_d} possesses a traits class
\ccc{CGAL::Polynomial_traits_d<Polynomial_d>}, which is a model of
\ccc{PolynomialTraits_d}. An \ccc{Polynomial_d} represents a multivariate
polynomial over some basic ring $R$, this type is denoted as the innermost
coefficient type and is accessible through the traits class
\ccc{CGAL::Polynomial_traits_d<Polynomial_d>::Innermost_coefficient}.
\ccRefines
\ccc{IntegralDomainWithoutDiv} \\
\ccc{Polynomial_d} and \ccc{Innermost_coefficient} are at least a
model of \ccc{IntegralDomainWithoutDiv}. \\
Moreover, the algebraic structure of \ccc{Polynomial} depends on the
algebraic structure of \ccc{Innermost_coefficient}:
\begin{tabular}{|l|l|}
\hline
\ccc{Innermost_coefficient}&\ccc{Polynomial_d}\\
\hline
\ccc{IntegralDomainWithoutDiv}&\ccc{IntegralDomainWithoutDiv}\\
\ccc{IntegralDomain}&\ccc{IntegralDomain}\\
\ccc{UFDomain}&\ccc{UFDomain}\\
\ccc{EuclideanRing}&\ccc{UFDomain}\\
\ccc{Field}&\ccc{UFDomain}\\
\hline
\end{tabular}
Note:The concept \ccc{Polynomial_1} refines \ccc{EuclideanRing} in case
\ccc{Innermost_coefficient} is a \ccc{Field}.
\ccSeeAlso
\ccRefIdfierPage{AlgebraicStructureTraits}\\
\ccRefIdfierPage{PolynomialTraits_d}\\
\ccHasModels
\end{ccRefConcept}

102
Polynomial/doc_tex/Polynomial_ref/intro.tex Executable file
View File

@ -0,0 +1,102 @@
\ccRefChapter{Polynomial}
%\label{ChapterRefPolynomial}
\ccChapterAuthor{Michael Hemmer and Who Soever}
\section{todo open questions:}
\begin{itemize}
\item Some of the functors in PolynomialTraits can be implemented using some more basic ones.
On the other hand, the way they should be implemented may depend on the way the polynomial is
represented and on the cost of the other functors.
I therefore decided to put them into the PolynomialTraits.
On the other hand one could decide to provide a very basic PolynomialTraits
(just constructor, access to coefficients, and properties (degree)) and call the current
PolynomialTraits a PolynomialToolBox. But I don't think that this is going to be very efficient
or used.
\item Note that the numbering of variables in \ccc{Exponent_vector} is inconsistent
with the one in \ccc{Polynomial_d} and \ccc{PolynomialTraits_d}. \\
TODO: resolve this conflict.
\item Should the concept define the total order of Polynomials, i.e. how two polynomials are compared?
\item Note that a Polynomial is also a Model of an algebraic structure. Therefore a Polynomial will have a
valid \ccc{Algebraic_structure_traits}. \\
Question: should concept \ccc{PolynomialTraits} refine \ccc{AlgebraicStructureTraits}.\\
However, the \ccc{Polynomial_traits} could easily derive from \ccc{Algebraic_structure_traits}.\\
see also package: \ccc{Algebraic_foundations}.
\item \ccc{PolynomialTraits_d::Evaluate}: take \ccc{Innermost_coefficient} as argument type only.
this relates \ccc{Coercion_traits} \ccc{Algebraic_foundations}
\item This is just the general concept for \ccc{Polynomial_d}. \\
I plan to propose additional concepts for \ccc{Polynomial_1},\ccc{Polynomial_2} and maybe \ccc{Polynomial_3}.
These concepts will refine \ccc{Polynomial_d}, i.e. fix the constant \ccc{Polynomial_traits_d::d} to the appropriate value
and introduce extra functors as \ccc{Sign_at}, for univariate bivariate polynomials.
\item Do we need a SignAt for multivariate polynomials?
\end{itemize}
\section{Classified Reference Pages}
\subsection*{Polynomial\_d}
\subsubsection*{Concepts}
\ccRefConceptPage{Polynomial_d}\\
\ccRefConceptPage{PolynomialTraits_d}\\
\ccRefConceptPage{PolynomialTraits_d::ConstructPolynomial_d}\\
\ccRefConceptPage{PolynomialTraits_d::Swap}\\
\ccRefConceptPage{PolynomialTraits_d::Move}\\
\ccRefConceptPage{PolynomialTraits_d::Degree}\\
\ccRefConceptPage{PolynomialTraits_d::TotalDegree}\\
\ccRefConceptPage{PolynomialTraits_d::LeadingCoefficient}\\
\ccRefConceptPage{PolynomialTraits_d::UnivariateContent}\\
\ccRefConceptPage{PolynomialTraits_d::MultivariateContent}\\
\ccRefConceptPage{PolynomialTraits_d::Canonicalize}\\
\ccRefConceptPage{PolynomialTraits_d::Differentiate}\\
\ccRefConceptPage{PolynomialTraits_d::SquareFreeFactorization}\\
\ccRefConceptPage{PolynomialTraits_d::MakeSquareFree}\\
\ccRefConceptPage{PolynomialTraits_d::PseudoDivision}\\
\ccRefConceptPage{PolynomialTraits_d::PseudoDivisionQuotient}\\
\ccRefConceptPage{PolynomialTraits_d::PseudoDivisionRemainder}\\
\ccRefConceptPage{PolynomialTraits_d::GcdUpToConstantFactor}\\
\ccRefConceptPage{PolynomialTraits_d::IntegralDivisionUpToConstantFactor}\\
\ccRefConceptPage{PolynomialTraits_d::UnivariateContentUpToConstantFactor}\\
\ccRefConceptPage{PolynomialTraits_d::SquareFreeFactorizationUpToConstantFactor}\\
\ccRefConceptPage{PolynomialTraits_d::Shift}\\
\ccRefConceptPage{PolynomialTraits_d::Negate}\\
\ccRefConceptPage{PolynomialTraits_d::Invert}\\
\ccRefConceptPage{PolynomialTraits_d::Translate}\\
\ccRefConceptPage{PolynomialTraits_d::TranslateHomogeneous}\\
\ccRefConceptPage{PolynomialTraits_d::Scale}\\
\ccRefConceptPage{PolynomialTraits_d::ScaleHomogeneous}\\
%\ccRefConceptPage{PolynomialTraits_d::ScaleUp}\\
%\ccRefConceptPage{PolynomialTraits_d::ScaleDown}\\
\ccRefConceptPage{PolynomialTraits_d::Resultant}\\
\ccRefConceptPage{PolynomialTraits_d::Evaluate}\\
\ccRefConceptPage{PolynomialTraits_d::EvaluateHomogeneous}\\
\ccRefConceptPage{PolynomialTraits_d::Compare}\\
\subsubsection*{Classes}
\ccRefConceptPage{Exponent_vector}\\
\ccRefConceptPage{Polynomial.tex}\\
\ccRefConceptPage{Polynomial_traits_d.tex}\\

56
Polynomial/doc_tex/Polynomial_ref/main.tex Executable file
View File

@ -0,0 +1,56 @@
\input{Polynomial_ref/intro.tex}
\input{Polynomial_ref/PolynomialTraits_d_ConstructPolynomial_d.tex}
\input{Polynomial_ref/Polynomial_d.tex}
\input{Polynomial_ref/PolynomialTraits_d.tex}
\input{Polynomial_ref/PolynomialTraits_d_ConstructPolynomial_d.tex}
\input{Polynomial_ref/PolynomialTraits_d_Swap.tex}
%\input{Polynomial_ref/PolynomialTraits_d_Move.tex}
\input{Polynomial_ref/PolynomialTraits_d_Degree.tex}
\input{Polynomial_ref/PolynomialTraits_d_TotalDegree.tex}
\input{Polynomial_ref/PolynomialTraits_d_LeadingCoefficient.tex}
\input{Polynomial_ref/PolynomialTraits_d_UnivariateContent.tex}
\input{Polynomial_ref/PolynomialTraits_d_MultivariateContent.tex}
\input{Polynomial_ref/PolynomialTraits_d_Canonicalize.tex}
\input{Polynomial_ref/PolynomialTraits_d_Differentiate.tex}
\input{Polynomial_ref/PolynomialTraits_d_SquareFreeFactorization.tex}
\input{Polynomial_ref/PolynomialTraits_d_MakeSquareFree.tex}
\input{Polynomial_ref/PolynomialTraits_d_PseudoDivision.tex}
\input{Polynomial_ref/PolynomialTraits_d_PseudoDivisionQuotient.tex}
\input{Polynomial_ref/PolynomialTraits_d_PseudoDivisionRemainder.tex}
\input{Polynomial_ref/PolynomialTraits_d_GcdUpToConstantFactor.tex}
\input{Polynomial_ref/PolynomialTraits_d_IntegralDivisionUpToConstantFactor.tex}
\input{Polynomial_ref/PolynomialTraits_d_UnivariateContentUpToConstantFactor.tex}
\input{Polynomial_ref/PolynomialTraits_d_SquareFreeFactorizationUpToConstantFactor.tex}
\input{Polynomial_ref/PolynomialTraits_d_Shift.tex}
\input{Polynomial_ref/PolynomialTraits_d_Negate.tex}
\input{Polynomial_ref/PolynomialTraits_d_Invert.tex}
\input{Polynomial_ref/PolynomialTraits_d_Translate.tex}
\input{Polynomial_ref/PolynomialTraits_d_TranslateHomogeneous.tex}
\input{Polynomial_ref/PolynomialTraits_d_Scale.tex}
\input{Polynomial_ref/PolynomialTraits_d_ScaleHomogeneous.tex}
\input{Polynomial_ref/PolynomialTraits_d_Resultant.tex}
\input{Polynomial_ref/PolynomialTraits_d_Evaluate.tex}
\input{Polynomial_ref/PolynomialTraits_d_EvaluateHomogeneous.tex}
\input{Polynomial_ref/PolynomialTraits_d_Compare.tex}
\input{Polynomial_ref/Exponent_vector.tex}
%\input{Polynomial_ref/Polynomial.tex}
%\input{Polynomial_ref/Polynomial_traits_d.tex}