Changeset 85ba0a in git for Singular

Timestamp:

May 4, 2011, 4:45:40 PM (13 years ago)

Author:

Hans Schoenemann <hannes@…>

Branches:

(u'spielwiese', '2a584933abf2a2d3082034c7586d38bb6de1a30a')

Children:

1396fe648a0f4205e55e98d2dae5d30cb1b6163c

Parents:

4173c743f8fca0f499b55fc60e21623199cb2dac

Message:

use div instead of /, part 2


git-svn-id: file:///usr/local/Singular/svn/trunk@14192 2c84dea3-7e68-4137-9b89-c4e89433aadc

Location:

Singular/LIB

Files:

• brnoeth.lib (modified) (2 diffs)
• classify.lib (modified) (15 diffs)
• dmod.lib (modified) (7 diffs)
• equising.lib (modified) (1 diff)
• finvar.lib (modified) (1 diff)
• mondromy.lib (modified) (1 diff)
• monomialideal.lib (modified) (1 diff)
• nctools.lib (modified) (1 diff)
• primdec.lib (modified) (1 diff)
• tst.lib (modified) (1 diff)

Singular/LIB/brnoeth.lib

@@ -4398 +4398 @@
   int m=deg_D(G,Places);
   int genusX=EC[2][2];
-  int e=(m+1-3*genusX)/2;
+  int e=(m+1-3*genusX) div 2;
   if (e<1)
   {
@@ -4559 +4559 @@
       // on the other hand, if Hamming_wt(sol) is too large the decoding may
       //     not be acceptable
-      if ( Hamming_wt(sol) <= (K[n+3][2]-1)/2 )
+      if ( Hamming_wt(sol) <= (K[n+3][2]-1) div 2 )
       {
         option(set,opgt);

Singular/LIB/classify.lib

@@ -1954 +1954 @@
 "USAGE:    parity()"
 {
-  int r = e/2;
+  int r = e div 2;
   if( 2*r == e ) { return(0); }
   return(1);
@@ -2000 +2000 @@
     if( parity(sg[2])) { // sg[2] ist ungerade
       if(sg[2]<=sg[3]) {
-        k = (sg[2]+1)/2;
+        k = (sg[2]+1) div 2;
         if(k>1) {
           cnt++;
@@ -2007 +2007 @@
       }
       if(sg[2]==sg[3]+2) {                              // E[6k+2]
-        k = (sg[2]-1)/2;
+        k = (sg[2]-1) div 2;
         if(k>0) {cnt++; SG_Typ=SG_Typ+" E[6k+2]=E[" + string(6*k+2) + "]"; }
       }
@@ -2013 +2013 @@
     else {              // sg[2] ist gerade
       if( sg[2] == sg[3]+1) {                           // E[6k]
-        k = sg[2]/2; cnt++; SG_Typ=SG_Typ + " E[6k]=E[" + string(6*k) + "]"; }
+        k = sg[2] div 2; cnt++; SG_Typ=SG_Typ + " E[6k]=E[" + string(6*k) + "]"; }
       if( sg[2] == sg[3]) {                             // E[6k+1]
-        k=sg[2]/2; cnt++; SG_Typ=SG_Typ+" E[6k+1]=E["+string(6*k+1)+"]"; }
+        k=sg[2] div 2; cnt++; SG_Typ=SG_Typ+" E[6k+1]=E["+string(6*k+1)+"]"; }
     }
   }
@@ -2044 +2044 @@
   debug_log(2, "entering HKclass5_teil_1", sg);
   if(parity(sg[3])) {  // Dritte Stelle soll ungerade sein
-    k = (sg[3]+1)/2;
+    k = (sg[3]+1) div 2;
     if(sg[3] > sg[4]) {
       k--;
@@ -2066 +2066 @@
       if( sg[4] == sg[5]) {
         if(parity(sg[4])) {                                  // Z[k,r,0]
-          r = (sg[4] - sg[3])/2;
+          r = (sg[4] - sg[3]) div 2;
           if( r>0 ) { cnt++;
             SG_Typ = SG_Typ + " Z[k,r,0]=Z["+string(k)+","+string(r)+",0]";
@@ -2072 +2072 @@
         }
         else {                                                // Z[k,12k+6r]
-          r = (sg[4] - 2*k)/2; cnt++;
+          r = (sg[4] - 2*k) div 2; cnt++;
           SG_Typ = SG_Typ+" Z[k,12k+6r]=Z["+string(k)+","+string(12*k+6*r)+"]";
         }
@@ -2079 +2079 @@
       if( parity(sg[4]) ) {  // 4. Stelle ist ungerade
         if(sg[4] == sg[5]+2) {                              // Z[k,12k+6r+1]
-          r = (sg[4]-2*k-1)/2; cnt++;
+          r = (sg[4]-2*k-1) div 2; cnt++;
           SG_Typ=SG_Typ+" Z[k,12k+6r+1]=Z["+string(k)+",";
           SG_Typ=SG_Typ+string(12*k+6*r+1)+"]";
        }
        if( (sg[5]>sg[4]) && (sg[4]>sg[3]) ) {           // Z[k,r,s]
-          r = (sg[4] - sg[3])/2; cnt++;
+          r = (sg[4] - sg[3]) div 2; cnt++;
           s = sg[5] - sg[4];
           SG_Typ = SG_Typ + " Z[k,r,s]=";
@@ -2092 +2092 @@
       else {  // 4. Stelle ist gerade
         if( sg[4] == sg[5]+1) {                             // Z[k,12k+6r-1]
-          r = (sg[4] - 2*k)/2; cnt++;
+          r = (sg[4] - 2*k) div 2; cnt++;
           SG_Typ=SG_Typ+" Z[k,12k+6r-1]=Z["+string(k)+",";
           SG_Typ=SG_Typ+string(12*k+6*r-1)+"]";
@@ -2108 +2108 @@
   }
   else {  // Dritte Stelle soll gerade sein
-    k = sg[3]/2;
+    k = sg[3] div 2;
     // sortiere verschiedene W's
     if(k>0) {
@@ -2157 +2157 @@
     if(parity(sg[4])) { // 4. Stelle ist ungerade.
       if(sg[4]==sg[5]) {                                // Q[6k+4]
-        k=(sg[4]+1)/2; cnt++; SG_Typ=SG_Typ+" Q[6k+4]=Q["+string(6*k+4)+"]";
+        k=(sg[4]+1) div 2; cnt++; SG_Typ=SG_Typ+" Q[6k+4]=Q["+string(6*k+4)+"]";
       }
       if(sg[4]+1==sg[5]) {                      // Q[6k+5]
-        k=sg[5]/2; cnt++; SG_Typ=SG_Typ+" Q[6k+5]=Q["+string(6*k+5)+"]";
+        k=sg[5] div 2; cnt++; SG_Typ=SG_Typ+" Q[6k+5]=Q["+string(6*k+5)+"]";
       }
     }
     else { // 4. Stelle ist gerade.
       if(sg[4]==sg[5]+1) {                      // Q[6k+6]
-        k=sg[4]/2; cnt++; SG_Typ=SG_Typ+" Q[6k+6]=Q["+string(6*k+6)+"]";
+        k=sg[4] div 2; cnt++; SG_Typ=SG_Typ+" Q[6k+6]=Q["+string(6*k+6)+"]";
       }
       if(sg[4]<sg[5]) {                 // Q[k,r]
-        k = (sg[4]+2)/2;
+        k = (sg[4]+2) div 2;
         if(k>=2) {
           r=sg[5]+1-2*k; cnt++;
@@ -2178 +2178 @@
   else {           // S[...]
     if(parity(sg[3])) {  // 3. Stelle ist ungerade.
-      k = (sg[3]-1)/2;
+      k = (sg[3]-1) div 2;
       if(sg[3]==sg[4]+3 && sg[3]==sg[5]+2) {    // S[12k-1]
         cnt++; SG_Typ = SG_Typ + " S[12k-1]=S["+string(12*k-1)+"]";
@@ -2200 +2200 @@
     else { // 3. Stelle ist gerade.
       if(sg[3]==sg[5]+1 && sg[5]==sg[4]+3) {    // S[12k+4]
-        k = (sg[3]-2)/2; cnt++;
+        k = (sg[3]-2) div 2; cnt++;
         SG_Typ = SG_Typ + " S[12k+4]=S["+string(12*k+4)+"]";
       }
       if(sg[3]==sg[5]+2 && sg[5]==sg[4]+1) {    // S[12k+5]
-        k = (sg[3]-2)/2; cnt++;
+        k = (sg[3]-2) div 2; cnt++;
         SG_Typ = SG_Typ + " S[12k+5]=S["+string(12*k+5)+"]";
       }
@@ -2707 +2707 @@
     if( t > 1 ) {
       i = k;
-      k = k/t;
+      k = k div t;
       b = i - t*k;
       if( (s1 == "Q[") && (b==0) ) { k=k-1; b=6; }
@@ -2745 +2745 @@
       if(Typ[2] == "#") {
         i = r+1;
-        r = i/2;
+        r = i div 2;
         b = i - 2*r;
         if( b == 1 ) { s4 = "2r"; }

Singular/LIB/dmod.lib

@@ -1512 +1512 @@
   def @R4@ = ring(L);
   setring @R4@;
-  int N = Nnew/2;
+  int N = Nnew div 2;
   matrix @D[Nnew][Nnew];
   for (i=1; i<=N; i++)
@@ -1588 +1588 @@
   temp[1] = nL[1];
   temp[4] = nL[4];
-  int @n = int((nvars(@R2)-1)/2); // # of x's
+  int @n = int((nvars(@R2)-1) div 2); // # of x's
   int i;
   for (i=1; i<=@n; i++)
@@ -1707 +1707 @@
   def @R4@ = ring(L);
   setring @R4@;
-  int N = Nnew/2;
+  int N = Nnew div 2;
   matrix @D[Nnew][Nnew];
   for (i=1; i<=N; i++)
@@ -4790 +4790 @@
   def @R4@ = ring(L);
   setring @R4@;
-  int N = Nnew/2;
+  int N = Nnew div 2;
   matrix @D[Nnew][Nnew];
   for (i=1; i<=N; i++)
@@ -5660 +5660 @@
   int N = nvars(basering);
   int Nnew = N-1;
-  int n = Nnew / 2;
+  int n = Nnew div 2;
   int i;
   string s;
@@ -5800 +5800 @@
   def save = basering;
   int N = nvars(basering);
-  int n = (N-1) / 2;
+  int n = (N-1) div 2;
   int i;
   string s;
@@ -6111 +6111 @@
   def @R2 = basering;
   int Nnew = nvars(@R2);
-  int N = Nnew/2;
+  int N = Nnew div 2;
   int ppl = printlevel-voice+2;
   // we're in D_n[s], where the elim ord for s is set

Singular/LIB/equising.lib

@@ -1526 +1526 @@
     for (j=1;j<=ncols(Mult);j++)
     {
-      conditions=conditions+(Mult[i,j]*(Mult[i,j]+1)/2);
+      conditions=conditions+(Mult[i,j]*(Mult[i,j]+1) div 2);
     }
   }

Singular/LIB/finvar.lib

@@ -276 +276 @@
             o2++;
           }
-          o1=o1*o2/gcd(o1,o2);         // lowest common multiple of the element
+          o1=o1*o2 div gcd(o1,o2);         // lowest common multiple of the element
         }                              // orders -
         REY=concat(REY,P(k)*vars);     // adding new mapping to REY

Singular/LIB/mondromy.lib

@@ -319 +319 @@
   list b=pcvbasis(N-of+2,N+dN-of+2);
   list P2;
-  P2[size(b)*((nvars(basering)-1)*nvars(basering))/2]=0;
+  P2[size(b)*((nvars(basering)-1)*nvars(basering)) div 2]=0;
   int i,j,k,l;
   intvec alpha;

Singular/LIB/monomialideal.lib

@@ -3277 +3277 @@
         else
         {
-          median = xiexp[(size(xiexp) + 1) / 2];
+          median = xiexp[(size(xiexp) + 1) div 2];
         }
       }

Singular/LIB/nctools.lib

@@ -1589 +1589 @@
   int N = nvars(basering);
   if (N mod 2 <> 0) { return(notW); } // odd number of generators
-  int n = N/2;
+  int n = N div 2;
   list L = ringlist(basering);
   if (size(L) < 6) { return(notW); } // basering is commutative

Singular/LIB/primdec.lib

@@ -476 +476 @@
         {
           f=f*char(basering);
-          e=e/char(basering);
+          e=e div char(basering);
         }
       }

Singular/LIB/tst.lib

@@ -746 +746 @@
     if (products[i] > 1 && products[i] <= n_vars)
     {
-      nn_vars = n_vars / products[i];
+      nn_vars = n_vars div products[i];
       nb_orderings = tst_rgen_generate_blocks(nn_vars, simple_orderings, extra_weights);
       for (j=1; j<=size(nb_orderings); j++)