Changeset cf42ab1 in git


Ignore:
Timestamp:
Dec 6, 2000, 12:03:33 PM (23 years ago)
Author:
Hans Schönemann <hannes@…>
Branches:
(u'spielwiese', '828514cf6e480e4bafc26df99217bf2a1ed1ef45')
Children:
81d00f6c5e73ee2ae0294081b3eb6ffc9485748f
Parents:
f7dade6bf24bb053c360ca399d303c8ffa2cc6da
Message:
*hannes: ring changes don't have complete any more


git-svn-id: file:///usr/local/Singular/svn/trunk@4817 2c84dea3-7e68-4137-9b89-c4e89433aadc
Location:
Singular
Files:
29 edited

Legend:

Unmodified
Added
Removed

  • Singular/clapconv.cc

    rf7dade rcf42ab1  
    33*  Computer Algebra System SINGULAR     *
    44****************************************/
    5 // $Id: clapconv.cc,v 1.28 2000-11-03 13:02:58 Singular Exp $
     5// $Id: clapconv.cc,v 1.29 2000-12-06 11:03:08 Singular Exp $
    66/*
    77* ABSTRACT: convert data between Singular and factory
    … …  
    1616#include "clapconv.h"
    1717#include "numbers.h"
     18#include "modulop.h"
    1819#include "longalg.h"
    1920#include "polys.h"
    20 #include "modulop.h"
    2121#include "febase.h"
    2222#include "ipid.h"

  • Singular/fglm.cc

    rf7dade rcf42ab1  
    11// emacs edit mode for this file is -*- C++ -*-
    2 // $Id: fglm.cc,v 1.22 2000-09-18 09:18:57 obachman Exp $
     2// $Id: fglm.cc,v 1.23 2000-12-06 11:03:09 Singular Exp $
    33
    44/****************************************
    … …  
    171171        // both rings are qrings, now check if both quotients define the same ideal.
    172172        // check if sring->qideal is contained in dring->qideal:
    173         rSetHdl( dringHdl, TRUE );
     173        rSetHdl( dringHdl );
    174174        //nSetMap( rInternalChar(sring), sring->parameter, npar, sring->minpoly );
    175175        nSetMap( sring );
    … …  
    184184        idDelete( & sqind );
    185185        idDelete( & sqindred );
    186         rSetHdl( sringHdl, TRUE );
     186        rSetHdl( sringHdl );
    187187        if ( state != FglmOk ) return state;
    188188        // check if dring->qideal is contained in sring->qideal:
    … …  
    264264    ideal destIdeal = NULL;
    265265    idhdl sourceRingHdl = (idhdl)first->data;
    266     rSetHdl( sourceRingHdl, TRUE );
     266    rSetHdl( sourceRingHdl );
    267267    ring sourceRing = currRing;
    268268
    … …  
    289289    }
    290290    if ( currRingHdl != destRingHdl )
    291         rSetHdl( destRingHdl, TRUE );
     291        rSetHdl( destRingHdl );
    292292    switch (state) {
    293293        case FglmOk:

  • Singular/fglmzero.cc

    rf7dade rcf42ab1  
    11// emacs edit mode for this file is -*- C++ -*-
    2 // $Id: fglmzero.cc,v 1.30 2000-09-18 09:18:59 obachman Exp $
     2// $Id: fglmzero.cc,v 1.31 2000-12-06 11:03:09 Singular Exp $
    33
    44/****************************************
    … …  
    11371137
    11381138    if ( currRingHdl != sourceRingHdl )
    1139         rSetHdl( sourceRingHdl, TRUE );
     1139        rSetHdl( sourceRingHdl );
    11401140    idealFunctionals L( 100, pVariables );
    11411141    fglmok = CalculateFunctionals( sourceIdeal, L );
    11421142    if ( deleteIdeal == TRUE )
    11431143        idDelete( & sourceIdeal );
    1144     rSetHdl( destRingHdl, TRUE );
     1144    rSetHdl( destRingHdl );
    11451145    if ( fglmok == TRUE ) {
    11461146        L.map( IDRING( sourceRingHdl ) );
    … …  
    11481148    }
    11491149    if ( (switchBack == TRUE) && (currRingHdl != initialRingHdl) )
    1150         rSetHdl( initialRingHdl, TRUE );
     1150        rSetHdl( initialRingHdl );
    11511151    return fglmok;
    11521152}

  • Singular/gnumpc.cc

    rf7dade rcf42ab1  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: gnumpc.cc,v 1.13 2000-09-18 09:18:59 obachman Exp $ */
     4/* $Id: gnumpc.cc,v 1.14 2000-12-06 11:03:09 Singular Exp $ */
    55/*
    66* ABSTRACT: computations with GMP complex floating-point numbers
    … …  
    1414#include "omalloc.h"
    1515#include "numbers.h"
    16 #include "modulop.h"
    1716#include "longrat.h"
    1817

  • Singular/grammar.y

    rf7dade rcf42ab1  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: grammar.y,v 1.86 2000-11-14 16:08:23 Singular Exp $ */
     4/* $Id: grammar.y,v 1.87 2000-12-06 11:03:10 Singular Exp $ */
    55/*
    66* ABSTRACT: SINGULAR shell grammatik
    … …  
    14421442                }
    14431443              }
    1444               if (h!=NULL) rSetHdl(h,TRUE);
     1444              if (h!=NULL) rSetHdl(h);
    14451445              else
    14461446              {

  • Singular/ideals.cc

    rf7dade rcf42ab1  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: ideals.cc,v 1.115 2000-12-05 09:05:58 Singular Exp $ */
     4/* $Id: ideals.cc,v 1.116 2000-12-06 11:03:10 Singular Exp $ */
    55/*
    66* ABSTRACT - all basic methods to manipulate ideals
    … …  
    11141114
    11151115  if(syz_ring!=orig_ring)
    1116     rChangeCurrRing(orig_ring,TRUE);
     1116    rChangeCurrRing(orig_ring);
    11171117
    11181118  result = idInit(IDELEMS(temp1),rank);
    … …  
    11421142  if(syz_ring!=orig_ring)
    11431143  {
    1144     rChangeCurrRing(syz_ring,FALSE);
     1144    rChangeCurrRing(syz_ring);
    11451145    idDelete(&temp1);
    1146     rChangeCurrRing(orig_ring,TRUE);
     1146    rChangeCurrRing(orig_ring);
    11471147    rKill(syz_ring);
    11481148  }
    … …  
    12391239
    12401240  if(syz_ring!=orig_ring)
    1241     rChangeCurrRing(orig_ring,TRUE);
     1241    rChangeCurrRing(orig_ring);
    12421242
    12431243  /* interprete result ----------------------------------------*/
    … …  
    12641264  /* clean up ----------------------------------------------------*/
    12651265  if(syz_ring!=orig_ring)
    1266     rChangeCurrRing(syz_ring,FALSE);
     1266    rChangeCurrRing(syz_ring);
    12671267  idDelete(&tempstd);
    12681268  if(syz_ring!=orig_ring)
    12691269  {
    1270     rChangeCurrRing(orig_ring,TRUE);
     1270    rChangeCurrRing(orig_ring);
    12711271    rKill(syz_ring);
    12721272  }
    … …  
    13961396    idSkipZeroes(s_h3);
    13971397    s_h3->rank -= k;
    1398     rChangeCurrRing(orig_ring, TRUE);
     1398    rChangeCurrRing(orig_ring);
    13991399    s_h3 = idrMoveR_NoSort(s_h3, syz_ring);
    14001400    rKill(syz_ring);
    … …  
    14431443    if (dp_C_ring != syz_ring)
    14441444    {
    1445       rChangeCurrRing(syz_ring, TRUE);
     1445      rChangeCurrRing(syz_ring);
    14461446      rKill(dp_C_ring);
    14471447    }
    … …  
    14951495    idDelete(&s_h1);
    14961496    idSkipZeroes(s_h3);
    1497     rChangeCurrRing(orig_ring, TRUE);
     1497    rChangeCurrRing(orig_ring);
    14981498    s_h3 = idrMoveR_NoSort(s_h3, syz_ring);
    14991499    rKill(syz_ring);
    … …  
    15711571  {
    15721572    idDelete(&s_h1);
    1573     rChangeCurrRing(orig_ring,TRUE);
     1573    rChangeCurrRing(orig_ring);
    15741574  }
    15751575
    … …  
    17991799  {
    18001800    idDelete(&s_mod);
    1801     rChangeCurrRing(orig_ring,TRUE);
     1801    rChangeCurrRing(orig_ring);
    18021802    s_result = idrMoveR_NoSort(s_result, syz_ring);
    18031803    s_rest = idrMoveR_NoSort(s_rest, syz_ring);
    … …  
    20242024  {
    20252025//    pDelete(&q);
    2026     rChangeCurrRing(orig_ring,TRUE);
     2026    rChangeCurrRing(orig_ring);
    20272027    s_h3 = idrMoveR_NoSort(s_h3, syz_ring);
    20282028    rKill(syz_ring);
    … …  
    22972297  // change into the new ring
    22982298  //pChangeRing(pVariables,currRing->OrdSgn,ord,block0,block1,wv);
    2299   rChangeCurrRing(&tmpR, TRUE);
     2299  rChangeCurrRing(&tmpR);
    23002300  currRing = &tmpR;
    23012301  h = idInit(IDELEMS(h1),h1->rank);
    … …  
    23072307
    23082308  // go back to the original ring
    2309   rChangeCurrRing(origR,TRUE);
     2309  rChangeCurrRing(origR);
    23102310  i = IDELEMS(hh)-1;
    23112311  while ((i >= 0) && (hh->m[i] == NULL)) i--;
    … …  
    23272327    }
    23282328  }
    2329   rChangeCurrRing(&tmpR, FALSE);
     2329  rChangeCurrRing(&tmpR);
    23302330  idDelete(&hh);
    2331   rChangeCurrRing(origR, TRUE);
     2331  rChangeCurrRing(origR);
    23322332  idSkipZeroes(h3);
    23332333  omFree((ADDRESS)wv[0]);
    … …  
    29162916  {
    29172917    idDelete(&s_temp);
    2918     rChangeCurrRing(orig_ring,TRUE);
     2918    rChangeCurrRing(orig_ring);
    29192919  }
    29202920
    … …  
    29242924  if (syz_ring!=orig_ring)
    29252925  {
    2926     rChangeCurrRing(syz_ring,FALSE);
     2926    rChangeCurrRing(syz_ring);
    29272927    idDelete(&s_temp1);
    2928     rChangeCurrRing(orig_ring,TRUE);
     2928    rChangeCurrRing(orig_ring);
    29292929    rKill(syz_ring);
    29302930  }
    … …  
    30353035  if (syz_ring!=orig_ring)
    30363036  {
    3037     rChangeCurrRing(orig_ring,TRUE);
     3037    rChangeCurrRing(orig_ring);
    30383038    s_temp1 = idrMoveR_NoSort(s_temp1, syz_ring);
    30393039    rKill(syz_ring);

  • Singular/iparith.cc

    rf7dade rcf42ab1  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: iparith.cc,v 1.237 2000-11-27 12:52:32 Singular Exp $ */
     4/* $Id: iparith.cc,v 1.238 2000-12-06 11:03:11 Singular Exp $ */
    55
    66/*
    … …  
    16451645        BITSET save_test=test;
    16461646        naSetChar(rInternalChar(r),TRUE, r);
    1647         nSetChar(currRing,TRUE);
     1647        nSetChar(currRing);
    16481648        test=save_test;
    16491649      }

  • Singular/ipassign.cc

    rf7dade rcf42ab1  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: ipassign.cc,v 1.61 2000-10-19 15:00:13 obachman Exp $ */
     4/* $Id: ipassign.cc,v 1.62 2000-12-06 11:03:14 Singular Exp $ */
    55
    66/*
    … …  
    472472  //currRingHdl=(idhdl)res->data;
    473473  //currQuotient=qr->qideal;
    474   rSetHdl((idhdl)res->data,TRUE);
     474  rSetHdl((idhdl)res->data);
    475475  return FALSE;
    476476}

  • Singular/ipid.cc

    rf7dade rcf42ab1  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: ipid.cc,v 1.45 2000-11-14 16:04:53 obachman Exp $ */
     4/* $Id: ipid.cc,v 1.46 2000-12-06 11:03:15 Singular Exp $ */
    55
    66/*
    … …  
    506506      {
    507507        needResetRing=TRUE;
    508         rSetHdl(h,FALSE);
     508        rSetHdl(h);
    509509        /* no complete init*/
    510510      }
    … …  
    536536      if (savecurrRingHdl!=NULL)
    537537      {
    538         rSetHdl(savecurrRingHdl,TRUE);
     538        rSetHdl(savecurrRingHdl);
    539539      }
    540540      else if (savecurrRing!=NULL)
    541541      {
    542         rChangeCurrRing(savecurrRing,TRUE);
     542        rChangeCurrRing(savecurrRing);
    543543      }
    544544    }

  • Singular/iplib.cc

    rf7dade rcf42ab1  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: iplib.cc,v 1.79 2000-12-04 14:33:49 Singular Exp $ */
     4/* $Id: iplib.cc,v 1.80 2000-12-06 11:03:16 Singular Exp $ */
    55/*
    66* ABSTRACT: interpreter: LIB and help
    … …  
    483483    if (iiLocalRing[myynest]!=NULL)
    484484    {
    485       rSetHdl(rFindHdl(iiLocalRing[myynest],NULL, NULL),TRUE);
     485      rSetHdl(rFindHdl(iiLocalRing[myynest],NULL, NULL));
    486486      iiLocalRing[myynest]=NULL;
    487487      namespaceroot->next->currRing = NULL;
    … …  
    510510    if (NS_LRING!=NULL)
    511511    {
    512       rSetHdl(rFindHdl(NS_LRING,NULL, NULL),TRUE);
     512      rSetHdl(rFindHdl(NS_LRING,NULL, NULL));
    513513      NS_LRING=NULL;
    514514    }
    … …  
    582582    if (iiLocalRing[myynest]!=NULL)
    583583    {
    584       rSetHdl(rFindHdl(iiLocalRing[myynest],NULL, NULL),TRUE);
     584      rSetHdl(rFindHdl(iiLocalRing[myynest],NULL, NULL));
    585585      iiLocalRing[myynest]=NULL;
    586586    }
    … …  
    596596    if (NS_LRING!=NULL)
    597597    {
    598       rSetHdl(rFindHdl(NS_LRING,NULL, NULL),TRUE);
     598      rSetHdl(rFindHdl(NS_LRING,NULL, NULL));
    599599      NS_LRING=NULL;
    600600    }

  • Singular/ipshell.cc

    rf7dade rcf42ab1  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: ipshell.cc,v 1.57 2000-10-19 15:00:13 obachman Exp $ */
     4/* $Id: ipshell.cc,v 1.58 2000-12-06 11:03:18 Singular Exp $ */
    55/*
    66* ABSTRACT:
    … …  
    279279    && (IDRING(h)->idroot!=NULL))
    280280    {
    281       if (h!=currRingHdl) {changed=TRUE;rSetHdl(h,FALSE);}
     281      if (h!=currRingHdl) {changed=TRUE;rSetHdl(h);}
    282282      killlocals0(v,&(IDRING(h)->idroot));
    283283    }
    … …  
    293293    {
    294294      //Print("=====> Toplevel: ring %s, lev: %d:\n",IDID(h),IDLEV(h));
    295       if (h!=currRingHdl) {changed=TRUE;rSetHdl(h,FALSE);}
     295      if (h!=currRingHdl) {changed=TRUE;rSetHdl(h);}
    296296      killlocals0(v,&(IDRING(h)->idroot));
    297297    }
    … …  
    307307        {
    308308          //Print("=====> '%s': ring %s, lev: %d:\n",IDID(h),IDID(h0),IDLEV(h0));
    309           if (h0!=currRingHdl) {changed=TRUE;rSetHdl(h0,FALSE);}
     309          if (h0!=currRingHdl) {changed=TRUE;rSetHdl(h0);}
    310310          killlocals0(v,&(IDRING(h0)->idroot));
    311311        }
    … …  
    321321    currRing=NULL;
    322322    currRingHdl=NULL;
    323     if (sh!=NULL) rSetHdl(sh,TRUE);
     323    if (sh!=NULL) rSetHdl(sh);
    324324  }
    325325

  • Singular/maps.cc

    rf7dade rcf42ab1  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: maps.cc,v 1.29 2000-11-09 16:32:52 obachman Exp $ */
     4/* $Id: maps.cc,v 1.30 2000-12-06 11:03:19 Singular Exp $ */
    55/*
    66* ABSTRACT - the mapping of polynomials to other rings
    … …  
    248248
    249249  // change to new ring
    250   rChangeCurrRing(&tmpR, FALSE);
     250  rChangeCurrRing(&tmpR);
    251251  if (id==NULL)
    252252    j = 0;
    … …  
    293293
    294294  // let's get back to the original ring
    295   rChangeCurrRing(sourcering, FALSE);
     295  rChangeCurrRing(sourcering);
    296296  temp1 = idInit(5,1);
    297297  j = 0;

  • Singular/modulop.cc

    rf7dade rcf42ab1  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: modulop.cc,v 1.21 2000-11-25 20:30:19 obachman Exp $ */
     4/* $Id: modulop.cc,v 1.22 2000-12-06 11:03:20 Singular Exp $ */
    55/*
    66* ABSTRACT: numbers modulo p (<=32003)
    … …  
    212212void npSetChar(int c, ring r)
    213213{
    214   int i, w;
    215 
    216   if (c==npPrimeM) return;
    217   if (npPrimeM > 1)
    218   {
    219     omFreeSize( (ADDRESS)npExpTable,npPrimeM*sizeof(CARDINAL) );
    220     omFreeSize( (ADDRESS)npLogTable,npPrimeM*sizeof(CARDINAL) );
    221   }
     214//  int i, w;
     215
     216//  if (c==npPrimeM) return;
     217//  if (npPrimeM > 1)
     218//  {
     219//    omFreeSize( (ADDRESS)npExpTable,npPrimeM*sizeof(CARDINAL) );
     220//    omFreeSize( (ADDRESS)npLogTable,npPrimeM*sizeof(CARDINAL) );
     221//  }
    222222  if ((c>1) || (c<(-1)))
    223223  {
    … …  
    225225    else     npPrimeM = -c;
    226226    npPminus1M = npPrimeM - 1;
    227     npExpTable= (CARDINAL *)omAlloc( npPrimeM*sizeof(CARDINAL) );
    228     npLogTable= (CARDINAL *)omAlloc( npPrimeM*sizeof(CARDINAL) );
    229     omMarkAsStaticAddr(npExpTable);
    230     omMarkAsStaticAddr(npLogTable);
    231     npExpTable[0] = 1;
    232     npLogTable[1] = 0;
    233     if (npPrimeM > 2)
    234     {
    235       w = 1;
    236       loop
    237       {
    238         npLogTable[1] = 0;
    239         w++;
    240         i = 0;
    241         loop
    242         {
    243           i++;
    244           npExpTable[i] = (int)(((long)w * (long)npExpTable[i-1]) % npPrimeM);
    245           npLogTable[npExpTable[i]] = i;
    246           if (/*(i == npPrimeM - 1 ) ||*/ (npExpTable[i] == 1))
    247             break;
    248         }
    249         if (i == npPrimeM - 1)
    250           break;
    251       }
    252       npGen=w;
    253     }
    254     else
    255     {
    256       npExpTable[1] = 1;
    257       npGen=1;
    258     }
    259     // if (npGen != npExpTable[1]) Print("npGen wrong:%d, %d\n",npGen, npExpTable[1]);
     227//    npExpTable= (CARDINAL *)omAlloc( npPrimeM*sizeof(CARDINAL) );
     228//     npLogTable= (CARDINAL *)omAlloc( npPrimeM*sizeof(CARDINAL) );
     229//     omMarkAsStaticAddr(npExpTable);
     230//     omMarkAsStaticAddr(npLogTable);
     231//     memcpy(npExpTable,r->cf->npExpTable,npPrimeM*sizeof(CARDINAL));
     232//     memcpy(npLogTable,r->cf->npLogTable,npPrimeM*sizeof(CARDINAL));
     233    npExpTable=r->cf->npExpTable;
     234    npLogTable=r->cf->npLogTable;
     235    npGen = npExpTable[1];
    260236  }
    261237  else
    … …  
    273249  if ((c>1) || (c<(-1)))
    274250  {
    275     // if (r->cf->npExpTable!=NULL)
    276     //   Print("npExpTable!=NULL\n");
    277     // if (r->cf->npLogTable!=NULL)
    278     //   Print("npLogTable!=NULL\n");
    279251    if (c>1) r->cf->npPrimeM = c;
    280252    else     r->cf->npPrimeM = -c;
    … …  
    283255    r->cf->npLogTable= (CARDINAL *)omAlloc( r->cf->npPrimeM*sizeof(CARDINAL) );
    284256    r->cf->npExpTable[0] = 1;
    285     r->cf->npLogTable[1] = 0;
     257    r->cf->npLogTable[0] = 0;
    286258    if (r->cf->npPrimeM > 2)
    287259    {
    … …  
    308280    {
    309281      r->cf->npExpTable[1] = 1;
     282      r->cf->npLogTable[1] = 0;
    310283    }
    311284  }

  • Singular/mpsr.h

    rf7dade rcf42ab1  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: mpsr.h,v 1.19 2000-09-18 09:19:21 obachman Exp $ */
     4/* $Id: mpsr.h,v 1.20 2000-12-06 11:03:22 Singular Exp $ */
    55/***************************************************************
    66 *
    … …  
    100100  {
    101101#ifdef PDEBUG
    102     nSetChar(rg, TRUE);
     102    nSetChar(rg);
    103103#else
    104     nSetChar(rg, complete);
     104    nSetChar(rg);
    105105#endif
    106106    rComplete(rg);

  • Singular/mpsr_GetMisc.cc

    rf7dade rcf42ab1  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: mpsr_GetMisc.cc,v 1.22 2000-12-05 11:15:09 obachman Exp $ */
     4/* $Id: mpsr_GetMisc.cc,v 1.23 2000-12-06 11:03:22 Singular Exp $ */
    55
    66/***************************************************************
    … …  
    321321    p_SetRingOfLeftv(mlv->lv, IDRING(rh));
    322322
    323     rSetHdl(rh, TRUE);
     323    rSetHdl(rh);
    324324
    325325    if (currRing != r)
    … …  
    336336    // reset currRing for reasons explained above
    337337    if (currRingHdl != NULL) mpsr_SetCurrRing(IDRING(currRingHdl), TRUE);
    338     rSetHdl(rh, TRUE);
     338    rSetHdl(rh);
    339339    rh->next = IDROOT;
    340340    IDROOT = rh;

  • Singular/mpsr_Put.cc

    rf7dade rcf42ab1  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: mpsr_Put.cc,v 1.23 2000-12-05 11:15:09 obachman Exp $ */
     4/* $Id: mpsr_Put.cc,v 1.24 2000-12-06 11:03:22 Singular Exp $ */
    55
    66/***************************************************************
    … …  
    616616        else
    617617        {
    618           rSetHdl(h, TRUE);
     618          rSetHdl(h);
    619619          r = IDRING(h);
    620620          h2 = r->idroot;
    … …  
    659659  MP_EndMsg(link);
    660660  omFreeBin(lv, sleftv_bin);
    661   if (rh != NULL && rh != currRingHdl) rSetHdl(rh, TRUE);
     661  if (rh != NULL && rh != currRingHdl) rSetHdl(rh);
    662662
    663663  if (h == NULL && h2 == NULL)

  • Singular/numbers.cc

    rf7dade rcf42ab1  
    22*  Computer Algebra System SINGULAR      *
    33*****************************************/
    4 /* $Id: numbers.cc,v 1.29 2000-12-01 15:41:31 Singular Exp $ */
     4/* $Id: numbers.cc,v 1.30 2000-12-06 11:03:24 Singular Exp $ */
    55
    66/*
    … …  
    9696* init nDelete    for characteristic c (complete==FALSE)
    9797*/
    98 void nSetChar(ring r, BOOLEAN complete)
     98void nSetChar(ring r)
    9999{
    100100  int c=rInternalChar(r);
    101101
    102   if (complete)
    103   {
    104     nChar=c;
    105   }
     102  nChar=c;
    106103#ifdef LDEBUG
    107104  nDBDelete= r->cf->nDBDelete;
    … …  
    111108  if (rField_is_Extension(r))
    112109  {
    113     naSetChar(c,complete,r);
    114     if (complete)
    115     {
    116       test |= Sy_bit(OPT_INTSTRATEGY); /*intStrategy*/
    117       test &= ~Sy_bit(OPT_REDTAIL); /*noredTail*/
    118     }
     110    naSetChar(c,TRUE,r);
     111    test |= Sy_bit(OPT_INTSTRATEGY); /*intStrategy*/
     112    test &= ~Sy_bit(OPT_REDTAIL); /*noredTail*/
    119113  }
    120114  else if (rField_is_Q(r))
    121115  {
    122     if (complete)
    123     {
    124       test |= Sy_bit(OPT_INTSTRATEGY); /*26*/
    125     }
     116    test |= Sy_bit(OPT_INTSTRATEGY); /*26*/
    126117  }
    127118  else if (rField_is_Zp(r))
    128119  /*----------------------char. p----------------*/
    129120  {
    130     if (complete)
    131     {
    132       npSetChar(c, r);
    133       test &= ~Sy_bit(OPT_INTSTRATEGY); /*26*/
    134     }
     121    npSetChar(c, r);
     122    test &= ~Sy_bit(OPT_INTSTRATEGY); /*26*/
    135123  }
    136124  /* -------------- GF(p^m) -----------------------*/
    137125  else if (rField_is_GF(r))
    138126  {
    139     if (complete)
    140     {
    141       test &= ~Sy_bit(OPT_INTSTRATEGY); /*26*/
    142       nfSetChar(c,r->parameter);
    143     }
     127    test &= ~Sy_bit(OPT_INTSTRATEGY); /*26*/
     128    nfSetChar(c,r->parameter);
    144129  }
    145130  /* -------------- R -----------------------*/
    … …  
    164149  }
    165150#endif
    166   if(complete)
    167   {
    168     nNew   = r->cf->nNew;
    169     nNormalize=r->cf->nNormalize;
    170     nInit  = r->cf->nInit;
    171     nPar   = r->cf->nPar;
    172     nParDeg= r->cf->nParDeg;
    173     nInt   = r->cf->nInt;
    174     nAdd   = r->cf->nAdd;
    175     nSub   = r->cf->nSub;
    176     nMult  = r->cf->nMult;
    177     nDiv   = r->cf->nDiv;
    178     nExactDiv= r->cf->nExactDiv;
    179     nIntDiv= r->cf->nIntDiv;
    180     nIntMod= r->cf->nIntMod;
    181     nNeg   = r->cf->nNeg;
    182     nInvers= r->cf->nInvers;
    183     nCopy  = r->cf->nCopy;
    184     nGreater = r->cf->nGreater;
    185     nEqual = r->cf->nEqual;
    186     nIsZero = r->cf->nIsZero;
    187     nIsOne = r->cf->nIsOne;
    188     nIsMOne = r->cf->nIsMOne;
    189     nGreaterZero = r->cf->nGreaterZero;
    190     nWrite = r->cf->nWrite;
    191     nRead = r->cf->nRead;
    192     nPower = r->cf->nPower;
    193     nGcd  = r->cf->nGcd;
    194     nLcm  = r->cf->nLcm;
    195     nSetMap = r->cf->nSetMap;
    196     nName= r->cf->nName;
    197     nSize  = r->cf->nSize;
    198     nGetDenom = r->cf->nGetDenom;
    199 #ifdef LDEBUG
    200     nDBTest=r->cf->nDBTest;
    201 #endif
    202     if (!errorreported) nNULL=r->cf->nNULL;
    203   }
     151  nNew   = r->cf->nNew;
     152  nNormalize=r->cf->nNormalize;
     153  nInit  = r->cf->nInit;
     154  nPar   = r->cf->nPar;
     155  nParDeg= r->cf->nParDeg;
     156  nInt   = r->cf->nInt;
     157  nAdd   = r->cf->nAdd;
     158  nSub   = r->cf->nSub;
     159  nMult  = r->cf->nMult;
     160  nDiv   = r->cf->nDiv;
     161  nExactDiv= r->cf->nExactDiv;
     162  nIntDiv= r->cf->nIntDiv;
     163  nIntMod= r->cf->nIntMod;
     164  nNeg   = r->cf->nNeg;
     165  nInvers= r->cf->nInvers;
     166  nCopy  = r->cf->nCopy;
     167  nGreater = r->cf->nGreater;
     168  nEqual = r->cf->nEqual;
     169  nIsZero = r->cf->nIsZero;
     170  nIsOne = r->cf->nIsOne;
     171  nIsMOne = r->cf->nIsMOne;
     172  nGreaterZero = r->cf->nGreaterZero;
     173  nWrite = r->cf->nWrite;
     174  nRead = r->cf->nRead;
     175  nPower = r->cf->nPower;
     176  nGcd  = r->cf->nGcd;
     177  nLcm  = r->cf->nLcm;
     178  nSetMap = r->cf->nSetMap;
     179  nName= r->cf->nName;
     180  nSize  = r->cf->nSize;
     181  nGetDenom = r->cf->nGetDenom;
     182#ifdef LDEBUG
     183  nDBTest=r->cf->nDBTest;
     184#endif
     185  if (!errorreported) nNULL=r->cf->nNULL;
    204186}
    205187

  • Singular/numbers.h

    rf7dade rcf42ab1  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: numbers.h,v 1.19 2000-12-01 15:21:35 Singular Exp $ */
     6/* $Id: numbers.h,v 1.20 2000-12-06 11:03:26 Singular Exp $ */
    77/*
    88* ABSTRACT: interface to coefficient aritmetics
    … …  
    7676void nInitChar(ring r);
    7777void nKillChar(ring r);
    78 void nSetChar(ring r, BOOLEAN complete);
     78void nSetChar(ring r);
    7979
    8080#endif

  • Singular/pDebug.cc

    rf7dade rcf42ab1  
    77 *  Author:  obachman (Olaf Bachmann)
    88 *  Created: 8/00
    9  *  Version: $Id: pDebug.cc,v 1.16 2000-12-05 11:15:09 obachman Exp $
     9 *  Version: $Id: pDebug.cc,v 1.17 2000-12-06 11:03:26 Singular Exp $
    1010 *******************************************************************/
    1111
    … …  
    445445
    446446#endif // PDEBUG_CC
    447 

  • Singular/polys-impl.cc

    rf7dade rcf42ab1  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: polys-impl.cc,v 1.52 2000-10-30 13:40:24 obachman Exp $ */
     4/* $Id: polys-impl.cc,v 1.53 2000-12-06 11:03:27 Singular Exp $ */
    55
    66/***************************************************************
    … …  
    5151{
    5252  ring origRing = currRing;
    53   rChangeCurrRing(rg, FALSE);
     53  rChangeCurrRing(rg);
    5454  pDelete(p);
    55   rChangeCurrRing(origRing, FALSE);
     55  rChangeCurrRing(origRing);
    5656}
    5757

  • Singular/ring.cc

    rf7dade rcf42ab1  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: ring.cc,v 1.146 2000-11-25 13:02:09 Singular Exp $ */
     4/* $Id: ring.cc,v 1.147 2000-12-06 11:03:27 Singular Exp $ */
    55
    66/*
    … …  
    8484// complete == FALSE : only delete operations are enabled
    8585// complete == TRUE  : full reset of all variables
    86 void rChangeCurrRing(ring r, BOOLEAN complete)
     86void rChangeCurrRing(ring r)
    8787{
    8888  /*------------ set global ring vars --------------------------------*/
    … …  
    9292  {
    9393    rTest(r);
    94     if (complete)
    95     {
    96       /*------------ set global ring vars --------------------------------*/
    97       currQuotient=r->qideal;
    98       /*------------ set redTail, except reset by nSetChar or pSetGlobals */
    99       test |= Sy_bit(OPT_REDTAIL);
    100     }
     94    /*------------ set global ring vars --------------------------------*/
     95    currQuotient=r->qideal;
     96    /*------------ set redTail, except reset by nSetChar or pSetGlobals */
     97    test |= Sy_bit(OPT_REDTAIL);
    10198
    10299    /*------------ global variables related to coefficients ------------*/
    103     nSetChar(r, complete);
     100    nSetChar(r);
    104101
    105102    /*------------ global variables related to polys -------------------*/
    106     pSetGlobals(r, complete);
    107 
    108     if (complete)
    109     {
     103    pSetGlobals(r);
     104
    110105    /*------------ set naMinimalPoly -----------------------------------*/
    111       if (r->minpoly!=NULL)
    112       {
    113         naMinimalPoly=((lnumber)r->minpoly)->z;
    114       }
    115     }
    116   }
    117 }
    118 
    119 void rSetHdl(idhdl h, BOOLEAN complete)
     106    if (r->minpoly!=NULL)
     107    {
     108      naMinimalPoly=((lnumber)r->minpoly)->z;
     109    }
     110  }
     111}
     112
     113void rSetHdl(idhdl h)
    120114{
    121115  int i;
    … …  
    129123    rTest(rg);
    130124  }
    131   else complete=FALSE;
    132125
    133126  // clean up history
    … …  
    140133
    141134   /*------------ change the global ring -----------------------*/
    142   rChangeCurrRing(rg,complete);
     135  rChangeCurrRing(rg);
    143136  currRingHdl = h;
    144137}
    … …  
    189182  /* complete ring intializations */
    190183  rComplete(r);
    191   rSetHdl(tmp,TRUE);
     184  rSetHdl(tmp);
    192185  return currRingHdl;
    193186}
    … …  
    12901283        if (r2->minpoly!=NULL)
    12911284        {
    1292           nSetChar(r1,TRUE);
     1285          nSetChar(r1);
    12931286          if ((strcmp(r1->parameter[0],r2->parameter[0])==0) /* 1 char */
    12941287              && naEqual(r1->minpoly,r2->minpoly))
    … …  
    12981291            tmpR.minpoly=naCopy(r1->minpoly);
    12991292            tmpR.P=1;
    1300             nSetChar(currRing,TRUE);
     1293            nSetChar(currRing);
    13011294          }
    13021295          else
    13031296          {
    1304             nSetChar(currRing,TRUE);
     1297            nSetChar(currRing);
    13051298            WerrorS("different minpolys");
    13061299            return -1;
    … …  
    13151308            tmpR.parameter[0]=omStrDup(r1->parameter[0]);
    13161309            tmpR.P=1;
    1317             nSetChar(r1,TRUE);
     1310            nSetChar(r1);
    13181311            tmpR.minpoly=naCopy(r1->minpoly);
    1319             nSetChar(currRing,TRUE);
     1312            nSetChar(currRing);
    13201313          }
    13211314          else
    … …  
    13361329            tmpR.parameter[0]=omStrDup(r1->parameter[0]);
    13371330            tmpR.P=1;
    1338             nSetChar(r2,TRUE);
     1331            nSetChar(r2);
    13391332            tmpR.minpoly=naCopy(r2->minpoly);
    1340             nSetChar(currRing,TRUE);
     1333            nSetChar(currRing);
    13411334          }
    13421335          else
    … …  
    13901383        if (r1->minpoly!=NULL)
    13911384        {
    1392           nSetChar(r1,TRUE);
     1385          nSetChar(r1);
    13931386          tmpR.minpoly=naCopy(r1->minpoly);
    1394           nSetChar(currRing,TRUE);
     1387          nSetChar(currRing);
    13951388        }
    13961389      }
    … …  
    14161409        if (r2->minpoly!=NULL)
    14171410        {
    1418           nSetChar(r1,TRUE);
     1411          nSetChar(r1);
    14191412          tmpR.minpoly=naCopy(r2->minpoly);
    1420           nSetChar(currRing,TRUE);
     1413          nSetChar(currRing);
    14211414        }
    14221415      }
    … …  
    14511444        if (r1->minpoly!=NULL)
    14521445        {
    1453           nSetChar(r1,TRUE);
     1446          nSetChar(r1);
    14541447          tmpR.minpoly=naCopy(r1->minpoly);
    1455           nSetChar(currRing,TRUE);
     1448          nSetChar(currRing);
    14561449        }
    14571450      }
    … …  
    14801473        if (r2->minpoly!=NULL)
    14811474        {
    1482           nSetChar(r2,TRUE);
     1475          nSetChar(r2);
    14831476          tmpR.minpoly=naCopy(r2->minpoly);
    1484           nSetChar(currRing,TRUE);
     1477          nSetChar(currRing);
    14851478        }
    14861479      }
    … …  
    34573450  {
    34583451    ring old_ring = currRing;
    3459     rChangeCurrRing(r, TRUE);
     3452    rChangeCurrRing(r);
    34603453    if (old_ring->qideal != NULL)
    34613454    {
    … …  
    35433536  {
    35443537    ring old_r = currRing;
    3545     rChangeCurrRing(new_r, TRUE);
     3538    rChangeCurrRing(new_r);
    35463539    if (old_r->qideal != NULL)
    35473540    {
    … …  
    35633556    if (new_r_1 != new_r && new_r_1 != old_r) rDelete(new_r_1);
    35643557    rComplete(new_r, 1);
    3565     rChangeCurrRing(new_r, TRUE);
     3558    rChangeCurrRing(new_r);
    35663559    if (old_r->qideal != NULL)
    35673560    {
    … …  
    36093602  res->OrdSgn = 1;
    36103603  rComplete(res, 1);
    3611   rChangeCurrRing(res, TRUE);
     3604  rChangeCurrRing(res);
    36123605  return res;
    36133606}

  • Singular/ring.h

    rf7dade rcf42ab1  
    77* ABSTRACT - the interpreter related ring operations
    88*/
    9 /* $Id: ring.h,v 1.59 2000-12-05 12:14:33 obachman Exp $ */
     9/* $Id: ring.h,v 1.60 2000-12-06 11:03:29 Singular Exp $ */
    1010
    1111/* includes */
    … …  
    1616
    1717
    18 void   rChangeCurrRing(ring r, BOOLEAN complete = TRUE);
    19 void   rSetHdl(idhdl h, BOOLEAN complete = TRUE);
     18void   rChangeCurrRing(ring r);
     19void   rSetHdl(idhdl h);
    2020ring   rInit(sleftv* pn, sleftv* rv, sleftv* ord);
    2121idhdl  rDefault(char *s);

  • Singular/silink.cc

    rf7dade rcf42ab1  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: silink.cc,v 1.36 2000-09-18 09:19:33 obachman Exp $ */
     4/* $Id: silink.cc,v 1.37 2000-12-06 11:03:29 Singular Exp $ */
    55
    66/*
    … …  
    497497  if (! status ) status = DumpAsciiMaps(fd, h, NULL);
    498498
    499   if (currRingHdl != rh) rSetHdl(rh, TRUE);
     499  if (currRingHdl != rh) rSetHdl(rh);
    500500  fprintf(fd, "RETURN();\n");
    501501  fflush(fd);
    … …  
    515515  // trouble with minpoly
    516516  if (IDTYP(h) == RING_CMD || IDTYP(h) == QRING_CMD)
    517     rSetHdl(h, TRUE);
     517    rSetHdl(h);
    518518
    519519  if (DumpAsciiIdhdl(fd, h)) return TRUE;
    … …  
    545545  {
    546546    char *rhs;
    547     rSetHdl(rhdl, TRUE);
     547    rSetHdl(rhdl);
    548548    rhs = h->String();
    549549

  • Singular/sparsmat.cc

    rf7dade rcf42ab1  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: sparsmat.cc,v 1.45 2000-11-28 11:50:56 obachman Exp $ */
     4/* $Id: sparsmat.cc,v 1.46 2000-12-06 11:03:30 Singular Exp $ */
    55
    66/*
    … …  
    155155    tmpR.block1=block1;
    156156    rComplete(&tmpR,1);
    157     rChangeCurrRing(&tmpR,TRUE);
     157    rChangeCurrRing(&tmpR);
    158158    // fetch data from the old ring
    159159    II=idInit(IDELEMS(I),I->rank);
    … …  
    171171void smRingClean(ring origR, ip_sring &tmpR)
    172172{
    173   rChangeCurrRing(origR,TRUE);
     173  rChangeCurrRing(origR);
    174174  rUnComplete(&tmpR);
    175175  omFreeSize((ADDRESS)tmpR.order,3*sizeof(int));
    … …  
    216216  if (origR!=NULL)
    217217  {
    218     rChangeCurrRing(origR,TRUE);
     218    rChangeCurrRing(origR);
    219219    save = res;
    220220    res = prCopyR( save, &tmpR);
    221     rChangeCurrRing(&tmpR,FALSE);
     221    rChangeCurrRing(&tmpR);
    222222    pDelete(&save);
    223223    smRingClean(origR,tmpR);
    … …  
    260260    if (origR!=NULL)
    261261    {
    262       rChangeCurrRing(origR,TRUE);
     262      rChangeCurrRing(origR);
    263263      mm=idInit(IDELEMS(m),m->rank);
    264264      int k;
    265265      for (k=0;k<IDELEMS(m);k++) mm->m[k] = prCopyR( m->m[k], &tmpR);
    266       rChangeCurrRing(&tmpR,FALSE);
     266      rChangeCurrRing(&tmpR);
    267267      idDelete(&m);
    268268      smRingClean(origR,tmpR);
    … …  
    308308    if (origR!=NULL)
    309309    {
    310       rChangeCurrRing(origR,TRUE);
     310      rChangeCurrRing(origR);
    311311      mm=idInit(IDELEMS(m),m->rank);
    312312      int k;
    313313      for (k=0;k<IDELEMS(m);k++) mm->m[k] = prCopyR( m->m[k], &tmpR);
    314       rChangeCurrRing(&tmpR,FALSE);
     314      rChangeCurrRing(&tmpR);
    315315      idDelete(&m);
    316316      smRingClean(origR,tmpR);
    … …  
    23432343  if ((origR!=NULL) && (ss!=NULL))
    23442344  {
    2345     rChangeCurrRing(origR,TRUE);
     2345    rChangeCurrRing(origR);
    23462346    rr = idInit(IDELEMS(ss), 1);
    23472347    for (k=0;k<IDELEMS(ss);k++)
    23482348      rr->m[k] = prCopyR(ss->m[k], &tmpR);
    2349     rChangeCurrRing(&tmpR,FALSE);
     2349    rChangeCurrRing(&tmpR);
    23502350    idDelete(&ss);
    23512351    ss = rr;

  • Singular/syz.cc

    rf7dade rcf42ab1  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: syz.cc,v 1.39 2000-10-19 15:00:23 obachman Exp $ */
     4/* $Id: syz.cc,v 1.40 2000-12-06 11:03:30 Singular Exp $ */
    55
    66/*
    … …  
    586586  if (origR != syz_ring)
    587587  {
    588     rChangeCurrRing(origR, TRUE);
     588    rChangeCurrRing(origR);
    589589    for (i=0; i<=syzIndex; i++)
    590590    {

  • Singular/syz0.cc

    rf7dade rcf42ab1  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: syz0.cc,v 1.34 2000-11-14 16:05:02 obachman Exp $ */
     4/* $Id: syz0.cc,v 1.35 2000-12-06 11:03:31 Singular Exp $ */
    55/*
    66* ABSTRACT: resolutions
    … …  
    957957  if (/*ringOrderChanged:*/ origR!=syRing && syRing != NULL)
    958958  {
    959     rChangeCurrRing(origR, TRUE);
     959    rChangeCurrRing(origR);
    960960    // Thomas: Here I assume that all (!) polys of res live in tmpR
    961961    while ((syzIndex < *length) && (res[syzIndex]))

  • Singular/syz1.cc

    rf7dade rcf42ab1  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: syz1.cc,v 1.68 2000-11-14 16:05:02 obachman Exp $ */
     4/* $Id: syz1.cc,v 1.69 2000-12-06 11:03:31 Singular Exp $ */
    55/*
    66* ABSTRACT: resolutions
    … …  
    16531653
    16541654    if ((syzstr->syRing != NULL) && (syzstr->syRing != origR))
    1655       rChangeCurrRing(syzstr->syRing, FALSE);
     1655      rChangeCurrRing(syzstr->syRing);
    16561656
    16571657    if (syzstr->resPairs!=NULL)
    … …  
    17421742    if ((syzstr->syRing != NULL) && (syzstr->syRing != origR))
    17431743    {
    1744       rChangeCurrRing(origR, FALSE);
     1744      rChangeCurrRing(origR);
    17451745      rKill(syzstr->syRing);
    17461746    }
    … …  
    25592559
    25602560  assume(syzstr->syRing != NULL);
    2561   rChangeCurrRing(syzstr->syRing, TRUE);
     2561  rChangeCurrRing(syzstr->syRing);
    25622562//Print("laeufts ");
    25632563  syzstr->bucket = kBucketCreate();
    … …  
    26082608  if (syzstr->syRing != NULL)
    26092609  {
    2610     rChangeCurrRing(origR,TRUE);
     2610    rChangeCurrRing(origR);
    26112611    // Thomas: now make sure that all data which you need is pFetchCopied
    26122612    // maybe incoporate it into syReorder ??
    … …  
    27572757  kBucketDestroy(&(syzstr->bucket));
    27582758  if (origR != syzstr->syRing)
    2759     rChangeCurrRing(origR,TRUE);
     2759    rChangeCurrRing(origR);
    27602760  pDeleteLm(&redpol);
    27612761  if (TEST_OPT_PROT) PrintLn();

  • Singular/syz2.cc

    rf7dade rcf42ab1  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: syz2.cc,v 1.19 2000-10-19 15:25:42 obachman Exp $ */
     4/* $Id: syz2.cc,v 1.20 2000-12-06 11:03:32 Singular Exp $ */
    55/*
    66* ABSTRACT: resolutions
    … …  
    10841084  kBucketDestroy(&(syzstr->syz_bucket));
    10851085  if (origR != syzstr->syRing) 
    1086     rChangeCurrRing(origR,TRUE);
     1086    rChangeCurrRing(origR);
    10871087  else
    10881088    currRing =  origR;

  • Singular/syz3.cc

    rf7dade rcf42ab1  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: syz3.cc,v 1.5 2000-09-18 09:19:37 obachman Exp $ */
     4/* $Id: syz3.cc,v 1.6 2000-12-06 11:03:33 Singular Exp $ */
    55/*
    66* ABSTRACT: resolutions
    … …  
    18971897          omFreeSize((ADDRESS)res,len*sizeof(ideal));
    18981898          idDelete(&initial);
    1899           rChangeCurrRing(syzstr->syRing, TRUE);
     1899          rChangeCurrRing(syzstr->syRing);
    19001900          rKill(dp_C_ring);
    19011901        }
    … …  
    20172017  if (origR!=syzstr->syRing)
    20182018  {
    2019     rChangeCurrRing(origR,TRUE);
     2019    rChangeCurrRing(origR);
    20202020    index = 0;
    20212021    while ((index<=*length) && (syzstr->fullres[index]!=NULL))
Note: See TracChangeset for help on using the changeset viewer.