My Project
Loading...
Searching...
No Matches
facFqFactorizeUtil.h
Go to the documentation of this file.
1/*****************************************************************************\
2 * Computer Algebra System SINGULAR
3\*****************************************************************************/
4/** @file facFqFactorizeUtil.h
5 *
6 * This file provides utility functions for multivariate factorization
7 *
8 * @author Martin Lee
9 *
10 **/
11/*****************************************************************************/
12
13#ifndef FAC_FQ_FACTORIZE_UTIL_H
14#define FAC_FQ_FACTORIZE_UTIL_H
15
16// #include "config.h"
17#include "canonicalform.h"
18#include "cf_map.h"
19
20/// append @a factors2 to @a factors1 and decompress
21///
22static inline
23void decompressAppend (CFList& factors1, ///< [in,out] a list of polys,
24 ///< returns @a factors2 appended
25 ///< to it and everything is
26 ///< decompressed
27 const CFList& factors2, ///< [in] a list of polys
28 const CFMap& N ///< [in] a map
29 )
30{
31 for (CFListIterator i= factors1; i.hasItem(); i++)
32 i.getItem()= N (i.getItem());
33 for (CFListIterator i= factors2; i.hasItem(); i++)
34 factors1.append (N (i.getItem()));
35}
36
37
38/// swap elements in @a factors2 and append them to @a factors1
39///
40void appendSwap (CFList& factors1, ///< [in,out] a list of polys,
41 ///< returns swapped elements of @a
42 ///< factors2 appended to it
43 const CFList& factors2, ///< [in] a list of polys
44 const int swapLevel1, ///< [in] level of variable to be
45 ///< swapped with x, 0 if no swapping
46 const int swapLevel2, ///< [in] level of variable to be
47 ///< swapped with x, 0 if no swapping
48 const Variable& x ///< [in] a variable
49 );
50
51/// swap elements in @a factors
52void swap (CFList& factors, ///< [in] a list of polys, returns swapped
53 ///< elements of factors
54 const int swapLevel1, ///< [in] level of variable to be
55 ///< swapped with x, 0 if no swapping
56 const int swapLevel2, ///< [in] level of variable to be
57 ///< swapped with x, 0 if no swapping
58 const Variable& x ///< [in] a variable
59 );
60
61/// swap elements of @a factors2, append them to @a factors1 and decompress
63 CFList& factors1, ///< [in,out] a list of polys,
64 ///< returns swapped elements of @a
65 ///< factors2 appended to it and
66 ///< everything is decompressed
67 const CFList& factors2, ///< [in] a list of polys
68 const CFMap& N, ///< [in] a map
69 const int swapLevel, ///< [in] level of variable to be
70 ///< swapped with x, 0 if no swapping
71 const Variable& x ///< [in] a variable
72 );
73
74/// swap elements of @a factors2, append them to @a factors1 and decompress
76 CFList& factors1, ///< [in,out] a list of polys,
77 ///< returns swapped elements of @a
78 ///< factors2 appended to it and
79 ///< everything is decompressed
80 const CFList& factors2, ///< [in] a list of polys
81 const CFMap& N, ///< [in] a map
82 const int swapLevel1, ///< [in] level of variable to be
83 ///< swapped with x, 0 if no swapping
84 const int swapLevel2, ///< [in] level of variable to be
85 ///< swapped with x, 0 if no swapping
86 const Variable& x ///< [in] a variable
87 );
88
89
90/// compute lifting bounds
91///
92/// @return @a liftingBounds returns an array containing the lift bounds for A
93int* liftingBounds (const CanonicalForm& A, ///< [in] a compressed poly
94 const int& bivarLiftBound ///< [in] lift bound for
95 ///< @a biFactorizer()
96 );
97
98/// shift evaluation point to zero
99/// @return @a shift2Zero returns @a F shifted by @a evaluation s.t. 0 is a
100/// valid evaluation point
101/// @sa evalPoints(), reverseShift()
103shift2Zero (const CanonicalForm& F, ///< [in] a compressed poly
104 CFList& Feval, ///< [in,out] an empty list, returns
105 ///< @a F successively evaluated
106 ///< at 0
107 const CFList& evaluation,///< [in] a valid evaluation point
108 int l= 2 ///< [in] level at which the evaluation
109 ///< starts
110 );
111
112/// reverse shifting the evaluation point to zero
113///
114/// @return @a reverseShift returns a poly whose shift to zero is reversed
115/// @sa shift2Zero(), evalPoints()
116CanonicalForm reverseShift (const CanonicalForm& F, ///< [in] a compressed poly
117 const CFList& evaluation,///< [in] a valid
118 ///< evaluation point
119 int l= 2 ///< [in] level at which
120 ///< the evaluation starts
121 );
122
123/// check if @a F consists of more than just the leading coeff wrt. Variable (1)
124///
125/// @return as described above
126bool isOnlyLeadingCoeff (const CanonicalForm& F ///< [in] some poly
127 );
128
129/// sort CFFList by the number variables in a factor
130CFFList sortCFFListByNumOfVars (CFFList & F ///< [in,out] a list of factors
131 );
132
133/// like getVars but each variable x occuring in @a F is raised to x^degree (F,x)
134CanonicalForm myGetVars (const CanonicalForm& F ///< [in] a polynomial
135 );
136
137/// evaluate @a F at @a evaluation
138///
139/// @return @a evaluateAtEval returns a list containing the successive
140/// evaluations of @a F, last entry is @a F again
141CFList
142evaluateAtEval (const CanonicalForm& F, ///<[in] some poly
143 const CFArray& evaluation ///<[in] some evaluation point
144 );
145
146/// evaluate @a F at @a evaluation
147///
148/// @return @a evaluateAtEval returns a list containing the successive
149/// evaluations of @a F starting at level @a l, last entry is @a F again
150CFList
151evaluateAtEval (const CanonicalForm& F, ///<[in] some poly
152 const CFList& evaluation,///<[in] some evaluation point
153 int l ///<[in] level to start at
154 );
155
156/// evaluate F successively n-2 at 0
157///
158/// @return returns a list of successive evaluations of F, ending with F
159CFList evaluateAtZero (const CanonicalForm& F ///< [in] some poly
160 );
161
162/// divides factors by their content wrt. Variable(1) and checks if these polys
163/// divide F
164///
165/// @return returns factors of F
166CFList recoverFactors (const CanonicalForm& F, ///< [in] some poly F
167 const CFList& factors ///< [in] some list of
168 ///< factor candidates
169 );
170
171/// divides factors shifted by evaluation by their content wrt. Variable(1) and
172/// checks if these polys divide F
173///
174/// @return returns factors of F
175CFList recoverFactors (const CanonicalForm& F, ///< [in] some poly F
176 const CFList& factors, ///< [in] some list of
177 ///< factor candidates
178 const CFList& evaluation ///< [in] evaluation point
179 );
180
181/// checks if factors divide F, if so F is divided by this factor and the factor
182/// is divided by its content wrt. Variable(1) and the entry in index at the
183/// position of the factor is set to 1, otherwise the entry in index is set to 0
184///
185/// @return returns factors of F
186CFList recoverFactors (CanonicalForm& F, ///< [in,out] some poly F
187 const CFList& factors,///< [in] some list of
188 ///< factor candidates
189 int* index ///< [in] position of real factors
190 );
191
192#endif
193/* FAC_FQ_FACTORIZE_UTIL_H */
194
#define swap(_i, _j)
Header for factory's main class CanonicalForm.
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:56
int l
Definition: cfEzgcd.cc:100
int i
Definition: cfEzgcd.cc:132
Variable x
Definition: cfModGcd.cc:4082
map polynomials
class CFMap
Definition: cf_map.h:85
factory's main class
Definition: canonicalform.h:86
void append(const T &)
Definition: ftmpl_list.cc:256
factory's class for variables
Definition: variable.h:33
const CanonicalForm int const CFList & evaluation
Definition: facAbsFact.cc:52
CanonicalForm Feval
Definition: facAbsFact.cc:60
const CFList & factors2
CFList recoverFactors(const CanonicalForm &F, const CFList &factors)
divides factors by their content wrt. Variable(1) and checks if these polys divide F
CanonicalForm reverseShift(const CanonicalForm &F, const CFList &evaluation, int l=2)
reverse shifting the evaluation point to zero
static void decompressAppend(CFList &factors1, const CFList &factors2, const CFMap &N)
append factors2 to factors1 and decompress
CFList evaluateAtEval(const CanonicalForm &F, const CFArray &evaluation)
evaluate F at evaluation
CanonicalForm shift2Zero(const CanonicalForm &F, CFList &Feval, const CFList &evaluation, int l=2)
shift evaluation point to zero
void appendSwapDecompress(CFList &factors1, const CFList &factors2, const CFMap &N, const int swapLevel, const Variable &x)
swap elements of factors2, append them to factors1 and decompress
int * liftingBounds(const CanonicalForm &A, const int &bivarLiftBound)
compute lifting bounds
CFList evaluateAtZero(const CanonicalForm &F)
evaluate F successively n-2 at 0
bool isOnlyLeadingCoeff(const CanonicalForm &F)
check if F consists of more than just the leading coeff wrt. Variable (1)
CFFList sortCFFListByNumOfVars(CFFList &F)
sort CFFList by the number variables in a factor
CanonicalForm myGetVars(const CanonicalForm &F)
like getVars but each variable x occuring in F is raised to x^degree (F,x)
void appendSwap(CFList &factors1, const CFList &factors2, const int swapLevel1, const int swapLevel2, const Variable &x)
swap elements in factors2 and append them to factors1
static int index(p_Length length, p_Ord ord)
Definition: p_Procs_Impl.h:592
#define A
Definition: sirandom.c:24