My Project
Macros | Functions
mpr_inout.h File Reference

Go to the source code of this file.

Macros

#define DEFAULT_DIGITS   30
 
#define MPR_DENSE   1
 
#define MPR_SPARSE   2
 

Functions

BOOLEAN nuUResSolve (leftv res, leftv args)
 solve a multipolynomial system using the u-resultant Input ideal must be 0-dimensional and (currRing->N) == IDELEMS(ideal). More...
 
BOOLEAN nuMPResMat (leftv res, leftv arg1, leftv arg2)
 returns module representing the multipolynomial resultant matrix Arguments 2: ideal i, int k k=0: use sparse resultant matrix of Gelfand, Kapranov and Zelevinsky k=1: use resultant matrix of Macaulay (k=0 is default) More...
 
BOOLEAN nuLagSolve (leftv res, leftv arg1, leftv arg2, leftv arg3)
 find the (complex) roots an univariate polynomial Determines the roots of an univariate polynomial using Laguerres' root-solver. More...
 
BOOLEAN nuVanderSys (leftv res, leftv arg1, leftv arg2, leftv arg3)
 COMPUTE: polynomial p with values given by v at points p1,..,pN derived from p; more precisely: consider p as point in K^n and v as N elements in K, let p1,..,pN be the points in K^n obtained by evaluating all monomials of degree 0,1,...,N at p in lexicographical order, then the procedure computes the polynomial f satisfying f(pi) = v[i] RETURN: polynomial f of degree d. More...
 
BOOLEAN loNewtonP (leftv res, leftv arg1)
 compute Newton Polytopes of input polynomials More...
 
BOOLEAN loSimplex (leftv res, leftv args)
 Implementation of the Simplex Algorithm. More...
 

Macro Definition Documentation

◆ DEFAULT_DIGITS

#define DEFAULT_DIGITS   30

Definition at line 13 of file mpr_inout.h.

◆ MPR_DENSE

#define MPR_DENSE   1

Definition at line 15 of file mpr_inout.h.

◆ MPR_SPARSE

#define MPR_SPARSE   2

Definition at line 16 of file mpr_inout.h.

Function Documentation

◆ loNewtonP()

BOOLEAN loNewtonP ( leftv  res,
leftv  arg1 
)

compute Newton Polytopes of input polynomials

Definition at line 4565 of file ipshell.cc.

4566{
4567 res->data= (void*)loNewtonPolytope( (ideal)arg1->Data() );
4568 return FALSE;
4569}
#define FALSE
Definition: auxiliary.h:96
void * Data()
Definition: subexpr.cc:1173
CanonicalForm res
Definition: facAbsFact.cc:60
ideal loNewtonPolytope(const ideal id)
Definition: mpr_base.cc:3191

◆ loSimplex()

BOOLEAN loSimplex ( leftv  res,
leftv  args 
)

Implementation of the Simplex Algorithm.

For args, see class simplex.

Definition at line 4571 of file ipshell.cc.

4572{
4573 if ( !(rField_is_long_R(currRing)) )
4574 {
4575 WerrorS("Ground field not implemented!");
4576 return TRUE;
4577 }
4578
4579 simplex * LP;
4580 matrix m;
4581
4582 leftv v= args;
4583 if ( v->Typ() != MATRIX_CMD ) // 1: matrix
4584 return TRUE;
4585 else
4586 m= (matrix)(v->CopyD());
4587
4588 LP = new simplex(MATROWS(m),MATCOLS(m));
4589 LP->mapFromMatrix(m);
4590
4591 v= v->next;
4592 if ( v->Typ() != INT_CMD ) // 2: m = number of constraints
4593 return TRUE;
4594 else
4595 LP->m= (int)(long)(v->Data());
4596
4597 v= v->next;
4598 if ( v->Typ() != INT_CMD ) // 3: n = number of variables
4599 return TRUE;
4600 else
4601 LP->n= (int)(long)(v->Data());
4602
4603 v= v->next;
4604 if ( v->Typ() != INT_CMD ) // 4: m1 = number of <= constraints
4605 return TRUE;
4606 else
4607 LP->m1= (int)(long)(v->Data());
4608
4609 v= v->next;
4610 if ( v->Typ() != INT_CMD ) // 5: m2 = number of >= constraints
4611 return TRUE;
4612 else
4613 LP->m2= (int)(long)(v->Data());
4614
4615 v= v->next;
4616 if ( v->Typ() != INT_CMD ) // 6: m3 = number of == constraints
4617 return TRUE;
4618 else
4619 LP->m3= (int)(long)(v->Data());
4620
4621#ifdef mprDEBUG_PROT
4622 Print("m (constraints) %d\n",LP->m);
4623 Print("n (columns) %d\n",LP->n);
4624 Print("m1 (<=) %d\n",LP->m1);
4625 Print("m2 (>=) %d\n",LP->m2);
4626 Print("m3 (==) %d\n",LP->m3);
4627#endif
4628
4629 LP->compute();
4630
4631 lists lres= (lists)omAlloc( sizeof(slists) );
4632 lres->Init( 6 );
4633
4634 lres->m[0].rtyp= MATRIX_CMD; // output matrix
4635 lres->m[0].data=(void*)LP->mapToMatrix(m);
4636
4637 lres->m[1].rtyp= INT_CMD; // found a solution?
4638 lres->m[1].data=(void*)(long)LP->icase;
4639
4640 lres->m[2].rtyp= INTVEC_CMD;
4641 lres->m[2].data=(void*)LP->posvToIV();
4642
4643 lres->m[3].rtyp= INTVEC_CMD;
4644 lres->m[3].data=(void*)LP->zrovToIV();
4645
4646 lres->m[4].rtyp= INT_CMD;
4647 lres->m[4].data=(void*)(long)LP->m;
4648
4649 lres->m[5].rtyp= INT_CMD;
4650 lres->m[5].data=(void*)(long)LP->n;
4651
4652 res->data= (void*)lres;
4653
4654 return FALSE;
4655}
#define TRUE
Definition: auxiliary.h:100
int m
Definition: cfEzgcd.cc:128
Variable next() const
Definition: factory.h:146
Linear Programming / Linear Optimization using Simplex - Algorithm.
Definition: mpr_numeric.h:195
intvec * zrovToIV()
BOOLEAN mapFromMatrix(matrix m)
int icase
Definition: mpr_numeric.h:201
void compute()
matrix mapToMatrix(matrix m)
intvec * posvToIV()
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
int rtyp
Definition: subexpr.h:91
void * data
Definition: subexpr.h:88
Definition: lists.h:24
sleftv * m
Definition: lists.h:46
INLINE_THIS void Init(int l=0)
#define Print
Definition: emacs.cc:80
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:39
void WerrorS(const char *s)
Definition: feFopen.cc:24
@ MATRIX_CMD
Definition: grammar.cc:286
ip_smatrix * matrix
Definition: matpol.h:43
#define MATROWS(i)
Definition: matpol.h:26
#define MATCOLS(i)
Definition: matpol.h:27
slists * lists
Definition: mpr_numeric.h:146
#define omAlloc(size)
Definition: omAllocDecl.h:210
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
static BOOLEAN rField_is_long_R(const ring r)
Definition: ring.h:542
@ INTVEC_CMD
Definition: tok.h:101
@ INT_CMD
Definition: tok.h:96

◆ nuLagSolve()

BOOLEAN nuLagSolve ( leftv  res,
leftv  arg1,
leftv  arg2,
leftv  arg3 
)

find the (complex) roots an univariate polynomial Determines the roots of an univariate polynomial using Laguerres' root-solver.

Good for polynomials with low and middle degree (<40). Arguments 3: poly arg1 , int arg2 , int arg3 arg2>0: defines precision of fractional part if ground field is Q arg3: number of iterations for approximation of roots (default=2) Returns a list of all (complex) roots of the polynomial arg1

Definition at line 4680 of file ipshell.cc.

4681{
4682 poly gls;
4683 gls= (poly)(arg1->Data());
4684 int howclean= (int)(long)arg3->Data();
4685
4686 if ( gls == NULL || pIsConstant( gls ) )
4687 {
4688 WerrorS("Input polynomial is constant!");
4689 return TRUE;
4690 }
4691
4693 {
4694 int* r=Zp_roots(gls, currRing);
4695 lists rlist;
4696 rlist= (lists)omAlloc( sizeof(slists) );
4697 rlist->Init( r[0] );
4698 for(int i=r[0];i>0;i--)
4699 {
4700 rlist->m[i-1].data=n_Init(r[i],currRing->cf);
4701 rlist->m[i-1].rtyp=NUMBER_CMD;
4702 }
4703 omFree(r);
4704 res->data=rlist;
4705 res->rtyp= LIST_CMD;
4706 return FALSE;
4707 }
4708 if ( !(rField_is_R(currRing) ||
4712 {
4713 WerrorS("Ground field not implemented!");
4714 return TRUE;
4715 }
4716
4719 {
4720 unsigned long int ii = (unsigned long int)arg2->Data();
4721 setGMPFloatDigits( ii, ii );
4722 }
4723
4724 int ldummy;
4725 int deg= currRing->pLDeg( gls, &ldummy, currRing );
4726 int i,vpos=0;
4727 poly piter;
4728 lists elist;
4729
4730 elist= (lists)omAlloc( sizeof(slists) );
4731 elist->Init( 0 );
4732
4733 if ( rVar(currRing) > 1 )
4734 {
4735 piter= gls;
4736 for ( i= 1; i <= rVar(currRing); i++ )
4737 if ( pGetExp( piter, i ) )
4738 {
4739 vpos= i;
4740 break;
4741 }
4742 while ( piter )
4743 {
4744 for ( i= 1; i <= rVar(currRing); i++ )
4745 if ( (vpos != i) && (pGetExp( piter, i ) != 0) )
4746 {
4747 WerrorS("The input polynomial must be univariate!");
4748 return TRUE;
4749 }
4750 pIter( piter );
4751 }
4752 }
4753
4754 rootContainer * roots= new rootContainer();
4755 number * pcoeffs= (number *)omAlloc( (deg+1) * sizeof( number ) );
4756 piter= gls;
4757 for ( i= deg; i >= 0; i-- )
4758 {
4759 if ( piter && pTotaldegree(piter) == i )
4760 {
4761 pcoeffs[i]= nCopy( pGetCoeff( piter ) );
4762 //nPrint( pcoeffs[i] );PrintS(" ");
4763 pIter( piter );
4764 }
4765 else
4766 {
4767 pcoeffs[i]= nInit(0);
4768 }
4769 }
4770
4771#ifdef mprDEBUG_PROT
4772 for (i=deg; i >= 0; i--)
4773 {
4774 nPrint( pcoeffs[i] );PrintS(" ");
4775 }
4776 PrintLn();
4777#endif
4778
4779 roots->fillContainer( pcoeffs, NULL, 1, deg, rootContainer::onepoly, 1 );
4780 roots->solver( howclean );
4781
4782 int elem= roots->getAnzRoots();
4783 char *dummy;
4784 int j;
4785
4786 lists rlist;
4787 rlist= (lists)omAlloc( sizeof(slists) );
4788 rlist->Init( elem );
4789
4791 {
4792 for ( j= 0; j < elem; j++ )
4793 {
4794 rlist->m[j].rtyp=NUMBER_CMD;
4795 rlist->m[j].data=(void *)nCopy((number)(roots->getRoot(j)));
4796 //rlist->m[j].data=(void *)(number)(roots->getRoot(j));
4797 }
4798 }
4799 else
4800 {
4801 for ( j= 0; j < elem; j++ )
4802 {
4803 dummy = complexToStr( (*roots)[j], gmp_output_digits, currRing->cf );
4804 rlist->m[j].rtyp=STRING_CMD;
4805 rlist->m[j].data=(void *)dummy;
4806 }
4807 }
4808
4809 elist->Clean();
4810 //omFreeSize( (ADDRESS) elist, sizeof(slists) );
4811
4812 // this is (via fillContainer) the same data as in root
4813 //for ( i= deg; i >= 0; i-- ) nDelete( &pcoeffs[i] );
4814 //omFreeSize( (ADDRESS) pcoeffs, (deg+1) * sizeof( number ) );
4815
4816 delete roots;
4817
4818 res->data= (void*)rlist;
4819
4820 return FALSE;
4821}
int i
Definition: cfEzgcd.cc:132
int * Zp_roots(poly p, const ring r)
Definition: clapsing.cc:2188
complex root finder for univariate polynomials based on laguers algorithm
Definition: mpr_numeric.h:66
gmp_complex * getRoot(const int i)
Definition: mpr_numeric.h:88
void fillContainer(number *_coeffs, number *_ievpoint, const int _var, const int _tdg, const rootType _rt, const int _anz)
Definition: mpr_numeric.cc:300
int getAnzRoots()
Definition: mpr_numeric.h:97
bool solver(const int polishmode=PM_NONE)
Definition: mpr_numeric.cc:437
void Clean(ring r=currRing)
Definition: lists.h:26
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
Definition: coeffs.h:535
int j
Definition: facHensel.cc:110
@ NUMBER_CMD
Definition: grammar.cc:288
#define pIter(p)
Definition: monomials.h:37
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
Definition: monomials.h:44
EXTERN_VAR size_t gmp_output_digits
Definition: mpr_base.h:115
char * complexToStr(gmp_complex &c, const unsigned int oprec, const coeffs src)
Definition: mpr_complex.cc:704
void setGMPFloatDigits(size_t digits, size_t rest)
Set size of mantissa digits - the number of output digits (basis 10) the size of mantissa consists of...
Definition: mpr_complex.cc:60
#define nCopy(n)
Definition: numbers.h:15
#define nPrint(a)
only for debug, over any initalized currRing
Definition: numbers.h:46
#define nInit(i)
Definition: numbers.h:24
#define omFree(addr)
Definition: omAllocDecl.h:261
#define NULL
Definition: omList.c:12
static long pTotaldegree(poly p)
Definition: polys.h:282
#define pIsConstant(p)
like above, except that Comp must be 0
Definition: polys.h:238
#define pGetExp(p, i)
Exponent.
Definition: polys.h:41
void PrintS(const char *s)
Definition: reporter.cc:284
void PrintLn()
Definition: reporter.cc:310
static BOOLEAN rField_is_R(const ring r)
Definition: ring.h:518
static BOOLEAN rField_is_Zp(const ring r)
Definition: ring.h:500
static BOOLEAN rField_is_long_C(const ring r)
Definition: ring.h:545
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:506
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:592
@ LIST_CMD
Definition: tok.h:118
@ STRING_CMD
Definition: tok.h:185

◆ nuMPResMat()

BOOLEAN nuMPResMat ( leftv  res,
leftv  arg1,
leftv  arg2 
)

returns module representing the multipolynomial resultant matrix Arguments 2: ideal i, int k k=0: use sparse resultant matrix of Gelfand, Kapranov and Zelevinsky k=1: use resultant matrix of Macaulay (k=0 is default)

Definition at line 4657 of file ipshell.cc.

4658{
4659 ideal gls = (ideal)(arg1->Data());
4660 int imtype= (int)(long)arg2->Data();
4661
4662 uResultant::resMatType mtype= determineMType( imtype );
4663
4664 // check input ideal ( = polynomial system )
4665 if ( mprIdealCheck( gls, arg1->Name(), mtype, true ) != mprOk )
4666 {
4667 return TRUE;
4668 }
4669
4670 uResultant *resMat= new uResultant( gls, mtype, false );
4671 if (resMat!=NULL)
4672 {
4673 res->rtyp = MODUL_CMD;
4674 res->data= (void*)resMat->accessResMat()->getMatrix();
4675 if (!errorreported) delete resMat;
4676 }
4677 return errorreported;
4678}
virtual ideal getMatrix()
Definition: mpr_base.h:31
const char * Name()
Definition: subexpr.h:120
Base class for solving 0-dim poly systems using u-resultant.
Definition: mpr_base.h:63
resMatrixBase * accessResMat()
Definition: mpr_base.h:78
VAR short errorreported
Definition: feFopen.cc:23
@ MODUL_CMD
Definition: grammar.cc:287
@ mprOk
Definition: mpr_base.h:98
uResultant::resMatType determineMType(int imtype)
mprState mprIdealCheck(const ideal theIdeal, const char *name, uResultant::resMatType mtype, BOOLEAN rmatrix=false)

◆ nuUResSolve()

BOOLEAN nuUResSolve ( leftv  res,
leftv  args 
)

solve a multipolynomial system using the u-resultant Input ideal must be 0-dimensional and (currRing->N) == IDELEMS(ideal).

Resultant method can be MPR_DENSE, which uses Macaulay Resultant (good for dense homogeneous polynoms) or MPR_SPARSE, which uses Sparse Resultant (Gelfand, Kapranov, Zelevinsky). Arguments 4: ideal i, int k, int l, int m k=0: use sparse resultant matrix of Gelfand, Kapranov and Zelevinsky k=1: use resultant matrix of Macaulay (k=0 is default) l>0: defines precision of fractional part if ground field is Q m=0,1,2: number of iterations for approximation of roots (default=2) Returns a list containing the roots of the system.

Definition at line 4924 of file ipshell.cc.

4925{
4926 leftv v= args;
4927
4928 ideal gls;
4929 int imtype;
4930 int howclean;
4931
4932 // get ideal
4933 if ( v->Typ() != IDEAL_CMD )
4934 return TRUE;
4935 else gls= (ideal)(v->Data());
4936 v= v->next;
4937
4938 // get resultant matrix type to use (0,1)
4939 if ( v->Typ() != INT_CMD )
4940 return TRUE;
4941 else imtype= (int)(long)v->Data();
4942 v= v->next;
4943
4944 if (imtype==0)
4945 {
4946 ideal test_id=idInit(1,1);
4947 int j;
4948 for(j=IDELEMS(gls)-1;j>=0;j--)
4949 {
4950 if (gls->m[j]!=NULL)
4951 {
4952 test_id->m[0]=gls->m[j];
4953 intvec *dummy_w=id_QHomWeight(test_id, currRing);
4954 if (dummy_w!=NULL)
4955 {
4956 WerrorS("Newton polytope not of expected dimension");
4957 delete dummy_w;
4958 return TRUE;
4959 }
4960 }
4961 }
4962 }
4963
4964 // get and set precision in digits ( > 0 )
4965 if ( v->Typ() != INT_CMD )
4966 return TRUE;
4967 else if ( !(rField_is_R(currRing) || rField_is_long_R(currRing) || \
4969 {
4970 unsigned long int ii=(unsigned long int)v->Data();
4971 setGMPFloatDigits( ii, ii );
4972 }
4973 v= v->next;
4974
4975 // get interpolation steps (0,1,2)
4976 if ( v->Typ() != INT_CMD )
4977 return TRUE;
4978 else howclean= (int)(long)v->Data();
4979
4980 uResultant::resMatType mtype= determineMType( imtype );
4981 int i,count;
4982 lists listofroots= NULL;
4983 number smv= NULL;
4984 BOOLEAN interpolate_det= (mtype==uResultant::denseResMat)?TRUE:FALSE;
4985
4986 //emptylist= (lists)omAlloc( sizeof(slists) );
4987 //emptylist->Init( 0 );
4988
4989 //res->rtyp = LIST_CMD;
4990 //res->data= (void *)emptylist;
4991
4992 // check input ideal ( = polynomial system )
4993 if ( mprIdealCheck( gls, args->Name(), mtype ) != mprOk )
4994 {
4995 return TRUE;
4996 }
4997
4998 uResultant * ures;
4999 rootContainer ** iproots;
5000 rootContainer ** muiproots;
5001 rootArranger * arranger;
5002
5003 // main task 1: setup of resultant matrix
5004 ures= new uResultant( gls, mtype );
5005 if ( ures->accessResMat()->initState() != resMatrixBase::ready )
5006 {
5007 WerrorS("Error occurred during matrix setup!");
5008 return TRUE;
5009 }
5010
5011 // if dense resultant, check if minor nonsingular
5012 if ( mtype == uResultant::denseResMat )
5013 {
5014 smv= ures->accessResMat()->getSubDet();
5015#ifdef mprDEBUG_PROT
5016 PrintS("// Determinant of submatrix: ");nPrint(smv);PrintLn();
5017#endif
5018 if ( nIsZero(smv) )
5019 {
5020 WerrorS("Unsuitable input ideal: Minor of resultant matrix is singular!");
5021 return TRUE;
5022 }
5023 }
5024
5025 // main task 2: Interpolate specialized resultant polynomials
5026 if ( interpolate_det )
5027 iproots= ures->interpolateDenseSP( false, smv );
5028 else
5029 iproots= ures->specializeInU( false, smv );
5030
5031 // main task 3: Interpolate specialized resultant polynomials
5032 if ( interpolate_det )
5033 muiproots= ures->interpolateDenseSP( true, smv );
5034 else
5035 muiproots= ures->specializeInU( true, smv );
5036
5037#ifdef mprDEBUG_PROT
5038 int c= iproots[0]->getAnzElems();
5039 for (i=0; i < c; i++) pWrite(iproots[i]->getPoly());
5040 c= muiproots[0]->getAnzElems();
5041 for (i=0; i < c; i++) pWrite(muiproots[i]->getPoly());
5042#endif
5043
5044 // main task 4: Compute roots of specialized polys and match them up
5045 arranger= new rootArranger( iproots, muiproots, howclean );
5046 arranger->solve_all();
5047
5048 // get list of roots
5049 if ( arranger->success() )
5050 {
5051 arranger->arrange();
5052 listofroots= listOfRoots(arranger, gmp_output_digits );
5053 }
5054 else
5055 {
5056 WerrorS("Solver was unable to find any roots!");
5057 return TRUE;
5058 }
5059
5060 // free everything
5061 count= iproots[0]->getAnzElems();
5062 for (i=0; i < count; i++) delete iproots[i];
5063 omFreeSize( (ADDRESS) iproots, count * sizeof(rootContainer*) );
5064 count= muiproots[0]->getAnzElems();
5065 for (i=0; i < count; i++) delete muiproots[i];
5066 omFreeSize( (ADDRESS) muiproots, count * sizeof(rootContainer*) );
5067
5068 delete ures;
5069 delete arranger;
5070 if (smv!=NULL) nDelete( &smv );
5071
5072 res->data= (void *)listofroots;
5073
5074 //emptylist->Clean();
5075 // omFreeSize( (ADDRESS) emptylist, sizeof(slists) );
5076
5077 return FALSE;
5078}
int BOOLEAN
Definition: auxiliary.h:87
void * ADDRESS
Definition: auxiliary.h:119
Definition: intvec.h:23
virtual number getSubDet()
Definition: mpr_base.h:37
virtual IStateType initState() const
Definition: mpr_base.h:41
void solve_all()
Definition: mpr_numeric.cc:858
bool success()
Definition: mpr_numeric.h:162
void arrange()
Definition: mpr_numeric.cc:883
int getAnzElems()
Definition: mpr_numeric.h:95
rootContainer ** specializeInU(BOOLEAN matchUp=false, const number subDetVal=NULL)
Definition: mpr_base.cc:3060
rootContainer ** interpolateDenseSP(BOOLEAN matchUp=false, const number subDetVal=NULL)
Definition: mpr_base.cc:2922
@ denseResMat
Definition: mpr_base.h:65
@ IDEAL_CMD
Definition: grammar.cc:284
lists listOfRoots(rootArranger *self, const unsigned int oprec)
Definition: ipshell.cc:5081
#define nDelete(n)
Definition: numbers.h:16
#define nIsZero(n)
Definition: numbers.h:19
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
void pWrite(poly p)
Definition: polys.h:308
int status int void size_t count
Definition: si_signals.h:59
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:35
intvec * id_QHomWeight(ideal id, const ring r)
#define IDELEMS(i)
Definition: simpleideals.h:23

◆ nuVanderSys()

BOOLEAN nuVanderSys ( leftv  res,
leftv  arg1,
leftv  arg2,
leftv  arg3 
)

COMPUTE: polynomial p with values given by v at points p1,..,pN derived from p; more precisely: consider p as point in K^n and v as N elements in K, let p1,..,pN be the points in K^n obtained by evaluating all monomials of degree 0,1,...,N at p in lexicographical order, then the procedure computes the polynomial f satisfying f(pi) = v[i] RETURN: polynomial f of degree d.

Definition at line 4823 of file ipshell.cc.

4824{
4825 int i;
4826 ideal p,w;
4827 p= (ideal)arg1->Data();
4828 w= (ideal)arg2->Data();
4829
4830 // w[0] = f(p^0)
4831 // w[1] = f(p^1)
4832 // ...
4833 // p can be a vector of numbers (multivariate polynom)
4834 // or one number (univariate polynom)
4835 // tdg = deg(f)
4836
4837 int n= IDELEMS( p );
4838 int m= IDELEMS( w );
4839 int tdg= (int)(long)arg3->Data();
4840
4841 res->data= (void*)NULL;
4842
4843 // check the input
4844 if ( tdg < 1 )
4845 {
4846 WerrorS("Last input parameter must be > 0!");
4847 return TRUE;
4848 }
4849 if ( n != rVar(currRing) )
4850 {
4851 Werror("Size of first input ideal must be equal to %d!",rVar(currRing));
4852 return TRUE;
4853 }
4854 if ( m != (int)pow((double)tdg+1,(double)n) )
4855 {
4856 Werror("Size of second input ideal must be equal to %d!",
4857 (int)pow((double)tdg+1,(double)n));
4858 return TRUE;
4859 }
4860 if ( !(rField_is_Q(currRing) /* ||
4861 rField_is_R() || rField_is_long_R() ||
4862 rField_is_long_C()*/ ) )
4863 {
4864 WerrorS("Ground field not implemented!");
4865 return TRUE;
4866 }
4867
4868 number tmp;
4869 number *pevpoint= (number *)omAlloc( n * sizeof( number ) );
4870 for ( i= 0; i < n; i++ )
4871 {
4872 pevpoint[i]=nInit(0);
4873 if ( (p->m)[i] )
4874 {
4875 tmp = pGetCoeff( (p->m)[i] );
4876 if ( nIsZero(tmp) || nIsOne(tmp) || nIsMOne(tmp) )
4877 {
4878 omFreeSize( (ADDRESS)pevpoint, n * sizeof( number ) );
4879 WerrorS("Elements of first input ideal must not be equal to -1, 0, 1!");
4880 return TRUE;
4881 }
4882 } else tmp= NULL;
4883 if ( !nIsZero(tmp) )
4884 {
4885 if ( !pIsConstant((p->m)[i]))
4886 {
4887 omFreeSize( (ADDRESS)pevpoint, n * sizeof( number ) );
4888 WerrorS("Elements of first input ideal must be numbers!");
4889 return TRUE;
4890 }
4891 pevpoint[i]= nCopy( tmp );
4892 }
4893 }
4894
4895 number *wresults= (number *)omAlloc( m * sizeof( number ) );
4896 for ( i= 0; i < m; i++ )
4897 {
4898 wresults[i]= nInit(0);
4899 if ( (w->m)[i] && !nIsZero(pGetCoeff((w->m)[i])) )
4900 {
4901 if ( !pIsConstant((w->m)[i]))
4902 {
4903 omFreeSize( (ADDRESS)pevpoint, n * sizeof( number ) );
4904 omFreeSize( (ADDRESS)wresults, m * sizeof( number ) );
4905 WerrorS("Elements of second input ideal must be numbers!");
4906 return TRUE;
4907 }
4908 wresults[i]= nCopy(pGetCoeff((w->m)[i]));
4909 }
4910 }
4911
4912 vandermonde vm( m, n, tdg, pevpoint, FALSE );
4913 number *ncpoly= vm.interpolateDense( wresults );
4914 // do not free ncpoly[]!!
4915 poly rpoly= vm.numvec2poly( ncpoly );
4916
4917 omFreeSize( (ADDRESS)pevpoint, n * sizeof( number ) );
4918 omFreeSize( (ADDRESS)wresults, m * sizeof( number ) );
4919
4920 res->data= (void*)rpoly;
4921 return FALSE;
4922}
Rational pow(const Rational &a, int e)
Definition: GMPrat.cc:411
int p
Definition: cfModGcd.cc:4078
vandermonde system solver for interpolating polynomials from their values
Definition: mpr_numeric.h:29
const CanonicalForm & w
Definition: facAbsFact.cc:51
#define nIsMOne(n)
Definition: numbers.h:26
#define nIsOne(n)
Definition: numbers.h:25
void Werror(const char *fmt,...)
Definition: reporter.cc:189