Changeset 55b8ae in git


Ignore:
Timestamp:
Aug 29, 2000, 4:10:31 PM (23 years ago)
Author:
Olaf Bachmann <obachman@…>
Branches:
(u'spielwiese', '8e0ad00ce244dfd0756200662572aef8402f13d5')
Children:
05e7d13dce909dfa04b941da1c487b7c2a3a6044
Parents:
b0bcea8fcc65d5fbdb1a6adb65122ac0da740929
Message:
* p_Procs update


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

Legend:

Unmodified
Added
Removed

  • Singular/LIB/tst.lib

    rb0bcea r55b8ae  
    1 // $Id: tst.lib,v 1.24 2000-08-14 11:26:30 obachman Exp $
     1// $Id: tst.lib,v 1.25 2000-08-29 14:10:31 obachman Exp $
    22//(obachman, last modified 6/30/98)
    33/////////////////////////////////////////////////////////////////////////////
    44
    5 version="$Id: tst.lib,v 1.24 2000-08-14 11:26:30 obachman Exp $";
     5version="$Id: tst.lib,v 1.25 2000-08-29 14:10:31 obachman Exp $";
    66info="
    77LIBRARY:  tst.lib      PROCEDURES FOR RUNNING AUTOMATIC TST TESTS
    … …  
    528528}
    529529
     530/////////////////////////////////////////////////////////////////////////////
     531proc tst_rgen_init_weights(int n)
     532{
     533  intvec v = 1..n;
     534  return (v);
     535}
     536
     537 
     538proc tst_rgen_generate_block(int n_vars, string simple_ordering, int extra_weights)
     539{
     540  string order = simple_ordering;
     541  if (extra_weights > n_vars)
     542  {
     543    extra_weights = n_vars;
     544  }
     545 
     546  if ((simple_ordering[1] == "W") || (simple_ordering[1] == "w"))
     547  {
     548    order = order + "(" + string(tst_rgen_init_weights(n_vars)) + ")";
     549  }
     550  else
     551  {
     552    if (simple_ordering[1] == "M")
     553    {
     554      order = order + "(" + string(tst_rgen_init_weights(n_vars*n_vars)) + ")";
     555    }
     556    else
     557    {
     558      order = order + "(" + string(n_vars) + ")";
     559    }
     560  }
     561  if (extra_weights >= 1)
     562  {
     563    order = "a(" + string(tst_rgen_init_weights(extra_weights)) + ")," + order;
     564  }
     565  return (order);
     566}
     567
     568proc tst_rgen_generate_blocks(int n_vars, list simple_orderings, intvec extra_weights)
     569{
     570  int i;
     571  int j;
     572  list blocks;
     573 
     574  for (i=1; i<=size(simple_orderings); i++)
     575  {
     576    for (j=1; j<=size(extra_weights); j++)
     577    {
     578      blocks = blocks + list(tst_rgen_generate_block(n_vars, simple_orderings[i], extra_weights[j]));
     579    }
     580  }
     581  return (blocks);
     582}
     583
     584proc tst_rgen_generate_product_orderings(int n_vars, list simple_orderings, intvec extra_weights, intvec products)
     585{
     586  list p_orderings;
     587  int i;
     588  int nn_vars, j, k,l;
     589  list nb_orderings;
     590  string n_ordering;
     591 
     592  for (i=1;i<=size(products);i++)
     593  {
     594    if (products[i] > 1 && products[i] <= n_vars)
     595    {
     596      nn_vars = n_vars / products[i];
     597      nb_orderings = tst_rgen_generate_blocks(nn_vars, simple_orderings, extra_weights);
     598      for (j=1; j<=size(nb_orderings); j++)
     599      {
     600        n_ordering = nb_orderings[j];
     601        for (k=2; k<=products[i]; k++)
     602        {
     603          l = (j + k - 1) %  size(nb_orderings);
     604          if (l == 0)
     605          {
     606            l = size(nb_orderings);
     607          }
     608          n_ordering = n_ordering + "," + nb_orderings[l];
     609        }
     610        if (products[i]*nn_vars < n_vars)
     611        {
     612          n_ordering = n_ordering + ", lp";
     613        }
     614        p_orderings = p_orderings + list(n_ordering);
     615      }
     616    }
     617    else
     618    {
     619      if (products[i] == 1)
     620      {
     621        p_orderings = p_orderings + tst_rgen_generate_blocks(n_vars, simple_orderings, extra_weights);
     622      }
     623    }
     624  }
     625  if (size(p_orderings) < 1)
     626  {
     627    p_orderings = tst_rgen_generate_blocks(n_vars, simple_orderings, extra_weights);
     628  }
     629  return (p_orderings);
     630}
     631
     632
     633proc tst_rgen_init()
     634{
     635  if (! defined(tst_rgen_charstrs))
     636  {
     637    list tst_rgen_charstrs;
     638    export(tst_rgen_charstrs);
     639    tst_rgen_charstrs = list("32003", "0");
     640  }
     641  if (! defined(tst_rgen_nvars))
     642  {
     643    intvec tst_rgen_nvars;
     644    export(tst_rgen_nvars);
     645    tst_rgen_nvars = 1..10;
     646  }
     647  if (! defined(tst_rgen_simple_orderings))
     648  {
     649    list tst_rgen_simple_orderings;
     650    export(tst_rgen_simple_orderings);
     651    tst_rgen_simple_orderings = list("lp", "dp", "Dp", "ls", "ds", "Ds", "wp","Wp","ws","Ws","M");
     652  }
     653  if (! defined(tst_rgen_comp_orderings))
     654  {
     655    list tst_rgen_comp_orderings;
     656    export(tst_rgen_comp_orderings);
     657    tst_rgen_comp_orderings = list("", "C", "c", "CC", "cc");
     658  }
     659  if (! defined(tst_rgen_products))
     660  {
     661    intvec tst_rgen_products;
     662    export(tst_rgen_products);
     663    tst_rgen_products = 1..3;
     664  }
     665  if (! defined(tst_rgen_extra_weights))
     666  {
     667    intvec tst_rgen_extra_weights;
     668    export(tst_rgen_extra_weights);
     669    tst_rgen_extra_weights = 0..2;
     670  }
     671
     672  if (! defined(tst_rgen_char_index))
     673  {
     674    int tst_rgen_char_index, tst_rgen_var_index, tst_rgen_comp_index, tst_rgen_ordering_index;
     675    list tst_rgen_orderings;
     676    export (tst_rgen_char_index, tst_rgen_var_index, tst_rgen_comp_index, tst_rgen_ordering_index, tst_rgen_orderings);
     677  }
     678   
     679  tst_rgen_char_index = 1;
     680  tst_rgen_var_index = 1;
     681  tst_rgen_comp_index = 1;
     682  tst_rgen_ordering_index = 1;
     683  tst_rgen_orderings = tst_rgen_generate_product_orderings(tst_rgen_nvars[1], tst_rgen_simple_orderings, tst_rgen_extra_weights, tst_rgen_products);
     684}
     685
     686proc tst_next_ring()
     687{
     688  tst_rgen_ordering_index++;
     689  if (tst_rgen_ordering_index > size(tst_rgen_orderings))
     690  {
     691    tst_rgen_comp_index++;
     692    if (tst_rgen_comp_index > size(tst_rgen_comp_orderings))
     693    {
     694      tst_rgen_var_index++;
     695      if (tst_rgen_var_index > size(tst_rgen_nvars))
     696      {
     697        tst_rgen_char_index++;
     698        if (tst_rgen_char_index > size(tst_rgen_charstrs))
     699        {
     700          return ("");
     701        }
     702        tst_rgen_var_index = 1;
     703      }
     704      tst_rgen_comp_index = 1;
     705      tst_rgen_orderings =  tst_rgen_generate_product_orderings(tst_rgen_nvars[tst_rgen_var_index], tst_rgen_simple_orderings, tst_rgen_extra_weights, tst_rgen_products);
     706    }
     707    tst_rgen_ordering_index = 1;
     708  }
     709 
     710  string rs = "(" + tst_rgen_charstrs[tst_rgen_char_index] + "),(" + A_Z("a", tst_rgen_nvars[tst_rgen_var_index]) + "),(";
     711
     712  if (tst_rgen_comp_orderings[tst_rgen_comp_index] == "CC")
     713  {
     714    rs = rs + "C," + tst_rgen_orderings[tst_rgen_ordering_index];
     715  }
     716  else
     717  {
     718    if (tst_rgen_comp_orderings[tst_rgen_comp_index] == "cc")
     719    {
     720      rs = rs + "c," + tst_rgen_orderings[tst_rgen_ordering_index];
     721    }
     722    else
     723    {
     724      if (tst_rgen_comp_orderings[tst_rgen_comp_index] == "C")
     725      {
     726        rs = rs + tst_rgen_orderings[tst_rgen_ordering_index] + ", C";
     727      }
     728      else
     729      {
     730        if (tst_rgen_comp_orderings[tst_rgen_comp_index] == "c")
     731        {
     732          rs = rs + tst_rgen_orderings[tst_rgen_ordering_index] + ",c";
     733        }
     734        else
     735        {
     736          rs = rs + tst_rgen_orderings[tst_rgen_ordering_index];
     737        }
     738      }
     739    }
     740  }
     741  rs = rs + ")";
     742  return (rs);
     743}
     744
     745
     746proc tst_rgen_test()
     747{
     748  tst_rgen_init();
     749  string rs = tst_next_ring();
     750 
     751  while (size(rs) > 1)
     752  {
     753    rs;
     754    rs = "ring r = " + rs + ";";
     755    execute (rs);
     756    rs = tst_next_ring();
     757  }
     758}
     759
     760proc tst_AddIdeal(ideal id, int how_often)
     761{
     762  int i, j, k, l;
     763  poly p;
     764  if (! defined(db_print))
     765  {
     766    int db_print = 0;
     767    export db_print;
     768  }
     769 
     770  for (i=1; i<= size(id); i++)
     771  {
     772    if (id[i] == 0)
     773    {
     774      id[i] = 1;
     775    }
     776  }
     777  dbprint(db_print, id);
     778  dbprint(db_print, "");
     779  ideal idl = lead(id);
     780  ideal idr = id;
     781  l = 0;
     782  for (j=1; j<= how_often; j++)
     783  {
     784    l++;
     785    if (l > size(id))
     786    {
     787      l=1;
     788    }
     789    for (k=1; k<=size(id); k++)
     790    {
     791      p = id[k] + idl[l]*idr[k];
     792      dbprint(db_print, p);
     793      for (i=1; i<=k; i++)
     794      {
     795        dbprint(db_print, idr[i]);
     796        p = p + idr[i];
     797        dbprint(db_print, p);
     798        dbprint(db_print, "");
     799      }
     800      idr[k] = p;
     801    }
     802  }
     803  return (idr);
     804}
     805
     806     
     807proc tst_AddModule(ideal id, int how_often)
     808{
     809  int i, j, k, l;
     810  vector v;
     811  if (! defined(db_print))
     812  {
     813    int db_print = 0;
     814    export db_print;
     815  }
     816 
     817  for (i=1; i<= size(id); i++)
     818  {
     819    if (id[i] == 0)
     820    {
     821      id[i] = 1;
     822    }
     823  }
     824  ideal idl = lead(id);
     825  module m = id;
     826 
     827  dbprint(db_print, id);
     828  dbprint(db_print, "");
     829  l = 0;
     830  for (j=1; j<= how_often; j++)
     831  {
     832    l++;
     833    if (l > size(id))
     834    {
     835      l=1;
     836    }
     837    for (k=1; k<=size(id); k++)
     838    {
     839      v = gen(k)*id[k];
     840      v = v + idl[l]*m[k];
     841      dbprint(db_print, v);
     842      for (i=1; i<=k; i++)
     843      {
     844        dbprint(db_print, m[i]);
     845        v = v + m[i];
     846        dbprint(db_print, v);
     847        dbprint(db_print, "");
     848      }
     849      m[k] = v;
     850    }
     851  }
     852  return (m);
     853}
     854
     855proc tst_TotalSize(def id)
     856{
     857  int i, s;
     858 
     859  for (i=1; i<=size(id); i++)
     860  {
     861    s = s + size(id[i]);
     862  }
     863  return (s);
     864}
     865
     866proc tst_PrintStats(def id)
     867{
     868  int i, is, s;
     869 
     870  for (i=1; i<=size(id); i++)
     871  {
     872    is = size(id[i]);
     873    s = s + is;
     874    string(i) + " : " + string(is) + " : " + string(lead(id[i]));
     875  }
     876  "s : " + string(s);
     877}
     878 

  • Singular/Makefile.in

    rb0bcea r55b8ae  
    100100    pcv.cc kbuckets.cc prProcs.cc \
    101101    mpr_inout.cc mpr_base.cc mpr_numeric.cc \
    102     prCopy.cc p_Procs.cc
     102    prCopy.cc p_Procs.cc p_Mult_q.cc
    103103
    104104
    … …  
    112112        grammar.y scanner.l libparse.l syz2.cc \
    113113        p_Delete__Template.cc p_ShallowCopyDelete__Template.cc \
    114         p_Copy__Template.cc p_Mult_n__Template.cc p_Mult_m__Template.cc \
    115         p_Minus_m_Mult_q__Template.cc p_Add_q__Template.cc
     114        p_Copy__Template.cc p_Mult_nn__Template.cc  pp_Mult_nn__Template.cc \
     115        pp_Mult_mm__Template.cc p_Mult_mm__Template.cc \
     116        p_Minus_mm_Mult_qq__Template.cc p_Add_q__Template.cc \
     117        p_Neg__Template.cc p_ReverseNeg__Template.cc \
     118        pInline.cc p_Inline.cc
    116119
    117120

  • Singular/p_Procs.cc

    rb0bcea r55b8ae  
    77 *  Author:  obachman (Olaf Bachmann)
    88 *  Created: 8/00
    9  *  Version: $Id: p_Procs.cc,v 1.2 2000-08-24 15:31:22 obachman Exp $
     9 *  Version: $Id: p_Procs.cc,v 1.3 2000-08-29 14:10:27 obachman Exp $
    1010 *******************************************************************/
    1111#include "mod2.h"
    … …  
    4242//   3 -- plus Field*_Length*_OrdGeneral procs
    4343//   4 -- all Field*_Length*_Ord* procs
    44 const int HAVE_FAST_P_PROCS = 2;
     44const int HAVE_FAST_P_PROCS = 0;
    4545
    4646// Set HAVE_FAST_FIELD to:
    … …  
    5656//   3 -- special cases for length <= 4
    5757//   4 -- special cases for length <= 8
    58 const int HAVE_FAST_LENGTH = 3;
     58const int HAVE_FAST_LENGTH = 8;
    5959
    6060// Set HAVE_FAST_ORD to:
    … …  
    7272//  1 -- only ZeroOrds for OrdPosNomogPosZero, OrdNomogPosZero, OrdPomogNegZero
    7373//  2 -- ZeroOrds for all
    74 const int HAVE_FAST_ZERO_ORD = 1;
     74const int HAVE_FAST_ZERO_ORD = 2;
    7575
    7676// Predicate which returns true if alloc/copy/free of numbers is
    … …  
    165165  p_Delete_Proc,
    166166  p_ShallowCopyDelete_Proc,
    167   p_Mult_n_Proc,
    168   p_Mult_m_Proc,
     167  p_Mult_nn_Proc,
     168  pp_Mult_nn_Proc,
     169  pp_Mult_mm_Proc,
     170  p_Mult_mm_Proc,
    169171  p_Add_q_Proc,
    170   p_Minus_m_Mult_q_Proc,
     172  p_Minus_mm_Mult_qq_Proc,
     173  p_ReverseNeg_Proc,
     174  p_Neg_Proc,
    171175  p_Unknown_Proc
    172176};
    … …  
    250254      case p_Delete_Proc: return "p_Delete_Proc";
    251255      case p_ShallowCopyDelete_Proc: return "p_ShallowCopyDelete_Proc";
    252       case p_Mult_n_Proc: return "p_Mult_n_Proc";
    253       case p_Mult_m_Proc: return "p_Mult_m_Proc";
     256      case p_Mult_nn_Proc: return "p_Mult_nn_Proc";
     257      case pp_Mult_nn_Proc: return "pp_Mult_nn_Proc";
     258      case pp_Mult_mm_Proc: return "pp_Mult_mm_Proc";
     259      case p_Mult_mm_Proc: return "p_Mult_mm_Proc";
    254260      case p_Add_q_Proc: return "p_Add_q_Proc";
    255       case p_Minus_m_Mult_q_Proc: return "p_Minus_m_Mult_q_Proc";
     261      case p_Minus_mm_Mult_qq_Proc: return "p_Minus_mm_Mult_qq_Proc";
     262      case p_ReverseNeg_Proc: return "p_ReverseNeg_Proc";
     263      case p_Neg_Proc: return "p_Neg_Proc";
    256264      case p_Unknown_Proc: return "p_Unknown_Proc";
    257265  }
    … …  
    454462  {
    455463      case p_Delete_Proc:
    456       case p_Mult_n_Proc:
     464      case p_Mult_nn_Proc:
     465      case p_ReverseNeg_Proc:
     466      case p_Neg_Proc:
    457467        return field;
    458468       
    … …  
    461471       
    462472      case p_Copy_Proc:
    463       case p_Mult_m_Proc:
     473      case pp_Mult_mm_Proc:
     474      case p_Mult_mm_Proc:
     475      case pp_Mult_nn_Proc:
    464476        return index(field, length);
    465477
    466478      case p_Add_q_Proc:
    467       case p_Minus_m_Mult_q_Proc:
     479      case p_Minus_mm_Mult_qq_Proc:
    468480        return index(field, length, ord);
    469481       
    … …  
    618630    (p_Procs->p_Delete != NULL) &&
    619631    (p_Procs->p_ShallowCopyDelete != NULL) &&
    620     (p_Procs->p_Mult_n != NULL) &&
     632    (p_Procs->p_Mult_nn != NULL) &&
     633    (p_Procs->pp_Mult_nn != NULL) &&
    621634    (p_Procs->p_Copy != NULL) &&
    622     (p_Procs->p_Mult_m != NULL) &&
     635    (p_Procs->pp_Mult_mm != NULL) &&
     636    (p_Procs->p_Mult_mm != NULL) &&
    623637    (p_Procs->p_Add_q != NULL) &&
    624     (p_Procs->p_Minus_m_Mult_q != NULL));
     638    (p_Procs->p_ReverseNeg != NULL) &&
     639    (p_Procs->p_Neg != NULL) &&
     640    (p_Procs->p_Minus_mm_Mult_qq != NULL));
    625641}
    626642
    … …  
    685701
    686702const char* macros_length[] =
    687 {"p_MemCopy", "p_MemAdd", NULL};
     703{"p_MemCopy", "p_MemAdd", "p_MemIncr", NULL};
    688704
    689705const char* macros_length_ord[] = {"p_MemCmp", NULL};
    … …  
    740756    printf("#define DECLARE_ORDSGN(what) what\n");
    741757
    742   // define p_Mult_m, for p_Minus_m_Mult_q
    743   if (strcmp(s_what, "p_Minus_m_Mult_q") == 0)
    744   {
    745     printf("#undef p_Mult_m\n");
    746     printf("#define p_Mult_m p_Mult_m__%s_%s_OrdGeneral\n", s_field, s_length);
     758  // define pp_Mult_mm, for p_Minus_mm_Mult_qq
     759  if (strcmp(s_what, "p_Minus_mm_Mult_qq") == 0)
     760  {
     761    printf("#undef pp_Mult_mm\n");
     762    printf("#define pp_Mult_mm pp_Mult_mm__%s_%s_OrdGeneral\n", s_field, s_length);
    747763  }
    748764  printf("#undef %s\n#define %s %s\n", s_what, s_what, s_full_proc_name);
    749765  printf("#include \"%s__Template.cc\"\n", s_what);
    750   printf("#undef %s\n#undef p_Mult_m\n", s_what);
     766  printf("#undef %s\n#undef pp_Mult_mm\n", s_what);
    751767}
    752768
    … …  
    870886  p_Ord t_ord = ord;                                        \
    871887  p_Length t_length = length;                               \
    872   FastProcFilter(what##_Proc, t_field, t_length, t_ord);   \
     888  FastProcFilter(what##_Proc, t_field, t_length, t_ord);    \
    873889  _SetProc(what, t_field, t_length, t_ord);                 \
    874890}                                                           \
    875 while (0)                                                   \
     891while (0)
    876892 
    877893static void SetProcs(p_Field field, p_Length length, p_Ord ord)
    878894{
    879895  SetProc(p_Delete, field, LengthGeneral, OrdGeneral);
    880   SetProc(p_Mult_n, field, LengthGeneral, OrdGeneral);
     896  SetProc(p_Mult_nn, field, LengthGeneral, OrdGeneral);
     897  SetProc(pp_Mult_nn, field, length, OrdGeneral);
    881898  SetProc(p_ShallowCopyDelete, FieldGeneral, length, OrdGeneral);
    882899  SetProc(p_Copy, field, length, OrdGeneral);
    883   SetProc(p_Mult_m, field, length, OrdGeneral);
     900  SetProc(pp_Mult_mm, field, length, OrdGeneral);
     901  SetProc(p_Mult_mm, field, length, OrdGeneral);
    884902  SetProc(p_Add_q, field, length, ord);
    885   SetProc(p_Minus_m_Mult_q, field, length, ord);
    886 }
    887 
    888 
    889 
     903  SetProc(p_Minus_mm_Mult_qq, field, length, ord);
     904  SetProc(p_ReverseNeg, field, LengthGeneral, OrdGeneral);
     905  SetProc(p_Neg, field, LengthGeneral, OrdGeneral);
     906}
     907
     908
     909

  • Singular/p_Procs.h

    rb0bcea r55b8ae  
    88 *  Author:  obachman (Olaf Bachmann)
    99 *  Created: 8/00
    10  *  Version: $Id: p_Procs.h,v 1.1 2000-08-24 14:42:43 obachman Exp $
     10 *  Version: $Id: p_Procs.h,v 1.2 2000-08-29 14:10:28 obachman Exp $
    1111 *******************************************************************/
    1212#ifndef P_PROCS_H
    … …  
    1414#include "structs.h"
    1515
    16 typedef poly (*p_Copy_Proc_Ptr)(poly p, ring r);
    17 typedef void (*p_Delete_Proc_Ptr)(poly *p, ring r);
    18 typedef poly (*p_ShallowCopyDelete_Proc_Ptr)(poly p, ring r, omBin dest_bin);
    19 typedef poly (*p_Mult_n_Proc_Ptr)(poly p, number n, ring r);
    20 typedef poly (*p_Mult_m_Proc_Ptr)(poly p, poly m,
    21                               poly spNoether, ring r);
    22 typedef poly (*p_Add_q_Proc_Ptr)(poly p, poly q, int & shorter, ring r);
    23 typedef poly (*p_Minus_m_Mult_q_Proc_Ptr)(poly p, poly m, poly q,
     16// define/undef P_INLINE to inline some procedures
     17#undef NO_P_INLINE
     18#if defined(NDEBUG) && !defined(NO_INLINE)
     19#define P_INLINE inline
     20#else
     21#define NO_P_INLINE 1
     22#define P_INLINE
     23#endif
     24
     25
     26// NOTE: the actual procedures below are not inlined,
     27// only the dispatching function call
     28
     29/*------------- Allocation/Deletion ----------------------*/
     30// returns a copy of p
     31P_INLINE poly p_Copy(poly p, const ring r = currRing);
     32// deletes *p, and sets *p to NULL
     33P_INLINE void p_Delete(poly *p, const ring r = currRing);
     34
     35/*------------- comparisons ----------------------*/
     36// returns 1 if Lm(p) > Lm(q)
     37//         0 if Lm(p) = Lm(q)
     38//        -1 if Lm(p) < Lm(q)
     39// assumes p != NULL && q != NULL
     40P_INLINE int p_LmCmp(const poly p, const poly q, const ring r = currRing);
     41
     42/*------------- Arithmetic operations ----------------------*/
     43/* NOTE as a general rule that
     44   pp means input is constant; p means input is destroyed */
     45// returns -p
     46P_INLINE poly p_Neg(poly p, const ring r = currRing);
     47// returns p*n, p is const
     48P_INLINE poly pp_Mult_nn(poly p, number n, const ring r = currRing);
     49// returns p*n, destroys p
     50P_INLINE poly p_Mult_nn(poly p, number n, const ring r = currRing);
     51// returns p*m, does neither destroy p nor m
     52P_INLINE poly pp_Mult_mm(poly p, poly m, const ring r = currRing);
     53// returns p*m, destroys p, const: m
     54P_INLINE poly p_Mult_mm(poly p, poly m, const ring r = currRing);
     55// returns p+q, destroys p and q
     56P_INLINE poly p_Add_q(poly p, poly q, const ring r = currRing);
     57// return p - m*q, destroys p; const: q,m
     58P_INLINE poly p_Minus_mm_Mult_qq(poly p, poly m, poly q, const ring r = currRing);
     59// returns p*q, destroys p and q
     60P_INLINE poly p_Mult_q(poly p, poly q, const ring r = currRing);
     61// returns p*q, does neither destroy p nor q
     62P_INLINE poly pp_Mult_qq(poly p, poly q, const ring r = currRing);
     63
     64/*------------- p_Proc stuff ----------------------*/
     65typedef poly (*p_Copy_Proc_Ptr)(poly p, const ring r);
     66typedef void (*p_Delete_Proc_Ptr)(poly *p, const ring r);
     67typedef poly (*p_ShallowCopyDelete_Proc_Ptr)(poly p, const ring r, omBin_s* dest_bin);
     68typedef poly (*p_Mult_nn_Proc_Ptr)(poly p, number n, const ring r);
     69typedef poly (*pp_Mult_nn_Proc_Ptr)(poly p, number n, const ring r);
     70typedef poly (*p_Mult_mm_Proc_Ptr)(poly p, poly m, const ring r);
     71typedef poly (*pp_Mult_mm_Proc_Ptr)(poly p, poly m,
     72                                   poly spNoether, const ring r);
     73typedef poly (*p_Add_q_Proc_Ptr)(poly p, poly q, int & shorter, const ring r);
     74typedef poly (*p_Minus_mm_Mult_qq_Proc_Ptr)(poly p, poly m, poly q,
    2475                                          int &shorter, poly spNoether,
    25                                           ring r);
     76                                          const ring r);
     77typedef poly (*p_ReverseNeg_Proc_Ptr)(poly p, const ring r);
     78typedef poly (*p_Neg_Proc_Ptr)(poly p, const ring r);
    2679
    2780typedef struct p_Procs_s
    … …  
    3083  p_Delete_Proc_Ptr             p_Delete;
    3184  p_ShallowCopyDelete_Proc_Ptr  p_ShallowCopyDelete;
    32   p_Mult_n_Proc_Ptr             p_Mult_n;
    33   p_Mult_m_Proc_Ptr             p_Mult_m;
     85  p_Mult_nn_Proc_Ptr            p_Mult_nn;
     86  pp_Mult_nn_Proc_Ptr           pp_Mult_nn;
     87  pp_Mult_mm_Proc_Ptr           pp_Mult_mm;
     88  p_Mult_mm_Proc_Ptr            p_Mult_mm;
    3489  p_Add_q_Proc_Ptr              p_Add_q;
    35   p_Minus_m_Mult_q_Proc_Ptr     p_Minus_m_Mult_q;
     90  p_Minus_mm_Mult_qq_Proc_Ptr   p_Minus_mm_Mult_qq;
     91  p_ReverseNeg_Proc_Ptr         p_ReverseNeg;
     92  p_Neg_Proc_Ptr                p_Neg;
    3693} pProcs_s;
    3794
    38 // returns a copy of p
    39 inline poly p_Copy(poly p, ring r = currRing)
    40 {
    41   assume(r != NULL && r->p_Procs != NULL);
    42   return r->p_Procs->p_Copy(p, r);
    43 }
    44 
    45 // deletes *p, and sets *p to NULL
    46 inline void p_Delete(poly *p, ring r = currRing)
    47 {
    48   assume(r != NULL && r->p_Procs != NULL);
    49   r->p_Procs->p_Delete(p, r);
    50 }
    51 
    52 // returns p+q, destroys p and q
    53 inline poly p_Add_q(poly p, poly q, ring r = currRing)
    54 {
    55   int shorter;
    56   assume(r != NULL && r->p_Procs != NULL);
    57   return r->p_Procs->p_Add_q(p, q, shorter, r);
    58 }
    59 
    60 // returns p*n, destroys p
    61 inline poly p_Mult_n(poly p, number n, ring r = currRing)
    62 {
    63   assume(r != NULL && r->p_Procs != NULL);
    64   return r->p_Procs->p_Mult_n(p, n, r);
    65 }
    66 
    67 // returns Copy(p)*m, does neither destroy p nor m
    68 inline poly p_Mult_m(poly p, poly m, ring r = currRing)
    69 {
    70   assume(r != NULL && r->p_Procs != NULL);
    71   return r->p_Procs->p_Mult_m(p, m, NULL, r);
    72 }
    73 
    74 // return p - m*Copy(q), destroys p; const: p,m
    75 inline poly p_Minus_m_Mult_q(poly p, poly m, poly q, ring r = currRing)
    76 {
    77   int shorter;
    78   assume(r != NULL && r->p_Procs != NULL);
    79   return r->p_Procs->p_Minus_m_Mult_q(p, m, q, shorter, NULL, r);
    80 }
    8195 
    8296void p_SetProcs(ring r, p_Procs_s* p_Procs);
    8397#ifdef RDEBUG
    84 void p_Debug_GetSpecNames(const ring r, char* &field, char* &length, char* &ord);
     98void p_Debug_GetSpecNames(const ring r, char* &field, char* &length,
     99                          char* &ord);
    85100void p_Debug_GetProcNames(const ring r, p_Procs_s* p_Procs);
    86101#endif
    87102
     103#include "p_Inline.cc"
     104
    88105#endif /* ! P_PROCS_H */

  • Singular/polys-impl.cc

    rb0bcea r55b8ae  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: polys-impl.cc,v 1.47 2000-08-24 14:42:44 obachman Exp $ */
     4/* $Id: polys-impl.cc,v 1.48 2000-08-29 14:10:28 obachman Exp $ */
    55
    66/***************************************************************
    … …  
    2828#include "ring.h"
    2929#include "polys-impl.h"
     30#include "p_Procs.h"
    3031
    3132#ifdef HAVE_SHIFTED_EXPONENTS

  • Singular/polys.cc

    rb0bcea r55b8ae  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: polys.cc,v 1.56 2000-08-24 11:21:45 Singular Exp $ */
     4/* $Id: polys.cc,v 1.57 2000-08-29 14:10:28 obachman Exp $ */
    55
    66/*
    … …  
    806806}
    807807
     808
     809#ifndef HAVE_P_PROCS
    808810/* -------------------------------------------------------- */
    809 
    810811static Exponent_t pMultT_nok;
    811812/*2
    … …  
    856857  pTest(aa);
    857858  return aa; /*TRUE*/
     859}
     860
     861
     862/*2
     863* update a by multiplying it with c (c will not be destroyed)
     864*/
     865void pMultN(poly a, number c)
     866{
     867  number t;
     868
     869  while (a!=NULL)
     870  {
     871    t=nMult(pGetCoeff(a), c);
     872    //nNormalize(t);
     873    pSetCoeff(a,t);
     874    pIter(a);
     875  }
     876}
     877
     878/*2
     879* return a copy of the poly a times the number c (a,c will not be destroyed)
     880*/
     881poly pMultCopyN(poly a, number c)
     882{
     883  poly result=NULL,hp;
     884
     885  if (a != NULL)
     886  {
     887    result=pNew();
     888    pCopy2(result,a);
     889    pNext(result)=NULL;
     890    pGetCoeff(result)=nMult(pGetCoeff(a),c);
     891    pIter(a);
     892    hp=result;
     893    while (a!=NULL)
     894    {
     895      hp=pNext(hp)=pNew();
     896      pCopy2(hp,a);
     897      pSetCoeff0(hp,nMult(pGetCoeff(a), c));
     898      pIter(a);
     899    }
     900    pNext(hp)=NULL;
     901  }
     902  return result;
    858903}
    859904
    … …  
    930975}
    931976
    932 /*2
    933 * update a by multiplying it with c (c will not be destroyed)
    934 */
    935 void pMultN(poly a, number c)
    936 {
    937   number t;
    938 
    939   while (a!=NULL)
    940   {
    941     t=nMult(pGetCoeff(a), c);
    942     //nNormalize(t);
    943     pSetCoeff(a,t);
    944     pIter(a);
    945   }
    946 }
    947 
    948 /*2
    949 * return a copy of the poly a times the number c (a,c will not be destroyed)
    950 */
    951 poly pMultCopyN(poly a, number c)
    952 {
    953   poly result=NULL,hp;
    954 
    955   if (a != NULL)
    956   {
    957     result=pNew();
    958     pCopy2(result,a);
    959     pNext(result)=NULL;
    960     pGetCoeff(result)=nMult(pGetCoeff(a),c);
    961     pIter(a);
    962     hp=result;
    963     while (a!=NULL)
    964     {
    965       hp=pNext(hp)=pNew();
    966       pCopy2(hp,a);
    967       pSetCoeff0(hp,nMult(pGetCoeff(a), c));
    968       pIter(a);
    969     }
    970     pNext(hp)=NULL;
    971   }
    972   return result;
    973 }
     977#endif
    974978
    975979/*2

  • Singular/polys.h

    rb0bcea r55b8ae  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: polys.h,v 1.33 2000-08-24 14:42:45 obachman Exp $ */
     6/* $Id: polys.h,v 1.34 2000-08-29 14:10:29 obachman Exp $ */
    77/*
    88* ABSTRACT - all basic methods to manipulate polynomials
    99*/
     10
     11// define/undef PINLINE to inlie some procedures
     12#undef NO_PINLINE
     13#if defined(NDEBUG) && !defined(NO_INLINE)
     14#define PINLINE inline
     15#else
     16#define PINLINE
     17#define NO_PINLINE 1
     18#endif
     19
    1020#include "polys-comp.h"
    1121#include "polys-impl.h"
    … …  
    162172  _pShallowCopyDelete(dest_heap, source_p, source_heap)
    163173
    164 
    165 
    166174// Adds exponents of p2 to exponents of p1
    167175// assumes that exponents >= 0 and and one Component != 0
    … …  
    177185
    178186/*-------------operations on polynomials:------------*/
    179 poly      pNeg(poly p);
    180187poly      pSub(poly a, poly b);
    181 poly      pMult(poly a, poly b);
     188poly      pPower(poly p, int i);
     189/*
    182190void      pMultN(poly a, number c);
    183191poly      pMultCopyN(poly a, number c);
    184 poly      pPower(poly p, int i);
    185 
     192poly      pMult(poly a, poly b);
     193poly      pNeg(poly p);
     194*/
    186195
    187196// ----------------- define to enable new p_procs -----*/
    … …  
    192201#define pCopy   p_Copy
    193202#define pAdd    p_Add_q
     203#define pMult   p_Mult_q
     204#define pNeg    p_Neg
     205#define pMultN  p_Mult_nn
     206#define pMultCopyN pp_Mult_nn
     207#define pMultT     p_Mult_mm
    194208#else
    195209// deletes the whole polynomial p
    … …  
    197211// Returns copy of the whole polynomial
    198212#define pCopy(p)        _pCopy(currPolyBin, p)
     213void      pMultN(poly a, number c);
     214poly      pMultCopyN(poly a, number c);
    199215poly      pAdd(poly p1, poly p2);
     216poly      pMult(poly a, poly b);
     217poly      pNeg(poly p);
     218poly      pMultT(poly a, poly e);
    200219#endif
    201220
    … …  
    323342
    324343/*-----------specials for spoly-computations--------------*/
    325 poly    pMultT(poly a, poly e);
    326344int     pDivComp(poly p, poly q);
    327345BOOLEAN pCompareChain (poly p,poly p1,poly p2,poly lcm);
    … …  
    333351// tests (see polys-impl.cc )
    334352unsigned long pGetShortExpVector(poly p);
    335 
     353// reverses the monomials of p
     354PINLINE poly pReverse(poly p);
    336355
    337356
    … …  
    353372#endif
    354373#endif
     374
     375#include "pInline.cc"

  • Singular/polys1.cc

    rb0bcea r55b8ae  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: polys1.cc,v 1.43 2000-08-24 14:42:45 obachman Exp $ */
     4/* $Id: polys1.cc,v 1.44 2000-08-29 14:10:30 obachman Exp $ */
    55
    66/*
    … …  
    137137
    138138#ifndef HAVE_P_PROCS
     139/*2
     140* multiply a polynomial by -1
     141*/
     142poly pNeg(poly p)
     143{
     144  poly h = p;
     145  while (h!=NULL)
     146  {
     147    pGetCoeff(h)=nNeg(pGetCoeff(h));
     148    pIter(h);
     149  }
     150  return p;
     151}
     152
    139153/*-------------operations on polynomials:------------*/
    140154/*2
    … …  
    210224
    211225
    212 /*2
    213 * multiply a polynomial by -1
    214 */
    215 poly pNeg(poly p)
    216 {
    217   poly h = p;
    218   while (h!=NULL)
    219   {
    220     pGetCoeff(h)=nNeg(pGetCoeff(h));
    221     pIter(h);
    222   }
    223   return p;
    224 }
    225226
    226227/*2

  • Singular/prCopy.cc

    rb0bcea r55b8ae  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: prCopy.cc,v 1.3 2000-08-14 12:56:46 obachman Exp $ */
     4/* $Id: prCopy.cc,v 1.4 2000-08-29 14:10:30 obachman Exp $ */
    55/*
    66* ABSTRACT - implementation of functions for Copy/Move/Delete for Polys
    … …  
    7272  if (revert)
    7373  {
     74    // there must be a bug here: consider m1->m2
    7475    while (p != NULL)
    7576    {
Note: See TracChangeset for help on using the changeset viewer.