Changeset d43600 in git

Timestamp:

Apr 29, 2015, 4:17:55 PM (8 years ago)

Author:

Hans Schoenemann <hannes@…>

Branches:

(u'spielwiese', '8e0ad00ce244dfd0756200662572aef8402f13d5')

Children:

037ce1bfb1e8b7036c7a8f612851416dbee04829

Parents:

c133871de8f09fac0f6b53cf6614e2c8b5a9dd45

Message:

format

Location:

Singular/LIB

Files:

• ffsolve.lib (modified) (61 diffs)
• ring.lib (modified) (1 diff)

Singular/LIB/ffsolve.lib

@@ -34 +34 @@
   poly lp;
   // check assumptions
-  if(npars(basering)>1){
+  if(npars(basering)>1)
+  {
     ERROR("Basering must have at most one parameter");
   }
-  if(char(basering)==0){
+  if(char(basering)==0)
+  {
     ERROR("Basering must have finite characteristic");
   }
-
-  if(size(#)){
-    if(size(#)==1 and typeof(#[1])=="list"){
-      lSolvers = #[1];
-    }else{
-      lSolvers = #;
-    }
-  }else{
-    if(deg(equations) == 2){
+  if(hasGFCoefficient(basering))
+  {
+    ERROR("not implemented for Galois fields");
+  }
+
+  if(size(#))
+  {
+    if(size(#)==1 and typeof(#[1])=="list")
+    { lSolvers = #[1]; }
+    else
+    { lSolvers = #; }
+  }
+  else
+  {
+    if(deg(equations) == 2)
+    {
       lSolvers = "XLsolve", "PEsolve", "simplesolver", "GBsolve", "ZZsolve";
-    }else{
+    }
+    else
+    {
       lSolvers = "PEsolve", "simplesolver", "GBsolve", "ZZsolve", "XLsolve";
     }
-    if(deg(equations) == 1){
+    if(deg(equations) == 1)
+    {
       lSolvers = "GBsolve";
     }
@@ -59 +71 @@
   n = size(lSolvers);
   R = random(1, n*(3*n+1) div 2);
-  for(i=1;i<n+1;i++){
-    if(R<=(2*n+1-i)){
-      string solver = lSolvers[i];
-    }else{
+  string solver;
+  for(i=1;i<n+1;i++)
+  {
+    if(R<=(2*n+1-i))
+    {
+      solver = lSolvers[i];
+    }
+    else
+    {
       R=R-(2*n+1-i);
     }
   }
 
-  if(nvars(basering)==1){
+  if(nvars(basering)==1)
+  {
     return(facstd(equations));
   }
@@ -73 +91 @@
   // search for the first univariate polynomial
   found = 0;
-  for(i=1; i<=ncols(equations); i++){
-    if(univariate(equations[i])>0){
+  for(i=1; i<=ncols(equations); i++)
+  {
+    if(univariate(equations[i])>0)
+    {
       factors=factorize(equations[i],1);
-      for(j=1; j<=ncols(factors); j++){
-        if(deg(factors[j])==1){
+      for(j=1; j<=ncols(factors); j++)
+      {
+        if(deg(factors[j])==1)
+        {
           linfacs[size(linfacs)+1] = factors[j];
         }
       }
-      if(deg(linfacs[1])>0){
+      if(deg(linfacs[1])>0)
+      {
         found=1;
         break;
@@ -88 +111 @@
   }
   //   if there is, collect its the linear factors
-  if(found){
+  if(found)
+  {
     // substitute the root and call recursively
     ideal neweqs, invmapideal, ti;
     map invmap;
-    for(k=1; k<=ncols(linfacs); k++){
+    for(k=1; k<=ncols(linfacs); k++)
+    {
       lp = linfacs[k];
       neweqs = reduce(equations, lp);
@@ -102 +127 @@
       ideal mappingIdeal;
       j=1;
-      for(i=1; i<=size(varexp); i++){
-        if(varexp[i]){
+      for(i=1; i<=size(varexp); i++)
+      {
+        if(varexp[i])
+        {
           mappingIdeal[i] = 0;
-        }else{
+        }
+        else
+        {
           mappingIdeal[i] = var(j);
           j++;
@@ -112 +141 @@
       map recmap = original_ring, mappingIdeal;
       list tsols = ffsolve(recmap(neweqs), lSolvers);
-      if(size(tsols)==0){
+      if(size(tsols)==0)
+      {
         tsols = list(ideal(1));
       }
       setring original_ring;
       j=1;
-      for(i=1;i<=size(varexp);i++){
-        if(varexp[i]==0){
+      for(i=1;i<=size(varexp);i++)
+      {
+        if(varexp[i]==0)
+        {
           invmapideal[j] = var(i);
           j++;
@@ -127 +159 @@
 
       // combine the solutions
-      for(j=1; j<=size(tempsols); j++){
+      for(j=1; j<=size(tempsols); j++)
+      {
         ti =  std(tempsols[j]+lp);
-        if(deg(ti)>0){
+        if(deg(ti)>0)
+        {
           solutions = insert(solutions,ti);
         }
       }
     }
-  }else{
+  }
+  else
+  {
     execute("solutions="+solver+"(equations);") ;
   }
@@ -163 +199 @@
                 checks if I has common roots, then return 1, otherwise
                 return 0.
-
 "
 {
@@ -170 +205 @@
   poly g;
   // check assumptions
-  if(npars(basering)>1){
+  if(npars(basering)>1)
+  {
     ERROR("Basering must have at most one parameter");
   }
-  if(char(basering)==0){
+  if(char(basering)==0)
+  {
     ERROR("Basering must have finite characteristic");
   }
-
-  if( size(#) > 0 ){
+  if(hasGFCoefficient(basering))
+  {
+    ERROR("not implemented for Galois fields");
+  }
+
+  if( size(#) > 0 )
+  {
     mode = #[1];
-  }else{
+  }
+  else
+  {
     mode = 2;
   }
@@ -185 +229 @@
   g = productOfEqs( L );
 
-  if(g == 0){
-    if(mode==0){
+  if(g == 0)
+  {
+    if(mode==0)
+    {
       return(0);
     }
     return( list() );
   }
-  if(g == 1){
+  if(g == 1)
+  {
     list vectors = every_vector();
-    for(j=1; j<=size(vectors); j++){
+    for(j=1; j<=size(vectors); j++)
+    {
       ideal res;
-      for(i=1; i<=nvars(basering); i++){
+      for(i=1; i<=nvars(basering); i++)
+      {
         res[i] = var(i)-vectors[j][i];
       }
@@ -203 +252 @@
   }
 
-  if( mode == 0 ){
+  if( mode == 0 )
+  {
     return( 1 );
-  }else{
-    for(i=1; i<=nvars(basering); i++){
+  }
+  else
+  {
+    for(i=1; i<=nvars(basering); i++)
+    {
       start[i] = 0:order_of_extension();
     }
 
-    if( mode == 1){
+    if( mode == 1)
+    {
       results[size(results)+1] = melyseg(g, start);
-    }else{
-      while(1){
+    }
+    else
+    {
+      while(1)
+      {
         start = melyseg(g, start);
-        if( size(start) > 0 ){
+        if( size(start) > 0 )
+        {
           ideal res;
-          for(i=1; i<=nvars(basering); i++){
+          for(i=1; i<=nvars(basering); i++)
+          {
             res[i] = var(i)-vec2elm(start[i]);
           }
@@ -257 +316 @@
   E = E+defaultIdeal();
   // check assumptions
-  if(npars(basering)>1){
+  if(npars(basering)>1)
+  {
     ERROR("Basering must have at most one parameter");
   }
-  if(char(basering)==0){
+  if(char(basering)==0)
+  {
     ERROR("Basering must have finite characteristic");
   }
-  for(k=1; k<=nvars(basering); k++){
+  if(hasGFCoefficient(basering))
+  {
+    ERROR("not implemented for Galois fields");
+  }
+  for(k=1; k<=nvars(basering); k++)
+  {
     partial_solutions = list();
-    for(i=1; i<=size(solutions); i++){
+    for(i=1; i<=size(solutions); i++)
+    {
       partial_system = reduce(E, solutions[i]);
-      for(j=1; j<=ncols(partial_system); j++){
-        if(univariate(partial_system[j])>0){
+      for(j=1; j<=ncols(partial_system); j++)
+      {
+        if(univariate(partial_system[j])>0)
+        {
           univar_poly = partial_system[j];
           break;
@@ -274 +343 @@
       }
       factors = factorize(univar_poly,1);
-      for(j=1; j<=ncols(factors); j++){
-        if(deg(factors[j])==1){
+      for(j=1; j<=ncols(factors); j++)
+      {
+        if(deg(factors[j])==1)
+        {
           curr_sol = std(solutions[i]+ideal(factors[j]));
           curr_sys = reduce(E, curr_sol);
           correct = 1;
-          for(t=1; t<=ncols(curr_sys); t++){
-            if(deg(curr_sys[t])==0){
+          for(t=1; t<=ncols(curr_sys); t++)
+          {
+            if(deg(curr_sys[t])==0)
+            {
               correct = 0;
               break;
             }
           }
-          if(correct){
+          if(correct)
+          {
             partial_solutions = insert(partial_solutions, curr_sol);
           }
@@ -322 +396 @@
   string new_vars;
   // check assumptions
-  if(npars(basering)>1){
+  if(npars(basering)>1)
+  {
     ERROR("Basering must have at most one parameter");
   }
-  if(char(basering)==0){
+  if(char(basering)==0)
+  {
     ERROR("Basering must have finite characteristic");
   }
+  if(hasGFCoefficient(basering))
+  {
+    ERROR("not implemented for Galois fields");
+  }
 
   def original_ring = basering;
-  if(npars(basering)==1){
+  if(npars(basering)==1)
+  {
     int prime_coeff_field=0;
     string minpolystr = "minpoly="+
     get_minpoly_str(size(original_ring),parstr(original_ring,1))+";" ;
-  }else{
+  }
+  else
+  {
     int prime_coeff_field=1;
   }
@@ -344 +427 @@
   ideal standard_basis = std(equation_system);
   list basis_factors = facstd(standard_basis);
-  if( basis_factors[1][1] == 1){
+  if( basis_factors[1][1] == 1)
+  {
     return(results)
   };
 
-  for(i=1; i<= size(basis_factors); i++){
+  for(i=1; i<= size(basis_factors); i++)
+  {
     prop = 0;
-    for(j=1; j<=size(basis_factors[i]); j++){
-      if( univariate(basis_factors[i][j])>0 and deg(basis_factors[i][j])>1){
+    for(j=1; j<=size(basis_factors[i]); j++)
+    {
+      if( univariate(basis_factors[i][j])>0 and deg(basis_factors[i][j])>1)
+      {
         prop =1;
         break;
       }
     }
-    if(prop == 0){
+    if(prop == 0)
+    {
       ls = solvelinearpart( basis_factors[i] );
-      if(ncols(ls) == nvars(basering) ){
+      if(ncols(ls) == nvars(basering) )
+      {
         ctrl, newelement = add_if_new(ctrl, ls);
-        if(newelement){
+        if(newelement)
+        {
           results = insert(results, ls);
         }
-      }else{
+      }
+      else
+      {
         slvbl = insert(slvbl, list(basis_factors[i],ls) );
       }
     }
   }
-  if(size(slvbl)<>0){
-    for(int E = 1; E<= size(slvbl); E++){
+  if(size(slvbl)<>0)
+  {
+    for(int E = 1; E<= size(slvbl); E++)
+    {
       I = slvbl[E][1];
       linear_solution = slvbl[E][2];
@@ -376 +470 @@
       univar_part = ideal();
       multivar_part = ideal();
-      for(i=1; i<=ncols(I); i++){
-        if(univariate(I[i])>0){
+      for(i=1; i<=ncols(I); i++)
+      {
+        if(univariate(I[i])>0)
+        {
           univar_part = univar_part+I[i];
-        }else{
+        }
+        else
+        {
           multivar_part = multivar_part+I[i];
         }
@@ -391 +489 @@
       def R_new = changevar(new_vars, original_ring);
       setring R_new;
-      if( !prime_coeff_field ){
+      if( !prime_coeff_field )
+      {
         execute(minpolystr);
       }
 
       ideal mapping_ideal;
-      for(i=1; i<=size(unsolved_var_nums); i++){
+      for(i=1; i<=size(unsolved_var_nums); i++)
+      {
         mapping_ideal[unsolved_var_nums[i]] = var(i);
       }
@@ -406 +506 @@
       int unsolvable = 0;
       sol_new = simplesolver(I_new);
-      if( size(sol_new) == 0){
+      if( size(sol_new) == 0)
+      {
         unsolvable = 1;
       }
-
       setring original_ring;
-
-      if(unsolvable){
+      if(unsolvable)
+      {
         list sol_old = list();
-      }else{
+      }
+      else
+      {
         map G = R_new, unsolved_vars;
         new_sols = G(sol_new);
-        for(i=1; i<=size(new_sols); i++){
+        for(i=1; i<=size(new_sols); i++)
+        {
           ideal sol = new_sols[i]+linear_solution;
           sol = std(sol);
           ctrl, newelement = add_if_new(ctrl, sol);
-          if(newelement){
+          if(newelement)
+          {
             results = insert(results, sol);
           }
@@ -457 +561 @@
   int SD = deg(I);
   list solutions;
-  if(size(#)){
-    if(typeof(#[1])=="int"){ D = #[1]; }
-  }else{
-    D = 2;
-  }
+  if(size(#))
+  {
+    if(typeof(#[1])=="int") { D = #[1]; }
+  }
+  else
+  { D = 2; }
   list lMonomialsForMultiplying = monomialsOfDegreeAtMost(D+SD);
 
@@ -467 +572 @@
   list extended_system;
   list mm;
-  for(k=1; k<=size(lMonomialsForMultiplying)-SD; k++){
+  for(k=1; k<=size(lMonomialsForMultiplying)-SD; k++)
+  {
     mm = lMonomialsForMultiplying[k];
-    for(i=1; i<=m; i++){
-      for(j=1; j<=size(mm); j++){
+    for(i=1; i<=m; i++)
+    {
+      for(j=1; j<=size(mm); j++)
+      {
         extended_system[size(extended_system)+1] = reduce(I[i]*mm[j], defaultIdeal());
       }
@@ -476 +584 @@
   }
   ideal new_system = I;
-  for(i=1; i<=size(extended_system); i++){
+  for(i=1; i<=size(extended_system); i++)
+  {
     new_system[m+i] = extended_system[i];
   }
@@ -511 +620 @@
   def original_ring = basering;
   // check assumptions
-  if(npars(basering)>1){
+  if(npars(basering)>1)
+  {
     ERROR("Basering must have at most one parameter");
   }
-  if(char(basering)==0){
+  if(char(basering)==0)
+  {
     ERROR("Basering must have finite characteristic");
+  }
+  if(hasGFCoefficient(basering))
+  {
+    ERROR("not implemented for Galois fields");
   }
 
@@ -521 +636 @@
   numeqs = ncols(I);
   l = numeqs % nv;
-  if( l == 0){
+  if( l == 0)
+  {
     r = numeqs div nv;
-  }else{
+  }
+  else
+  {
     r = (numeqs div nv) +1;
   }
@@ -529 +647 @@
 
   list list_of_equations;
-  for(i=1; i<=r; i++){
+  for(i=1; i<=r; i++)
+  {
     list_of_equations[i] = ideal();
   }
-  for(i=0; i<numeqs; i++){
+  for(i=0; i<numeqs; i++)
+  {
     list_of_equations[(i div nv)+1][(i % nv) +1] = I[i+1];
   }
@@ -540 +660 @@
 
   ideal IV;
-  for(i=1; i<=nv; i++){
+  for(i=1; i<=nv; i++)
+  {
     IV[i] = var(i);
   }
 
   matrix M_C[nv][nv];
-  for(i=1;i<=nrows(M_C); i++){
-    for(j=1; j<=ncols(M_C); j++){
+  for(i=1;i<=nrows(M_C); i++)
+  {
+    for(j=1; j<=ncols(M_C); j++)
+    {
       M_C[i,j] = @c(i)(j);
     }
@@ -554 +677 @@
   ideal IX_power_poly;
   ideal IX_power_var;
-  for(i=1; i<=nv; i++){
+  for(i=1; i<=nv; i++)
+  {
     e = (size(original_ring)^(i-1));
     IX_power_poly[i] = X^e;
@@ -564 +688 @@
 
   ideal IC;
-  for(i=1; i<=ncols(M); i++){
-    for(j=1; j<=ncols(IV); j++){
+  for(i=1; i<=ncols(M); i++)
+  {
+    for(j=1; j<=ncols(IV); j++)
+    {
       IC[(i-1)*ncols(M)+j] = coeffs(M[1,i],IV[j])[2,1];
     }
@@ -572 +698 @@
   ideal IC_solultion = std(Presolve::solvelinearpart(IC));
 
-
   matrix M_C_sol[nv][nv];
-  for(i=1;i<=nrows(M_C_sol); i++){
-    for(j=1; j<=ncols(M_C_sol); j++){
+  for(i=1;i<=nrows(M_C_sol); i++)
+  {
+    for(j=1; j<=ncols(M_C_sol); j++)
+    {
       M_C_sol[i,j] = reduce(@c(i)(j), std(IC_solultion));
     }
@@ -595 +722 @@
 
   list list_of_F;
-  for(i=1; i<=r; i++){
+  for(i=1; i<=r; i++)
+  {
     list_of_F[i] = Z_phi( list_of_equations[i] );
   }
 
-  for(i=1; i<=nv; i++){
-
-    for(j=1; j<=r; j++){
+  for(i=1; i<=nv; i++)
+  {
+    for(j=1; j<=r; j++)
+    {
       list_of_F[j] = subst( list_of_F[j], var(i), I_subs[i] );
     }
   }
   int s = size(original_ring);
-  if(npars(original_ring)==1){
-    for(j=1; j<=r; j++){
+  if(npars(original_ring)==1)
+  {
+    for(j=1; j<=r; j++)
+    {
       list_of_F[j] = subst(list_of_F[j], par(1), (@y^( (s^nv-1) div (s-1) )));
     }
@@ -620 +751 @@
   list list_of_F = rho(list_of_F);
   poly G = 0;
-  for(i=1; i<=r; i++){
+  for(i=1; i<=r; i++)
+  {
     G = gcd(G, list_of_F[i]);
   }
-  if(G==1){
+  if(G==1)
+  {
     return(list());
   }
@@ -630 +763 @@
 
   ideal check;
-  for(i=1; i<=nv; i++){
+  for(i=1; i<=nv; i++)
+  {
     check[i] = X^(size(original_ring)^(i-1));
   }
@@ -639 +773 @@
   def sM;
   matrix M_for_sol = fetch(ring_for_matrix, M_C_sol);
-  for(i=1; i<=size(factors[1]); i++){
+  for(i=1; i<=size(factors[1]); i++)
+  {
     sc = matrix(reduce(check, std(factors[1][i])), 1,nv  );
 
     sl = list();
     sM = sc*M_for_sol;
-    for(j=1; j<=ncols(sM); j++){
+    for(j=1; j<=ncols(sM); j++)
+    {
       sl[j] = sM[1,j];
     }
     fsols[i] = sl;
   }
-  if(size(fsols)==0){
+  if(size(fsols)==0)
+  {
     return(list());
   }
   setring ring_for_substitution;
   list ssols = imap(ring_for_factorization, fsols);
-  if(npars(original_ring)==1){
+  if(npars(original_ring)==1)
+  {
     execute("poly P="+Z_get_minpoly(size(original_ring)^nv, "@y"));
     poly RP = gcd(P,  (@y^( (s^nv-1) div (s-1) ))-a);
-    for(i=1; i<=size(ssols); i++){
-      for(j=1; j<=size(ssols[i]); j++){
+    for(i=1; i<=size(ssols); i++)
+    {
+      for(j=1; j<=size(ssols[i]); j++)
+      {
         ssols[i][j] = reduce( ssols[i][j], std(RP));
       }
@@ -667 +807 @@
   list final_solutions;
   ideal ps;
-  for(i=1; i<=size(solutions); i++){
+  for(i=1; i<=size(solutions); i++)
+  {
     ps = ideal();
-    for(j=1; j<=nvars(original_ring); j++){
+    for(j=1; j<=nvars(original_ring); j++)
+    {
       ps[j] = var(j)-solutions[i][j];
     }
@@ -691 +833 @@
 static proc linearReduce(ideal I, list mons)
 {
-  system("--no-warn", 1);
+  //system("--no-warn", 1);
   int LRtime = rtimer;
   int i,j ;
   int prime_field = 1;
   list solutions, monomials;
-  for(i=1; i<=size(mons); i++){
+  for(i=1; i<=size(mons); i++)
+  {
     monomials = reorderMonomials(mons[i])+monomials;
   }
@@ -702 +845 @@
 
   def original_ring = basering;
-  if(npars(basering)==1){
+  if(npars(basering)==1)
+  {
     prime_field=0;
     string minpolystr = "minpoly="
@@ -712 +856 @@
   def ring_for_var_change = changevar( old_vars+","+new_vars, original_ring);
   setring ring_for_var_change;
-  if( prime_field == 0){
+  if( prime_field == 0)
+  {
     execute(minpolystr);
   }
@@ -721 +866 @@
   intvec weights=1:nvars(original_ring);
 
-  for(i=1; i<= number_of_monomials; i++){
+  for(i=1; i<= number_of_monomials; i++)
+  {
     C[i] = monomials[i] - @y(i);
     weights = weights,deg(monomials[i])+1;
   }
   ideal linear_eqs = I;
-  for(i=1; i<=ncols(C); i++){
+  for(i=1; i<=ncols(C); i++)
+  {
     linear_eqs = reduce(linear_eqs, C[i]);
   }
@@ -732 +879 @@
   def ring_for_elimination = changevar( new_vars, ring_for_var_change);
   setring ring_for_elimination;
-  if( prime_field == 0){
+  if( prime_field == 0)
+  {
     execute(minpolystr);
   }
@@ -741 +889 @@
 
   setring ring_for_back_change;
-  if( prime_field == 0){
+  if( prime_field == 0)
+  {
     execute(minpolystr);
   }
@@ -748 +897 @@
   ideal C = imap(ring_for_var_change, C);
   ideal J = lin_sol;
-  for(i=1; i<=ncols(C); i++){
+  for(i=1; i<=ncols(C); i++)
+  {
     J = reduce(J, C[i]);
   }
@@ -762 +912 @@
   int n = nvars(basering);
   int t,i,l,j,s;
-  for(i=1; i<=n; i++){
+  for(i=1; i<=n; i++)
+  {
     monoms_one[i] = var(i);
   }
   monomials = list(monoms_one);
-  if(1 < k){
-    for(t=2; t<=k; t++){
+  if(1 < k)
+  {
+    for(t=2; t<=k; t++)
+    {
       lower_monoms = monomials[t-1];
       monoms = list();
       s = 1;
-      for(i=1; i<=n; i++){
-        for(j=s; j<=size(lower_monoms); j++){
+      for(i=1; i<=n; i++)
+      {
+        for(j=s; j<=size(lower_monoms); j++)
+        {
           monoms = monoms+list(lower_monoms[j]*var(i));
         }
@@ -787 +942 @@
   list univar_monoms, mixed_monoms;
 
-  for(int j=1; j<=size(monomials); j++){
-    if( univariate(monomials[j])>0 ){
+  for(int j=1; j<=size(monomials); j++)
+  {
+    if( univariate(monomials[j])>0 )
+    {
       univar_monoms = univar_monoms + list(monomials[j]);
-    }else{
+    }
+    else
+    {
       mixed_monoms = mixed_monoms + list(monomials[j]);
     }
@@ -803 +962 @@
   int i = 1;
 
-  while( start[1][1] <> char(basering) ){
+  while( start[1][1] <> char(basering) )
+  {
     gsub[i+1] = subst( gsub[i], var(i), vec2elm(start[i]));
-    if( gsub[i+1] == 0 ){
+    if( gsub[i+1] == 0 )
+    {
       list new = increment(start,i);
-      for(int l=1; l<=size(start); l++){
-        if(start[l]<>new[l]){
+      for(int l=1; l<=size(start); l++)
+      {
+        if(start[l]<>new[l])
+        {
           i = l;
           break;
@@ -814 +977 @@
       }
       start = new;
-    }else{
-      if(i == nvars(basering)){
+    }
+    else
+    {
+      if(i == nvars(basering))
+      {
         return(start);
       }else{
@@ -827 +993 @@
 static proc productOfEqs(ideal I)
 {
-  system("--no-warn", 1);
+  //system("--no-warn", 1);
   ideal eqs = sort_ideal(I);
   int i,q;
@@ -834 +1000 @@
   ideal I = defaultIdeal();
 
-  for(i=1; i<=size(eqs); i++){
+  for(i=1; i<=size(eqs); i++)
+  {
     if(g==0){return(g);}
     g = reduce(g*(eqs[i]^(q-1)-1), I);
@@ -846 +1013 @@
   int n = nvars(original_ring);
   int prime_field=npars(basering);
-  if(prime_field){
+  if(prime_field)
+  {
     string minpolystr = "minpoly="+
     get_minpoly_str(size(original_ring),parstr(original_ring,1))+";" ;
   }
 
-  if(size(#)){
+  if(size(#))
+  {
     int newvars = #[1];
-
-  }else{
+  }
+  else
+  {
     int newvars = nvars(original_ring);
   }
@@ -860 +1030 @@
   def newring = changevar(newvarstr, original_ring);
   setring newring;
-  if( prime_field ){
+  if( prime_field )
+  {
     execute(minpolystr);
   }
@@ -869 +1040 @@
 {
   ideal I;
-  for(int i=1; i<=nvars(basering); i++){
+  for(int i=1; i<=nvars(basering); i++)
+  {
     I[i] = var(i)^size(basering)-var(i);
   }
@@ -879 +1051 @@
   int oe=1;
   list rl = ringlist(basering);
-  if( size(rl[1]) <> 1){
+  if( size(rl[1]) <> 1)
+  {
     oe = deg( subst(minpoly,par(1),var(1)) );
   }
@@ -888 +1061 @@
 {
   number g = 1;
-  if(npars(basering) == 1){ g=par(1); }
+  if(npars(basering) == 1) { g=par(1); }
   number e=0;
   int oe = size(v);
-  for(int i=1; i<=oe; i++){
+  for(int i=1; i<=oe; i++)
+  {
     e = e+v[i]*g^(oe-i);
   }
@@ -903 +1077 @@
   c = char(basering);
 
-  if( size(#) == 1 ){
+  if( size(#) == 1 )
+  {
     i = #[1];
-  }else{
+  }
+  else
+  {
     i = size(l);
   }
 
   l[i] = nextVec(l[i]);
-  while( l[i][1] == c && i>1 ){
+  while( l[i][1] == c && i>1 )
+  {
     l[i] = 0:oe;
     i--;
     l[i] = nextVec(l[i]);
   }
-  if( i < size(l) ){
-    for(j=i+1; j<=size(l); j++){
+  if( i < size(l) )
+  {
+    for(j=i+1; j<=size(l); j++)
+    {
       l[j] = 0:oe;
     }
@@ -929 +1109 @@
   c = char(basering);
   l[i] = l[i] + 1;
-  while( l[i] == c && i>1 ){
+  while( l[i] == c && i>1 )
+  {
     l[i] = 0;
     i--;
@@ -941 +1122 @@
   list element, list_of_elements;
 
-  for(int i=1; i<=nvars(basering); i++){
+  for(int i=1; i<=nvars(basering); i++)
+  {
     element[i] = 0:order_of_extension();
   }
 
-  while(size(list_of_elements) < size(basering)^nvars(basering)){
+  while(size(list_of_elements) < size(basering)^nvars(basering))
+  {
     list_of_elements = list_of_elements + list(element);
     element = increment(element);
   }
-  for(int i=1; i<=size(list_of_elements); i++){
-    for(int j=1; j<=size(list_of_elements[i]); j++){
+  for(int i=1; i<=size(list_of_elements); i++)
+  {
+    for(int j=1; j<=size(list_of_elements[i]); j++)
+    {
       list_of_elements[i][j] = vec2elm(list_of_elements[i][j]);
     }
@@ -960 +1145 @@
 {
   int N=0;
-  if(order_of_extension() == 1){
+  if(order_of_extension() == 1)
+  {
     N = int(a);
-    if(N<0){
+    if(N<0)
+    {
       N = N + char(basering);
     }
-  }else{
+  }
+  else
+  {
     ideal C = coeffs(subst(a,par(1),var(1)),var(1));
-    for(int i=1; i<=ncols(C); i++){
+    for(int i=1; i<=ncols(C); i++)
+    {
       int c = int(C[i]);
-      if(c<0){ c = c + char(basering); }
+      if(c<0) { c = c + char(basering); }
       N = N + c*char(basering)^(i-1);
     }
@@ -982 +1172 @@
   string S = string(minpoly);
   string SMP;
-  if(S=="0"){
+  if(S=="0")
+  {
     SMP = SMP+parname;
-  }else{
-    for(int i=1; i<=size(S); i++){
-      if(S[i]=="A"){
+  }
+  else
+  {
+    for(int i=1; i<=size(S); i++)
+    {
+      if(S[i]=="A")
+      {
         SMP = SMP+parname;
-      }else{
+      }
+      else
+      {
         SMP = SMP+S[i];
       }
@@ -1003 +1200 @@
   M = ncols(I);
   OI = I;
-  for(i=2; i<=M; i++){
+  for(i=2; i<=M; i++)
+  {
     j=i;
-    while(size(OI[j-1])>size(OI[j])){
+    while(size(OI[j-1])>size(OI[j]))
+    {
       P = OI[j-1];
       OI[j-1] = OI[j];
       OI[j] = P;
       j--;
-      if(j==1){ break; }
+      if(j==1) break;
     }
   }
@@ -1022 +1221 @@
 
   I=std(I);
-  for(i=1; i<=nvars(basering); i++){
+  for(i=1; i<=nvars(basering); i++)
+  {
     P = P +  reduce(var(i),I)*var(1)^(i-1);
   }
   newelement=1;
-  for(i=1; i<=size(L); i++){
-    if(L[i]==P){
+  for(i=1; i<=size(L); i++)
+  {
+    if(L[i]==P)
+    {
       newelement=0;
       break;
     }
   }
-  if(newelement){
+  if(newelement)
+  {
     L = insert(L, P);
   }
@@ -1044 +1247 @@
   string S = string(minpoly);
   string SMP;
-  if(S=="0"){
+  if(S=="0")
+  {
     SMP = SMP+parname;
-  }else{
-    for(int i=1; i<=size(S); i++){
-      if(S[i]=="A"){
+  }
+  else
+  {
+    for(int i=1; i<=size(S); i++)
+    {
+      if(S[i]=="A")
+      {
         SMP = SMP+parname;
-      }else{
+      }
+      else
+      {
         SMP = SMP+S[i];
       }
@@ -1061 +1271 @@
 {
   poly f;
-  for(int i=1; i<= ncols(I); i++){
+  for(int i=1; i<= ncols(I); i++)
+{
     f = f+I[i]*@y^(i-1);
   }
@@ -1070 +1281 @@
 {
   ideal DI;
-  for(int i=1; i<=number_of_variables; i++){
+  for(int i=1; i<=number_of_variables; i++)
+  {
     DI[i] = var(i)^q-var(i);
   }

Singular/LIB/ring.lib

@@ -983 +983 @@
 proc hasFieldCoefficient(def rng )
 "USAGE: hasFieldCoefficient ( rng );
-RETURN:  1 if the coeffcients form  (and are considered to be) a field, 0 otherwise.
+RETURN:  1 if the coefficients form  (and are considered to be) a field, 0 otherwise.
 KEYWORDS: ring coefficients
 EXAMPLE: example hasFieldCoefficient; shows an example