My Project  UNKNOWN_GIT_VERSION
Functions | Variables
subexpr.cc File Reference
#include "kernel/mod2.h"
#include "omalloc/omalloc.h"
#include "misc/intvec.h"
#include "misc/options.h"
#include "coeffs/numbers.h"
#include "coeffs/bigintmat.h"
#include "coeffs/ffields.h"
#include "polys/monomials/maps.h"
#include "polys/matpol.h"
#include "polys/monomials/ring.h"
#include "kernel/polys.h"
#include "kernel/ideals.h"
#include "kernel/GBEngine/kstd1.h"
#include "kernel/GBEngine/syz.h"
#include "kernel/oswrapper/timer.h"
#include "Singular/tok.h"
#include "Singular/ipid.h"
#include "Singular/ipshell.h"
#include "Singular/lists.h"
#include "Singular/attrib.h"
#include "Singular/links/silink.h"
#include "Singular/ipprint.h"
#include "Singular/subexpr.h"
#include "Singular/blackbox.h"
#include "Singular/number2.h"
#include <ctype.h>

Go to the source code of this file.

Functions

static void * s_internalCopy (const int t, void *d)
 
void s_internalDelete (const int t, void *d, const ring r)
 
void * slInternalCopy (leftv source, const int t, void *d, Subexpr e)
 
BOOLEAN assumeStdFlag (leftv h)
 
void syMake (leftv v, const char *id, package pa)
 

Variables

omBin sSubexpr_bin = omGetSpecBin(sizeof(_ssubexpr))
 
omBin sleftv_bin = omGetSpecBin(sizeof(sleftv))
 
omBin procinfo_bin = omGetSpecBin(sizeof(procinfo))
 
omBin libstack_bin = omGetSpecBin(sizeof(libstack))
 
static omBin size_two_bin = omGetSpecBin(2)
 
sleftv sLastPrinted
 
BOOLEAN siq =FALSE
 

Function Documentation

◆ assumeStdFlag()

BOOLEAN assumeStdFlag ( leftv  h)

Definition at line 1557 of file subexpr.cc.

1559 {
1560  if (h->e!=NULL)
1561  {
1562  leftv hh=h->LData();
1563  if (h!=hh) return assumeStdFlag(h->LData());
1564  }
1565  if (!hasFlag(h,FLAG_STD))
1566  {
1567  if (!TEST_VERB_NSB)
1568  {
1569  if (TEST_V_ALLWARN)
1570  Warn("%s is no standard basis in >>%s<<",h->Name(),my_yylinebuf);
1571  else
1572  Warn("%s is no standard basis",h->Name());
1573  }
1574  return FALSE;
1575  }
1576  return TRUE;

◆ s_internalCopy()

static void* s_internalCopy ( const int  t,
void *  d 
)
inlinestatic

Definition at line 435 of file subexpr.cc.

437 {
438  switch (t)
439  {
440  case CRING_CMD:
441  {
442  coeffs cf=(coeffs)d;
443  cf->ref++;
444  return (void*)d;
445  }
446 #ifdef SINGULAR_4_2
447  case CNUMBER_CMD:
448  return (void*)n2Copy((number2)d);
449  case CPOLY_CMD:
450  return (void*)p2Copy((poly2)d);
451  case CMATRIX_CMD: // like BIGINTMAT
452 #endif
453  case BIGINTMAT_CMD:
454  return (void*)bimCopy((bigintmat *)d);
455  case BUCKET_CMD:
456  return (void*)sBucketCopy((sBucket_pt)d);
457  case INTVEC_CMD:
458  case INTMAT_CMD:
459  return (void *)ivCopy((intvec *)d);
460  case MATRIX_CMD:
461  return (void *)mp_Copy((matrix)d, currRing);
462  case SMATRIX_CMD:
463  case IDEAL_CMD:
464  case MODUL_CMD:
465  return (void *)idCopy((ideal)d);
466  case STRING_CMD:
467  return (void *)omStrDup((char *)d);
468  case PACKAGE_CMD:
469  return (void *)paCopy((package) d);
470  case PROC_CMD:
471  return (void *)piCopy((procinfov) d);
472  case POLY_CMD:
473  case VECTOR_CMD:
474  return (void *)pCopy((poly)d);
475  case INT_CMD:
476  return d;
477  case NUMBER_CMD:
478  return (void *)nCopy((number)d);
479  case BIGINT_CMD:
480  return (void *)n_Copy((number)d, coeffs_BIGINT);
481  case MAP_CMD:
482  return (void *)maCopy((map)d, currRing);
483  case LIST_CMD:
484  return (void *)lCopy((lists)d);
485  case LINK_CMD:
486  return (void *)slCopy((si_link) d);
487  case RING_CMD:
488  {
489  ring r=(ring)d;
490  if (r!=NULL)
491  {
492  r->ref++;
493  //Print("s_internalCopy:+ ring %d, ref %d\n",r,r->ref);
494  }
495  return d;
496  }
497  case RESOLUTION_CMD:
498  return (void*)syCopy((syStrategy)d);
499  case DEF_CMD:
500  case NONE:
501  case 0: /* type in error case */
502  break; /* error recovery: do nothing */
503  //case COMMAND:
504  default:
505  {
506  if (t>MAX_TOK)
507  {
508  blackbox *b=getBlackboxStuff(t);
509  if (b!=NULL) return b->blackbox_Copy(b,d);
510  return NULL;
511  }
512  else
513  Warn("s_internalCopy: cannot copy type %s(%d)",
514  Tok2Cmdname(t),t);
515  }
516  }
517  return NULL;

◆ s_internalDelete()

void s_internalDelete ( const int  t,
void *  d,
const ring  r 
)

Definition at line 519 of file subexpr.cc.

521 {
522  assume(d!=NULL);
523  switch (t)
524  {
525  case CRING_CMD:
526  {
527  coeffs cf=(coeffs)d;
528  if ((cf->ref<1)&&
529  ((cf->type <=n_GF)
530  ||((cf->type >=n_long_C)&&(cf->type <=n_CF))))
531  {
532  Warn("cannot kill `%s`",nCoeffName(cf));
533  }
534  else // allow nKillChar for n_long_R, extensions, and user defined:
535  nKillChar((coeffs)d);
536  break;
537  }
538 #ifdef SINGULAR_4_2
539  case CNUMBER_CMD:
540  {
541  number2 n=(number2)d;
542  n2Delete(n);
543  break;
544  }
545  case CPOLY_CMD:
546  {
547  poly2 n=(poly2)d;
548  p2Delete(n);
549  break;
550  }
551  case CMATRIX_CMD: //like BIGINTMAT
552 #endif
553  case BIGINTMAT_CMD:
554  {
555  bigintmat *v=(bigintmat*)d;
556  delete v;
557  break;
558  }
559  case BUCKET_CMD:
560  {
563  break;
564  }
565  case INTVEC_CMD:
566  case INTMAT_CMD:
567  {
568  intvec *v=(intvec*)d;
569  delete v;
570  break;
571  }
572  case MAP_CMD:
573  {
574  map m=(map)d;
575  omFreeBinAddr((ADDRESS)m->preimage);
576  m->preimage=NULL;
577  /* no break: continue as IDEAL*/
578  }
579  case SMATRIX_CMD:
580  case MATRIX_CMD:
581  case IDEAL_CMD:
582  case MODUL_CMD:
583  {
584  ideal i=(ideal)d;
585  id_Delete(&i,r);
586  break;
587  }
588  case STRING_CMD:
589  omFree(d);
590  break;
591  //case PACKAGE_CMD:
592  // return (void *)paCopy((package) d);
593  case PROC_CMD:
594  piKill((procinfo*)d);
595  break;
596  case POLY_CMD:
597  case VECTOR_CMD:
598  {
599  poly p=(poly)d;
600  p_Delete(&p,r);
601  break;
602  }
603  case NUMBER_CMD:
604  {
605  number n=(number)d;
606  n_Delete(&n,r->cf);
607  break;
608  }
609  case BIGINT_CMD:
610  {
611  number n=(number)d;
613  break;
614  }
615  case LIST_CMD:
616  {
617  lists l=(lists)d;
618  l->Clean(r);
619  break;
620  }
621  case LINK_CMD:
622  {
623  si_link l=(si_link)d;
624  slKill(l);
625  break;
626  }
627  case RING_CMD:
628  {
629  ring R=(ring)d;
630  if ((R!=currRing)||(R->ref>=0))
631  rKill(R);
632  #ifdef TEST
633  else
634  Print("currRing? ref=%d\n",R->ref);
635  #endif
636  break;
637  }
638  case RESOLUTION_CMD:
639  {
641  if (s!=NULL) syKillComputation(s,r);
642  break;
643  }
644  case COMMAND:
645  {
646  command cmd=(command)d;
647  if (cmd->arg1.rtyp!=0) cmd->arg1.CleanUp(r);
648  if (cmd->arg2.rtyp!=0) cmd->arg2.CleanUp(r);
649  if (cmd->arg3.rtyp!=0) cmd->arg3.CleanUp(r);
651  break;
652  }
653  case INT_CMD:
654  case DEF_CMD:
655  case ALIAS_CMD:
656  case PACKAGE_CMD:
657  case IDHDL:
658  case NONE:
659  case ANY_TYPE:
660  case VECHO:
661  case VPRINTLEVEL:
662  case VCOLMAX:
663  case VTIMER:
664  case VRTIMER:
665  case VOICE:
666  case VMAXDEG:
667  case VMAXMULT:
668  case TRACE:
669  case VSHORTOUT:
670  case VNOETHER:
671  case VMINPOLY:
672  case 0: /* type in error case */
673  break; /* error recovery: do nothing */
674  //case COMMAND:
675  //case COMMAND:
676  default:
677  {
678  if (t>MAX_TOK)
679  {
680  blackbox *b=getBlackboxStuff(t);
681  if (b!=NULL) b->blackbox_destroy(b,d);
682  break;
683  }
684  else
685  Warn("s_internalDelete: cannot delete type %s(%d)",
686  Tok2Cmdname(t),t);
687  }
688  }

◆ slInternalCopy()

void* slInternalCopy ( leftv  source,
const int  t,
void *  d,
Subexpr  e 
)

Definition at line 690 of file subexpr.cc.

692 {
693  if (t==STRING_CMD)
694  {
695  if ((e==NULL)
696  || (source->rtyp==LIST_CMD)
697  || ((source->rtyp==IDHDL)
698  &&((IDTYP((idhdl)source->data)==LIST_CMD)
699  || (IDTYP((idhdl)source->data)>MAX_TOK)))
700  || (source->rtyp>MAX_TOK))
701  return (void *)omStrDup((char *)d);
702  else if (e->next==NULL)
703  {
704  char *s=(char*)omAllocBin(size_two_bin);
705  s[0]=*(char *)d;
706  s[1]='\0';
707  return s;
708  }
709  #ifdef TEST
710  else
711  {
712  Werror("not impl. string-op in `%s`",my_yylinebuf);
713  return NULL;
714  }
715  #endif
716  }
717  return s_internalCopy(t,d);

◆ syMake()

void syMake ( leftv  v,
const char *  id,
package  pa 
)

Definition at line 1583 of file subexpr.cc.

1585 {
1586  /* resolv an identifier: (to DEF_CMD, if siq>0)
1587  * 1) reserved id: done by scanner
1588  * 2) `basering` / 'Current`
1589  * 3) existing identifier, local
1590  * 4) ringvar, ringpar, local ring
1591  * 5) existing identifier, global
1592  * 6) monom (resp. number), local ring: consisting of:
1593  * 6') ringvar, ringpar,global ring
1594  * 6'') monom (resp. number), local ring
1595  * 7) monom (resp. number), non-local ring
1596  * 8) basering
1597  * 9) `_`
1598  * 10) everything else is of type 0
1599  */
1600 #ifdef TEST
1601  if ((*id<' ')||(*id>(char)126))
1602  {
1603  Print("wrong id :%s:\n",id);
1604  }
1605 #endif
1606  idhdl save_ring=currRingHdl;
1607  v->Init();
1608  if(pa != NULL)
1609  {
1610  v->req_packhdl = pa;
1611  }
1612  else v->req_packhdl = currPack;
1613 // if (v->req_packhdl!=basePack)
1614 // Print("search %s in %s\n",id,v->req_packhdl->libname);
1615  idhdl h=NULL;
1616 #ifdef SIQ
1617  if (siq<=0)
1618 #endif
1619  {
1620  if (!isdigit(id[0]))
1621  {
1622  if (strcmp(id,"basering")==0)
1623  {
1624  if (currRingHdl!=NULL)
1625  {
1626  if (id!=IDID(currRingHdl)) omFreeBinAddr((ADDRESS)id);
1627  h=currRingHdl;
1628  goto id_found;
1629  }
1630  else
1631  {
1632  v->name = id;
1633  return; /* undefined */
1634  }
1635  }
1636  else if (strcmp(id,"Current")==0)
1637  {
1638  if (currPackHdl!=NULL)
1639  {
1640  omFreeBinAddr((ADDRESS)id);
1641  h=currPackHdl;
1642  goto id_found;
1643  }
1644  else
1645  {
1646  v->name = id;
1647  return; /* undefined */
1648  }
1649  }
1650  if(v->req_packhdl!=currPack)
1651  {
1652  h=v->req_packhdl->idroot->get(id,myynest);
1653  }
1654  else
1655  h=ggetid(id);
1656  /* 3) existing identifier, local */
1657  if ((h!=NULL) && (IDLEV(h)==myynest))
1658  {
1659  if (id!=IDID(h)) omFreeBinAddr((ADDRESS)id); /*assume strlen(id) <1000 */
1660  goto id_found;
1661  }
1662  }
1664  {
1665  currRingHdl=NULL;
1666  }
1667  /* 4. local ring: ringvar */
1668  if ((currRingHdl!=NULL) && (IDLEV(currRingHdl)==myynest)
1669  /*&& (!yyInRingConstruction)*/)
1670  {
1671  int vnr;
1672  if ((vnr=r_IsRingVar(id, currRing->names,currRing->N))>=0)
1673  {
1674  poly p=pOne();
1675  pSetExp(p,vnr+1,1);
1676  pSetm(p);
1677  v->data = (void *)p;
1678  v->name = id;
1679  v->rtyp = POLY_CMD;
1680  return;
1681  }
1682  if((n_NumberOfParameters(currRing->cf)>0)
1683  &&((vnr=r_IsRingVar(id, (char**)n_ParameterNames(currRing->cf),
1684  n_NumberOfParameters(currRing->cf))>=0)))
1685  {
1686  BOOLEAN ok=FALSE;
1687  poly p = pmInit(id,ok);
1688  if (ok && (p!=NULL))
1689  {
1690  v->data = pGetCoeff(p);
1691  pGetCoeff(p)=NULL;
1692  pLmFree(p);
1693  v->rtyp = NUMBER_CMD;
1694  v->name = id;
1695  return;
1696  }
1697  }
1698  }
1699  /* 5. existing identifier, global */
1700  if (h!=NULL)
1701  {
1702  if (id!=IDID(h)) omFreeBinAddr((ADDRESS)id); /*assume strlen(id) <1000 */
1703  goto id_found;
1704  }
1705  /* 6. local ring: number/poly */
1706  if ((currRingHdl!=NULL) && (IDLEV(currRingHdl)==myynest))
1707  {
1708  BOOLEAN ok=FALSE;
1709  /*poly p = (!yyInRingConstruction) ? pmInit(id,ok) : (poly)NULL;*/
1710  poly p = pmInit(id,ok);
1711  if (ok)
1712  {
1713  if (p==NULL)
1714  {
1715  v->data = (void *)nInit(0);
1716  v->rtyp = NUMBER_CMD;
1717  #ifdef HAVE_PLURAL
1718  // in this case we may have monomials equal to 0 in p_Read
1719  v->name = id;
1720  #else
1721  omFreeBinAddr((ADDRESS)id);
1722  #endif
1723  }
1724  else if (pIsConstant(p))
1725  {
1726  v->data = pGetCoeff(p);
1727  pGetCoeff(p)=NULL;
1728  pLmFree(p);
1729  v->rtyp = NUMBER_CMD;
1730  v->name = id;
1731  }
1732  else
1733  {
1734  v->data = p;
1735  v->rtyp = POLY_CMD;
1736  v->name = id;
1737  }
1738  return;
1739  }
1740  }
1741  /* 7. non-local ring: number/poly */
1742  {
1743  BOOLEAN ok=FALSE;
1744  poly p = ((currRing!=NULL) /* ring required */
1745  && (currRingHdl!=NULL)
1746  /*&& (!yyInRingConstruction) - not in decl */
1747  && (IDLEV(currRingHdl)!=myynest)) /* already in case 4/6 */
1748  ? pmInit(id,ok) : (poly)NULL;
1749  if (ok)
1750  {
1751  if (p==NULL)
1752  {
1753  v->data = (void *)nInit(0);
1754  v->rtyp = NUMBER_CMD;
1755  omFreeBinAddr((ADDRESS)id);
1756  }
1757  else
1758  if (pIsConstant(p))
1759  {
1760  v->data = pGetCoeff(p);
1761  pGetCoeff(p)=NULL;
1762  pLmFree(p);
1763  v->rtyp = NUMBER_CMD;
1764  v->name = id;
1765  }
1766  else
1767  {
1768  v->data = p;
1769  v->rtyp = POLY_CMD;
1770  v->name = id;
1771  }
1772  //if (TEST_V_ALLWARN /*&& (myynest>0)*/
1773  //&& ((r_IsRingVar(id, currRing->names,currRing->N)>=0)
1774  // || ((n_NumberOfParameters(currRing->cf)>0)
1775  // &&(r_IsRingVar(id, (char**)n_ParameterNames(currRing->cf),
1776  // n_NumberOfParameters(currRing->cf))>=0))))
1777  //{
1778  //// WARNING: do not use ring variable names in procedures
1779  // Warn("use of variable >>%s<< in a procedure in line %s",id,my_yylinebuf);
1780  //}
1781  return;
1782  }
1783  }
1784  /* 8. basering ? */
1785  if ((myynest>1)&&(currRingHdl!=NULL))
1786  {
1787  if (strcmp(id,IDID(currRingHdl))==0)
1788  {
1789  if (IDID(currRingHdl)!=id) omFreeBinAddr((ADDRESS)id); /*assume strlen (id) <1000 */
1790  h=currRingHdl;
1791  goto id_found;
1792  }
1793  }
1794  if((v->req_packhdl!=basePack) && (v->req_packhdl==currPack))
1795  {
1796  h=basePack->idroot->get(id,myynest);
1797  if (h!=NULL)
1798  {
1799  if (id!=IDID(h)) omFreeBinAddr((ADDRESS)id); /*assume strlen(id) <1000 */
1800  v->req_packhdl=basePack;
1801  goto id_found;
1802  }
1803  }
1804  }
1805 #ifdef SIQ
1806  else
1807  v->rtyp=DEF_CMD;
1808 #endif
1809  /* 9: _ */
1810  if (strcmp(id,"_")==0)
1811  {
1812  omFreeBinAddr((ADDRESS)id);
1813  v->Copy(&sLastPrinted);
1814  }
1815  else
1816  {
1817  /* 10: everything else */
1818  /* v->rtyp = UNKNOWN;*/
1819  v->name = id;
1820  }
1821  currRingHdl=save_ring;
1822  return;
1823 id_found: // we have an id (in h) found, to set the data in from h
1824  if (IDTYP(h)!=ALIAS_CMD)
1825  {
1826  v->rtyp = IDHDL;
1827  v->flag = IDFLAG(h);
1828  v->attribute=IDATTR(h);
1829  }
1830  else
1831  {
1832  v->rtyp = ALIAS_CMD;
1833  }
1834  v->name = IDID(h);
1835  v->data = (char *)h;
1836  currRingHdl=save_ring;

Variable Documentation

◆ libstack_bin

omBin libstack_bin = omGetSpecBin(sizeof(libstack))

Definition at line 48 of file subexpr.cc.

◆ procinfo_bin

omBin procinfo_bin = omGetSpecBin(sizeof(procinfo))

Definition at line 47 of file subexpr.cc.

◆ siq

BOOLEAN siq =FALSE

Definition at line 53 of file subexpr.cc.

◆ size_two_bin

omBin size_two_bin = omGetSpecBin(2)
static

Definition at line 49 of file subexpr.cc.

◆ sLastPrinted

sleftv sLastPrinted

Definition at line 51 of file subexpr.cc.

◆ sleftv_bin

omBin sleftv_bin = omGetSpecBin(sizeof(sleftv))

Definition at line 46 of file subexpr.cc.

◆ sSubexpr_bin

omBin sSubexpr_bin = omGetSpecBin(sizeof(_ssubexpr))

Definition at line 45 of file subexpr.cc.

VNOETHER
Definition: grammar.cc:308
FALSE
#define FALSE
Definition: auxiliary.h:94
idCopy
ideal idCopy(ideal A)
Definition: ideals.h:59
pIsConstant
#define pIsConstant(p)
like above, except that Comp might be != 0
Definition: polys.h:223
ip_smatrix
Definition: matpol.h:13
TRACE
Definition: tok.h:209
omFree
#define omFree(addr)
Definition: omAllocDecl.h:259
pLmFree
static void pLmFree(poly p)
frees the space of the monomial m, assumes m != NULL coef is not freed, m is not advanced
Definition: polys.h:68
CRING_CMD
Definition: tok.h:55
NUMBER_CMD
Definition: grammar.cc:288
bigintmat
Definition: bigintmat.h:50
BIGINT_CMD
Definition: tok.h:37
n_long_C
complex floating point (GMP) numbers
Definition: coeffs.h:41
LIST_CMD
Definition: tok.h:117
syStrategy
ssyStrategy * syStrategy
Definition: syz.h:34
ADDRESS
void * ADDRESS
Definition: auxiliary.h:133
piCopy
procinfov piCopy(procinfov pi)
Definition: subexpr.h:147
MODUL_CMD
Definition: grammar.cc:287
STRING_CMD
Definition: tok.h:182
CNUMBER_CMD
Definition: tok.h:46
map
CanonicalForm map(const CanonicalForm &primElem, const Variable &alpha, const CanonicalForm &F, const Variable &beta)
map from to such that is mapped onto
Definition: cf_map_ext.cc:400
lCopy
lists lCopy(lists L)
Definition: lists.cc:31
yyInRingConstruction
BOOLEAN yyInRingConstruction
Definition: grammar.cc:172
NONE
#define NONE
Definition: tok.h:218
paCopy
package paCopy(package pack)
Definition: ipid.h:42
cf
CanonicalForm cf
Definition: cfModGcd.cc:4024
sBucketDeleteAndDestroy
void sBucketDeleteAndDestroy(sBucket_pt *bucket_pt)
Definition: sbuckets.cc:110
MAX_TOK
Definition: tok.h:215
rKill
void rKill(ring r)
Definition: ipshell.cc:6118
procinfo
Definition: subexpr.h:52
omStrDup
#define omStrDup(s)
Definition: omAllocDecl.h:261
bimCopy
bigintmat * bimCopy(const bigintmat *b)
same as copy constructor - apart from it being able to accept NULL as input
Definition: bigintmat.cc:405
n_Delete
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition: coeffs.h:454
VMAXMULT
Definition: grammar.cc:307
DEF_CMD
Definition: tok.h:57
n_GF
\GF{p^n < 2^16}
Definition: coeffs.h:32
omAllocBin
#define omAllocBin(bin)
Definition: omAllocDecl.h:203
BIGINTMAT_CMD
Definition: grammar.cc:278
currPack
package currPack
Definition: ipid.cc:58
n_NumberOfParameters
static FORCE_INLINE int n_NumberOfParameters(const coeffs r)
Returns the number of parameters.
Definition: coeffs.h:795
sleftv
Class used for (list of) interpreter objects.
Definition: subexpr.h:81
sip_command_bin
omBin sip_command_bin
Definition: ipid.cc:46
RING_CMD
Definition: grammar.cc:281
b
CanonicalForm b
Definition: cfModGcd.cc:4044
currRingHdl
idhdl currRingHdl
Definition: ipid.cc:60
VTIMER
Definition: tok.h:207
s_internalCopy
static void * s_internalCopy(const int t, void *d)
Definition: subexpr.cc:435
MATRIX_CMD
Definition: grammar.cc:286
ANY_TYPE
#define ANY_TYPE
Definition: tok.h:29
VOICE
Definition: tok.h:210
IDLEV
#define IDLEV(a)
Definition: ipid.h:115
syCopy
syStrategy syCopy(syStrategy syzstr)
Definition: syz1.cc:1884
size_two_bin
static omBin size_two_bin
Definition: subexpr.cc:49
r_IsRingVar
int r_IsRingVar(const char *n, char **names, int N)
Definition: ring.cc:212
VMINPOLY
Definition: grammar.cc:309
VRTIMER
Definition: tok.h:208
currRing
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
maCopy
map maCopy(map theMap, const ring r)
Definition: maps.cc:33
TRUE
#define TRUE
Definition: auxiliary.h:98
i
int i
Definition: cfEzgcd.cc:125
hasFlag
#define hasFlag(A, F)
Definition: ipid.h:106
ivCopy
intvec * ivCopy(const intvec *o)
Definition: intvec.h:132
id_Delete
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
Definition: simpleideals.cc:113
INT_CMD
Definition: tok.h:95
COMMAND
#define COMMAND
Definition: tok.h:28
n_CF
?
Definition: coeffs.h:47
IDFLAG
#define IDFLAG(a)
Definition: ipid.h:114
CPOLY_CMD
Definition: tok.h:47
BOOLEAN
int BOOLEAN
Definition: auxiliary.h:85
VPRINTLEVEL
Definition: tok.h:212
PROC_CMD
Definition: grammar.cc:280
omFreeBinAddr
#define omFreeBinAddr(addr)
Definition: omAllocDecl.h:256
IDEAL_CMD
Definition: grammar.cc:284
h
static Poly * h
Definition: janet.cc:972
sBucket_pt
sBucket * sBucket_pt
Definition: sbuckets.h:14
coeffs
pOne
#define pOne()
Definition: polys.h:297
piKill
BOOLEAN piKill(procinfov pi)
Definition: ipid.cc:665
IDATTR
#define IDATTR(a)
Definition: ipid.h:117
intvec
Definition: intvec.h:16
sleftv::data
void * data
Definition: subexpr.h:87
VECTOR_CMD
Definition: grammar.cc:292
myynest
int myynest
Definition: febase.cc:40
IDTYP
#define IDTYP(a)
Definition: ipid.h:113
my_yylinebuf
char my_yylinebuf[80]
Definition: febase.cc:42
siq
BOOLEAN siq
Definition: subexpr.cc:53
sBucket
Definition: sbuckets.cc:29
n_ParameterNames
static FORCE_INLINE const char ** n_ParameterNames(const coeffs r)
Returns a (const!) pointer to (const char*) names of parameters.
Definition: coeffs.h:799
slists
Definition: lists.h:21
INTVEC_CMD
Definition: tok.h:100
INTMAT_CMD
Definition: grammar.cc:279
coeffs_BIGINT
coeffs coeffs_BIGINT
Definition: ipid.cc:51
idrec
Definition: idrec.h:33
p_Delete
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:843
ALIAS_CMD
Definition: tok.h:33
VMAXDEG
Definition: grammar.cc:306
VECHO
Definition: tok.h:205
BUCKET_CMD
Definition: grammar.cc:283
pmInit
#define pmInit(a, b)
Definition: polys.h:271
Print
#define Print
Definition: emacs.cc:79
Werror
void Werror(const char *fmt,...)
Definition: reporter.cc:188
PACKAGE_CMD
Definition: tok.h:148
sBucketCopy
sBucket_pt sBucketCopy(const sBucket_pt bucket)
Copy sBucket non-intrusive!!!
Definition: sbuckets.cc:70
assumeStdFlag
BOOLEAN assumeStdFlag(leftv h)
Definition: subexpr.cc:1557
command
ip_command * command
Definition: ipid.h:21
IDHDL
#define IDHDL
Definition: tok.h:30
n_Copy
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
Definition: coeffs.h:450
m
int m
Definition: cfEzgcd.cc:121
Variable::name
char name() const
Definition: variable.cc:122
sleftv::rtyp
int rtyp
Definition: subexpr.h:90
basePack
package basePack
Definition: ipid.cc:59
assume
#define assume(x)
Definition: mod2.h:384
sLastPrinted
sleftv sLastPrinted
Definition: subexpr.cc:51
NULL
#define NULL
Definition: omList.c:9
MAP_CMD
Definition: grammar.cc:285
VCOLMAX
Definition: tok.h:206
nCoeffName
static FORCE_INLINE char * nCoeffName(const coeffs cf)
Definition: coeffs.h:984
lists
slists * lists
Definition: mpr_numeric.h:145
pSetm
#define pSetm(p)
Definition: polys.h:254
currPackHdl
idhdl currPackHdl
Definition: ipid.cc:56
l
int l
Definition: cfEzgcd.cc:93
R
#define R
Definition: sirandom.c:26
Warn
#define Warn
Definition: emacs.cc:76
pSetExp
#define pSetExp(p, i, v)
Definition: polys.h:41
v
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
p
int p
Definition: cfModGcd.cc:4019
ggetid
idhdl ggetid(const char *n)
Definition: ipid.cc:522
s
const CanonicalForm int s
Definition: facAbsFact.cc:55
RESOLUTION_CMD
Definition: grammar.cc:290
nInit
#define nInit(i)
Definition: numbers.h:24
POLY_CMD
Definition: grammar.cc:289
Tok2Cmdname
const char * Tok2Cmdname(int tok)
Definition: gentable.cc:139
IDID
#define IDID(a)
Definition: ipid.h:116
pCopy
#define pCopy(p)
return a copy of the poly
Definition: polys.h:173
FLAG_STD
#define FLAG_STD
Definition: ipid.h:103
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
mp_Copy
matrix mp_Copy(matrix a, const ring r)
copies matrix a (from ring r to r)
Definition: matpol.cc:63
omFreeBin
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:257
TEST_V_ALLWARN
#define TEST_V_ALLWARN
Definition: options.h:139
getBlackboxStuff
blackbox * getBlackboxStuff(const int t)
return the structure to the type given by t
Definition: blackbox.cc:16
nCopy
#define nCopy(n)
Definition: numbers.h:15
LINK_CMD
Definition: tok.h:116
CMATRIX_CMD
Definition: tok.h:45
syKillComputation
void syKillComputation(syStrategy syzstr, ring r=currRing)
Definition: syz1.cc:1495
package
ip_package * package
Definition: structs.h:45
nKillChar
void nKillChar(coeffs r)
undo all initialisations
Definition: numbers.cc:511
ssyStrategy
Definition: syz.h:36
VSHORTOUT
Definition: tok.h:211
SMATRIX_CMD
Definition: grammar.cc:291
TEST_VERB_NSB
#define TEST_VERB_NSB
Definition: options.h:133