Changeset 1f9a84 in git


Ignore:
Timestamp:
May 5, 2011, 2:19:42 PM (13 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'd25190065115c859833252500a64cfb7b11e3a50')
Children:
750e704356a16e0d46bd540f5fe07a831a40cded
Parents:
d44974deb309558594f4d26a7d11c490304c77cf
Message:
more int division from the manual

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

Legend:

Unmodified
Added
Removed
  • Singular/LIB/atkins.lib

    rd44974d r1f9a84  
    372372  ring R=(real,k),var(1),dp;
    373373  poly f=imap(S,f);
    374   ideal I=nt_solve(f,1.1,list(k,int(intPart(k/5))));
     374  ideal I=nt_solve(f,1.1,list(k,k div 5));
    375375  number c=leadcoef(I[1]);
    376376  setring S;
     
    427427  ti=impart(t);
    428428  if(tr==-1/2){qr1=-1;}
    429   if(tr==0){qr1=1;}
    430   if((tr!=-1/2)&&(tr!=0))
    431   {
    432     tr=tr-round(tr);
    433     qr1=expo(2*i*pi*tr,10*k);
     429  else
     430  {
     431    if(tr==0){qr1=1;}
     432    else
     433    {
     434      tr=tr-round(tr);
     435      qr1=expo(2*i*pi*tr,10*k);
     436    }
    434437  }
    435438
     
    441444  while(n<=k)
    442445  {
    443     m1=m1+(-1)^n*(q1^(n*(3*n-1)/2)+q1^(n*(3*n+1)/2));
    444     m2=m2+(-1)^n*(q2^(n*(3*n-1)/2)+q2^(n*(3*n+1)/2));
     446    m1=m1+(-1)^n*(q1^(n*(3*n-1) div 2)+q1^(n*(3*n+1) div 2));
     447    m2=m2+(-1)^n*(q2^(n*(3*n-1) div 2)+q2^(n*(3*n+1) div 2));
    445448    n++;
    446449  }
     
    725728    {
    726729      a=random(0,p-1);
    727       B=gcd((var(1)+a)^((p-1)/2)-1,A);
     730      B=gcd((var(1)+a)^((p-1) div 2)-1,A);
    728731      C=A/B;
    729732    }
     
    820823
    821824    if(printlevel>=1) {"List H of possibly suitable discriminants will be calculated.";}
    822     H=disc(N,K/2);
     825    H=disc(N,K div 2);
    823826    if(printlevel>=1) {"H = "+string(H);pause();"";}
    824827
  • Singular/LIB/bfun.lib

    rd44974d r1f9a84  
    106106  int i;
    107107  def save = basering;
    108   int n = nvars(save)/2;
     108  int n = nvars(save) div 2;
    109109  if (nrows(u)<>n || nrows(v)<>n)
    110110  {
     
    16381638  int i;
    16391639  def save = basering;
    1640   int n = nvars(save)/2;
     1640  int n = nvars(save) div 2;
    16411641  int whichengine = 0; // default
    16421642  int methodord   = 0; // default
  • Singular/LIB/cisimplicial.lib

    rd44974d r1f9a84  
    5151   {
    5252      answer[1] = 1;
    53           answer[2] = 0;
    54           return (answer);
     53      answer[2] = 0;
     54      return (answer);
    5555   }
    5656
     
    7070   {
    7171      s = 0;
    72           for (i = 1; i <= nrows(A); i++)
     72      for (i = 1; i <= nrows(A); i++)
    7373      {
    7474          if ((v[i] == 0)&&(A[i,j] != 0))
    7575          {
    7676             // it is not multiple of A_j
    77                          break;
    78                   }
    79                   if (v[i] != 0)
    80                   {
    81                      if (A[i,j] == 0)
    82                          {
    83                             // it is not multiple of A_j
    84                             break;
    85                          }
    86                          if (s == 0)
    87                          {
    88                             s = v[i] / A[i,j];
    89                          }
    90                          if (v[i] != s * A[i,j])
    91                          {
    92                             break;
    93                          }
    94                   }
    95                   if (i == nrows(A))
    96                   {
    97                      answer[1] = j;
    98                      answer[2] = s;
    99                      // v = s * A_j
    100                      return (answer);
    101                   }
     77            break;
    10278          }
     79          if (v[i] != 0)
     80          {
     81            if (A[i,j] == 0)
     82            {
     83              // it is not multiple of A_j
     84              break;
     85            }
     86            if (s == 0)
     87            {
     88              s = v[i] div A[i,j];
     89            }
     90            if (v[i] != s * A[i,j])
     91            {
     92              break;
     93            }
     94      }
     95      if (i == nrows(A))
     96      {
     97        answer[1] = j;
     98        answer[2] = s;
     99        // v = s * A_j
     100        return (answer);
     101      }
     102    }
    103103   }
    104104
     
    149149      {
    150150         // ---- n is multiple of v[i]
    151          belong[i] = n / v[i];
     151         belong[i] = n div v[i];
    152152         return (belong);
    153153      }
     
    173173         {
    174174            // ---- n belongs to the semigroup generated by v,
    175             belong[cambio[1]] = (n - PartialSum) / w[1];
     175            belong[cambio[1]] = (n - PartialSum) div w[1];
    176176            for (j = 2; j <= num; j++)
    177177            {
     
    269269      for (j = 1; j <= nrows(v); j++)
    270270      {
    271          counters[j] = v[j] / d[j];
     271         counters[j] = v[j] div d[j];
    272272      }
    273273      return(counters);
     
    329329         if (A[j,i] > 0)
    330330         {
    331             order[i] = lcm(order[i], d[j] / gcd(A[j,i],d[j]));
     331            order[i] = lcm(order[i], d[j] div gcd(A[j,i],d[j]));
    332332         }
    333333      }
     
    390390               for (k = 1; k <= nrows(v); k++)
    391391               {
    392                   counters[k] = v[k] / d[k];
     392                  counters[k] = v[k] div d[k];
    393393               }
    394394               for (k = nrows(v) + 1; k <= nrows(counters2); k++)
     
    620620         {
    621621            gcdiv = extgcd(A[i,i],A[i,k]);
    622             coef1 = A[i,k] / gcdiv[1];
    623             coef2 = A[i,i] / gcdiv[1];
     622            coef1 = A[i,k] div gcdiv[1];
     623            coef2 = A[i,i] div gcdiv[1];
    624624            for (l = i; l <= nrows(A); l++)
    625625            {
     
    965965          if (A[j,i] > 0)
    966966          {
    967              order[i] = lcm(order[i], d[j] / gcd(A[j,i],d[j]));
     967             order[i] = lcm(order[i], d[j] div gcd(A[j,i],d[j]));
    968968          }
    969969       }
     
    16061606                     int dp;
    16071607                     dp = gcd(B[k,i], B[k,j]);
    1608                      int factor = B[k,i] / dp;
     1608                     int factor = B[k,i] div dp;
    16091609                     B[k,i] = dp;
    16101610                     k++;
  • Singular/LIB/crypto.lib

    rd44974d r1f9a84  
    10881088      for(l=1;l<=k;l++)
    10891089      {
    1090          y=y*B[l]^(v[l]/2) mod n;
     1090         y=y*B[l]^(v[l] div 2) mod n;
    10911091      }
    10921092      d=gcdN(x-y,n);
     
    15841584"
    15851585{
    1586    poly f;
    1587    if(m==0){return(f);}
    1588    if(m==1){return(1);}
    1589    if(m==2){f=2*var(1);return(f);}
    1590    if(m==3){f=3*var(2)^4+6*a*var(2)^2+12*b*var(2)-a^2;return(f);}
     1586   if(m==0){return(poly(0));}
     1587   if(m==1){return(poly(1));}
     1588   if(m==2){return(2*var(1));}
     1589   if(m==3){return(3*var(2)^4+6*a*var(2)^2+12*b*var(2)-a^2);}
    15911590   if(m==4)
    15921591   {
    1593       f=4*var(1)*(var(2)^6+5*a*var(2)^4+20*b*var(2)^3-5*a^2*var(2)^2
    1594         -4*a*b*var(2)-8*b^2-a^3);
    1595       return(f);
     1592      return(4*var(1)*(var(2)^6+5*a*var(2)^4+20*b*var(2)^3-5*a^2*var(2)^2
     1593        -4*a*b*var(2)-8*b^2-a^3));
    15961594   }
    15971595   if((m mod 2)==0)
    15981596   {
    1599       f=(generateG(a,b,m/2+2)*generateG(a,b,m/2-1)^2
    1600         -generateG(a,b,m/2-2)*generateG(a,b,m/2+1)^2)
    1601         *generateG(a,b,m/2)/(2*var(1));
    1602       return(f);
    1603    }
    1604    f=generateG(a,b,(m-1)/2+2)*generateG(a,b,(m-1)/2)^3
    1605      -generateG(a,b,(m-1)/2-1)*generateG(a,b,(m-1)/2+1)^3;
    1606    return(f);
     1597      return((generateG(a,b,m div 2+2)*generateG(a,b,m div 2-1)^2
     1598        -generateG(a,b,m div 2-2)*generateG(a,b,m div 2+1)^2)
     1599        *generateG(a,b,m div 2)/(2*var(1)));
     1600   }
     1601   return(generateG(a,b,(m-1) div 2+2)*generateG(a,b,(m-1) div 2)^3
     1602     -generateG(a,b,(m-1) div 2-1)*generateG(a,b,(m-1) div 2+1)^3);
    16071603}
    16081604example
     
    17841780      pause();
    17851781   }
    1786    while(t<(l-1)/2)
     1782   while(t<(l-1) div 2)
    17871783   {
    17881784      t++;
  • Singular/LIB/dmodapp.lib

    rd44974d r1f9a84  
    210210  // wrong sequence of vars
    211211  int i,n;
    212   n = nvars(basering)/2;
     212  n = nvars(basering) div 2;
    213213  for (i=1; i<=n; i++)
    214214  {
     
    920920  setring @R2;
    921921  // now supply with Weyl algebra relations
    922   int N = nvars(@R2)/2;
     922  int N = nvars(@R2) div 2;
    923923  matrix @D[2*N][2*N];
    924924  for(i=1; i<=N; i++)
     
    12591259    def @R4@ = ring(L);
    12601260    setring @R4@;
    1261     int N = Nnew/2;
     1261    int N = Nnew div 2;
    12621262    matrix @D[Nnew][Nnew];
    12631263    for (i=1; i<=N; i++)
     
    15701570  int ppl = printlevel - voice +2;
    15711571  def save = basering;
    1572   int n = nvars(save)/2;
     1572  int n = nvars(save) div 2;
    15731573  int whichengine = 0;           // default
    15741574  int methodord   = 0;           // default
     
    19921992  int ppl = printlevel;
    19931993  int i,j,k;
    1994   int n = nvars(basering)/2;
     1994  int n = nvars(basering) div 2;
    19951995  if (w == 0:size(w))
    19961996  {
     
    21222122// returns ring, which contains module "str"
    21232123{
    2124   int n = nvars(basering)/2;
     2124  int n = nvars(basering) div 2;
    21252125  int i,j;
    21262126  def save = basering;
     
    23792379    }
    23802380  }
    2381   int n = nvars(basering)/2;
     2381  int n = nvars(basering) div 2;
    23822382  int i;
    23832383  if(v <> 0:size(v))
     
    24482448    }
    24492449  }
    2450   int n = nvars(basering)/2;
     2450  int n = nvars(basering) div 2;
    24512451  int i;
    24522452  if(v <> 0:size(v))
     
    25512551  int ppl = printlevel;
    25522552  int i;
    2553   int n = nvars(basering)/2;
     2553  int n = nvars(basering) div 2;
    25542554  intvec v;
    25552555  for (i=1; i<=n; i++)
     
    26902690"
    26912691{
    2692   intvec w = 1:(nvars(basering)/2);
     2692  intvec w = 1:(nvars(basering) div 2);
    26932693  int l0,l0set,Gset;
    26942694  ideal G;
     
    27342734  int ppl = printlevel;
    27352735  int i,j;
    2736   int n = nvars(basering)/2;
     2736  int n = nvars(basering) div 2;
    27372737  intvec v;
    27382738  for (i=1; i<=n; i++)
     
    30503050  int ppl = printlevel - voice + 2;
    30513051  def save = basering;
    3052   int n = nvars(save)/2;
     3052  int n = nvars(save) div 2;
    30533053  intvec u = 0:n;
    30543054  intvec v = 1:n;
  • Singular/LIB/freegb.lib

    rd44974d r1f9a84  
    32653265{int i,j,k,r1,r2; intvec D;
    32663266 int n = attrib(basering,"lV");
    3267  k = size(V)/n; r1 = 0; r2 = 0;
     3267 k = size(V) div n; r1 = 0; r2 = 0;
    32683268 for (i=1; i<= k; i++)
    32693269  {for (j=(1+((i-1)*n)); j <= (i*n); j++)
     
    33723372 }
    33733373
    3374  d = size(cq)/n;
     3374 d = size(cq) div n;
    33753375 for (i = 1; i<= d; i++)
    33763376 {bla = cq[((i-1)*n+1)..(i*n)];
  • Singular/LIB/grobcov.lib

    rd44974d r1f9a84  
    13771377  int comment=0;
    13781378  list L=#;
    1379   for(i=1;i<=size(L)/2;i++)
     1379  for(i=1;i<=size(L) div 2;i++)
    13801380  {
    13811381    if(L[2*i-1]=="null"){N=L[2*i];}
     
    22592259    {
    22602260      comp0=compos0[r1];
    2261       if (comp0[1]<=bound/2)
     2261      if (comp0[1]<=bound div 2)
    22622262      {
    22632263        compos1=comp(comp0[1],ncols(PW1));
     
    22652265        while ((s1<=size(compos1)) and not(t))
    22662266        {
    2267           if (comp0[2]<=bound/2)
     2267          if (comp0[2]<=bound div 2)
    22682268          {
    22692269            compos2=comp(comp0[2],ncols(PW2));
     
    35413541  def W=ideal(1);
    35423542  list L=#;
    3543   for(i=1;i<=size(L)/2;i++)
     3543  for(i=1;i<=size(L) div 2;i++)
    35443544  {
    35453545    if(L[2*i-1]=="null"){N=L[2*i];}
     
    39063906  def W=ideal(1);
    39073907  list L=#;
    3908   for(i=1;i<=size(L)/2;i++)
     3908  for(i=1;i<=size(L) div 2;i++)
    39093909  {
    39103910    if(L[2*i-1]=="null"){N=L[2*i];}
     
    41164116//  def W=ideal(1);
    41174117//  list L=#;
    4118 //  for(i=1;i<=size(L)/2;i++)
     4118//  for(i=1;i<=size(L) div 2;i++)
    41194119//  {
    41204120//    if(L[2*i-1]=="null"){N=L[2*i];}
     
    49754975  int comment=0;
    49764976  list L=#;
    4977   for(i=1;i<=size(L)/2;i++)
     4977  for(i=1;i<=size(L) div 2;i++)
    49784978  {
    49794979    if(L[2*i-1]=="null"){N=L[2*i];}
     
    58205820  CGS=1;   // CGS=1 if cgsdr is to be used (default)
    58215821           // CGS=0 if buildtree is to be used instead
    5822   for(i=1;i<=size(L)/2;i++)
     5822  for(i=1;i<=size(L) div 2;i++)
    58235823  {
    58245824    if(L[2*i-1]=="can"){canop=L[2*i];}
     
    70667066  def RR=basering; list empty; int i;
    70677067  setglobalrings();
    7068   for(i=1;i<=size(L)/2;i++)
     7068  for(i=1;i<=size(L) div 2;i++)
    70697069  {
    70707070    if(L[2*i-1]=="compbas"){compbas=L[2*i];}
     
    71937193  int i; int comment=1; list L=#; ideal N; list gc; list GC; list GCA;
    71947194  int start=timer; int ni; int nw;
    7195   for(i=1;i<=size(L)/2;i++)
     7195  for(i=1;i<=size(L) div 2;i++)
    71967196  {
    71977197    if (L[2*i-1]=="comment"){comment=L[2*i];}
     
    73497349{
    73507350  int i; list L=#; int oldop=1;
    7351   for(i=1;i<=size(L)/2;i++)
     7351  for(i=1;i<=size(L) div 2;i++)
    73527352  {
    73537353    if(L[2*i-1]=="old"){oldop=L[2*i];}
     
    75317531           // outop=1 for an output as in the old library redcgs.lib
    75327532           //         in form of tree that can be transformed into Maple.
    7533   for(i=1;i<=size(LL)/2;i++)
     7533  for(i=1;i<=size(LL) div 2;i++)
    75347534  {
    75357535    if(LL[2*i-1]=="can"){canop=LL[2*i];}
  • Singular/LIB/hyperel.lib

    rd44974d r1f9a84  
    826826     }
    827827     bas=double(bas,h,f);
    828      exp=exp/2;
     828     exp=exp div 2;
    829829   }
    830830   if ( m < 0 )
  • Singular/LIB/multigrading.lib

    rd44974d r1f9a84  
    1515
    1616OVERVIEW: This library allows one to virtually add multigradings to Singular:
    17 grade multivariate polynomial rings with arbitrary (fin. gen. Abelian) groups. 
     17grade multivariate polynomial rings with arbitrary (fin. gen. Abelian) groups.
    1818For more see http://code.google.com/p/convex-singular/wiki/Multigrading
    1919For theoretical references see:
     
    425425  // And now a quick-and-dirty fix of Singular inability to handle attribs of attribs:
    426426  // For the use of a group as an attribute for multigraded rings
    427   G[3] = attrib(L, attrGroupHNF); 
     427  G[3] = attrib(L, attrGroupHNF);
    428428  G[4] = attrib(L, attrGroupSNF);
    429  
     429
    430430
    431431  attrib(G, isGroup, (1==1)); // mark it "a group"
     
    584584
    585585  isGroup(G);
    586  
     586
    587587  printGroup(G);
    588588
     
    960960
    961961
    962   def T = G[2]; 
     962  def T = G[2];
    963963
    964964  if( size(#) >= i )
     
    970970      ERROR("Sorry wrong arguments!");
    971971    }
    972    
     972
    973973    if( a == "hermite" )
    974974    {
     
    11071107                  0,1,3,4;
    11081108  setBaseMultigrading(MM);
    1109  
     1109
    11101110  module M = ideal(  xw-yz, x2z-y3, xz2-y2w, yw2-z3);
    11111111
     
    11311131  print(v);
    11321132  print(setModuleGrading(v));
    1133  
     1133
    11341134  isHomogeneous(v);
    11351135
     
    15731573  while(av[1]*bv[1] != 0)
    15741574  {
    1575     bv = bv - (bv[1] - bv[1]%av[1])/av[1] * av;
     1575    bv = bv - (bv[1] - bv[1]%av[1]) div av[1] * av;
    15761576    save = bv;
    15771577    bv = av;
     
    16641664                  -46,32,37,42,15;
    16651665  lll(m);
    1666  
     1666
    16671667  list l =
    16681668      intvec(13,25,37, 83, 294),
     
    16981698  // D;
    16991699  intvec v;
    1700   if((cc==1)||(rr==1)){
     1700  if((cc==1)||(rr==1))
     1701  {
    17011702    if(size(#)==0)
    17021703    {
    17031704      return(D);
    1704     } else
     1705    }
     1706    else
    17051707    {
    17061708      return(list(P,D,Q));
    17071709    }
    17081710  }
    1709   while(D[k+1,k+1] !=0){
    1710     if(D[k+1,k+1]%D[k,k]!=0){
     1711  while(D[k+1,k+1] !=0)
     1712  {
     1713    if(D[k+1,k+1]%D[k,k]!=0)
     1714    {
    17111715      b = D[k, k]; c = D[k+1, k+1];
    17121716      v = gcdcomb(D[k,k],D[k+1,k+1]);
    17131717      transform = unitMatrix(cc);
    17141718      transform[k+1,k] = 1;
    1715       a = -v[3]*D[k+1,k+1]/v[1];
     1719      a = -v[3]*D[k+1,k+1] div v[1];
    17161720      transform[k, k+1] = a;
    17171721      transform[k+1, k+1] = a+1;
     
    17231727      transform[k,k] = v[2];
    17241728      transform[k,k+1] = v[3];
    1725       transform[k+1,k] = -c/v[1];
    1726       transform[k+1,k+1] = b/v[1];
     1729      transform[k+1,k] = -c div v[1];
     1730      transform[k+1,k+1] = b div v[1];
    17271731      D = transform * D;
    17281732      P = transform * P;
     
    17341738    }
    17351739    k++;
    1736     if((k==rr) || (k==cc)){
     1740    if((k==rr) || (k==cc))
     1741    {
    17371742      break;
    17381743    }
    17391744  }
    17401745  //"here is the size ",size(#);
    1741   if(size(#) == 0){
     1746  if(size(#) == 0)
     1747  {
    17421748    return(D);
    1743   } else {
     1749  }
     1750  else
     1751  {
    17441752    return(list(P, D, Q));
    17451753  }
     
    18211829              v2 = A[1..rr,j];
    18221830              transform = unitMatrix(cc);
    1823               transform[j,j] = v1[row]/gcdvec[1];
     1831              transform[j,j] = v1[row] div gcdvec[1];
    18241832              transform[column, column] = gcdvec[2];
    1825               transform[column,j] = -v2[row]/gcdvec[1];
     1833              transform[column,j] = -v2[row] div gcdvec[1];
    18261834              transform[j,column] = gcdvec[3];
    18271835              q = q*transform;
     
    18401848        if(A[row, j]!=0){
    18411849          transform = unitMatrix(cc);
    1842           transform[column, j] = (-A[row,j]+A[row, j]%A[row, column])/A[row, column];
     1850          transform[column, j] = (-A[row,j]+A[row, j]%A[row, column]) div A[row, column];
    18431851          if(A[row,j]<0){
    18441852            transform[column,j]=transform[column,j]+1;}
     
    19301938  ideal I = a, b;
    19311939  print(multiDeg(I));
    1932  
     1940
    19331941  intmat m[5][2]=multiDeg(a),multiDeg(b); m=transpose(m);
    19341942
     
    19371945
    19381946  print(m);
    1939  
     1947
    19401948  areZeroElements(m);
    19411949
     
    19741982    kill a;
    19751983  }
    1976  
     1984
    19771985  if( i == 1 )
    19781986  {
     
    20012009      {
    20022010        v = H[1..r,i];
    2003         mdeg = mdeg-(mdeg[row]-mdeg[row]%v[row])/v[row]*v;
     2011        mdeg = mdeg-(mdeg[row]-mdeg[row]%v[row]) div v[row]*v;
    20042012      }
    20052013    }
     
    21982206  intmat newgrad[pp][np];
    21992207
    2200   //This will set the finest grading on the image ring. We will proceed by coarsening this grading until f becomes homogeneous. 
     2208  //This will set the finest grading on the image ring. We will proceed by coarsening this grading until f becomes homogeneous.
    22012209  for(i=1;i<=np;i++){ newgrad[p+i,i]=1;}
    22022210
     
    22162224    for(j=1;j<=n;j++){ toadd1[i,j]=oldgrad[i,j];}
    22172225  }
    2218  
     2226
    22192227  // This will make the images of homogeneous elements homogeneous, namely the variables of the preimage ring.
    22202228  for(i=1;i<=n;i++){
     
    22632271    columns=columns+ncols(newlat[k]);
    22642272  }
    2265  
     2273
    22662274  //The following is just for reducing the size of the matrices.
    22672275  gragr=hermiteNormalForm(gragr);
     
    47624770    3,6,12;
    47634771
    4764   intmat B = latticeBasis(L); 
     4772  intmat B = latticeBasis(L);
    47654773  print(B); // should result in a matrix whose columns generate the same lattice as  [1,2,3] and [0,3,6]:
    47664774
     
    48434851  // generate the same lattice as [-1,2,-1,0],[2,-3,0,1]
    48444852  intmat B = kernelLattice(LL);
    4845  
     4853
    48464854  print(B);
    48474855
     
    50715079      // we want a matrix with column operations so we transpose
    50725080      intmat BB = transpose(B);
    5073       list L = hermiteNormalForm(BB, "transform"); 
     5081      list L = hermiteNormalForm(BB, "transform");
    50745082      intmat U = transpose(L[2]);
    50755083
    5076  
     5084
    50775085      // delete rows 1 to r
    50785086      intmat Udel[nrows(U) - r][ncols(U)];
     
    52985306    2,1,
    52995307    3,2;
    5300  
     5308
    53015309  intmat D  = intInverse(C);
    53025310
     
    56015609
    56025610  // should return a (3x2)-matrix whose columns
    5603   // generate the same lattice as [1, 2, 3] and [0, 1, 2] 
     5611  // generate the same lattice as [1, 2, 3] and [0, 1, 2]
    56045612  intmat R = primitiveSpan(V);
    56055613  print(R);
     
    56115619
    56125620  // should return a (2x2)-matrix whose columns
    5613   // generate the same lattice as [1, 0] and [0, 1] 
     5621  // generate the same lattice as [1, 0] and [0, 1]
    56145622  intmat S = primitiveSpan(W);
    56155623  print(S);
  • Singular/LIB/ncalg.lib

    rd44974d r1f9a84  
    324324  for( k=1; k<=N; k++)
    325325  {
    326     ik = 1 + ((k-1)/n);
     326    ik = 1 + ((k-1) div n);
    327327    jk = k -  n*(ik-1);
    328328
    329329    for( l=k+1; l<=N; l++)
    330330    {
    331         il = 1 + ((l-1)/n);
     331        il = 1 + ((l-1) div n);
    332332        jl = l -  n*(il-1);
    333333        p = 0;
  • Singular/LIB/nctools.lib

    rd44974d r1f9a84  
    209209  {
    210210    N=N[2..size(N)]; // Deleting the zero added in the definition of N
    211     M=intmat(N,size(N)/nc,nc); // Conversion from vector to matrix
     211    M=intmat(N,size(N) div nc,nc); // Conversion from vector to matrix
    212212  }
    213213  else
     
    252252  {
    253253    T=T[2..size(T)]; // Deleting the zero added in the definition of T
    254     intmat C = intmat(T,size(T)/k,k); // Conversion from vector to matrix
     254    intmat C = intmat(T,size(T) div k,k); // Conversion from vector to matrix
    255255  }
    256256  return (C);
  • Singular/LIB/ntsolve.lib

    rd44974d r1f9a84  
    5555    int prot = printlevel-voice+2;  // prot=printlevel (default:prot=0)
    5656    if (i1 < 1){itmax = 100;}else{itmax = ipar[1];}
    57     if (i1 < 2){acc = prec/2;}else{acc = ipar[2];}
     57    if (i1 < 2){acc = prec div 2;}else{acc = ipar[2];}
    5858    if ((acc <= 0)||(acc > prec-1)){acc = prec-1;}
    5959
  • Singular/LIB/perron.lib

    rd44974d r1f9a84  
    7777      ERROR( "Wrong set of polynomials!" );
    7878    }
    79     D = D / min;
     79    D = D div min;
    8080  }
    8181  ////////////////////////////////////////////////////////////////////////
  • Singular/LIB/poly.lib

    rd44974d r1f9a84  
    809809        {
    810810           q=gcd(p,i[k]);
    811            p=p/q;
     811           p=p div q;
    812812           p=p*i[k];
    813813        }
     
    11881188  }
    11891189  N = N[2..size(N)]; // Deletes the zero added in the definition of T
    1190   intmat M=intmat(N,(size(N)/n),n); // Conversion from vector to matrix
     1190  intmat M=intmat(N,(size(N) div n),n); // Conversion from vector to matrix
    11911191  return (M);
    11921192}
  • Singular/LIB/presolve.lib

    rd44974d r1f9a84  
    10901090   {
    10911091      @L2=@L2+list("dp",0);
    1092       if ( @L2[@ii/2] != 0)
     1092      if ( @L2[@ii div 2] != 0)
    10931093      {
    10941094         @v = @l[@ii];
    10951095         for ( @jj=1; @jj<=size(@v); @jj++ )
    10961096         {
    1097            @o = @o+@L2[@ii/2 -1]+"("+string(@v[@jj])+"),";
     1097           @o = @o+@L2[@ii div 2 -1]+"("+string(@v[@jj])+"),";
    10981098         }
    10991099      }
    11001100      else
    11011101      {
    1102          @o = @o+@L2[@ii/2 -1]+"("+string(size(@l[@ii/2]))+"),";
     1102         @o = @o+@L2[@ii div 2 -1]+"("+string(size(@l[@ii div 2]))+"),";
    11031103      }
    11041104   }
     
    12641264      if ( size(m)!=0 )
    12651265      {
    1266          l = 2*(l/2)+2;
     1266         l = 2*(l div 2)+2;
    12671267         ideal a(l) = simplify(m,2);
    12681268         intvec v(l) = compress(v);
     
    13141314      vec = sort(L)[2];
    13151315      if ( n(kk) != 0 ) { vec = vec[size(vec)..1]; }
    1316       blockvec[kk/2] = vec;
     1316      blockvec[kk div 2] = vec;
    13171317      vec = sort(v(kk),vec)[1];
    13181318      varvec = varvec,vec;
  • Singular/LIB/qhmoduli.lib

    rd44974d r1f9a84  
    5555  if(size(#) > 0) { opt = #[1]; }
    5656  else { opt = 7; }
    57   if(opt / 4 > 0) { imageQ = 1; opt = opt - 4;}
     57  if(opt div 4 > 0) { imageQ = 1; opt = opt - 4;}
    5858  else { imageQ = 0; }
    5959
     
    215215  else { opt = 3; }
    216216
    217   if(opt / 2 > 0) { primaryDec = 1; opt = opt - 2; }
     217  if(opt div 2 > 0) { primaryDec = 1; opt = opt - 2; }
    218218  else { primaryDec = 0; }
    219219  if(opt > 0) { relationsQ = 1;}
     
    879879    maxSIZE = SUBSMAXSIZE / size(h);
    880880    //print(" SUBSMAXSIZE = "+string(SUBSMAXSIZE)+" exceeded by "+string(size(g)*size(h)) + ", maxSIZE = ", string(maxSIZE));
    881     nrParts = size(g) / maxSIZE + 1;
    882     partSize = size(g) / nrParts;
     881    nrParts = size(g) div maxSIZE + 1;
     882    partSize = size(g) div nrParts;
    883883    gxh = 0;  // 'g times h'
    884884    for(i = 1; i <= nrParts; i++)
     
    13561356
    13571357    parts = parts + restP;
    1358     for(i = 1; i <= n / nr[1]; i = i + 1)
     1358    for(i = 1; i <= n div nr[1]; i = i + 1)
    13591359    {
    13601360      temp = Table(string(nr[1]), "i", 1, i);
     
    13831383"
    13841384{
    1385   int c = int(b/a);
     1385  int c = b div a;
    13861386  if(c*a == b) { return(c); }
    13871387  else {return(0)}
  • Singular/LIB/random.lib

    rd44974d r1f9a84  
    433433       r2 = random(-b,b);
    434434       r2 = r2 + (r2==0)*random(-b,-1);
    435        i = i,r1*m[random(1,s/2)] + r1*m[random(s/2+1,s)];
     435       i = i,r1*m[random(1,s div 2)] + r1*m[random(s div 2+1,s)];
    436436       if ( ii < c+u )
    437437       {  r1 = random(-b,b);
     
    439439          r2 = random(-b,b);
    440440          r2 = r2 + (r2==0)*random(-b,-1);
    441           i = i,r1*m[random(1,s/2)] + r2*m[random(s/2+1,s)];
     441          i = i,r1*m[random(1,s div 2)] + r2*m[random(s div 2+1,s)];
    442442       }
    443443     }
  • Singular/LIB/reszeta.lib

    rd44974d r1f9a84  
    18401840   for(i=1;i<=size(ast_list[1]);i++)
    18411841   {
    1842       if((((Nvec[ast_list[1][i][1][1]]/d)*d)-Nvec[ast_list[1][i][1][1]]==0)&&
     1842      if((((Nvec[ast_list[1][i][1][1]] div d)*d)-Nvec[ast_list[1][i][1][1]]==0)&&
    18431843         (ast_list[1][i][2]!=0))
    18441844      {
     
    18541854   for(i=1;i<=size(ast_list[2]);i++)
    18551855   {
    1856       if((((Nvec[ast_list[2][i][1][1]]/d)*d)-Nvec[ast_list[2][i][1][1]]==0)&&
    1857          (((Nvec[ast_list[2][i][1][2]]/d)*d)-Nvec[ast_list[2][i][1][2]]==0)&&
     1856      if((((Nvec[ast_list[2][i][1][1]] div d)*d)-Nvec[ast_list[2][i][1][1]]==0)&&
     1857         (((Nvec[ast_list[2][i][1][2]] div d)*d)-Nvec[ast_list[2][i][1][2]]==0)&&
    18581858          (ast_list[2][i][2]!=0))
    18591859      {
     
    18671867   for(i=1;i<=size(ast_list[3]);i++)
    18681868   {
    1869       if((((Nvec[ast_list[3][i][1][1]]/d)*d)-Nvec[ast_list[3][i][1][1]]==0)&&
    1870          (((Nvec[ast_list[3][i][1][2]]/d)*d)-Nvec[ast_list[3][i][1][2]]==0)&&
    1871          (((Nvec[ast_list[3][i][1][3]]/d)*d)-Nvec[ast_list[3][i][1][3]]==0)&&
     1869      if((((Nvec[ast_list[3][i][1][1]] div d)*d)-Nvec[ast_list[3][i][1][1]]==0)&&
     1870         (((Nvec[ast_list[3][i][1][2]] div d)*d)-Nvec[ast_list[3][i][1][2]]==0)&&
     1871         (((Nvec[ast_list[3][i][1][3]] div d)*d)-Nvec[ast_list[3][i][1][3]]==0)&&
    18721872         (ast_list[3][i][2]!=0))
    18731873      {
     
    25922592   {
    25932593      k=L[2][i] mod d;
    2594       s=1/number((L[1][i])^(L[2][i]/d));
     2594      s=1/number((L[1][i])^(L[2][i] div d));
    25952595      if(!k){p=subst(p,t,s*t);}
    25962596   }
     
    26012601   {
    26022602      k=L[2][i] mod d;
    2603       s=(L[1][i])^(L[2][i]/d);
     2603      s=(L[1][i])^(L[2][i] div d);
    26042604      if(!k){p=subst(p,t,s*t);}
    26052605   }
  • Singular/LIB/rootsur.lib

    rd44974d r1f9a84  
    970970      }
    971971      nofzeros = 0;
    972       lastsign = temp/lastsign;
     972      lastsign = temp div lastsign;
    973973    }
    974974    i++;
  • Singular/LIB/standard.lib

    rd44974d r1f9a84  
    21172117  if(va==1)
    21182118  {
    2119     m2=drest/wwtop[1];
     2119    m2=drest div wwtop[1];
    21202120    if((m2*wwtop[1])==drest)
    21212121    {
Note: See TracChangeset for help on using the changeset viewer.