source: git/factory/facFqBivar.h @ c1b9927

fieker-DuValspielwiese
Last change on this file since c1b9927 was c1b9927, checked in by Hans Schoenemann <hannes@…>, 13 years ago
- removed some unsed variables - never put static inline routine without a body in a .h file git-svn-id: file:///usr/local/Singular/svn/trunk@14265 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 23.3 KB
Line 
1/*****************************************************************************\
2 * Computer Algebra System SINGULAR
3\*****************************************************************************/
4/** @file facFqBivar.h
5 *
6 * This file provides functions for factorizing a bivariate polynomial over
7 * \f$ F_{p} \f$ , \f$ F_{p}(\alpha ) \f$ or GF.
8 *
9 * ABSTRACT: In contrast to biFactorizer() in facFqFactorice.cc we evaluate and
10 * factorize the polynomial in both variables. So far factor recombination is
11 * done naive!
12 *
13 * @author Martin Lee
14 *
15 * @internal @version \$Id$
16 *
17 **/
18/*****************************************************************************/
19
20#ifndef FAC_FQ_BIVAR_H
21#define FAC_FQ_BIVAR_H
22
23#include <config.h>
24
25#include "assert.h"
26
27#include "facFqBivarUtil.h"
28#include "DegreePattern.h"
29#include "ExtensionInfo.h"
30#include "cf_util.h"
31#include "facFqSquarefree.h"
32#include "cf_map.h"
33#include "cfNewtonPolygon.h"
34
35static const double log2exp= 1.442695041;
36
37/// Factorization of a squarefree bivariate polynomials over an arbitrary finite
38/// field, information on the current field we work over is in @a info. @a info
39/// may also contain information about the initial field if initial and current
40/// field do not coincide. In this case the current field is an extension of the
41/// initial field and the factors returned are factors of F over the initial
42/// field.
43///
44/// @return @a biFactorize returns a list of factors of F. If F is not monic
45///         its leading coefficient is not outputted.
46/// @sa extBifactorize()
47CFList
48biFactorize (const CanonicalForm& F,       ///< [in] a bivariate poly
49             const ExtensionInfo& info     ///< [in] information about extension
50            );
51
52/// factorize a squarefree bivariate polynomial over \f$ F_{p} \f$.
53///
54/// @return @a FpBiSqrfFactorize returns a list of monic factors, the first
55///         element is the leading coefficient.
56/// @sa FqBiSqrfFactorize(), GFBiSqrfFactorize()
57#ifdef HAVE_NTL
58inline
59CFList FpBiSqrfFactorize (const CanonicalForm & G ///< [in] a bivariate poly
60                         )
61{
62  ExtensionInfo info= ExtensionInfo (false);
63  CFMap N;
64  CanonicalForm F= compress (G, N);
65  CanonicalForm contentX= content (F, 1);
66  CanonicalForm contentY= content (F, 2);
67  F /= (contentX*contentY);
68  CFFList contentXFactors, contentYFactors;
69  contentXFactors= factorize (contentX);
70  contentYFactors= factorize (contentY);
71  if (contentXFactors.getFirst().factor().inCoeffDomain())
72    contentXFactors.removeFirst();
73  if (contentYFactors.getFirst().factor().inCoeffDomain())
74    contentYFactors.removeFirst();
75  if (F.inCoeffDomain())
76  {
77    CFList result;
78    for (CFFListIterator i= contentXFactors; i.hasItem(); i++)
79      result.append (N (i.getItem().factor()));
80    for (CFFListIterator i= contentYFactors; i.hasItem(); i++)
81      result.append (N (i.getItem().factor()));
82    normalize (result);
83    result.insert (Lc (G));
84    return result;
85  }
86  mat_ZZ M;
87  vec_ZZ S;
88  F= compress (F, M, S);
89  CFList result= biFactorize (F, info);
90  for (CFListIterator i= result; i.hasItem(); i++)
91    i.getItem()= N (decompress (i.getItem(), M, S));
92  for (CFFListIterator i= contentXFactors; i.hasItem(); i++)
93    result.append (N(i.getItem().factor()));
94  for (CFFListIterator i= contentYFactors; i.hasItem(); i++)
95    result.append (N (i.getItem().factor()));
96  normalize (result);
97  result.insert (Lc(G));
98  return result;
99}
100
101/// factorize a squarefree bivariate polynomial over \f$ F_{p}(\alpha ) \f$.
102///
103/// @return @a FqBiSqrfFactorize returns a list of monic factors, the first
104///         element is the leading coefficient.
105/// @sa FpBiSqrfFactorize(), GFBiSqrfFactorize()
106inline
107CFList FqBiSqrfFactorize (const CanonicalForm & G, ///< [in] a bivariate poly
108                          const Variable& alpha    ///< [in] algebraic variable
109                         )
110{
111  ExtensionInfo info= ExtensionInfo (alpha, false);
112  CFMap N;
113  CanonicalForm F= compress (G, N);
114  CanonicalForm contentX= content (F, 1);
115  CanonicalForm contentY= content (F, 2);
116  F /= (contentX*contentY);
117  CFFList contentXFactors, contentYFactors;
118  contentXFactors= factorize (contentX);
119  contentYFactors= factorize (contentY);
120  if (contentXFactors.getFirst().factor().inCoeffDomain())
121    contentXFactors.removeFirst();
122  if (contentYFactors.getFirst().factor().inCoeffDomain())
123    contentYFactors.removeFirst();
124  if (F.inCoeffDomain())
125  {
126    CFList result;
127    for (CFFListIterator i= contentXFactors; i.hasItem(); i++)
128      result.append (N (i.getItem().factor()));
129    for (CFFListIterator i= contentYFactors; i.hasItem(); i++)
130      result.append (N (i.getItem().factor()));
131    normalize (result);
132    result.insert (Lc (G));
133    return result;
134  }
135  mat_ZZ M;
136  vec_ZZ S;
137  F= compress (F, M, S);
138  CFList result= biFactorize (F, info);
139  for (CFListIterator i= result; i.hasItem(); i++)
140    i.getItem()= N (decompress (i.getItem(), M, S));
141  for (CFFListIterator i= contentXFactors; i.hasItem(); i++)
142    result.append (N(i.getItem().factor()));
143  for (CFFListIterator i= contentYFactors; i.hasItem(); i++)
144    result.append (N (i.getItem().factor()));
145  normalize (result);
146  result.insert (Lc(G));
147  return result;
148}
149
150/// factorize a squarefree bivariate polynomial over GF
151///
152/// @return @a GFBiSqrfFactorize returns a list of monic factors, the first
153///         element is the leading coefficient.
154/// @sa FpBiSqrfFactorize(), FqBiSqrfFactorize()
155inline
156CFList GFBiSqrfFactorize (const CanonicalForm & G ///< [in] a bivariate poly
157                         )
158{
159  ASSERT (CFFactory::gettype() == GaloisFieldDomain,
160          "GF as base field expected");
161  ExtensionInfo info= ExtensionInfo (getGFDegree(), gf_name, false);
162  CFMap N;
163  CanonicalForm F= compress (G, N);
164  CanonicalForm contentX= content (F, 1);
165  CanonicalForm contentY= content (F, 2);
166  F /= (contentX*contentY);
167  CFList contentXFactors, contentYFactors;
168  contentXFactors= biFactorize (contentX, info);
169  contentYFactors= biFactorize (contentY, info);
170  if (contentXFactors.getFirst().inCoeffDomain())
171    contentXFactors.removeFirst();
172  if (contentYFactors.getFirst().inCoeffDomain())
173    contentYFactors.removeFirst();
174  if (F.inCoeffDomain())
175  {
176    CFList result;
177    for (CFListIterator i= contentXFactors; i.hasItem(); i++)
178      result.append (N (i.getItem()));
179    for (CFListIterator i= contentYFactors; i.hasItem(); i++)
180      result.append (N (i.getItem()));
181    normalize (result);
182    result.insert (Lc (G));
183    return result;
184  }
185  mat_ZZ M;
186  vec_ZZ S;
187  F= compress (F, M, S);
188  CFList result= biFactorize (F, info);
189  for (CFListIterator i= result; i.hasItem(); i++)
190    i.getItem()= N (decompress (i.getItem(), M, S));
191  for (CFListIterator i= contentXFactors; i.hasItem(); i++)
192    result.append (N(i.getItem()));
193  for (CFListIterator i= contentYFactors; i.hasItem(); i++)
194    result.append (N (i.getItem()));
195  normalize (result);
196  result.insert (Lc(G));
197  return result;
198}
199
200/// factorize a bivariate polynomial over \f$ F_{p} \f$
201///
202/// @return @a FpBiFactorize returns a list of monic factors with
203///         multiplicity, the first element is the leading coefficient.
204/// @sa FqBiFactorize(), GFBiFactorize()
205inline
206CFFList FpBiFactorize (const CanonicalForm & G ///< [in] a bivariate poly
207                      )
208{
209  ExtensionInfo info= ExtensionInfo (false);
210  CFMap N;
211  CanonicalForm F= compress (G, N);
212  CanonicalForm LcF= Lc (F);
213  CanonicalForm contentX= content (F, 1);
214  CanonicalForm contentY= content (F, 2);
215  F /= (contentX*contentY);
216  CFFList contentXFactors, contentYFactors;
217  contentXFactors= factorize (contentX);
218  contentYFactors= factorize (contentY);
219  if (contentXFactors.getFirst().factor().inCoeffDomain())
220    contentXFactors.removeFirst();
221  if (contentYFactors.getFirst().factor().inCoeffDomain())
222    contentYFactors.removeFirst();
223  decompress (contentXFactors, N);
224  decompress (contentYFactors, N);
225  CFFList result, resultRoot;
226  if (F.inCoeffDomain())
227  {
228    result= Union (contentXFactors, contentYFactors);
229    normalize (result);
230    result.insert (CFFactor (LcF, 1));
231    return result;
232  }
233  mat_ZZ M;
234  vec_ZZ S;
235  F= compress (F, M, S);
236  CanonicalForm pthRoot, A;
237  CanonicalForm sqrfP= sqrfPart (F/Lc(F), pthRoot, info.getAlpha());
238  CFList buf, bufRoot;
239  int p= getCharacteristic();
240  int l;
241  if (degree (pthRoot) > 0)
242  {
243    pthRoot= maxpthRoot (pthRoot, p, l);
244    result= FpBiFactorize (pthRoot);
245    result.removeFirst();
246    for (CFFListIterator i= result; i.hasItem(); i++)
247      i.getItem()= CFFactor (N (decompress (i.getItem().factor(), M, S)),
248                             i.getItem().exp()*ipower (p,l));
249    result= Union (result, contentXFactors);
250    result= Union (result, contentYFactors);
251    normalize (result);
252    result.insert (CFFactor (LcF, 1));
253    return result;
254  }
255  else
256  {
257    buf= biFactorize (sqrfP, info);
258    A= F/LcF;
259    result= multiplicity (A, buf);
260    for (CFFListIterator i= result; i.hasItem(); i++)
261      i.getItem()= CFFactor (N (decompress (i.getItem().factor(), M, S)),
262                             i.getItem().exp());
263  }
264  if (degree (A) > 0)
265  {
266    resultRoot= FpBiFactorize (A);
267    resultRoot.removeFirst();
268    for (CFFListIterator i= resultRoot; i.hasItem(); i++)
269      i.getItem()= CFFactor (N (decompress (i.getItem().factor(), M, S)),
270                             i.getItem().exp());
271    result= Union (result, resultRoot);
272  }
273  result= Union (result, contentXFactors);
274  result= Union (result, contentYFactors);
275  normalize (result);
276  result.insert (CFFactor (LcF, 1));
277  return result;
278}
279
280/// factorize a bivariate polynomial over \f$ F_{p}(\alpha ) \f$
281///
282/// @return @a FqBiFactorize returns a list of monic factors with
283///         multiplicity, the first element is the leading coefficient.
284/// @sa FpBiFactorize(), FqBiFactorize()
285inline
286CFFList FqBiFactorize (const CanonicalForm & G, ///< [in] a bivariate poly
287                       const Variable & alpha   ///< [in] algebraic variable
288                      )
289{
290  ExtensionInfo info= ExtensionInfo (alpha, false);
291  CFMap N;
292  CanonicalForm F= compress (G, N);
293  CanonicalForm LcF= Lc (F);
294  CanonicalForm contentX= content (F, 1);
295  CanonicalForm contentY= content (F, 2);
296  F /= (contentX*contentY);
297  CFFList contentXFactors, contentYFactors;
298  contentXFactors= factorize (contentX);
299  contentYFactors= factorize (contentY);
300  if (contentXFactors.getFirst().factor().inCoeffDomain())
301    contentXFactors.removeFirst();
302  if (contentYFactors.getFirst().factor().inCoeffDomain())
303    contentYFactors.removeFirst();
304  decompress (contentXFactors, N);
305  decompress (contentYFactors, N);
306  CFFList result, resultRoot;
307  if (F.inCoeffDomain())
308  {
309    result= Union (contentXFactors, contentYFactors);
310    normalize (result);
311    result.insert (CFFactor (LcF, 1));
312    return result;
313  }
314  mat_ZZ M;
315  vec_ZZ S;
316  CanonicalForm oldF= F;
317  F= compress (F, M, S);
318  CanonicalForm pthRoot, A, tmp;
319  CanonicalForm sqrfP= sqrfPart (F/Lc(F), pthRoot, alpha);
320  CFList buf, bufRoot;
321  int p= getCharacteristic();
322  int q= ipower (p, degree (getMipo (alpha)));
323  int l;
324  if (degree (pthRoot) > 0)
325  {
326    pthRoot= maxpthRoot (pthRoot, q, l);
327    result= FqBiFactorize (pthRoot, alpha);
328    result.removeFirst();
329    for (CFFListIterator i= result; i.hasItem(); i++)
330      i.getItem()= CFFactor (N (decompress (i.getItem().factor(), M, S)),
331                             i.getItem().exp()*ipower (p,l));
332    result= Union (result, contentXFactors);
333    result= Union (result, contentYFactors);
334    normalize (result);
335    result.insert (CFFactor (LcF, 1));
336    return result;
337  }
338  else
339  {
340    buf= biFactorize (sqrfP, info);
341    A= F/LcF;
342    result= multiplicity (A, buf);
343    for (CFFListIterator i= result; i.hasItem(); i++)
344      i.getItem()= CFFactor (N (decompress (i.getItem().factor(), M, S)),
345                             i.getItem().exp());
346  }
347  if (degree (A) > 0)
348  {
349    resultRoot= FqBiFactorize (A, alpha);
350    resultRoot.removeFirst();
351    for (CFFListIterator i= resultRoot; i.hasItem(); i++)
352      i.getItem()= CFFactor (N (decompress (i.getItem().factor(), M, S)),
353                             i.getItem().exp());
354    result= Union (result, resultRoot);
355  }
356  result= Union (result, contentXFactors);
357  result= Union (result, contentYFactors);
358  normalize (result);
359  result.insert (CFFactor (LcF, 1));
360  return result;
361}
362
363/// factorize a bivariate polynomial over GF
364///
365/// @return @a GFBiFactorize returns a list of monic factors with
366///         multiplicity, the first element is the leading coefficient.
367/// @sa FpBiFactorize(), FqBiFactorize()
368inline
369CFFList GFBiFactorize (const CanonicalForm & G ///< [in] a bivariate poly
370                      )
371{
372  ASSERT (CFFactory::gettype() == GaloisFieldDomain,
373          "GF as base field expected");
374  ExtensionInfo info= ExtensionInfo (getGFDegree(), gf_name, false);
375  CFMap N;
376  CanonicalForm F= compress (G, N);
377  CanonicalForm LcF= Lc (F);
378  CanonicalForm contentX= content (F, 1);
379  CanonicalForm contentY= content (F, 2);
380  F /= (contentX*contentY);
381  CFFList contentXFactors, contentYFactors;
382  contentXFactors= factorize (contentX);
383  contentYFactors= factorize (contentY);
384  if (contentXFactors.getFirst().factor().inCoeffDomain())
385    contentXFactors.removeFirst();
386  if (contentYFactors.getFirst().factor().inCoeffDomain())
387    contentYFactors.removeFirst();
388  decompress (contentXFactors, N);
389  decompress (contentYFactors, N);
390  CFFList result, resultRoot;
391  if (F.inCoeffDomain())
392  {
393    result= Union (contentXFactors, contentYFactors);
394    normalize (result);
395    result.insert (CFFactor (LcF, 1));
396    return result;
397  }
398  mat_ZZ M;
399  vec_ZZ S;
400  F= compress (F, M, S);
401  CanonicalForm pthRoot, A;
402  CanonicalForm sqrfP= sqrfPart (F/LcF, pthRoot, info.getAlpha());
403  CFList buf;
404  int p= getCharacteristic();
405  int q= ipower (p, getGFDegree());
406  int l;
407  if (degree (pthRoot) > 0)
408  {
409    pthRoot= maxpthRoot (pthRoot, q, l);
410    result= GFBiFactorize (pthRoot);
411    result.removeFirst();
412    for (CFFListIterator i= result; i.hasItem(); i++)
413      i.getItem()= CFFactor (N (decompress (i.getItem().factor(), M, S)),
414                             i.getItem().exp()*ipower (p,l));
415    result= Union (result, contentXFactors);
416    result= Union (result, contentYFactors);
417    normalize (result);
418    result.insert (CFFactor (LcF, 1));
419    return result;
420  }
421  else
422  {
423    buf= biFactorize (sqrfP, info);
424    A= F/LcF;
425    result= multiplicity (A, buf);
426    for (CFFListIterator i= result; i.hasItem(); i++)
427      i.getItem()= CFFactor (N (decompress (i.getItem().factor(), M, S)),
428                             i.getItem().exp());
429  }
430  if (degree (A) > 0)
431  {
432    resultRoot= GFBiFactorize (A);
433    resultRoot.removeFirst();
434    for (CFFListIterator i= resultRoot; i.hasItem(); i++)
435      i.getItem()= CFFactor (N (decompress (i.getItem().factor(), M, S)),
436                             i.getItem().exp());
437    result= Union (result, resultRoot);
438  }
439  result= Union (result, contentXFactors);
440  result= Union (result, contentYFactors);
441  normalize (result);
442  result.insert (CFFactor (LcF, 1));
443  return result;
444}
445
446#endif
447
448/// \f$ \prod_{f\in L} {f (0, x)} \ mod\ M \f$ via divide-and-conquer
449///
450/// @return @a prodMod0 computes the above defined product
451/// @sa prodMod()
452CanonicalForm prodMod0 (const CFList& L,       ///< [in] a list of compressed,
453                                               ///< bivariate polynomials
454                        const CanonicalForm& M ///< [in] a power of Variable (2)
455                       );
456
457/// find an evaluation point p, s.t. F(p,y) is squarefree and
458/// \f$ deg_{y} (F(p,y))= deg_{y} (F(x,y)) \f$.
459///
460/// @return @a evalPoint returns an evaluation point, which is valid if and only
461///         if fail == false.
462CanonicalForm
463evalPoint (const CanonicalForm& F, ///< [in] compressed, bivariate poly
464           CanonicalForm & eval,   ///< [in,out] F (p, y)
465           const Variable& alpha,  ///< [in] algebraic variable
466           CFList& list,           ///< [in] list of points already considered
467           const bool& GF,         ///< [in] GaloisFieldDomain?
468           bool& fail              ///< [in,out] equals true, if there is no
469                                   ///< valid evaluation point
470          );
471
472/// Univariate factorization of squarefree monic polys over finite fields via
473/// NTL. If the characteristic is even special GF2 routines of NTL are used.
474///
475/// @return @a uniFactorizer returns a list of monic factors
476CFList
477uniFactorizer (const CanonicalForm& A, ///< [in] squarefree univariate poly
478               const Variable& alpha,  ///< [in] algebraic variable
479               const bool& GF          ///< [in] GaloisFieldDomain?
480              );
481
482/// naive factor recombination over an extension of the initial field.
483/// Uses precomputed data to exclude combinations that are not possible.
484///
485/// @return @a extFactorRecombination returns a list of factors over the initial
486///         field, whose shift to zero is reversed.
487/// @sa factorRecombination(), extEarlyFactorDetection()
488inline CFList
489extFactorRecombination (
490         CFList& factors,          ///< [in,out] list of lifted factors that are
491                                   ///< monic wrt Variable (1),
492                                   ///< original factors-factors found
493         CanonicalForm& F,         ///< [in,out] poly to be factored,
494                                   ///< F/factors found
495         const CanonicalForm& M,   ///< [in] Variable (2)^liftBound
496         const ExtensionInfo& info,///< [in] contains information about
497                                   ///< extension
498         DegreePattern& degs,
499         const CanonicalForm& eval,///< [in] evaluation point
500         int s,                    ///< [in] algorithm starts checking subsets
501                                   ///< of size s
502         int thres                 ///< [in] threshold for the size of subsets
503                                   ///< which are checked, for a full factor
504                                   ///< recombination choose
505                                   ///< thres= factors.length()/2
506                       );
507
508/// naive factor recombination.
509/// Uses precomputed data to exclude combinations that are not possible.
510///
511/// @return @a factorRecombination returns a list of factors of F.
512/// @sa extFactorRecombination(), earlyFactorDetectection()
513inline CFList
514factorRecombination (
515                CFList& factors,       ///< [in,out] list of lifted factors
516                                       ///< that are monic wrt Variable (1)
517                CanonicalForm& F,      ///< [in,out] poly to be factored
518                const CanonicalForm& M,///< [in] Variable (2)^liftBound
519                DegreePattern& degs,   ///< [in] degree pattern
520                int s,                 ///< [in] algorithm starts checking
521                                       ///< subsets of size s
522                int thres              ///< [in] threshold for the size of
523                                       ///< subsets which are checked, for a
524                                       ///< full factor recombination choose
525                                       ///< thres= factors.length()/2
526                    );
527
528/// chooses a field extension.
529///
530/// @return @a chooseExtension returns an extension specified by @a beta of
531///         appropiate size
532Variable chooseExtension (
533                      const Variable & alpha, ///< [in] some algebraic variable
534                      const Variable & beta,  ///< [in] some algebraic variable
535                      int k                   ///< [in] some int
536                         );
537
538/// detects factors of @a F at stage @a deg of Hensel lifting.
539/// No combinations of more than one factor are tested. Lift bound and possible
540/// degree pattern are updated.
541///
542/// @return @a earlyFactorDetection returns a list of factors of F (possibly in-
543///         complete), in case of success. Otherwise an empty list.
544/// @sa factorRecombination(), extEarlyFactorDetection()
545inline CFList
546earlyFactorDetection (
547           CanonicalForm& F,       ///< [in,out] poly to be factored, returns
548                                   ///< poly divided by detected factors in case
549                                   ///< of success
550           CFList& factors,        ///< [in,out] list of factors lifted up to
551                                   ///< @a deg, returns a list of factors
552                                   ///< without detected factors
553           int& adaptedLiftBound,  ///< [in,out] adapted lift bound
554           DegreePattern& degs,    ///< [in,out] degree pattern, is updated
555                                   ///< whenever we find a factor
556           bool& success,          ///< [in,out] indicating success
557           int deg                 ///< [in] stage of Hensel lifting
558                     );
559
560/// detects factors of @a F at stage @a deg of Hensel lifting.
561/// No combinations of more than one factor are tested. Lift bound and possible
562/// degree pattern are updated.
563///
564/// @return @a extEarlyFactorDetection returns a list of factors of F (possibly
565///         incomplete), whose shift to zero is reversed, in case of success.
566///         Otherwise an empty list.
567/// @sa factorRecombination(), earlyFactorDetection()
568inline CFList
569extEarlyFactorDetection (
570        CanonicalForm& F,          ///< [in,out] poly to be factored, returns
571                                   ///< poly divided by detected factors in case
572                                   ///< of success
573        CFList& factors,           ///< [in,out] list of factors lifted up to
574                                   ///< @a deg, returns a list of factors
575                                   ///< without detected factors
576        int& adaptedLiftBound,     ///< [in,out] adapted lift bound
577        DegreePattern& degs,       ///< [in,out] degree pattern, is updated
578                                   ///< whenever we find a factor
579        bool& success,             ///< [in,out] indicating success
580        const ExtensionInfo& info,  ///< [in] information about extension
581        const CanonicalForm& eval, ///< [in] evaluation point
582        int deg                    ///< [in] stage of Hensel lifting
583                      );
584
585/// hensel Lifting and early factor detection
586///
587/// @return @a henselLiftAndEarly returns monic (wrt Variable (1)) lifted
588///         factors without factors which have been detected at an early stage
589///         of Hensel lifting
590/// @sa earlyFactorDetection(), extEarlyFactorDetection()
591
592inline CFList
593henselLiftAndEarly (
594        CanonicalForm& A,          ///< [in,out] poly to be factored,
595                                   ///< returns poly divided by detected factors
596                                   ///< in case of success
597        bool& earlySuccess,        ///< [in,out] indicating success
598        CFList& earlyFactors,      ///< [in,out] list of factors detected
599                                   ///< at early stage of Hensel lifting
600        DegreePattern& degs,       ///< [in,out] degree pattern
601        int& liftBound,            ///< [in,out] (adapted) lift bound
602        const CFList& uniFactors,  ///< [in] univariate factors
603        const ExtensionInfo& info, ///< [in] information about extension
604        const CanonicalForm& eval  ///< [in] evaluation point
605                  );
606
607/// Factorization over an extension of initial field
608///
609/// @return @a extBiFactorize returns factorization of F over initial field
610/// @sa biFactorize()
611inline CFList
612extBiFactorize (const CanonicalForm& F,    ///< [in] poly to be factored
613                const ExtensionInfo& info  ///< [in] info about extension
614               );
615
616
617#endif
618/* FAC_FQ_BIVAR_H */
619
Note: See TracBrowser for help on using the repository browser.