Changeset d43600 in git


Ignore:
Timestamp:
Apr 29, 2015, 4:17:55 PM (9 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', '648d28f488f6ff08f5607ff229b9ad9e4a5b93c2')
Children:
037ce1bfb1e8b7036c7a8f612851416dbee04829
Parents:
c133871de8f09fac0f6b53cf6614e2c8b5a9dd45
Message:
format
Location:
Singular/LIB
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • Singular/LIB/ffsolve.lib

    rc133871 rd43600  
    3434  poly lp;
    3535  // check assumptions
    36   if(npars(basering)>1){
     36  if(npars(basering)>1)
     37  {
    3738    ERROR("Basering must have at most one parameter");
    3839  }
    39   if(char(basering)==0){
     40  if(char(basering)==0)
     41  {
    4042    ERROR("Basering must have finite characteristic");
    4143  }
    42 
    43   if(size(#)){
    44     if(size(#)==1 and typeof(#[1])=="list"){
    45       lSolvers = #[1];
    46     }else{
    47       lSolvers = #;
    48     }
    49   }else{
    50     if(deg(equations) == 2){
     44  if(hasGFCoefficient(basering))
     45  {
     46    ERROR("not implemented for Galois fields");
     47  }
     48
     49  if(size(#))
     50  {
     51    if(size(#)==1 and typeof(#[1])=="list")
     52    { lSolvers = #[1]; }
     53    else
     54    { lSolvers = #; }
     55  }
     56  else
     57  {
     58    if(deg(equations) == 2)
     59    {
    5160      lSolvers = "XLsolve", "PEsolve", "simplesolver", "GBsolve", "ZZsolve";
    52     }else{
     61    }
     62    else
     63    {
    5364      lSolvers = "PEsolve", "simplesolver", "GBsolve", "ZZsolve", "XLsolve";
    5465    }
    55     if(deg(equations) == 1){
     66    if(deg(equations) == 1)
     67    {
    5668      lSolvers = "GBsolve";
    5769    }
     
    5971  n = size(lSolvers);
    6072  R = random(1, n*(3*n+1) div 2);
    61   for(i=1;i<n+1;i++){
    62     if(R<=(2*n+1-i)){
    63       string solver = lSolvers[i];
    64     }else{
     73  string solver;
     74  for(i=1;i<n+1;i++)
     75  {
     76    if(R<=(2*n+1-i))
     77    {
     78      solver = lSolvers[i];
     79    }
     80    else
     81    {
    6582      R=R-(2*n+1-i);
    6683    }
    6784  }
    6885
    69   if(nvars(basering)==1){
     86  if(nvars(basering)==1)
     87  {
    7088    return(facstd(equations));
    7189  }
     
    7391  // search for the first univariate polynomial
    7492  found = 0;
    75   for(i=1; i<=ncols(equations); i++){
    76     if(univariate(equations[i])>0){
     93  for(i=1; i<=ncols(equations); i++)
     94  {
     95    if(univariate(equations[i])>0)
     96    {
    7797      factors=factorize(equations[i],1);
    78       for(j=1; j<=ncols(factors); j++){
    79         if(deg(factors[j])==1){
     98      for(j=1; j<=ncols(factors); j++)
     99      {
     100        if(deg(factors[j])==1)
     101        {
    80102          linfacs[size(linfacs)+1] = factors[j];
    81103        }
    82104      }
    83       if(deg(linfacs[1])>0){
     105      if(deg(linfacs[1])>0)
     106      {
    84107        found=1;
    85108        break;
     
    88111  }
    89112  //   if there is, collect its the linear factors
    90   if(found){
     113  if(found)
     114  {
    91115    // substitute the root and call recursively
    92116    ideal neweqs, invmapideal, ti;
    93117    map invmap;
    94     for(k=1; k<=ncols(linfacs); k++){
     118    for(k=1; k<=ncols(linfacs); k++)
     119    {
    95120      lp = linfacs[k];
    96121      neweqs = reduce(equations, lp);
     
    102127      ideal mappingIdeal;
    103128      j=1;
    104       for(i=1; i<=size(varexp); i++){
    105         if(varexp[i]){
     129      for(i=1; i<=size(varexp); i++)
     130      {
     131        if(varexp[i])
     132        {
    106133          mappingIdeal[i] = 0;
    107         }else{
     134        }
     135        else
     136        {
    108137          mappingIdeal[i] = var(j);
    109138          j++;
     
    112141      map recmap = original_ring, mappingIdeal;
    113142      list tsols = ffsolve(recmap(neweqs), lSolvers);
    114       if(size(tsols)==0){
     143      if(size(tsols)==0)
     144      {
    115145        tsols = list(ideal(1));
    116146      }
    117147      setring original_ring;
    118148      j=1;
    119       for(i=1;i<=size(varexp);i++){
    120         if(varexp[i]==0){
     149      for(i=1;i<=size(varexp);i++)
     150      {
     151        if(varexp[i]==0)
     152        {
    121153          invmapideal[j] = var(i);
    122154          j++;
     
    127159
    128160      // combine the solutions
    129       for(j=1; j<=size(tempsols); j++){
     161      for(j=1; j<=size(tempsols); j++)
     162      {
    130163        ti =  std(tempsols[j]+lp);
    131         if(deg(ti)>0){
     164        if(deg(ti)>0)
     165        {
    132166          solutions = insert(solutions,ti);
    133167        }
    134168      }
    135169    }
    136   }else{
     170  }
     171  else
     172  {
    137173    execute("solutions="+solver+"(equations);") ;
    138174  }
     
    163199                checks if I has common roots, then return 1, otherwise
    164200                return 0.
    165 
    166201"
    167202{
     
    170205  poly g;
    171206  // check assumptions
    172   if(npars(basering)>1){
     207  if(npars(basering)>1)
     208  {
    173209    ERROR("Basering must have at most one parameter");
    174210  }
    175   if(char(basering)==0){
     211  if(char(basering)==0)
     212  {
    176213    ERROR("Basering must have finite characteristic");
    177214  }
    178 
    179   if( size(#) > 0 ){
     215  if(hasGFCoefficient(basering))
     216  {
     217    ERROR("not implemented for Galois fields");
     218  }
     219
     220  if( size(#) > 0 )
     221  {
    180222    mode = #[1];
    181   }else{
     223  }
     224  else
     225  {
    182226    mode = 2;
    183227  }
     
    185229  g = productOfEqs( L );
    186230
    187   if(g == 0){
    188     if(mode==0){
     231  if(g == 0)
     232  {
     233    if(mode==0)
     234    {
    189235      return(0);
    190236    }
    191237    return( list() );
    192238  }
    193   if(g == 1){
     239  if(g == 1)
     240  {
    194241    list vectors = every_vector();
    195     for(j=1; j<=size(vectors); j++){
     242    for(j=1; j<=size(vectors); j++)
     243    {
    196244      ideal res;
    197       for(i=1; i<=nvars(basering); i++){
     245      for(i=1; i<=nvars(basering); i++)
     246      {
    198247        res[i] = var(i)-vectors[j][i];
    199248      }
     
    203252  }
    204253
    205   if( mode == 0 ){
     254  if( mode == 0 )
     255  {
    206256    return( 1 );
    207   }else{
    208     for(i=1; i<=nvars(basering); i++){
     257  }
     258  else
     259  {
     260    for(i=1; i<=nvars(basering); i++)
     261    {
    209262      start[i] = 0:order_of_extension();
    210263    }
    211264
    212     if( mode == 1){
     265    if( mode == 1)
     266    {
    213267      results[size(results)+1] = melyseg(g, start);
    214     }else{
    215       while(1){
     268    }
     269    else
     270    {
     271      while(1)
     272      {
    216273        start = melyseg(g, start);
    217         if( size(start) > 0 ){
     274        if( size(start) > 0 )
     275        {
    218276          ideal res;
    219           for(i=1; i<=nvars(basering); i++){
     277          for(i=1; i<=nvars(basering); i++)
     278          {
    220279            res[i] = var(i)-vec2elm(start[i]);
    221280          }
     
    257316  E = E+defaultIdeal();
    258317  // check assumptions
    259   if(npars(basering)>1){
     318  if(npars(basering)>1)
     319  {
    260320    ERROR("Basering must have at most one parameter");
    261321  }
    262   if(char(basering)==0){
     322  if(char(basering)==0)
     323  {
    263324    ERROR("Basering must have finite characteristic");
    264325  }
    265   for(k=1; k<=nvars(basering); k++){
     326  if(hasGFCoefficient(basering))
     327  {
     328    ERROR("not implemented for Galois fields");
     329  }
     330  for(k=1; k<=nvars(basering); k++)
     331  {
    266332    partial_solutions = list();
    267     for(i=1; i<=size(solutions); i++){
     333    for(i=1; i<=size(solutions); i++)
     334    {
    268335      partial_system = reduce(E, solutions[i]);
    269       for(j=1; j<=ncols(partial_system); j++){
    270         if(univariate(partial_system[j])>0){
     336      for(j=1; j<=ncols(partial_system); j++)
     337      {
     338        if(univariate(partial_system[j])>0)
     339        {
    271340          univar_poly = partial_system[j];
    272341          break;
     
    274343      }
    275344      factors = factorize(univar_poly,1);
    276       for(j=1; j<=ncols(factors); j++){
    277         if(deg(factors[j])==1){
     345      for(j=1; j<=ncols(factors); j++)
     346      {
     347        if(deg(factors[j])==1)
     348        {
    278349          curr_sol = std(solutions[i]+ideal(factors[j]));
    279350          curr_sys = reduce(E, curr_sol);
    280351          correct = 1;
    281           for(t=1; t<=ncols(curr_sys); t++){
    282             if(deg(curr_sys[t])==0){
     352          for(t=1; t<=ncols(curr_sys); t++)
     353          {
     354            if(deg(curr_sys[t])==0)
     355            {
    283356              correct = 0;
    284357              break;
    285358            }
    286359          }
    287           if(correct){
     360          if(correct)
     361          {
    288362            partial_solutions = insert(partial_solutions, curr_sol);
    289363          }
     
    322396  string new_vars;
    323397  // check assumptions
    324   if(npars(basering)>1){
     398  if(npars(basering)>1)
     399  {
    325400    ERROR("Basering must have at most one parameter");
    326401  }
    327   if(char(basering)==0){
     402  if(char(basering)==0)
     403  {
    328404    ERROR("Basering must have finite characteristic");
    329405  }
     406  if(hasGFCoefficient(basering))
     407  {
     408    ERROR("not implemented for Galois fields");
     409  }
    330410
    331411  def original_ring = basering;
    332   if(npars(basering)==1){
     412  if(npars(basering)==1)
     413  {
    333414    int prime_coeff_field=0;
    334415    string minpolystr = "minpoly="+
    335416    get_minpoly_str(size(original_ring),parstr(original_ring,1))+";" ;
    336   }else{
     417  }
     418  else
     419  {
    337420    int prime_coeff_field=1;
    338421  }
     
    344427  ideal standard_basis = std(equation_system);
    345428  list basis_factors = facstd(standard_basis);
    346   if( basis_factors[1][1] == 1){
     429  if( basis_factors[1][1] == 1)
     430  {
    347431    return(results)
    348432  };
    349433
    350   for(i=1; i<= size(basis_factors); i++){
     434  for(i=1; i<= size(basis_factors); i++)
     435  {
    351436    prop = 0;
    352     for(j=1; j<=size(basis_factors[i]); j++){
    353       if( univariate(basis_factors[i][j])>0 and deg(basis_factors[i][j])>1){
     437    for(j=1; j<=size(basis_factors[i]); j++)
     438    {
     439      if( univariate(basis_factors[i][j])>0 and deg(basis_factors[i][j])>1)
     440      {
    354441        prop =1;
    355442        break;
    356443      }
    357444    }
    358     if(prop == 0){
     445    if(prop == 0)
     446    {
    359447      ls = solvelinearpart( basis_factors[i] );
    360       if(ncols(ls) == nvars(basering) ){
     448      if(ncols(ls) == nvars(basering) )
     449      {
    361450        ctrl, newelement = add_if_new(ctrl, ls);
    362         if(newelement){
     451        if(newelement)
     452        {
    363453          results = insert(results, ls);
    364454        }
    365       }else{
     455      }
     456      else
     457      {
    366458        slvbl = insert(slvbl, list(basis_factors[i],ls) );
    367459      }
    368460    }
    369461  }
    370   if(size(slvbl)<>0){
    371     for(int E = 1; E<= size(slvbl); E++){
     462  if(size(slvbl)<>0)
     463  {
     464    for(int E = 1; E<= size(slvbl); E++)
     465    {
    372466      I = slvbl[E][1];
    373467      linear_solution = slvbl[E][2];
     
    376470      univar_part = ideal();
    377471      multivar_part = ideal();
    378       for(i=1; i<=ncols(I); i++){
    379         if(univariate(I[i])>0){
     472      for(i=1; i<=ncols(I); i++)
     473      {
     474        if(univariate(I[i])>0)
     475        {
    380476          univar_part = univar_part+I[i];
    381         }else{
     477        }
     478        else
     479        {
    382480          multivar_part = multivar_part+I[i];
    383481        }
     
    391489      def R_new = changevar(new_vars, original_ring);
    392490      setring R_new;
    393       if( !prime_coeff_field ){
     491      if( !prime_coeff_field )
     492      {
    394493        execute(minpolystr);
    395494      }
    396495
    397496      ideal mapping_ideal;
    398       for(i=1; i<=size(unsolved_var_nums); i++){
     497      for(i=1; i<=size(unsolved_var_nums); i++)
     498      {
    399499        mapping_ideal[unsolved_var_nums[i]] = var(i);
    400500      }
     
    406506      int unsolvable = 0;
    407507      sol_new = simplesolver(I_new);
    408       if( size(sol_new) == 0){
     508      if( size(sol_new) == 0)
     509      {
    409510        unsolvable = 1;
    410511      }
    411 
    412512      setring original_ring;
    413 
    414       if(unsolvable){
     513      if(unsolvable)
     514      {
    415515        list sol_old = list();
    416       }else{
     516      }
     517      else
     518      {
    417519        map G = R_new, unsolved_vars;
    418520        new_sols = G(sol_new);
    419         for(i=1; i<=size(new_sols); i++){
     521        for(i=1; i<=size(new_sols); i++)
     522        {
    420523          ideal sol = new_sols[i]+linear_solution;
    421524          sol = std(sol);
    422525          ctrl, newelement = add_if_new(ctrl, sol);
    423           if(newelement){
     526          if(newelement)
     527          {
    424528            results = insert(results, sol);
    425529          }
     
    457561  int SD = deg(I);
    458562  list solutions;
    459   if(size(#)){
    460     if(typeof(#[1])=="int"){ D = #[1]; }
    461   }else{
    462     D = 2;
    463   }
     563  if(size(#))
     564  {
     565    if(typeof(#[1])=="int") { D = #[1]; }
     566  }
     567  else
     568  { D = 2; }
    464569  list lMonomialsForMultiplying = monomialsOfDegreeAtMost(D+SD);
    465570
     
    467572  list extended_system;
    468573  list mm;
    469   for(k=1; k<=size(lMonomialsForMultiplying)-SD; k++){
     574  for(k=1; k<=size(lMonomialsForMultiplying)-SD; k++)
     575  {
    470576    mm = lMonomialsForMultiplying[k];
    471     for(i=1; i<=m; i++){
    472       for(j=1; j<=size(mm); j++){
     577    for(i=1; i<=m; i++)
     578    {
     579      for(j=1; j<=size(mm); j++)
     580      {
    473581        extended_system[size(extended_system)+1] = reduce(I[i]*mm[j], defaultIdeal());
    474582      }
     
    476584  }
    477585  ideal new_system = I;
    478   for(i=1; i<=size(extended_system); i++){
     586  for(i=1; i<=size(extended_system); i++)
     587  {
    479588    new_system[m+i] = extended_system[i];
    480589  }
     
    511620  def original_ring = basering;
    512621  // check assumptions
    513   if(npars(basering)>1){
     622  if(npars(basering)>1)
     623  {
    514624    ERROR("Basering must have at most one parameter");
    515625  }
    516   if(char(basering)==0){
     626  if(char(basering)==0)
     627  {
    517628    ERROR("Basering must have finite characteristic");
     629  }
     630  if(hasGFCoefficient(basering))
     631  {
     632    ERROR("not implemented for Galois fields");
    518633  }
    519634
     
    521636  numeqs = ncols(I);
    522637  l = numeqs % nv;
    523   if( l == 0){
     638  if( l == 0)
     639  {
    524640    r = numeqs div nv;
    525   }else{
     641  }
     642  else
     643  {
    526644    r = (numeqs div nv) +1;
    527645  }
     
    529647
    530648  list list_of_equations;
    531   for(i=1; i<=r; i++){
     649  for(i=1; i<=r; i++)
     650  {
    532651    list_of_equations[i] = ideal();
    533652  }
    534   for(i=0; i<numeqs; i++){
     653  for(i=0; i<numeqs; i++)
     654  {
    535655    list_of_equations[(i div nv)+1][(i % nv) +1] = I[i+1];
    536656  }
     
    540660
    541661  ideal IV;
    542   for(i=1; i<=nv; i++){
     662  for(i=1; i<=nv; i++)
     663  {
    543664    IV[i] = var(i);
    544665  }
    545666
    546667  matrix M_C[nv][nv];
    547   for(i=1;i<=nrows(M_C); i++){
    548     for(j=1; j<=ncols(M_C); j++){
     668  for(i=1;i<=nrows(M_C); i++)
     669  {
     670    for(j=1; j<=ncols(M_C); j++)
     671    {
    549672      M_C[i,j] = @c(i)(j);
    550673    }
     
    554677  ideal IX_power_poly;
    555678  ideal IX_power_var;
    556   for(i=1; i<=nv; i++){
     679  for(i=1; i<=nv; i++)
     680  {
    557681    e = (size(original_ring)^(i-1));
    558682    IX_power_poly[i] = X^e;
     
    564688
    565689  ideal IC;
    566   for(i=1; i<=ncols(M); i++){
    567     for(j=1; j<=ncols(IV); j++){
     690  for(i=1; i<=ncols(M); i++)
     691  {
     692    for(j=1; j<=ncols(IV); j++)
     693    {
    568694      IC[(i-1)*ncols(M)+j] = coeffs(M[1,i],IV[j])[2,1];
    569695    }
     
    572698  ideal IC_solultion = std(Presolve::solvelinearpart(IC));
    573699
    574 
    575700  matrix M_C_sol[nv][nv];
    576   for(i=1;i<=nrows(M_C_sol); i++){
    577     for(j=1; j<=ncols(M_C_sol); j++){
     701  for(i=1;i<=nrows(M_C_sol); i++)
     702  {
     703    for(j=1; j<=ncols(M_C_sol); j++)
     704    {
    578705      M_C_sol[i,j] = reduce(@c(i)(j), std(IC_solultion));
    579706    }
     
    595722
    596723  list list_of_F;
    597   for(i=1; i<=r; i++){
     724  for(i=1; i<=r; i++)
     725  {
    598726    list_of_F[i] = Z_phi( list_of_equations[i] );
    599727  }
    600728
    601   for(i=1; i<=nv; i++){
    602 
    603     for(j=1; j<=r; j++){
     729  for(i=1; i<=nv; i++)
     730  {
     731    for(j=1; j<=r; j++)
     732    {
    604733      list_of_F[j] = subst( list_of_F[j], var(i), I_subs[i] );
    605734    }
    606735  }
    607736  int s = size(original_ring);
    608   if(npars(original_ring)==1){
    609     for(j=1; j<=r; j++){
     737  if(npars(original_ring)==1)
     738  {
     739    for(j=1; j<=r; j++)
     740    {
    610741      list_of_F[j] = subst(list_of_F[j], par(1), (@y^( (s^nv-1) div (s-1) )));
    611742    }
     
    620751  list list_of_F = rho(list_of_F);
    621752  poly G = 0;
    622   for(i=1; i<=r; i++){
     753  for(i=1; i<=r; i++)
     754  {
    623755    G = gcd(G, list_of_F[i]);
    624756  }
    625   if(G==1){
     757  if(G==1)
     758  {
    626759    return(list());
    627760  }
     
    630763
    631764  ideal check;
    632   for(i=1; i<=nv; i++){
     765  for(i=1; i<=nv; i++)
     766  {
    633767    check[i] = X^(size(original_ring)^(i-1));
    634768  }
     
    639773  def sM;
    640774  matrix M_for_sol = fetch(ring_for_matrix, M_C_sol);
    641   for(i=1; i<=size(factors[1]); i++){
     775  for(i=1; i<=size(factors[1]); i++)
     776  {
    642777    sc = matrix(reduce(check, std(factors[1][i])), 1,nv  );
    643778
    644779    sl = list();
    645780    sM = sc*M_for_sol;
    646     for(j=1; j<=ncols(sM); j++){
     781    for(j=1; j<=ncols(sM); j++)
     782    {
    647783      sl[j] = sM[1,j];
    648784    }
    649785    fsols[i] = sl;
    650786  }
    651   if(size(fsols)==0){
     787  if(size(fsols)==0)
     788  {
    652789    return(list());
    653790  }
    654791  setring ring_for_substitution;
    655792  list ssols = imap(ring_for_factorization, fsols);
    656   if(npars(original_ring)==1){
     793  if(npars(original_ring)==1)
     794  {
    657795    execute("poly P="+Z_get_minpoly(size(original_ring)^nv, "@y"));
    658796    poly RP = gcd(P,  (@y^( (s^nv-1) div (s-1) ))-a);
    659     for(i=1; i<=size(ssols); i++){
    660       for(j=1; j<=size(ssols[i]); j++){
     797    for(i=1; i<=size(ssols); i++)
     798    {
     799      for(j=1; j<=size(ssols[i]); j++)
     800      {
    661801        ssols[i][j] = reduce( ssols[i][j], std(RP));
    662802      }
     
    667807  list final_solutions;
    668808  ideal ps;
    669   for(i=1; i<=size(solutions); i++){
     809  for(i=1; i<=size(solutions); i++)
     810  {
    670811    ps = ideal();
    671     for(j=1; j<=nvars(original_ring); j++){
     812    for(j=1; j<=nvars(original_ring); j++)
     813    {
    672814      ps[j] = var(j)-solutions[i][j];
    673815    }
     
    691833static proc linearReduce(ideal I, list mons)
    692834{
    693   system("--no-warn", 1);
     835  //system("--no-warn", 1);
    694836  int LRtime = rtimer;
    695837  int i,j ;
    696838  int prime_field = 1;
    697839  list solutions, monomials;
    698   for(i=1; i<=size(mons); i++){
     840  for(i=1; i<=size(mons); i++)
     841  {
    699842    monomials = reorderMonomials(mons[i])+monomials;
    700843  }
     
    702845
    703846  def original_ring = basering;
    704   if(npars(basering)==1){
     847  if(npars(basering)==1)
     848  {
    705849    prime_field=0;
    706850    string minpolystr = "minpoly="
     
    712856  def ring_for_var_change = changevar( old_vars+","+new_vars, original_ring);
    713857  setring ring_for_var_change;
    714   if( prime_field == 0){
     858  if( prime_field == 0)
     859  {
    715860    execute(minpolystr);
    716861  }
     
    721866  intvec weights=1:nvars(original_ring);
    722867
    723   for(i=1; i<= number_of_monomials; i++){
     868  for(i=1; i<= number_of_monomials; i++)
     869  {
    724870    C[i] = monomials[i] - @y(i);
    725871    weights = weights,deg(monomials[i])+1;
    726872  }
    727873  ideal linear_eqs = I;
    728   for(i=1; i<=ncols(C); i++){
     874  for(i=1; i<=ncols(C); i++)
     875  {
    729876    linear_eqs = reduce(linear_eqs, C[i]);
    730877  }
     
    732879  def ring_for_elimination = changevar( new_vars, ring_for_var_change);
    733880  setring ring_for_elimination;
    734   if( prime_field == 0){
     881  if( prime_field == 0)
     882  {
    735883    execute(minpolystr);
    736884  }
     
    741889
    742890  setring ring_for_back_change;
    743   if( prime_field == 0){
     891  if( prime_field == 0)
     892  {
    744893    execute(minpolystr);
    745894  }
     
    748897  ideal C = imap(ring_for_var_change, C);
    749898  ideal J = lin_sol;
    750   for(i=1; i<=ncols(C); i++){
     899  for(i=1; i<=ncols(C); i++)
     900  {
    751901    J = reduce(J, C[i]);
    752902  }
     
    762912  int n = nvars(basering);
    763913  int t,i,l,j,s;
    764   for(i=1; i<=n; i++){
     914  for(i=1; i<=n; i++)
     915  {
    765916    monoms_one[i] = var(i);
    766917  }
    767918  monomials = list(monoms_one);
    768   if(1 < k){
    769     for(t=2; t<=k; t++){
     919  if(1 < k)
     920  {
     921    for(t=2; t<=k; t++)
     922    {
    770923      lower_monoms = monomials[t-1];
    771924      monoms = list();
    772925      s = 1;
    773       for(i=1; i<=n; i++){
    774         for(j=s; j<=size(lower_monoms); j++){
     926      for(i=1; i<=n; i++)
     927      {
     928        for(j=s; j<=size(lower_monoms); j++)
     929        {
    775930          monoms = monoms+list(lower_monoms[j]*var(i));
    776931        }
     
    787942  list univar_monoms, mixed_monoms;
    788943
    789   for(int j=1; j<=size(monomials); j++){
    790     if( univariate(monomials[j])>0 ){
     944  for(int j=1; j<=size(monomials); j++)
     945  {
     946    if( univariate(monomials[j])>0 )
     947    {
    791948      univar_monoms = univar_monoms + list(monomials[j]);
    792     }else{
     949    }
     950    else
     951    {
    793952      mixed_monoms = mixed_monoms + list(monomials[j]);
    794953    }
     
    803962  int i = 1;
    804963
    805   while( start[1][1] <> char(basering) ){
     964  while( start[1][1] <> char(basering) )
     965  {
    806966    gsub[i+1] = subst( gsub[i], var(i), vec2elm(start[i]));
    807     if( gsub[i+1] == 0 ){
     967    if( gsub[i+1] == 0 )
     968    {
    808969      list new = increment(start,i);
    809       for(int l=1; l<=size(start); l++){
    810         if(start[l]<>new[l]){
     970      for(int l=1; l<=size(start); l++)
     971      {
     972        if(start[l]<>new[l])
     973        {
    811974          i = l;
    812975          break;
     
    814977      }
    815978      start = new;
    816     }else{
    817       if(i == nvars(basering)){
     979    }
     980    else
     981    {
     982      if(i == nvars(basering))
     983      {
    818984        return(start);
    819985      }else{
     
    827993static proc productOfEqs(ideal I)
    828994{
    829   system("--no-warn", 1);
     995  //system("--no-warn", 1);
    830996  ideal eqs = sort_ideal(I);
    831997  int i,q;
     
    8341000  ideal I = defaultIdeal();
    8351001
    836   for(i=1; i<=size(eqs); i++){
     1002  for(i=1; i<=size(eqs); i++)
     1003  {
    8371004    if(g==0){return(g);}
    8381005    g = reduce(g*(eqs[i]^(q-1)-1), I);
     
    8461013  int n = nvars(original_ring);
    8471014  int prime_field=npars(basering);
    848   if(prime_field){
     1015  if(prime_field)
     1016  {
    8491017    string minpolystr = "minpoly="+
    8501018    get_minpoly_str(size(original_ring),parstr(original_ring,1))+";" ;
    8511019  }
    8521020
    853   if(size(#)){
     1021  if(size(#))
     1022  {
    8541023    int newvars = #[1];
    855 
    856   }else{
     1024  }
     1025  else
     1026  {
    8571027    int newvars = nvars(original_ring);
    8581028  }
     
    8601030  def newring = changevar(newvarstr, original_ring);
    8611031  setring newring;
    862   if( prime_field ){
     1032  if( prime_field )
     1033  {
    8631034    execute(minpolystr);
    8641035  }
     
    8691040{
    8701041  ideal I;
    871   for(int i=1; i<=nvars(basering); i++){
     1042  for(int i=1; i<=nvars(basering); i++)
     1043  {
    8721044    I[i] = var(i)^size(basering)-var(i);
    8731045  }
     
    8791051  int oe=1;
    8801052  list rl = ringlist(basering);
    881   if( size(rl[1]) <> 1){
     1053  if( size(rl[1]) <> 1)
     1054  {
    8821055    oe = deg( subst(minpoly,par(1),var(1)) );
    8831056  }
     
    8881061{
    8891062  number g = 1;
    890   if(npars(basering) == 1){ g=par(1); }
     1063  if(npars(basering) == 1) { g=par(1); }
    8911064  number e=0;
    8921065  int oe = size(v);
    893   for(int i=1; i<=oe; i++){
     1066  for(int i=1; i<=oe; i++)
     1067  {
    8941068    e = e+v[i]*g^(oe-i);
    8951069  }
     
    9031077  c = char(basering);
    9041078
    905   if( size(#) == 1 ){
     1079  if( size(#) == 1 )
     1080  {
    9061081    i = #[1];
    907   }else{
     1082  }
     1083  else
     1084  {
    9081085    i = size(l);
    9091086  }
    9101087
    9111088  l[i] = nextVec(l[i]);
    912   while( l[i][1] == c && i>1 ){
     1089  while( l[i][1] == c && i>1 )
     1090  {
    9131091    l[i] = 0:oe;
    9141092    i--;
    9151093    l[i] = nextVec(l[i]);
    9161094  }
    917   if( i < size(l) ){
    918     for(j=i+1; j<=size(l); j++){
     1095  if( i < size(l) )
     1096  {
     1097    for(j=i+1; j<=size(l); j++)
     1098    {
    9191099      l[j] = 0:oe;
    9201100    }
     
    9291109  c = char(basering);
    9301110  l[i] = l[i] + 1;
    931   while( l[i] == c && i>1 ){
     1111  while( l[i] == c && i>1 )
     1112  {
    9321113    l[i] = 0;
    9331114    i--;
     
    9411122  list element, list_of_elements;
    9421123
    943   for(int i=1; i<=nvars(basering); i++){
     1124  for(int i=1; i<=nvars(basering); i++)
     1125  {
    9441126    element[i] = 0:order_of_extension();
    9451127  }
    9461128
    947   while(size(list_of_elements) < size(basering)^nvars(basering)){
     1129  while(size(list_of_elements) < size(basering)^nvars(basering))
     1130  {
    9481131    list_of_elements = list_of_elements + list(element);
    9491132    element = increment(element);
    9501133  }
    951   for(int i=1; i<=size(list_of_elements); i++){
    952     for(int j=1; j<=size(list_of_elements[i]); j++){
     1134  for(int i=1; i<=size(list_of_elements); i++)
     1135  {
     1136    for(int j=1; j<=size(list_of_elements[i]); j++)
     1137    {
    9531138      list_of_elements[i][j] = vec2elm(list_of_elements[i][j]);
    9541139    }
     
    9601145{
    9611146  int N=0;
    962   if(order_of_extension() == 1){
     1147  if(order_of_extension() == 1)
     1148  {
    9631149    N = int(a);
    964     if(N<0){
     1150    if(N<0)
     1151    {
    9651152      N = N + char(basering);
    9661153    }
    967   }else{
     1154  }
     1155  else
     1156  {
    9681157    ideal C = coeffs(subst(a,par(1),var(1)),var(1));
    969     for(int i=1; i<=ncols(C); i++){
     1158    for(int i=1; i<=ncols(C); i++)
     1159    {
    9701160      int c = int(C[i]);
    971       if(c<0){ c = c + char(basering); }
     1161      if(c<0) { c = c + char(basering); }
    9721162      N = N + c*char(basering)^(i-1);
    9731163    }
     
    9821172  string S = string(minpoly);
    9831173  string SMP;
    984   if(S=="0"){
     1174  if(S=="0")
     1175  {
    9851176    SMP = SMP+parname;
    986   }else{
    987     for(int i=1; i<=size(S); i++){
    988       if(S[i]=="A"){
     1177  }
     1178  else
     1179  {
     1180    for(int i=1; i<=size(S); i++)
     1181    {
     1182      if(S[i]=="A")
     1183      {
    9891184        SMP = SMP+parname;
    990       }else{
     1185      }
     1186      else
     1187      {
    9911188        SMP = SMP+S[i];
    9921189      }
     
    10031200  M = ncols(I);
    10041201  OI = I;
    1005   for(i=2; i<=M; i++){
     1202  for(i=2; i<=M; i++)
     1203  {
    10061204    j=i;
    1007     while(size(OI[j-1])>size(OI[j])){
     1205    while(size(OI[j-1])>size(OI[j]))
     1206    {
    10081207      P = OI[j-1];
    10091208      OI[j-1] = OI[j];
    10101209      OI[j] = P;
    10111210      j--;
    1012       if(j==1){ break; }
     1211      if(j==1) break;
    10131212    }
    10141213  }
     
    10221221
    10231222  I=std(I);
    1024   for(i=1; i<=nvars(basering); i++){
     1223  for(i=1; i<=nvars(basering); i++)
     1224  {
    10251225    P = P +  reduce(var(i),I)*var(1)^(i-1);
    10261226  }
    10271227  newelement=1;
    1028   for(i=1; i<=size(L); i++){
    1029     if(L[i]==P){
     1228  for(i=1; i<=size(L); i++)
     1229  {
     1230    if(L[i]==P)
     1231    {
    10301232      newelement=0;
    10311233      break;
    10321234    }
    10331235  }
    1034   if(newelement){
     1236  if(newelement)
     1237  {
    10351238    L = insert(L, P);
    10361239  }
     
    10441247  string S = string(minpoly);
    10451248  string SMP;
    1046   if(S=="0"){
     1249  if(S=="0")
     1250  {
    10471251    SMP = SMP+parname;
    1048   }else{
    1049     for(int i=1; i<=size(S); i++){
    1050       if(S[i]=="A"){
     1252  }
     1253  else
     1254  {
     1255    for(int i=1; i<=size(S); i++)
     1256    {
     1257      if(S[i]=="A")
     1258      {
    10511259        SMP = SMP+parname;
    1052       }else{
     1260      }
     1261      else
     1262      {
    10531263        SMP = SMP+S[i];
    10541264      }
     
    10611271{
    10621272  poly f;
    1063   for(int i=1; i<= ncols(I); i++){
     1273  for(int i=1; i<= ncols(I); i++)
     1274{
    10641275    f = f+I[i]*@y^(i-1);
    10651276  }
     
    10701281{
    10711282  ideal DI;
    1072   for(int i=1; i<=number_of_variables; i++){
     1283  for(int i=1; i<=number_of_variables; i++)
     1284  {
    10731285    DI[i] = var(i)^q-var(i);
    10741286  }
  • Singular/LIB/ring.lib

    rc133871 rd43600  
    983983proc hasFieldCoefficient(def rng )
    984984"USAGE: hasFieldCoefficient ( rng );
    985 RETURN:  1 if the coeffcients form  (and are considered to be) a field, 0 otherwise.
     985RETURN:  1 if the coefficients form  (and are considered to be) a field, 0 otherwise.
    986986KEYWORDS: ring coefficients
    987987EXAMPLE: example hasFieldCoefficient; shows an example
Note: See TracChangeset for help on using the changeset viewer.