My Project  UNKNOWN_GIT_VERSION
Public Types | Public Member Functions | Private Member Functions | Private Attributes
uResultant Class Reference

Base class for solving 0-dim poly systems using u-resultant. More...

#include <mpr_base.h>

Public Types

enum  resMatType { none, sparseResMat, denseResMat }
 

Public Member Functions

 uResultant (const ideal _gls, const resMatType _rmt=sparseResMat, BOOLEAN extIdeal=true)
 
 ~uResultant ()
 
poly interpolateDense (const number subDetVal=NULL)
 
rootContainer ** interpolateDenseSP (BOOLEAN matchUp=false, const number subDetVal=NULL)
 
rootContainer ** specializeInU (BOOLEAN matchUp=false, const number subDetVal=NULL)
 
resMatrixBaseaccessResMat ()
 

Private Member Functions

 uResultant (const uResultant &)
 
ideal extendIdeal (const ideal gls, poly linPoly, const resMatType rmt)
 
poly linearPoly (const resMatType rmt)
 
int nextPrime (const int p)
 

Private Attributes

ideal gls
 
int n
 
resMatType rmt
 
resMatrixBaseresMat
 

Detailed Description

Base class for solving 0-dim poly systems using u-resultant.

Definition at line 61 of file mpr_base.h.

Member Enumeration Documentation

◆ resMatType

Enumerator
none 
sparseResMat 
denseResMat 

Definition at line 64 of file mpr_base.h.

64 :

Constructor & Destructor Documentation

◆ uResultant() [1/2]

uResultant::uResultant ( const ideal  _gls,
const resMatType  _rmt = sparseResMat,
BOOLEAN  extIdeal = true 
)

Definition at line 2686 of file mpr_base.cc.

2687  : rmt( _rmt )
2688 {
2689  if ( extIdeal )
2690  {
2691  // extend given ideal by linear poly F0=u0x0 + u1x1 +...+ unxn
2692  gls= extendIdeal( _gls, linearPoly( rmt ), rmt );
2693  n= IDELEMS( gls );
2694  }
2695  else
2696  gls= idCopy( _gls );
2697 
2698  switch ( rmt )
2699  {
2700  case sparseResMat:
2701  resMat= new resMatrixSparse( gls );
2702  break;
2703  case denseResMat:
2704  resMat= new resMatrixDense( gls );
2705  break;
2706  default:
2707  WerrorS("uResultant::uResultant: Unknown chosen resultant matrix type!");
2708  }
2709 }

◆ ~uResultant()

uResultant::~uResultant ( )

Definition at line 2711 of file mpr_base.cc.

2712 {
2713  delete resMat;
2714 }

◆ uResultant() [2/2]

uResultant::uResultant ( const uResultant )
private

Member Function Documentation

◆ accessResMat()

resMatrixBase* uResultant::accessResMat ( )
inline

Definition at line 77 of file mpr_base.h.

78 { return resMat; }

◆ extendIdeal()

ideal uResultant::extendIdeal ( const ideal  gls,
poly  linPoly,
const resMatType  rmt 
)
private

Definition at line 2716 of file mpr_base.cc.

2717 {
2718  ideal newGls= idCopy( igls );
2719  newGls->m= (poly *)omReallocSize( newGls->m,
2720  IDELEMS(igls) * sizeof(poly),
2721  (IDELEMS(igls) + 1) * sizeof(poly) );
2722  IDELEMS(newGls)++;
2723 
2724  switch ( rrmt )
2725  {
2726  case sparseResMat:
2727  case denseResMat:
2728  {
2729  int i;
2730  for ( i= IDELEMS(newGls)-1; i > 0; i-- )
2731  {
2732  newGls->m[i]= newGls->m[i-1];
2733  }
2734  newGls->m[0]= linPoly;
2735  }
2736  break;
2737  default:
2738  WerrorS("uResultant::extendIdeal: Unknown chosen resultant matrix type!");
2739  }
2740 
2741  return( newGls );
2742 }

◆ interpolateDense()

poly uResultant::interpolateDense ( const number  subDetVal = NULL)

Definition at line 2771 of file mpr_base.cc.

2772 {
2773  int i,j,p;
2774  long tdg;
2775 
2776  // D is a Polynom homogeneous in the coeffs of F0 and of degree tdg = d0*d1*...*dn
2777  tdg= resMat->getDetDeg();
2778 
2779  // maximum number of terms in polynom D (homogeneous, of degree tdg)
2780  // long mdg= (facul(tdg+n-1) / facul( tdg )) / facul( n - 1 );
2781  long mdg= over( n-1, tdg );
2782 
2783  // maximal number of terms in a polynom of degree tdg
2784  long l=(long)pow( (double)(tdg+1), n );
2785 
2786 #ifdef mprDEBUG_PROT
2787  Print("// total deg of D: tdg %ld\n",tdg);
2788  Print("// maximum number of terms in D: mdg: %ld\n",mdg);
2789  Print("// maximum number of terms in polynom of deg tdg: l %ld\n",l);
2790 #endif
2791 
2792  // we need mdg results of D(p0,p1,...,pn)
2793  number *presults;
2794  presults= (number *)omAlloc( mdg * sizeof( number ) );
2795  for (i=0; i < mdg; i++) presults[i]= nInit(0);
2796 
2797  number *pevpoint= (number *)omAlloc( n * sizeof( number ) );
2798  number *pev= (number *)omAlloc( n * sizeof( number ) );
2799  for (i=0; i < n; i++) pev[i]= nInit(0);
2800 
2801  mprPROTnl("// initial evaluation point: ");
2802  // initial evaluatoin point
2803  p=1;
2804  for (i=0; i < n; i++)
2805  {
2806  // init pevpoint with primes 3,5,7,11, ...
2807  p= nextPrime( p );
2808  pevpoint[i]=nInit( p );
2809  nTest(pevpoint[i]);
2810  mprPROTNnl(" ",pevpoint[i]);
2811  }
2812 
2813  // evaluate the determinant in the points pev^0, pev^1, ..., pev^mdg
2814  mprPROTnl("// evaluating:");
2815  for ( i=0; i < mdg; i++ )
2816  {
2817  for (j=0; j < n; j++)
2818  {
2819  nDelete( &pev[j] );
2820  nPower(pevpoint[j],i,&pev[j]);
2821  mprPROTN(" ",pev[j]);
2822  }
2823  mprPROTnl("");
2824 
2825  nDelete( &presults[i] );
2826  presults[i]=resMat->getDetAt( pev );
2827 
2829  }
2830  mprSTICKYPROT("\n");
2831 
2832  // now interpolate using vandermode interpolation
2833  mprPROTnl("// interpolating:");
2834  number *ncpoly;
2835  {
2836  vandermonde vm( mdg, n, tdg, pevpoint );
2837  ncpoly= vm.interpolateDense( presults );
2838  }
2839 
2840  if ( subDetVal != NULL )
2841  { // divide by common factor
2842  number detdiv;
2843  for ( i= 0; i <= mdg; i++ )
2844  {
2845  detdiv= nDiv( ncpoly[i], subDetVal );
2846  nNormalize( detdiv );
2847  nDelete( &ncpoly[i] );
2848  ncpoly[i]= detdiv;
2849  }
2850  }
2851 
2852 #ifdef mprDEBUG_ALL
2853  PrintLn();
2854  for ( i=0; i < mdg; i++ )
2855  {
2856  nPrint(ncpoly[i]); PrintS(" --- ");
2857  }
2858  PrintLn();
2859 #endif
2860 
2861  // prepare ncpoly for later use
2862  number nn=nInit(0);
2863  for ( i=0; i < mdg; i++ )
2864  {
2865  if ( nEqual(ncpoly[i],nn) )
2866  {
2867  nDelete( &ncpoly[i] );
2868  ncpoly[i]=NULL;
2869  }
2870  }
2871  nDelete( &nn );
2872 
2873  // create poly presenting the determinat of the uResultant
2874  intvec exp( n );
2875  for ( i= 0; i < n; i++ ) exp[i]=0;
2876 
2877  poly result= NULL;
2878 
2879  long sum=0;
2880  long c=0;
2881 
2882  for ( i=0; i < l; i++ )
2883  {
2884  if ( sum == tdg )
2885  {
2886  if ( !nIsZero(ncpoly[c]) )
2887  {
2888  poly p= pOne();
2889  if ( rmt == denseResMat )
2890  {
2891  for ( j= 0; j < n; j++ ) pSetExp( p, j+1, exp[j] );
2892  }
2893  else if ( rmt == sparseResMat )
2894  {
2895  for ( j= 1; j < n; j++ ) pSetExp( p, j, exp[j] );
2896  }
2897  pSetCoeff( p, ncpoly[c] );
2898  pSetm( p );
2899  if (result!=NULL) result= pAdd( result, p );
2900  else result= p;
2901  }
2902  c++;
2903  }
2904  sum=0;
2905  exp[0]++;
2906  for ( j= 0; j < n - 1; j++ )
2907  {
2908  if ( exp[j] > tdg )
2909  {
2910  exp[j]= 0;
2911  exp[j + 1]++;
2912  }
2913  sum+=exp[j];
2914  }
2915  sum+=exp[n-1];
2916  }
2917 
2918  pTest( result );
2919 
2920  return result;
2921 }

◆ interpolateDenseSP()

rootContainer ** uResultant::interpolateDenseSP ( BOOLEAN  matchUp = false,
const number  subDetVal = NULL 
)

Definition at line 2923 of file mpr_base.cc.

2924 {
2925  int i,p,uvar;
2926  long tdg;
2927  int loops= (matchUp?n-2:n-1);
2928 
2929  mprPROTnl("uResultant::interpolateDenseSP");
2930 
2931  tdg= resMat->getDetDeg();
2932 
2933  // evaluate D in tdg+1 distinct points, so
2934  // we need tdg+1 results of D(p0,1,0,...,0) =
2935  // c(0)*u0^tdg + c(1)*u0^tdg-1 + ... + c(tdg-1)*u0 + c(tdg)
2936  number *presults;
2937  presults= (number *)omAlloc( (tdg + 1) * sizeof( number ) );
2938  for ( i=0; i <= tdg; i++ ) presults[i]= nInit(0);
2939 
2940  rootContainer ** roots;
2941  roots= (rootContainer **) omAlloc( loops * sizeof(rootContainer*) );
2942  for ( i=0; i < loops; i++ ) roots[i]= new rootContainer(); // 0..n-2
2943 
2944  number *pevpoint= (number *)omAlloc( n * sizeof( number ) );
2945  for (i=0; i < n; i++) pevpoint[i]= nInit(0);
2946 
2947  number *pev= (number *)omAlloc( n * sizeof( number ) );
2948  for (i=0; i < n; i++) pev[i]= nInit(0);
2949 
2950  // now we evaluate D(u0,-1,0,...0), D(u0,0,-1,0,...,0), ..., D(u0,0,..,0,-1)
2951  // or D(u0,k1,k2,0,...,0), D(u0,k1,k2,k3,0,...,0), ..., D(u0,k1,k2,k3,...,kn)
2952  // this gives us n-1 evaluations
2953  p=3;
2954  for ( uvar= 0; uvar < loops; uvar++ )
2955  {
2956  // generate initial evaluation point
2957  if ( matchUp )
2958  {
2959  for (i=0; i < n; i++)
2960  {
2961  // prime(random number) between 1 and MAXEVPOINT
2962  nDelete( &pevpoint[i] );
2963  if ( i == 0 )
2964  {
2965  //p= nextPrime( p );
2966  pevpoint[i]= nInit( p );
2967  }
2968  else if ( i <= uvar + 2 )
2969  {
2970  pevpoint[i]=nInit(1+siRand()%MAXEVPOINT);
2971  //pevpoint[i]=nInit(383);
2972  }
2973  else
2974  pevpoint[i]=nInit(0);
2975  mprPROTNnl(" ",pevpoint[i]);
2976  }
2977  }
2978  else
2979  {
2980  for (i=0; i < n; i++)
2981  {
2982  // init pevpoint with prime,0,...0,1,0,...,0
2983  nDelete( &pevpoint[i] );
2984  if ( i == 0 )
2985  {
2986  //p=nextPrime( p );
2987  pevpoint[i]=nInit( p );
2988  }
2989  else
2990  {
2991  if ( i == (uvar + 1) ) pevpoint[i]= nInit(-1);
2992  else pevpoint[i]= nInit(0);
2993  }
2994  mprPROTNnl(" ",pevpoint[i]);
2995  }
2996  }
2997 
2998  // prepare aktual evaluation point
2999  for (i=0; i < n; i++)
3000  {
3001  nDelete( &pev[i] );
3002  pev[i]= nCopy( pevpoint[i] );
3003  }
3004  // evaluate the determinant in the points pev^0, pev^1, ..., pev^tdg
3005  for ( i=0; i <= tdg; i++ )
3006  {
3007  nDelete( &pev[0] );
3008  nPower(pevpoint[0],i,&pev[0]); // new evpoint
3009 
3010  nDelete( &presults[i] );
3011  presults[i]=resMat->getDetAt( pev ); // evaluate det at point evpoint
3012 
3013  mprPROTNnl("",presults[i]);
3014 
3016  mprPROTL("",tdg-i);
3017  }
3018  mprSTICKYPROT("\n");
3019 
3020  // now interpolate
3021  vandermonde vm( tdg + 1, 1, tdg, pevpoint, FALSE );
3022  number *ncpoly= vm.interpolateDense( presults );
3023 
3024  if ( subDetVal != NULL )
3025  { // divide by common factor
3026  number detdiv;
3027  for ( i= 0; i <= tdg; i++ )
3028  {
3029  detdiv= nDiv( ncpoly[i], subDetVal );
3030  nNormalize( detdiv );
3031  nDelete( &ncpoly[i] );
3032  ncpoly[i]= detdiv;
3033  }
3034  }
3035 
3036 #ifdef mprDEBUG_ALL
3037  PrintLn();
3038  for ( i=0; i <= tdg; i++ )
3039  {
3040  nPrint(ncpoly[i]); PrintS(" --- ");
3041  }
3042  PrintLn();
3043 #endif
3044 
3045  // save results
3046  roots[uvar]->fillContainer( ncpoly, pevpoint, uvar+1, tdg,
3048  loops );
3049  }
3050 
3051  // free some stuff: pev, presult
3052  for ( i=0; i < n; i++ ) nDelete( pev + i );
3053  omFreeSize( (void *)pev, n * sizeof( number ) );
3054 
3055  for ( i=0; i <= tdg; i++ ) nDelete( presults+i );
3056  omFreeSize( (void *)presults, (tdg + 1) * sizeof( number ) );
3057 
3058  return roots;
3059 }

◆ linearPoly()

poly uResultant::linearPoly ( const resMatType  rmt)
private

Definition at line 2744 of file mpr_base.cc.

2745 {
2746  int i;
2747 
2748  poly newlp= pOne();
2749  poly actlp, rootlp= newlp;
2750 
2751  for ( i= 1; i <= (currRing->N); i++ )
2752  {
2753  actlp= newlp;
2754  pSetExp( actlp, i, 1 );
2755  pSetm( actlp );
2756  newlp= pOne();
2757  actlp->next= newlp;
2758  }
2759  actlp->next= NULL;
2760  pDelete( &newlp );
2761 
2762  if ( rrmt == sparseResMat )
2763  {
2764  newlp= pOne();
2765  actlp->next= newlp;
2766  newlp->next= NULL;
2767  }
2768  return ( rootlp );
2769 }

◆ nextPrime()

int uResultant::nextPrime ( const int  p)
private

Definition at line 3174 of file mpr_base.cc.

3175 {
3176  int init=i;
3177  int ii=i+2;
3178  extern int IsPrime(int p); // from Singular/ipshell.{h,cc}
3179  int j= IsPrime( ii );
3180  while ( j <= init )
3181  {
3182  ii+=2;
3183  j= IsPrime( ii );
3184  }
3185  return j;
3186 }

◆ specializeInU()

rootContainer ** uResultant::specializeInU ( BOOLEAN  matchUp = false,
const number  subDetVal = NULL 
)

Definition at line 3061 of file mpr_base.cc.

3062 {
3063  int i,/*p,*/uvar;
3064  long tdg;
3065  poly pures,piter;
3066  int loops=(matchUp?n-2:n-1);
3067  int nn=n;
3068  if (loops==0) { loops=1;nn++;}
3069 
3070  mprPROTnl("uResultant::specializeInU");
3071 
3072  tdg= resMat->getDetDeg();
3073 
3074  rootContainer ** roots;
3075  roots= (rootContainer **) omAlloc( loops * sizeof(rootContainer*) );
3076  for ( i=0; i < loops; i++ ) roots[i]= new rootContainer(); // 0..n-2
3077 
3078  number *pevpoint= (number *)omAlloc( nn * sizeof( number ) );
3079  for (i=0; i < nn; i++) pevpoint[i]= nInit(0);
3080 
3081  // now we evaluate D(u0,-1,0,...0), D(u0,0,-1,0,...,0), ..., D(u0,0,..,0,-1)
3082  // or D(u0,k1,k2,0,...,0), D(u0,k1,k2,k3,0,...,0), ..., D(u0,k1,k2,k3,...,kn)
3083  // p=3;
3084  for ( uvar= 0; uvar < loops; uvar++ )
3085  {
3086  // generate initial evaluation point
3087  if ( matchUp )
3088  {
3089  for (i=0; i < n; i++)
3090  {
3091  // prime(random number) between 1 and MAXEVPOINT
3092  nDelete( &pevpoint[i] );
3093  if ( i <= uvar + 2 )
3094  {
3095  pevpoint[i]=nInit(1+siRand()%MAXEVPOINT);
3096  //pevpoint[i]=nInit(383);
3097  }
3098  else pevpoint[i]=nInit(0);
3099  mprPROTNnl(" ",pevpoint[i]);
3100  }
3101  }
3102  else
3103  {
3104  for (i=0; i < n; i++)
3105  {
3106  // init pevpoint with prime,0,...0,-1,0,...,0
3107  nDelete( &(pevpoint[i]) );
3108  if ( i == (uvar + 1) ) pevpoint[i]= nInit(-1);
3109  else pevpoint[i]= nInit(0);
3110  mprPROTNnl(" ",pevpoint[i]);
3111  }
3112  }
3113 
3114  pures= resMat->getUDet( pevpoint );
3115 
3116  number *ncpoly= (number *)omAlloc( (tdg+1) * sizeof(number) );
3117 
3118 #ifdef MPR_MASI
3119  BOOLEAN masi=true;
3120 #endif
3121 
3122  piter= pures;
3123  for ( i= tdg; i >= 0; i-- )
3124  {
3125  if ( piter && pTotaldegree(piter) == i )
3126  {
3127  ncpoly[i]= nCopy( pGetCoeff( piter ) );
3128  pIter( piter );
3129 #ifdef MPR_MASI
3130  masi=false;
3131 #endif
3132  }
3133  else
3134  {
3135  ncpoly[i]= nInit(0);
3136  }
3137  mprPROTNnl("", ncpoly[i] );
3138  }
3139 #ifdef MPR_MASI
3140  if ( masi ) mprSTICKYPROT("MASI");
3141 #endif
3142 
3143  mprSTICKYPROT(ST_BASE_EV); // .
3144 
3145  if ( subDetVal != NULL ) // divide by common factor
3146  {
3147  number detdiv;
3148  for ( i= 0; i <= tdg; i++ )
3149  {
3150  detdiv= nDiv( ncpoly[i], subDetVal );
3151  nNormalize( detdiv );
3152  nDelete( &ncpoly[i] );
3153  ncpoly[i]= detdiv;
3154  }
3155  }
3156 
3157  pDelete( &pures );
3158 
3159  // save results
3160  roots[uvar]->fillContainer( ncpoly, pevpoint, uvar+1, tdg,
3162  loops );
3163  }
3164 
3165  mprSTICKYPROT("\n");
3166 
3167  // free some stuff: pev, presult
3168  for ( i=0; i < n; i++ ) nDelete( pevpoint + i );
3169  omFreeSize( (void *)pevpoint, n * sizeof( number ) );
3170 
3171  return roots;
3172 }

Field Documentation

◆ gls

ideal uResultant::gls
private

Definition at line 87 of file mpr_base.h.

◆ n

int uResultant::n
private

Definition at line 88 of file mpr_base.h.

◆ resMat

resMatrixBase* uResultant::resMat
private

Definition at line 91 of file mpr_base.h.

◆ rmt

resMatType uResultant::rmt
private

Definition at line 90 of file mpr_base.h.


The documentation for this class was generated from the following files:
FALSE
#define FALSE
Definition: auxiliary.h:94
idCopy
ideal idCopy(ideal A)
Definition: ideals.h:59
mprPROTNnl
#define mprPROTNnl(msg, nval)
Definition: mpr_global.h:48
nNormalize
#define nNormalize(n)
Definition: numbers.h:30
IsPrime
int IsPrime(int p)
Definition: prime.cc:61
uResultant::denseResMat
Definition: mpr_base.h:64
j
int j
Definition: facHensel.cc:105
nPower
#define nPower(a, b, res)
Definition: numbers.h:38
result
return result
Definition: facAbsBiFact.cc:76
uResultant::resMatType
resMatType
Definition: mpr_base.h:64
resMatrixBase::getDetAt
virtual number getDetAt(const number *)
Definition: mpr_base.h:35
nEqual
#define nEqual(n1, n2)
Definition: numbers.h:20
mprPROTN
#define mprPROTN(msg, nval)
Definition: mpr_global.h:47
vandermonde
vandermonde system solver for interpolating polynomials from their values
Definition: mpr_numeric.h:27
mprPROTL
#define mprPROTL(msg, intval)
Definition: mpr_global.h:45
pDelete
#define pDelete(p_ptr)
Definition: polys.h:174
mprPROTnl
#define mprPROTnl(msg)
Definition: mpr_global.h:41
uResultant::extendIdeal
ideal extendIdeal(const ideal gls, poly linPoly, const resMatType rmt)
Definition: mpr_base.cc:2716
mprSTICKYPROT
#define mprSTICKYPROT(msg)
Definition: mpr_global.h:53
pTotaldegree
static long pTotaldegree(poly p)
Definition: polys.h:264
nTest
#define nTest(a)
Definition: numbers.h:35
currRing
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
i
int i
Definition: cfEzgcd.cc:125
uResultant::none
Definition: mpr_base.h:64
PrintS
void PrintS(const char *s)
Definition: reporter.cc:283
omFreeSize
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:258
BOOLEAN
int BOOLEAN
Definition: auxiliary.h:85
pTest
#define pTest(p)
Definition: polys.h:396
uResultant::gls
ideal gls
Definition: mpr_base.h:87
nPrint
#define nPrint(a)
only for debug, over any initalized currRing
Definition: numbers.h:46
pOne
#define pOne()
Definition: polys.h:297
intvec
Definition: intvec.h:16
pIter
#define pIter(p)
Definition: monomials.h:35
omAlloc
#define omAlloc(size)
Definition: omAllocDecl.h:208
nDiv
#define nDiv(a, b)
Definition: numbers.h:32
MAXEVPOINT
#define MAXEVPOINT
Definition: mpr_base.cc:2654
ST_BASE_EV
#define ST_BASE_EV
Definition: mpr_global.h:61
pAdd
#define pAdd(p, q)
Definition: polys.h:190
rootContainer::fillContainer
void fillContainer(number *_coeffs, number *_ievpoint, const int _var, const int _tdg, const rootType _rt, const int _anz)
Definition: mpr_numeric.cc:303
pSetCoeff
#define pSetCoeff(p, n)
deletes old coeff before setting the new one
Definition: polys.h:30
resMatrixSparse
Definition: mpr_base.cc:68
exp
gmp_float exp(const gmp_float &a)
Definition: mpr_complex.cc:357
uResultant::resMat
resMatrixBase * resMat
Definition: mpr_base.h:91
nIsZero
#define nIsZero(n)
Definition: numbers.h:19
over
unsigned long over(const unsigned long n, const unsigned long d)
Definition: mpr_base.cc:2660
uResultant::sparseResMat
Definition: mpr_base.h:64
Print
#define Print
Definition: emacs.cc:79
resMatrixDense
Definition: mpr_base.cc:1930
rootContainer::cspecialmu
Definition: mpr_numeric.h:67
pow
Rational pow(const Rational &a, int e)
Definition: GMPrat.cc:414
WerrorS
void WerrorS(const char *s)
Definition: feFopen.cc:24
uResultant::linearPoly
poly linearPoly(const resMatType rmt)
Definition: mpr_base.cc:2744
NULL
#define NULL
Definition: omList.c:9
resMatrixBase::getUDet
virtual poly getUDet(const number *)
Definition: mpr_base.h:33
pSetm
#define pSetm(p)
Definition: polys.h:254
resMatrixBase::getDetDeg
virtual long getDetDeg()
Definition: mpr_base.h:38
l
int l
Definition: cfEzgcd.cc:93
nDelete
#define nDelete(n)
Definition: numbers.h:16
uResultant::rmt
resMatType rmt
Definition: mpr_base.h:90
pSetExp
#define pSetExp(p, i, v)
Definition: polys.h:41
p
int p
Definition: cfModGcd.cc:4019
rootContainer::cspecial
Definition: mpr_numeric.h:67
nInit
#define nInit(i)
Definition: numbers.h:24
IDELEMS
#define IDELEMS(i)
Definition: simpleideals.h:24
uResultant::n
int n
Definition: mpr_base.h:88
rootContainer
complex root finder for univariate polynomials based on laguers algorithm
Definition: mpr_numeric.h:64
pGetCoeff
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
Definition: monomials.h:42
PrintLn
void PrintLn()
Definition: reporter.cc:309
siRand
int siRand()
Definition: sirandom.c:41
nCopy
#define nCopy(n)
Definition: numbers.h:15
uResultant::nextPrime
int nextPrime(const int p)
Definition: mpr_base.cc:3174
omReallocSize
#define omReallocSize(addr, o_size, size)
Definition: omAllocDecl.h:218