Changeset 6cc7f5 in git


Ignore:
Timestamp:
Aug 12, 2011, 5:35:41 PM (12 years ago)
Author:
Burcin Erocal <burcin@…>
Branches:
(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', 'a800fe4b3e9d37a38c5a10cc0ae9dfa0c15a4ee6')
Children:
15ff9a6aa572d653f57ec07a5a7dbca09e320c29
Parents:
45c9bd3cc75a93224a2ce248f62c450b05c2ec61
git-author:
Burcin Erocal <burcin@erocal.org>2011-08-12 17:35:41+02:00
git-committer:
Mohamed Barakat <mohamed.barakat@rwth-aachen.de>2011-11-09 13:24:02+01:00
Message:
Convert Singular/ipshell.cc to libpolys (not done).
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • Singular/ipshell.cc

    r45c9bd3 r6cc7f5  
    77*/
    88
    9 //#include <stdlib.h>
    10 #include <stdio.h>
    11 #include <string.h>
    12 #include <ctype.h>
    139#include <math.h>
    1410
     11#include <misc/options.h>
     12#include <misc/auxiliary.h>
     13#ifdef HAVE_FACTORY
     14#define SI_DONT_HAVE_GLOBAL_VARS
     15#include <factory/factory.h>
     16#endif
     17
     18#include <Singular/maps_ip.h>
    1519#include <kernel/mod2.h>
    1620#include <Singular/tok.h>
    … …  
    2125#include <kernel/febase.h>
    2226#include <polys/polys.h>
     27#include <coeffs/numbers.h>
    2328#include <polys/prCopy.h>
    2429#include <kernel/ideals.h>
    … …  
    4853#include <polys/monomials/ring.h>
    4954#include <Singular/ipshell.h>
    50 #ifdef HAVE_FACTORY
    51 #define SI_DONT_HAVE_GLOBAL_VARS
    52 #include <factory/factory.h>
    53 #endif
     55#include <polys/ext_fields/algext.h>
     56#include <coeffs/mpr_complex.h>
     57#include <coeffs/longrat.h>
     58#include <numeric/mpr_base.h>
     59#include <numeric/mpr_numeric.h>
    5460
    5561// define this if you want to use the fast_map routine for mapping ideals
    … …  
    653659    //             rPar(IDRING(r)),
    654660    //             IDRING(r)->minpoly)))
    655     if ((nMap=nSetMap(IDRING(r)))==NULL)
     661    if ((nMap=nSetMap(IDRING(r)->cf))==NULL)
    656662    {
    657663      if (rEqual(IDRING(r),currRing))
    658664      {
    659         nMap=nCopy;
     665        nMap=n_SetMap(currRing->cf, currRing->cf);
    660666      }
    661667      else
    … …  
    11971203         break;
    11981204      case BIGINT_CMD:
    1199          nlDelete(&IDNUMBER(pp),currRing);
     1205         n_Delete(&IDNUMBER(pp),currRing->cf);
    12001206         break;
    12011207      case MAP_CMD:
    … …  
    15061512  ring r = IDRING(tmp);
    15071513
    1508   r->ch    = 32003;
    1509   r->N     = 3;
     1514  r->cf->ch = 32003;
     1515  r->N      = 3;
    15101516  /*r->P     = 0; Alloc0 in idhdl::set, ipid.cc*/
    15111517  /*names*/
    … …  
    15761582  // 0: char/ cf - ring
    15771583  L->m[0].rtyp=INT_CMD;
    1578   L->m[0].data=(void *)r->ch;
     1584  L->m[0].data=(void *)r->cf->ch;
    15791585  // ----------------------------------------
    15801586  // 1: list (var)
    … …  
    16791685  {
    16801686    L->m[2].rtyp=STRING_CMD;
    1681     L->m[2].data=(void *)omStrDup(R->parameter[0]);
     1687    L->m[2].data=(void *)omStrDup(rParameter(R)[0]);
    16821688  }
    16831689  // ----------------------------------------
    … …  
    17051711  LL->Init(2);
    17061712  LL->m[0].rtyp=BIGINT_CMD;
    1707   LL->m[0].data=nlMapGMP((number) R->ringflaga);
     1713  LL->m[0].data=nlMapGMP((number) R->cf->modBase, R->cf, R->cf);
    17081714  LL->m[1].rtyp=INT_CMD;
    1709   LL->m[1].data=(void *) R->ringflagb;
     1715  LL->m[1].data=(void *) R->cf->modExponent;
    17101716  L->m[1].rtyp=LIST_CMD;
    17111717  L->m[1].data=(void *)LL;
    … …  
    17541760  else if (rIsExtension(r))
    17551761  {
    1756     if (r->extRing!=NULL)
    1757       rDecomposeCF(&(L->m[0]),r->extRing,r);
     1762    if (nCoeff_is_algExt(r->cf))
     1763      rDecomposeCF(&(L->m[0]),r->cf->extRing,r);
    17581764    else
    17591765    {
    … …  
    17621768      // char:
    17631769      Lc->m[0].rtyp=INT_CMD;
    1764       Lc->m[0].data=(void*)r->ch;
     1770      Lc->m[0].data=(void*)r->cf->ch;
    17651771      // var:
    17661772      lists Lv=(lists)omAlloc0Bin(slists_bin);
    17671773      Lv->Init(1);
    17681774      Lv->m[0].rtyp=STRING_CMD;
    1769       Lv->m[0].data=(void *)omStrDup(r->parameter[0]);
     1775      Lv->m[0].data=(void *)omStrDup(rParameter(r)[0]);
    17701776      Lc->m[1].rtyp=LIST_CMD;
    17711777      Lc->m[1].data=(void*)Lv;
    … …  
    18021808  {
    18031809    L->m[0].rtyp=INT_CMD;
    1804     L->m[0].data=(void *)r->ch;
     1810    L->m[0].data=(void *)r->cf->ch;
    18051811  }
    18061812  // ----------------------------------------
    … …  
    18851891  {
    18861892    L->m[4].rtyp=MATRIX_CMD;
    1887     L->m[4].data=(void *)mpCopy(r->GetNC()->C);
     1893    L->m[4].data=(void *)mp_Copy(r->GetNC()->C, r, r);
    18881894    L->m[5].rtyp=MATRIX_CMD;
    1889     L->m[5].data=(void *)mpCopy(r->GetNC()->D);
     1895    L->m[5].data=(void *)mp_Copy(r->GetNC()->D, r, r);
    18901896  }
    18911897  #endif
    … …  
    19031909    return;
    19041910  }
    1905   R->ch=-1;
     1911  R->cf->ch=-1;
    19061912  // ----------------------------------------
    19071913  // 1:
    … …  
    19261932  if (L->nr==2)
    19271933  {
    1928     R->P=1;
     1934    R->cf->extRing->N=1;
    19291935    if (L->m[2].rtyp!=STRING_CMD)
    19301936    {
    … …  
    19321938      return;
    19331939    }
    1934     R->parameter=(char**)omAlloc0(R->P*sizeof(char_ptr));
    1935     R->parameter[0]=omStrDup((char *)L->m[2].data);
     1940    R->cf->extRing->names=(char**)omAlloc0(rPar(R)*sizeof(char_ptr));
     1941    R->cf->extRing->names[0]=omStrDup((char *)L->m[2].data);
    19361942  }
    19371943  // ----------------------------------------
    … …  
    19451951  // 0: string: integer
    19461952  // no further entries --> Z
    1947   R->ringflaga = (int_number) omAlloc(sizeof(mpz_t));
     1953  R->cf->modBase = (int_number) omAlloc(sizeof(mpz_t));
    19481954  if (L->nr == 0)
    19491955  {
    1950     mpz_init_set_ui(R->ringflaga,0);
    1951     R->ringflagb = 1;
     1956    mpz_init_set_ui(R->cf->modBase,0);
     1957    R->cf->modExponent = 1;
    19521958  }
    19531959  // ----------------------------------------
    … …  
    19571963    if (L->m[1].rtyp!=LIST_CMD) Werror("invald data, expecting list of numbers");
    19581964    lists LL=(lists)L->m[1].data;
    1959     mpz_init(R->ringflaga);
     1965    mpz_init(R->cf->modBase);
    19601966    if ((LL->nr >= 0) && LL->m[0].rtyp == BIGINT_CMD)
    19611967    {
    1962       number ringflaga = (number) LL->m[0].data;
    1963       nlGMP(ringflaga, (number) R->ringflaga);
    1964       LL->m[0].data = (void *)ringflaga;
     1968      number modBase = (number) LL->m[0].data;
     1969      nlGMP(modBase, (number) R->cf->modBase, R->cf);
     1970      LL->m[0].data = (void *)modBase;
    19651971    }
    19661972    else if ((LL->nr >= 0) && LL->m[0].rtyp == INT_CMD)
    19671973    {
    1968       mpz_set_ui(R->ringflaga,(unsigned long) LL->m[0].data);
     1974      mpz_set_ui(R->cf->modBase,(unsigned long) LL->m[0].data);
    19691975    }
    19701976    else
    19711977    {
    1972       mpz_set_ui(R->ringflaga,0);
     1978      mpz_set_ui(R->cf->modBase,0);
    19731979    }
    19741980    if (LL->nr >= 1)
    19751981    {
    1976       R->ringflagb = (unsigned long) LL->m[1].data;
     1982      R->cf->modExponent = (unsigned long) LL->m[1].data;
    19771983    }
    19781984    else
    19791985    {
    1980       R->ringflagb = 1;
     1986      R->cf->modExponent = 1;
    19811987    }
    19821988  }
    19831989  // ----------------------------------------
    1984   if ((mpz_cmp_ui(R->ringflaga, 1) == 0) && (mpz_cmp_ui(R->ringflaga, 0) < 0))
     1990  if ((mpz_cmp_ui(R->cf->modBase, 1) == 0) && (mpz_cmp_ui(R->cf->modBase, 0) < 0))
    19851991  {
    19861992    Werror("Wrong ground ring specification (module is 1)");
    19871993    return;
    19881994  }
    1989   if (R->ringflagb < 1)
     1995  if (R->cf->modExponent < 1)
    19901996  {
    19911997    Werror("Wrong ground ring specification (exponent smaller than 1");
    … …  
    19931999  }
    19942000  // module is 0 ---> integers
    1995   if (mpz_cmp_ui(R->ringflaga, 0) == 0)
    1996   {
    1997     R->ch = 0;
    1998     R->ringtype = 4;
     2001  if (mpz_cmp_ui(R->cf->modBase, 0) == 0)
     2002  {
     2003    R->cf->ch = 0;
     2004    R->cf->ringtype = 4;
    19992005  }
    20002006  // we have an exponent
    2001   else if (R->ringflagb > 1)
    2002   {
    2003     R->ch = R->ringflagb;
    2004     if ((mpz_cmp_ui(R->ringflaga, 2) == 0) && (R->ringflagb <= 8*sizeof(NATNUMBER)))
    2005     {
    2006       /* this branch should be active for ringflagb = 2..32 resp. 2..64,
     2007  else if (R->cf->modExponent > 1)
     2008  {
     2009    R->cf->ch = R->cf->modExponent;
     2010    if ((mpz_cmp_ui(R->cf->modBase, 2) == 0) && (R->cf->modExponent <= 8*sizeof(NATNUMBER)))
     2011    {
     2012      /* this branch should be active for modExponent = 2..32 resp. 2..64,
    20072013           depending on the size of a long on the respective platform */
    2008       R->ringtype = 1;       // Use Z/2^ch
     2014      R->cf->ringtype = 1;       // Use Z/2^ch
    20092015    }
    20102016    else
    20112017    {
    2012       R->ringtype = 3;
     2018      R->cf->ringtype = 3;
    20132019    }
    20142020  }
    … …  
    20162022  else
    20172023  {
    2018     R->ringtype = 2;
    2019     R->ch = mpz_get_ui(R->ringflaga);
     2024    R->cf->ringtype = 2;
     2025    R->cf->ch = mpz_get_ui(R->cf->modBase);
    20202026  }
    20212027}
    … …  
    20382044    }
    20392045  }
    2040   for(i=0;i<R->P; i++)
     2046  for(i=0;i<rPar(R); i++)
    20412047  {
    20422048    for(j=0;j<R->N;j++)
    20432049    {
    2044       if (strcmp(R->parameter[i],R->names[j])==0)
     2050      if (strcmp(rParameter(R)[i],R->names[j])==0)
    20452051      {
    20462052        Warn("name conflict par(%d) and var(%d): `%s`, rename to `@@(%d)`",i+1,j+1,R->names[j],i+1);
    2047         omFree(R->parameter[i]);
    2048         R->parameter[i]=(char *)omAlloc(10);
    2049         sprintf(R->parameter[i],"@@(%d)",i+1);
     2053        omFree(rParameter(R)[i]);
     2054        rParameter(R)[i]=(char *)omAlloc(10);
     2055        sprintf(rParameter(R)[i],"@@(%d)",i+1);
    20502056      }
    20512057    }
    … …  
    22702276  if (L->m[0].Typ()==INT_CMD)
    22712277  {
    2272     R->ch=(int)(long)L->m[0].Data();
    2273     if (R->ch!=-1)
     2278    R->cf->ch=(int)(long)L->m[0].Data();
     2279    if (R->cf->ch!=-1)
    22742280    {
    22752281      int l=0;
    2276       if (((R->ch!=0) && (R->ch<2) && (is_gf_char=-1))
     2282      if (((R->cf->ch!=0) && (R->cf->ch<2) && (is_gf_char=-1))
    22772283      #ifndef NV_OPS
    2278       || (R->ch > 32003)
     2284      || (R->cf->ch > 32003)
    22792285      #endif
    2280       || ((l=IsPrime(R->ch))!=R->ch)
     2286      || ((l=IsPrime(R->cf->ch))!=R->cf->ch)
    22812287      )
    22822288      {
    2283         Warn("%d is invalid characteristic of ground field. %d is used.", R->ch,l);
    2284         R->ch=l;
     2289        Warn("%d is invalid characteristic of ground field. %d is used.", R->cf->ch,l);
     2290        R->cf->ch=l;
    22852291      }
    22862292    }
    … …  
    23082314      if (is_gf_char==-1)
    23092315      {
    2310         R->extRing=rCompose((lists)L->m[0].Data());
    2311         if (R->extRing==NULL)
     2316        R->cf->extRing=rCompose((lists)L->m[0].Data());
     2317        if (R->cf->extRing==NULL)
    23122318        {
    23132319          WerrorS("could not create rational function coefficient field");
    23142320          goto rCompose_err;
    23152321        }
    2316         if (R->extRing->ch>0)
    2317           R->ch= -R->extRing->ch;
     2322        if (R->cf->extRing->cf->ch>0)
     2323          R->cf->ch= -R->cf->extRing->cf->ch;
    23182324        else
    2319           R->ch=1;
    2320         R->P=R->extRing->N;
    2321         R->parameter=(char**)omAlloc0(R->P*sizeof(char_ptr));
     2325          R->cf->ch=1;
     2326        R->cf->extRing->names=(char**)omAlloc0(rPar(R)*sizeof(char_ptr));
    23222327        int i;
    2323         for(i=R->P-1;i>=0;i--)
    2324           R->parameter[i]=omStrDup(R->extRing->names[i]);
    2325         if (R->extRing->qideal!=NULL)
     2328        for(i=rPar(R)-1;i>=0;i--)
     2329          R->cf->extRing->names[i]=omStrDup(R->cf->extRing->names[i]);
     2330        if (R->cf->extRing->qideal!=NULL)
    23262331        {
    2327           if (IDELEMS(R->extRing->qideal)==1)
     2332          if (IDELEMS(R->cf->extRing->qideal)==1)
    23282333          {
    2329             R->minpoly=naInit(1,R);
     2334            R->cf->extRing->qideal->m[0]=naInit(1,R);
    23302335            lnumber n=(lnumber)R->minpoly;
    2331             n->z=R->extRing->qideal->m[0];
     2336            n->z=R->cf->extRing->qideal->m[0];
    23322337            naMinimalPoly=n->z;
    2333             R->extRing->qideal->m[0]=NULL;
    2334             idDelete(&(R->extRing->qideal));
     2338            R->cf->extRing->qideal->m[0]=NULL;
     2339            idDelete(&(R->cf->extRing->qideal));
    23352340            //redefineFunctionPointers();
    23362341          }
    … …  
    23432348      else
    23442349      { // gf-char
    2345         R->ch=fftable[is_gf_char];
    2346         R->P=1;
    2347         R->parameter=(char**)omAlloc0(1*sizeof(char_ptr));
    2348         R->parameter[0]=omStrDup((char*)((lists)(LL->m[1].Data()))->m[0].Data());
     2350        R->cf->ch=fftable[is_gf_char];
     2351        R->cf->extRing->N=1;
     2352        R->cf->extRing->names=(char**)omAlloc0(1*sizeof(char_ptr));
     2353        R->cf->extRing->names[0]=omStrDup((char*)((lists)(LL->m[1].Data()))->m[0].Data());
    23492354      }
    23502355    }
    … …  
    23722377    if (q->m[0]!=NULL)
    23732378    {
    2374       if (R->ch!=currRing->ch)
     2379      if (R->cf->ch!=currRing->cf->ch)
    23752380      {
    23762381      #if 0
    … …  
    23862391        BOOLEAN bo;
    23872392
    2388         if ((nMap=nSetMap(orig_ring))==NULL)
     2393        if ((nMap=nSetMap(orig_ring->cf))==NULL)
    23892394        {
    23902395          if (rEqual(orig_ring,currRing))
    23912396          {
    2392             nMap=nCopy;
     2397            nMap=n_SetMap(currRing->cf, currRing->cf);
    23932398          }
    23942399          else
    23952400          // Allow imap/fetch to be make an exception only for:
    23962401          if ( (rField_is_Q_a(orig_ring) &&  // Q(a..) -> Q(a..) || Q || Zp || Zp(a)
    2397             (rField_is_Q() || rField_is_Q_a() ||
    2398              (rField_is_Zp() || rField_is_Zp_a())))
     2402            (rField_is_Q(currRing) || rField_is_Q_a(currRing) ||
     2403             (rField_is_Zp(currRing) || rField_is_Zp_a(currRing))))
    23992404           ||
    24002405           (rField_is_Zp_a(orig_ring) &&  // Zp(a..) -> Zp(a..) || Zp
    … …  
    24072412              naSetChar(rInternalChar(orig_ring),orig_ring);
    24082413            else naSetChar(rInternalChar(orig_ring),orig_ring);
    2409             nSetChar(currRing);
     2414            nSetChar(currRing->cf);
    24102415            test=save_test;
    24112416          }
    … …  
    24382443        for(i=IDELEMS(q)-1; i>=0; i--)
    24392444        {
    2440           dest_id->m[i]=pPermPoly(q->m[i],perm,orig_ring,nMap,
     2445          dest_id->m[i]=p_PermPoly(q->m[i],perm,orig_ring, currRing,nMap,
    24412446                                  par_perm,par_perm_size);
    24422447          //  PrintS("map:");pWrite(dest_id->m[i]);PrintLn();
    … …  
    26542659      }
    26552660    }
    2656     if (idRankFreeModule(trueres[0]) > 0)
     2661    if (/* idRankFreeModule(trueres[0]) */ trueres[0] > 0)
    26572662      typ0 = MODUL_CMD;
    26582663    if (syzstr->weights!=NULL)
    … …  
    27512756  wFunctional = wFunctionalBuch;
    27522757  x = (int * )omAlloc(2 * (n + 1) * sizeof(int));
    2753   wCall(s, sl, x, wNsqr);
     2758  wCall(s, sl, x, wNsqr, currRing);
    27542759  for (i = n; i!=0; i--)
    27552760    (*iv)[i-1] = x[i + n + 1];
    … …  
    27782783BOOLEAN jjRESULTANT(leftv res, leftv u, leftv v, leftv w)
    27792784{
    2780   res->data=singclap_resultant((poly)u->CopyD(),(poly)v->CopyD(), (poly)w->CopyD());
     2785  res->data=singclap_resultant((poly)u->CopyD(),(poly)v->CopyD(),
     2786                  (poly)w->CopyD(), currRing);
    27812787  return errorreported;
    27822788}
    27832789BOOLEAN jjCHARSERIES(leftv res, leftv u)
    27842790{
    2785   res->data=singclap_irrCharSeries((ideal)u->Data());
     2791  res->data=singclap_irrCharSeries((ideal)u->Data(), currRing);
    27862792  return (res->data==NULL);
    27872793}
    … …  
    30313037  // ----------------------------------
    30323038
    3033   if( hasConstTerm( h ) )
     3039  if( hasConstTerm( h, currRing ) )
    30343040  {
    30353041    return  spectrumBadPoly;
    … …  
    30403046  // --------------------------------
    30413047
    3042   if( hasLinearTerm( h ) )
     3048  if( hasLinearTerm( h, currRing ) )
    30433049  {
    30443050    *L = (lists)omAllocBin( slists_bin);
    … …  
    31233129  // ------------------------------------------
    31243130
    3125   if( hasOne( stdJ ) )
     3131  if( hasOne( stdJ, currRing ) )
    31263132  {
    31273133    // -------------------------------
    … …  
    31443150  for( i=rVar(currRing); i>0; i-- )
    31453151  {
    3146     if( hasAxis( stdJ,i )==FALSE )
     3152    if( hasAxis( stdJ,i, currRing )==FALSE )
    31473153    {
    31483154      return  spectrumNotIsolated;
    … …  
    32313237
    32323238  poly    wc = ( fast==0 ? pCopy( hc ) :
    3233                ( fast==1 ? computeWC( nph,(Rational)rVar(currRing) ) :
    3234               /* fast==2 */computeWC( nph,((Rational)rVar(currRing))/(Rational)2 ) ) );
     3239               ( fast==1 ? computeWC( nph,(Rational)rVar(currRing), currRing ) :
     3240              /* fast==2 */computeWC( nph,
     3241                      ((Rational)rVar(currRing))/(Rational)2, currRing ) ) );
    32353242
    32363243  #ifdef SPECTRUM_DEBUG
    … …  
    32613268  spectrumPolyList NF( &nph );
    32623269
    3263   computeNF( stdJ,hc,wc,&NF );
     3270  computeNF( stdJ,hc,wc,&NF, currRing );
    32643271
    32653272  #ifdef SPECTRUM_DEBUG
    … …  
    33293336  //  check for a local ring
    33303337
    3331   if( !ringIsLocal( ) )
     3338  if( !ringIsLocal(currRing ) )
    33323339  {
    33333340    WerrorS( "only works for local orderings" );
    … …  
    40084015BOOLEAN loSimplex( leftv res, leftv args )
    40094016{
    4010   if ( !(rField_is_long_R()) )
     4017  if ( !(rField_is_long_R(currRing)) )
    40114018  {
    40124019    WerrorS("Ground field not implemented!");
    … …  
    41224129  int howclean= (int)(long)arg3->Data();
    41234130
    4124   if ( !(rField_is_R() ||
    4125          rField_is_Q() ||
    4126          rField_is_long_R() ||
    4127          rField_is_long_C()) )
     4131  if ( !(rField_is_R(currRing) ||
     4132         rField_is_Q(currRing) ||
     4133         rField_is_long_R(currRing) ||
     4134         rField_is_long_C(currRing)) )
    41284135  {
    41294136    WerrorS("Ground field not implemented!");
    … …  
    41314138  }
    41324139
    4133   if ( !(rField_is_R()||rField_is_long_R()||rField_is_long_C()) )
     4140  if ( !(rField_is_R(currRing) || rField_is_long_R(currRing) || \
     4141                          rField_is_long_C(currRing)) )
    41344142  {
    41354143    unsigned long int ii = (unsigned long int)arg2->Data();
    … …  
    42134221  rlist->Init( elem );
    42144222
    4215   if (rField_is_long_C())
     4223  if (rField_is_long_C(currRing))
    42164224  {
    42174225    for ( j= 0; j < elem; j++ )
    … …  
    42264234    for ( j= 0; j < elem; j++ )
    42274235    {
    4228       dummy = complexToStr( (*roots)[j], gmp_output_digits );
     4236      dummy = complexToStr( (*roots)[j], gmp_output_digits, currRing->cf );
    42294237      rlist->m[j].rtyp=STRING_CMD;
    42304238      rlist->m[j].data=(void *)dummy;
    … …  
    42844292    return TRUE;
    42854293  }
    4286   if ( !(rField_is_Q() /* ||
     4294  if ( !(rField_is_Q(currRing) /* ||
    42874295         rField_is_R() || rField_is_long_R() ||
    42884296         rField_is_long_C()*/ ) )
    … …  
    43914399  if ( v->Typ() != INT_CMD )
    43924400    return TRUE;
    4393   else if ( !(rField_is_R()||rField_is_long_R()||rField_is_long_C()) )
     4401  else if ( !(rField_is_R(currRing) || rField_is_long_R(currRing) || \
     4402                          rField_is_long_C(currRing)) )
    43944403  {
    43954404    unsigned long int ii=(unsigned long int)v->Data();
    … …  
    45234532      for ( j= 0; j < elem; j++ )
    45244533      {
    4525         if ( !rField_is_long_C() )
     4534        if ( !rField_is_long_C(currRing) )
    45264535        {
    45274536          onepoint->m[j].rtyp=STRING_CMD;
    4528           onepoint->m[j].data=(void *)complexToStr((*roots[j])[i],oprec);
     4537          onepoint->m[j].data=(void *)complexToStr((*roots[j])[i],oprec,
     4538                          currRing->cf);
    45294539        }
    45304540        else
    … …  
    48874897#ifdef HAVE_RINGS
    48884898  unsigned int ringtype = 0;
    4889   int_number ringflaga = NULL;
    4890   unsigned int ringflagb = 1;
     4899  int_number modBase = NULL;
     4900  unsigned int modExponent = 1;
    48914901#endif
    48924902  int float_len=0;
    … …  
    49304940  else if ((pn->name != NULL) && (strcmp(pn->name, "integer") == 0))
    49314941  {
    4932     ringflaga = (int_number) omAlloc(sizeof(mpz_t));
    4933     mpz_init_set_si(ringflaga, 0);
     4942    modBase = (int_number) omAlloc(sizeof(mpz_t));
     4943    mpz_init_set_si(modBase, 0);
    49344944    if ((pn->next!=NULL) && (pn->next->Typ()==INT_CMD))
    49354945    {
    4936       mpz_set_ui(ringflaga, (int)(long) pn->next->Data());
     4946      mpz_set_ui(modBase, (int)(long) pn->next->Data());
    49374947      pn=pn->next;
    49384948      if ((pn->next!=NULL) && (pn->next->Typ()==INT_CMD))
    49394949      {
    4940         ringflagb = (long) pn->next->Data();
     4950        modExponent = (long) pn->next->Data();
    49414951        pn=pn->next;
    49424952      }
    49434953      while ((pn->next!=NULL) && (pn->next->Typ()==INT_CMD))
    49444954      {
    4945         mpz_mul_ui(ringflaga, ringflaga, (int)(long) pn->next->Data());
     4955        mpz_mul_ui(modBase, modBase, (int)(long) pn->next->Data());
    49464956        pn=pn->next;
    49474957      }
    49484958    }
    4949     if ((mpz_cmp_ui(ringflaga, 1) == 0) && (mpz_cmp_ui(ringflaga, 0) < 0))
     4959    if ((mpz_cmp_ui(modBase, 1) == 0) && (mpz_cmp_ui(modBase, 0) < 0))
    49504960    {
    49514961      Werror("Wrong ground ring specification (module is 1)");
    49524962      goto rInitError;
    49534963    }
    4954     if (ringflagb < 1)
     4964    if (modExponent < 1)
    49554965    {
    49564966      Werror("Wrong ground ring specification (exponent smaller than 1");
    … …  
    49584968    }
    49594969    // module is 0 ---> integers
    4960     if (mpz_cmp_ui(ringflaga, 0) == 0)
     4970    if (mpz_cmp_ui(modBase, 0) == 0)
    49614971    {
    49624972      ch = 0;
    … …  
    49644974    }
    49654975    // we have an exponent
    4966     else if (ringflagb > 1)
    4967     {
    4968       ch = ringflagb;
    4969       if ((mpz_cmp_ui(ringflaga, 2) == 0) && (ringflagb <= 8*sizeof(NATNUMBER)))
    4970       {
    4971         /* this branch should be active for ringflagb = 2..32 resp. 2..64,
     4976    else if (modExponent > 1)
     4977    {
     4978      ch = modExponent;
     4979      if ((mpz_cmp_ui(modBase, 2) == 0) && (modExponent <= 8*sizeof(NATNUMBER)))
     4980      {
     4981        /* this branch should be active for modExponent = 2..32 resp. 2..64,
    49724982           depending on the size of a long on the respective platform */
    49734983        ringtype = 1;       // Use Z/2^ch
    … …  
    49824992    {
    49834993      ringtype = 2;
    4984       ch = mpz_get_ui(ringflaga);
     4994      ch = mpz_get_ui(modBase);
    49854995    }
    49864996  }
    … …  
    50445054  // allocated ring and set ch
    50455055  R = (ring) omAlloc0Bin(sip_sring_bin);
    5046   R->ch = ch;
     5056  R->cf->ch = ch;
    50475057#ifdef HAVE_RINGS
    5048   R->ringtype = ringtype;
    5049   R->ringflaga = ringflaga;
    5050   R->ringflagb = ringflagb;
     5058  R->cf->ringtype = ringtype;
     5059  R->cf->modBase = modBase;
     5060  R->cf->modExponent = modExponent;
    50515061#endif
    50525062  if (ch == -1)
    … …  
    50595069  if (pn!=NULL)
    50605070  {
    5061     R->P=pn->listLength();
    5062     //if ((ffChar|| (ch == 1)) && (R->P > 1))
    5063     if ((R->P > 1) && (ffChar || (ch == -1)))
     5071    R->cf->extRing->N=pn->listLength();
     5072    //if ((ffChar|| (ch == 1)) && (rPar(R) > 1))
     5073    if ((rPar(R) > 1) && (ffChar || (ch == -1)))
    50645074    {
    50655075      WerrorS("too many parameters");
    50665076      goto rInitError;
    50675077    }
    5068     R->parameter=(char**)omAlloc0(R->P*sizeof(char_ptr));
    5069     if (rSleftvList2StringArray(pn, R->parameter))
     5078    R->cf->extRing->names=(char**)omAlloc0(rPar(R)*sizeof(char_ptr));
     5079    if (rSleftvList2StringArray(pn, R->cf->extRing->names))
    50705080    {
    50715081      WerrorS("parameter expected");
    50725082      goto rInitError;
    50735083    }
    5074     if (ch>1 && !ffChar) R->ch=-ch;
    5075     else if (ch==0) R->ch=1;
     5084    if (ch>1 && !ffChar) R->cf->ch=-ch;
     5085    else if (ch==0) R->cf->ch=1;
    50765086  }
    50775087  else if (ffChar)
    … …  
    50825092  /* post-processing of field description */
    50835093  // we have short reals, but no short complex
    5084   if ((R->ch == - 1)
    5085   && (R->parameter !=NULL)
     5094  if ((R->cf->ch == - 1)
     5095  && (rParameter(R) !=NULL)
    50865096  && (R->float_len < SHORT_REAL_LENGTH))
    50875097  {
    … …  
    54115421}
    54125422
    5413 idhdl rSimpleFindHdl(ring r, idhdl root, idhdl n=NULL)
     5423idhdl rSimpleFindHdl(ring r, idhdl root, idhdl n)
    54145424{
    54155425  //idhdl next_best=NULL;

  • Singular/ipshell.h

    r45c9bd3 r6cc7f5  
    206206void rSetHdl(idhdl h);
    207207ring rInit(sleftv* pn, sleftv* rv, sleftv* ord);
     208idhdl rSimpleFindHdl(ring r, idhdl root, idhdl n=NULL);
    208209idhdl rFindHdl(ring r, idhdl n, idhdl w);
    209210void   rKill(idhdl h);

  • Singular/maps_ip.h

    r45c9bd3 r6cc7f5  
    2020ideal  idSubstPoly(ideal id, int n, poly e);
    2121ideal  idSubstPar(ideal id, int n, poly e);
     22
     23
     24/*
     25* maps the expression w to res,
     26* switch what: MAP_CMD: use theMap for mapping, N for preimage ring
     27*              //FETCH_CMD: use pOrdPoly for mapping
     28*              IMAP_CMD: use perm for mapping, N for preimage ring
     29*              default: map only poly-structures,
     30*                       use perm and par_perm, N and P,
     31*/
     32BOOLEAN maApplyFetch(int what,map theMap,leftv res, leftv w, ring preimage_r,
     33                     int *perm, int *par_perm, int P, nMapFunc nMap);
    2234#endif

  • libpolys/coeffs/longrat.h

    r45c9bd3 r6cc7f5  
    6969
    7070#ifdef HAVE_RINGS
     71number nlMapGMP(number from, const coeffs src, const coeffs dst);
    7172void     nlGMP(number &i, number n, const coeffs r);
    7273#endif

  • libpolys/polys/monomials/ring.cc

    r45c9bd3 r6cc7f5  
    7777};
    7878
    79 #define  rInternalChar(r) ((r)->cf->ch)
    8079
    8180const char * rSimpleOrdStr(int ord)

  • libpolys/polys/monomials/ring.h

    r45c9bd3 r6cc7f5  
    568568/// if m == var(i)/1 => return i,
    569569int n_IsParam(number m, const ring r);
     570
     571//#define  rInternalChar(r) ((r)->cf->ch)
     572static inline int rInternalChar(const ring r)
     573{
     574  assume(r != NULL);
     575  const coeffs C = r->cf;
     576  assume(C != NULL);
     577  return C->ch;
     578}
     579
    570580   
    571581/* R, Q, Fp: FALSE */

  • numeric/mpr_base.h

    r45c9bd3 r6cc7f5  
    1111*/
    1212
    13 #include <kernel/mpr_numeric.h>
     13#include <numeric/mpr_numeric.h>
    1414
    1515#define SNONE -1

  • numeric/mpr_numeric.h

    r45c9bd3 r6cc7f5  
    1313
    1414//-> include & define stuff
    15 #include <kernel/numbers.h>
    16 #include <kernel/mpr_global.h>
    17 #include <kernel/mpr_complex.h>
     15#include <coeffs/numbers.h>
     16#include <coeffs/mpr_global.h>
     17#include <coeffs/mpr_complex.h>
    1818
    1919// define polish mode when finding roots
Note: See TracChangeset for help on using the changeset viewer.