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 ///
22 static inline
23 void 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 ///
40 void 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
52 void 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
93 int* 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()
103 shift2Zero (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()
116 CanonicalForm 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
126 bool isOnlyLeadingCoeff (const CanonicalForm& F ///< [in] some poly
127  );
128 
129 /// sort CFFList by the number variables in a factor
130 CFFList 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)
134 CanonicalForm 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
141 CFList
142 evaluateAtEval (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
150 CFList
151 evaluateAtEval (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
159 CFList 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
166 CFList 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
175 CFList 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
186 CFList 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 
CFFList sortCFFListByNumOfVars(CFFList &F)
sort CFFList by the number variables in a factor
CanonicalForm reverseShift(const CanonicalForm &F, const CFList &evaluation, int l=2)
reverse shifting the evaluation point to zero
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
factory&#39;s class for variables
Definition: variable.h:32
static void decompressAppend(CFList &factors1, const CFList &factors2, const CFMap &N)
append factors2 to factors1 and decompress
CanonicalForm myGetVars(const CanonicalForm &F)
like getVars but each variable x occuring in F is raised to x^degree (F,x)
CFList evaluateAtEval(const CanonicalForm &F, const CFArray &evaluation)
evaluate F at evaluation
factory&#39;s main class
Definition: canonicalform.h:75
CFList recoverFactors(const CanonicalForm &F, const CFList &factors)
divides factors by their content wrt. Variable(1) and checks if these polys divide F ...
const CanonicalForm int const CFList & evaluation
Definition: facAbsFact.cc:55
const CFList & factors2
map polynomials
CFList evaluateAtZero(const CanonicalForm &F)
evaluate F successively n-2 at 0
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
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:49
#define A
Definition: sirandom.c:23
int * liftingBounds(const CanonicalForm &A, const int &bivarLiftBound)
compute lifting bounds
int i
Definition: cfEzgcd.cc:123
bool isOnlyLeadingCoeff(const CanonicalForm &F)
check if F consists of more than just the leading coeff wrt. Variable (1)
static int index(p_Length length, p_Ord ord)
Definition: p_Procs_Impl.h:597
class CFMap
Definition: cf_map.h:84
CanonicalForm Feval
Definition: facAbsFact.cc:64
Variable x
Definition: cfModGcd.cc:4023
void swap(CFList &factors, const int swapLevel1, const int swapLevel2, const Variable &x)
swap elements in factors
void append(const T &)
Definition: ftmpl_list.cc:256
CanonicalForm shift2Zero(const CanonicalForm &F, CFList &Feval, const CFList &evaluation, int l=2)
shift evaluation point to zero
int l
Definition: cfEzgcd.cc:94
Header for factory&#39;s main class CanonicalForm.