Changeset 0f401f in git


Ignore:
Timestamp:
Jul 14, 2011, 2:48:53 PM (12 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', 'f875bbaccd0831e36aaed09ff6adeb3eb45aeb94')
Children:
210e07a1e0428569506a64e13a3ad98460b707e3
Parents:
4ecc5a466643ed4b440bdb5eff9c7fe6f19452a4
git-author:
Hans Schoenemann <hannes@mathematik.uni-kl.de>2011-07-14 14:48:53+02:00
git-committer:
Mohamed Barakat <mohamed.barakat@rwth-aachen.de>2011-11-09 12:39:15+01:00
Message:
fixed options.h, numbers.h, restored ideals.cc
Files:
1 added
37 edited

Legend:

Unmodified
Added
Removed

  • kernel/eigenval.cc

    r4ecc5a4 r0f401f  
    1515//#include "ipid.h"
    1616#include <kernel/intvec.h>
    17 #include <kernel/numbers.h>
     17#include <coeffs/numbers.h>
    1818#include <kernel/polys.h>
    1919#include <kernel/ideals.h>

  • kernel/fast_maps.cc

    r4ecc5a4 r0f401f  
    1111#include <kernel/mod2.h>
    1212#include <omalloc/omalloc.h>
    13 #include <kernel/options.h>
     13#include <misc/options.h>
    1414#include <kernel/p_polys.h>
    1515#include <kernel/prCopy.h>

  • kernel/febase.cc

    r4ecc5a4 r0f401f  
    2525#include <kernel/febase.h>
    2626#include <omalloc/omalloc.h>
    27 #include <kernel/dError.h>
    28 #include <kernel/options.h>
     27#include <reporter/reporter.h>
     28#include <resources/feFopen.h>
     29#include <misc/options.h>
    2930
    3031#define fePutChar(c) fputc((unsigned char)(c),stdout)

  • kernel/feread.cc

    r4ecc5a4 r0f401f  
    2020#include <kernel/febase.h>
    2121#include <omalloc/omalloc.h>
    22 #include <kernel/options.h>
     22#include <misc/options.h>
    2323
    2424#include <Singular/static.h>

  • kernel/fglmcomb.cc

    r4ecc5a4 r0f401f  
    1212
    1313#ifdef HAVE_FACTORY
    14 #include <kernel/options.h>
     14#include <misc/options.h>
    1515#include <kernel/polys.h>
    1616#include <kernel/ideals.h>

  • kernel/fglmgauss.cc

    r4ecc5a4 r0f401f  
    1414#ifdef  HAVE_FACTORY
    1515#include <kernel/structs.h>
    16 #include <kernel/numbers.h>
     16#include <coeffs/numbers.h>
    1717#include <kernel/ring.h>
    1818#include <omalloc/omalloc.h>

  • kernel/fglmvec.cc

    r4ecc5a4 r0f401f  
    1818#include <omalloc/omalloc.h>
    1919#include <kernel/structs.h>
    20 #include <kernel/numbers.h>
     20#include <coeffs/numbers.h>
    2121#include <kernel/fglm.h>
    2222#include <kernel/fglmvec.h>

  • kernel/fglmzero.cc

    r4ecc5a4 r0f401f  
    2222
    2323#ifdef HAVE_FACTORY
    24 #include <kernel/options.h>
     24#include <misc/options.h>
    2525#include <kernel/polys.h>
    2626#include <kernel/ideals.h>

  • kernel/gfan.cc

    r4ecc5a4 r0f401f  
    1010
    1111#ifdef HAVE_FANS
    12 #include <kernel/options.h>
     12#include <misc/options.h>
    1313#include <kernel/kstd1.h>
    1414#include <kernel/kutil.h>

  • kernel/gr_kstd2.cc

    r4ecc5a4 r0f401f  
    1717#include <kernel/ideals.h>
    1818#include <kernel/febase.h>
    19 #include <kernel/options.h>
     19#include <misc/options.h>
    2020#include <kernel/kutil.h>
    2121#include <kernel/kstd1.h>

  • kernel/hdegree.cc

    r4ecc5a4 r0f401f  
    1616#include <kernel/polys.h>
    1717#include <kernel/intvec.h>
    18 #include <kernel/numbers.h>
     18#include <coeffs/numbers.h>
    1919#include <kernel/hutil.h>
    2020#include <kernel/stairc.h>

  • kernel/kInline.cc

    r4ecc5a4 r0f401f  
    1919#include <kernel/kbuckets.h>
    2020#include <omalloc/omalloc.h>
    21 #include <kernel/options.h>
     21#include <misc/options.h>
    2222
    2323#define HAVE_TAIL_BIN

  • kernel/khstd.cc

    r4ecc5a4 r0f401f  
    99#include <kernel/mod2.h>
    1010#include <kernel/febase.h>
    11 #include <kernel/options.h>
     11#include <misc/options.h>
    1212#include <kernel/polys.h>
    1313#include <kernel/intvec.h>

  • kernel/kspoly.cc

    r4ecc5a4 r0f401f  
    99// #define PDEBUG 2
    1010#include <kernel/mod2.h>
    11 #include <kernel/options.h>
     11#include <misc/options.h>
    1212#include <kernel/kutil.h>
    13 #include <kernel/numbers.h>
     13#include <coeffs/numbers.h>
    1414#include <kernel/p_polys.h>
    1515#include <kernel/p_Procs.h>

  • kernel/kstd1.cc

    r4ecc5a4 r0f401f  
    3030#endif /* if MYTEST */
    3131
    32 #include <kernel/options.h>
     32#include <misc/options.h>
    3333#include <kernel/kutil.h>
    3434#include <kernel/kInline.cc>

  • kernel/kstd2.cc

    r4ecc5a4 r0f401f  
    3535#endif
    3636#include <kernel/kutil.h>
    37 #include <kernel/options.h>
     37#include <misc/options.h>
    3838#include <omalloc/omalloc.h>
    3939#include <kernel/polys.h>

  • kernel/kstdfac.cc

    r4ecc5a4 r0f401f  
    99#include <kernel/mod2.h>
    1010#include <omalloc/omalloc.h>
    11 #include <kernel/options.h>
     11#include <misc/options.h>
    1212#include <kernel/polys.h>
    1313#include <kernel/ideals.h>

  • kernel/kutil.cc

    r4ecc5a4 r0f401f  
    2222
    2323#include <omalloc/mylimits.h>
    24 #include <kernel/options.h>
     24#include <misc/options.h>
    2525#include <kernel/gring.h>
    2626#include <kernel/sca.h>
    … …  
    4848#include <kernel/febase.h>
    4949#include <omalloc/omalloc.h>
    50 #include <kernel/numbers.h>
     50#include <coeffs/numbers.h>
    5151#include <kernel/polys.h>
    5252#include <kernel/ring.h>

  • kernel/linearAlgebra.cc

    r4ecc5a4 r0f401f  
    2121#include <kernel/polys.h>
    2222#include <kernel/ideals.h>
    23 #include <kernel/numbers.h>
     23#include <coeffs/numbers.h>
    2424#include <kernel/matpol.h>
    2525#include <Singular/lists.h>

  • kernel/misc.cc

    r4ecc5a4 r0f401f  
    1717#include <omalloc/omalloc.h>
    1818#include <kernel/structs.h>
    19 #include <kernel/options.h>
     19#include <misc/options.h>
    2020#include <kernel/febase.h>
    2121//#include "cntrlc.h"

  • kernel/mod2.h

    r4ecc5a4 r0f401f  
    5353/* letterplace gb:*/
    5454#define HAVE_SHIFTBBA 1
    55 
    56 /* rings as coefficients */
    57 #define HAVE_RINGS
    5855
    5956/* procedures to compute with units */

  • kernel/ratgring.cc

    r4ecc5a4 r0f401f  
    1616#include <kernel/ring.h>
    1717#include <kernel/polys.h>
    18 #include <kernel/numbers.h>
     18#include <coeffs/numbers.h>
    1919#include <kernel/ideals.h>
    2020#include <kernel/matpol.h>
    … …  
    2525#include <kernel/p_Mult_q.h>
    2626#include <kernel/clapsing.h>
    27 #include <kernel/options.h>
     27#include <misc/options.h>
    2828
    2929void pLcmRat(poly a, poly b, poly m, int rat_shift)

  • kernel/shiftgb.cc

    r4ecc5a4 r0f401f  
    1313#include <kernel/ring.h>
    1414#include <kernel/polys.h>
    15 #include <kernel/numbers.h>
     15#include <coeffs/numbers.h>
    1616#include <kernel/ideals.h>
    1717#include <kernel/matpol.h>

  • kernel/spectrum.cc

    r4ecc5a4 r0f401f  
    2121#include <omalloc/mylimits.h>
    2222
    23 #include <kernel/numbers.h>
     23#include <coeffs/numbers.h>
    2424#include <kernel/polys.h>
    2525#include <kernel/ideals.h>

  • kernel/splist.cc

    r4ecc5a4 r0f401f  
    2121#include <kernel/structs.h>
    2222#include <kernel/GMPrat.h>
    23 #include <kernel/numbers.h>
     23#include <coeffs/numbers.h>
    2424#include <kernel/polys.h>
    2525#include <kernel/npolygon.h>

  • kernel/structs.h

    r4ecc5a4 r0f401f  
    3535#define BITSET  unsigned int
    3636
    37 #if defined(SI_CPU_I386) || defined(SI_CPU_X86_64)
    38   // the following settings seems to be better on i386 and x86_64 processors
    39   // define if a*b is with mod instead of tables
    40   #define HAVE_MULT_MOD
    41   // #define HAVE_GENERIC_ADD
    42   // #ifdef HAVE_MULT_MOD
    43   // #define HAVE_DIV_MOD
    44   // #endif
    45 #elif defined(SI_CPU_IA64)
    46   // the following settings seems to be better on itanium processors
    47   // #define HAVE_MULT_MOD
    48   #define HAVE_GENERIC_ADD
    49   // #ifdef HAVE_MULT_MOD
    50   // #define HAVE_DIV_MOD
    51   // #endif
    52 #elif defined(SI_CPU_SPARC)
    53   // #define HAVE_GENERIC_ADD
    54   #define HAVE_MULT_MOD
    55   #ifdef HAVE_MULT_MOD
    56   #define HAVE_DIV_MOD
    57   #endif
    58 #elif defined(SI_CPU_PPC)
    59   // the following settings seems to be better on ppc processors
    60   // testet on: ppc_Linux, 740/750 PowerMac G3, 512k L2 cache
    61   #define HAVE_MULT_MOD
    62   // #ifdef HAVE_MULT_MOD
    63   // #define HAVE_DIV_MOD
    64   // #endif
    65 #endif
    66 
    6737#if SIZEOF_LONG == 4
    6838typedef long long int64;
    … …  
    7444
    7545
    76 enum n_coeffType
    77 {
    78   n_unknown=0,
    79   n_Zp,
    80   n_Q,
    81   n_R,
    82   n_GF,
    83   n_long_R,
    84   n_Zp_a,
    85   n_Q_a,
    86   n_long_C
    87 #ifdef HAVE_RINGS
    88   ,n_Z,
    89   n_Zm,
    90   n_Zpn,
    91   n_Z2n
    92 #endif
    93 };
    94 
    95 
    96 struct snumber;
    97 typedef struct snumber *   number;
    98 typedef number (*numberfunc)(number a,number b);
    99 
    10046/* C++-part */
    10147#ifdef __cplusplus
    102 class ip_smatrix;
    103 class intvec;
    10448class sleftv;
    10549class slists;
    … …  
    10852class ssyStrategy;
    10953class procinfo;
    110 class kBucket;
    111 class sBucket;
    11254class CPolynomialSummator;
    11355class CGlobalMultiplier;
    … …  
    11557#endif
    11658
    117 struct n_Procs_s;
    118 struct sip_sring;
    119 struct sip_link;
    120 struct spolynom;
    121 
    12259struct sip_package;
    12360typedef struct sip_package ip_package;
    12461typedef ip_package *       package;
    125 
    126 // forward for ideals.h:
    127 struct sip_sideal;
    128 typedef struct sip_sideal *       ideal;
    12962
    13063
    … …  
    13669// #endif
    13770
    138 typedef struct spolyrec    polyrec;
    139 typedef struct sip_sring   ip_sring;
    14071typedef struct sip_link    ip_link;
    14172
    … …  
    14374typedef char *             char_ptr;
    14475typedef int  *             int_ptr;
    145 typedef ip_sring *         ring;
    146 typedef poly *             polyset;
    14776
    14877#ifdef __cplusplus
    149 typedef ip_smatrix *       matrix;
    15078typedef ip_link *          si_link;
    15179typedef sleftv *           leftv;
    … …  
    15583typedef ssyStrategy *      syStrategy;
    15684typedef procinfo *         procinfov;
    157 typedef kBucket*           kBucket_pt;
    158 typedef sBucket*           sBucket_pt;
    159 typedef struct p_Procs_s p_Procs_s;
    160 
    161 struct n_Procs_s
    162 {
    163    n_Procs_s* next;
    164    // the union stuff
    165    // Zp:
    166    int npPrimeM;
    167    int npPminus1M;
    168    #ifdef HAVE_DIV_MOD
    169    unsigned short *npInvTable;
    170    #endif
    171    #if !defined(HAVE_DIV_MOD) || !defined(HAVE_MULT_MOD)
    172    unsigned short *npExpTable;
    173    unsigned short *npLogTable;
    174    #endif
    175    // Zp_a, Q_a
    176 
    177    // general stuff
    178    numberfunc nMult, nSub ,nAdd ,nDiv, nIntDiv, nIntMod, nExactDiv;
    179    number  (*cfInit)(int i,const ring r);
    180    number  (*nPar)(int i);
    181    int     (*nParDeg)(number n);
    182    int     (*nSize)(number n);
    183    int     (*n_Int)(number &n, const ring r);
    184 #ifdef HAVE_RINGS
    185    int     (*nDivComp)(number a,number b);
    186    BOOLEAN (*nIsUnit)(number a);
    187    number  (*nGetUnit)(number a);
    188    number  (*nExtGcd)(number a, number b, number *s, number *t);
    189 #endif
    190    number  (*nNeg)(number a);
    191    number  (*nInvers)(number a);
    192    number  (*nCopy)(number a);
    193    number  (*cfCopy)(number a, const ring r);
    194    number  (*nRePart)(number a);
    195    number  (*nImPart)(number a);
    196    void    (*cfWrite)(number &a, const ring r);
    197    const char *  (*nRead)(const char * s, number * a);
    198    void    (*nNormalize)(number &a);
    199    BOOLEAN (*nGreater)(number a,number b),
    200 #ifdef HAVE_RINGS
    201            (*nDivBy)(number a, number b),
    202 #endif
    203            (*nEqual)(number a,number b),
    204            (*nIsZero)(number a),
    205            (*nIsOne)(number a),
    206            (*nIsMOne)(number a),
    207            (*nGreaterZero)(number a);
    208    void    (*nPower)(number a, int i, number * result);
    209    number  (*cfGetDenom)(number &n, const ring r);
    210    number  (*cfGetNumerator)(number &n, const ring r);
    211    number  (*nGcd)(number a, number b, const ring r);
    212    number  (*nLcm)(number a, number b, const ring r);
    213    void    (*cfDelete)(number * a, const ring r);
    214    nMapFunc (*cfSetMap)(const ring src, const ring dst);
    215    char *  (*nName)(number n);
    216    void    (*nInpMult)(number &a, number b, ring r);
    217 #ifdef LDEBUG
    218    BOOLEAN (*nDBTest)(number a, const char *f,const int l);
    219 #endif
    220 
    221    number nNULL; /* the 0 as constant */
    222    int     char_flag;
    223    int     ref;
    224    n_coeffType type;
    225    short   nChar;
    226 };
    22785
    22886/* the function pointer types */
    22987
    230 typedef long     (*pLDegProc)(poly p, int *length, ring r);
    231 typedef long     (*pFDegProc)(poly p, ring r);
    232 typedef void     (*p_SetmProc)(poly p, const ring r);
    233 
    234 typedef enum
    235 {
    236   ro_dp, // ordering is a degree ordering
    237   ro_wp, // ordering is a weighted degree ordering
    238   ro_wp64, // ordering is a weighted64 degree ordering
    239   ro_wp_neg, // ordering is a weighted degree ordering
    240              // with possibly negative weights
    241   ro_cp,    // ordering duplicates variables
    242   ro_syzcomp, // ordering indicates "subset" of component number (ringorder_S)
    243   ro_syz, // ordering  with component number >syzcomp is lower (ringorder_s)
    244   ro_isTemp, ro_is, // Induced Syzygy (Schreyer) ordering (and prefix data placeholder dummy) (ringorder_IS)
    245   ro_none
    246 }
    247 ro_typ;
    248 
    249 // ordering is a degree ordering
    250 struct sro_dp
    251 {
    252   short place;  // where degree is stored (in L):
    253   short start;  // bounds of ordering (in E):
    254   short end;
    255 };
    256 typedef struct sro_dp sro_dp;
    257 
    258 // ordering is a weighted degree ordering
    259 struct sro_wp
    260 {
    261   short place;  // where weighted degree is stored (in L)
    262   short start;  // bounds of ordering (in E)
    263   short end;
    264   int *weights; // pointers into wvhdl field
    265 };
    266 typedef struct sro_wp sro_wp;
    267 
    268 // ordering is a weighted degree ordering
    269 struct sro_wp64
    270 {
    271     short place;  // where weighted degree is stored (in L)
    272     short start;  // bounds of ordering (in E)
    273     short end;
    274     int64 *weights64; // pointers into wvhdl field
    275 };
    276 typedef struct sro_wp64 sro_wp64;
    277 
    278 // ordering duplicates variables
    279 struct sro_cp
    280 {
    281   short place;  // where start is copied to (in E)
    282   short start;  // bounds of sources of copied variables (in E)
    283   short end;
    284 };
    285 typedef struct sro_cp sro_cp;
    286 
    287 // ordering indicates "subset" of component number
    288 struct sro_syzcomp
    289 {
    290   short place;  // where the index is stored (in L)
    291   long *ShiftedComponents; // pointer into index field
    292   int* Components;
    293 #ifdef PDEBUG
    294   long length;
    295 #endif
    296 };
    297 typedef struct sro_syzcomp sro_syzcomp;
    298 
    299 // ordering  with component number >syzcomp is lower
    300 struct sro_syz
    301 {
    302   short place;       // where the index is stored (in L)
    303   int limit;         // syzcomp
    304   int* syz_index;    // mapping Component -> SyzIndex for Comp <= limit
    305   int  curr_index;   // SyzIndex for Component > limit
    306 };
    307 
    308 typedef struct sro_syz sro_syz;
    309 // Induced Syzygy (Schreyer) ordering is built inductively as follows:
    310 // we look for changes made by ordering blocks which are between prefix/suffix markers:
    311 // that is: which variables where placed by them and where (judging by v)
    312 
    313 // due to prefix/suffix nature we need some placeholder:
    314 // prefix stores here initial state
    315 // suffix cleares this up
    316 struct sro_ISTemp
    317 {
    318   short start; // 1st member SHOULD be short "place"
    319   int   suffixpos;
    320   int*  pVarOffset; // copy!
    321 };
    322 
    323 // So this is the actuall thing!
    324 // suffix uses last sro_ISTemp (cleares it up afterwards) and
    325 // creates this block
    326 struct sro_IS
    327 {
    328   short start, end;  // which part of L we want to want to update...
    329   int*  pVarOffset; // same as prefix!
    330 
    331   int limit; // first referenced component
    332 
    333   // reference poly set?? // Should it be owned by ring?!!!
    334   ideal F; // reference leading (module)-monomials set. owned by ring...
    335   const intvec* componentWeights; // component weights! owned by ring...
    336 };
    337 
    338 typedef struct sro_IS sro_IS;
    339 typedef struct sro_ISTemp sro_ISTemp;
    340 
    341 struct sro_ord
    342 {
    343   ro_typ  ord_typ;
    344   int     order_index; // comes from r->order[order_index]
    345   union
    346   {
    347      sro_dp dp;
    348      sro_wp wp;
    349      sro_wp64 wp64;
    350      sro_cp cp;
    351      sro_syzcomp syzcomp;
    352      sro_syz syz;
    353      sro_IS is;
    354      sro_ISTemp isTemp;
    355   } data;
    356 };
    357 
    358 #ifdef HAVE_PLURAL
    359 // NC pProcs:
    360 typedef poly (*mm_Mult_p_Proc_Ptr)(const poly m, poly p, const ring r);
    361 typedef poly (*mm_Mult_pp_Proc_Ptr)(const poly m, const poly p, const ring r);
    362 
    363 typedef ideal (*GB_Proc_Ptr)(const ideal F, const ideal Q, const intvec *w, const intvec *hilb, kStrategy strat);
    364 
    365 typedef poly (*SPoly_Proc_Ptr)(const poly p1, const poly p2, const ring r);
    366 typedef poly (*SPolyReduce_Proc_Ptr)(const poly p1, poly p2, const ring r);
    367 
    368 typedef void (*bucket_Proc_Ptr)(kBucket_pt b, poly p, number *c);
    369 
    370 struct nc_pProcs
    371 {
    372 public:
    373   mm_Mult_p_Proc_Ptr                    mm_Mult_p;
    374   mm_Mult_pp_Proc_Ptr                   mm_Mult_pp;
    375 
    376   bucket_Proc_Ptr                       BucketPolyRed;
    377   bucket_Proc_Ptr                       BucketPolyRed_Z;
    378 
    379   SPoly_Proc_Ptr                        SPoly;
    380   SPolyReduce_Proc_Ptr                  ReduceSPoly;
    381 
    382   GB_Proc_Ptr                           GB;
    383 //                                         GlobalGB, // BBA
    384 //                                         LocalGB;  // MORA
    385 };
    386 
    387 
    388 struct nc_struct
    389 {
    390   nc_type type;
    391   //ring basering; // the ring C,D,.. live in (commutative ring with this NC structure!)
    392 
    393   // initial data: square matrices rVar() x rVar()
    394   // logically: upper triangular!!!
    395   // TODO: eliminate this waste of memory!!!!
    396   matrix C;
    397   matrix D;
    398 
    399   // computed data:
    400   matrix *MT; // size 0.. (rVar()*rVar()-1)/2
    401   matrix COM;
    402   int *MTsize; // size 0.. (rVar()*rVar()-1)/2
    403 
    404   // IsSkewConstant indicates whethere coeffs C_ij are all equal,
    405   // effective together with nc_type=nc_skew
    406   int IsSkewConstant;
    407 
    408   private:
    409     // internal data for different implementations
    410     // if dynamic => must be deallocated in destructor (nc_rKill!)
    411     union
    412     {
    413       struct
    414       {
    415         // treat variables from iAltVarsStart till iAltVarsEnd as alternating vars.
    416         // these variables should have odd degree, though that will not be checked
    417         // iAltVarsStart, iAltVarsEnd are only used together with nc_type=nc_exterior
    418         // 1 <= iAltVarsStart <= iAltVarsEnd <= r->N
    419         unsigned int iFirstAltVar, iLastAltVar; // = 0 by default
    420 
    421         // for factors of super-commutative algebras we need
    422         // the part of general quotient ideal modulo squares!   
    423         ideal idSCAQuotient; // = NULL by default. // must be deleted in Kill!
    424       } sca;
    425     } data;
    426 
    427     CGlobalMultiplier* m_Multiplier;
    428     CFormulaPowerMultiplier* m_PowerMultiplier;
    429 
    430   public:
    431    
    432     inline nc_type& ncRingType() { return (type); };
    433     inline nc_type ncRingType() const { return (type); };
    434 
    435     inline unsigned int& FirstAltVar()
    436         { assume(ncRingType() == nc_exterior); return (data.sca.iFirstAltVar); };
    437     inline unsigned int& LastAltVar ()
    438         { assume(ncRingType() == nc_exterior); return (data.sca.iLastAltVar ); };
    439 
    440     inline unsigned int FirstAltVar() const
    441         { assume(ncRingType() == nc_exterior); return (data.sca.iFirstAltVar); };
    442     inline unsigned int LastAltVar () const
    443         { assume(ncRingType() == nc_exterior); return (data.sca.iLastAltVar ); };
    444 
    445     inline ideal& SCAQuotient()
    446         { assume(ncRingType() == nc_exterior); return (data.sca.idSCAQuotient); };
    447 
    448     inline CGlobalMultiplier* GetGlobalMultiplier() const
    449         { return (m_Multiplier); };
    450 
    451     inline CGlobalMultiplier*& GetGlobalMultiplier()
    452         { return (m_Multiplier); };
    453 
    454 
    455     inline CFormulaPowerMultiplier* GetFormulaPowerMultiplier() const
    456         { return (m_PowerMultiplier); };
    457 
    458     inline CFormulaPowerMultiplier*& GetFormulaPowerMultiplier()
    459         { return (m_PowerMultiplier); };
    460    
    461   public:
    462     nc_pProcs p_Procs; // NC procedures.
    463 
    464 };
    465 #endif
    466 
    46788class idrec;
    46889typedef idrec *   idhdl;
    469 
    470 struct sip_sring
    471 {
    472 // each entry must have a description and a procedure defining it,
    473 // general ordering: pointer/structs, long, int, short, BOOLEAN/char/enum
    474 // general defining procedures: rInit, rComplete, interpreter, ??
    475   idhdl      idroot; /* local objects , interpreter*/
    476   int*       order;  /* array of orderings, rInit/rSleftvOrdering2Ordering */
    477   int*       block0; /* starting pos., rInit/rSleftvOrdering2Ordering*/
    478   int*       block1; /* ending pos., rInit/rSleftvOrdering2Ordering*/
    479   char**     parameter; /* names of parameters, rInit */
    480   number     minpoly;  /* for Q_a/Zp_a, rInit */
    481   ideal      minideal;
    482   int**      wvhdl;  /* array of weight vectors, rInit/rSleftvOrdering2Ordering */
    483   char **    names;  /* array of variable names, rInit */
    484 
    485   // what follows below here should be set by rComplete, _only_
    486   long      *ordsgn;  /* array of +/- 1 (or 0) for comparing monomials */
    487                        /*  ExpL_Size entries*/
    488 
    489   // is NULL for lp or N == 1, otherwise non-NULL (with OrdSize > 0 entries) */
    490   sro_ord*   typ;   /* array of orderings + sizes, OrdSize entries */
    491   /* if NegWeightL_Size > 0, then NegWeightL_Offset[0..size_1] is index of longs
    492   in ExpVector whose values need an offset due to negative weights */
    493   /* array of NegWeigtL_Size indicies */
    494   int*      NegWeightL_Offset;
    495 
    496   int*     VarOffset;
    497 
    498   ideal      qideal; /* extension to the ring structure: qring, rInit */
    499 
    500   int*     firstwv;
    501 
    502   omBin    PolyBin; /* Bin from where monoms are allocated */
    503 #ifdef HAVE_RINGS
    504   unsigned int  ringtype;  /* cring = 0 => coefficient field, cring = 1 => coeffs from Z/2^m */
    505   int_number    ringflaga; /* Z/(ringflag^ringflagb)=Z/nrnModul*/
    506   unsigned long ringflagb;
    507   unsigned long nr2mModul;  /* Z/nr2mModul */
    508   int_number    nrnModul;
    509 #endif
    510   unsigned long options; /* ring dependent options */
    511 
    512   int        ch;  /* characteristic, rInit */
    513   int        ref; /* reference counter to the ring, interpreter */
    514 
    515   short      float_len; /* additional char-flags, rInit */
    516   short      float_len2; /* additional char-flags, rInit */
    517 
    518   short      N;      /* number of vars, rInit */
    519 
    520   short      P;      /* number of pars, rInit */
    521   short      OrdSgn; /* 1 for polynomial rings, -1 otherwise, rInit */
    522 
    523   short     firstBlockEnds;
    524 #ifdef HAVE_PLURAL
    525   short     real_var_start, real_var_end;
    526 #endif
    527 
    528 #ifdef HAVE_SHIFTBBA
    529   short          isLPring; /* 0 for non-letterplace rings, otherwise the number of LP blocks, at least 1, known also as lV */
    530 #endif
    531 
    532   BOOLEAN   VectorOut;
    533   BOOLEAN   ShortOut;
    534   BOOLEAN   CanShortOut;
    535   BOOLEAN   LexOrder; // TRUE if the monomial ordering has polynomial and power series blocks
    536   BOOLEAN   MixedOrder; // TRUE for global/local mixed orderings, FALSE otherwise
    537 
    538   BOOLEAN   ComponentOrder; // ???
    539 
    540   // what follows below here should be set by rComplete, _only_
    541   // contains component, but no weight fields in E */
    542   short      ExpL_Size; // size of exponent vector in long
    543   short      CmpL_Size; // portions which need to be compared
    544   /* number of long vars in exp vector:
    545      long vars are those longs in the exponent vector which are
    546      occupied by variables, only */
    547   short      VarL_Size;
    548   short      BitsPerExp; /* number of bits per exponent */
    549   short      ExpPerLong; /* maximal number of Exponents per long */
    550   short      pCompIndex; /* p->exp.e[pCompIndex] is the component */
    551   short      pOrdIndex; /* p->exp[pOrdIndex] is pGetOrd(p) */
    552   short      OrdSize; /* size of ord vector (in sro_ord) */
    553 
    554   /* if >= 0, long vars in exp vector are consecutive and start there
    555      if <  0, long vars in exp vector are not consecutive */
    556   short     VarL_LowIndex;
    557   // number of exponents in r->VarL_Offset[0]
    558   // is minimal number of exponents in a long var
    559   short     MinExpPerLong;
    560 
    561   short     NegWeightL_Size;
    562   /* array of size VarL_Size,
    563      VarL_Offset[i] gets i-th long var in exp vector */
    564   int*      VarL_Offset;
    565 
    566   /* mask for getting single exponents */
    567   unsigned long bitmask;
    568   /* mask used for divisiblity tests */
    569   unsigned long divmask; // rComplete
    570 
    571   p_Procs_s*    p_Procs; // rComplete/p_ProcsSet
    572 
    573   /* FDeg and LDeg */
    574   pFDegProc     pFDeg; // rComplete/rSetDegStuff
    575   pLDegProc     pLDeg; // rComplete/rSetDegStuff
    576 
    577   /* as it was determined by rComplete */
    578   pFDegProc     pFDegOrig;
    579   /* and as it was determined before rOptimizeLDeg */
    580   pLDegProc     pLDegOrig;
    581 
    582   p_SetmProc    p_Setm;
    583   n_Procs_s*    cf;
    584   ring          extRing;
    585 #ifdef HAVE_PLURAL
    586   private:
    587     nc_struct*    _nc; // private
    588   public:
    589     inline const nc_struct* GetNC() const { return _nc; }; // public!!!
    590     inline nc_struct*& GetNC() { return _nc; }; // public!!!
    591 #endif
    592 };
    59390
    59491#endif /* __cplusplus */

  • kernel/syz.cc

    r4ecc5a4 r0f401f  
    1010
    1111#include <kernel/mod2.h>
    12 #include <kernel/options.h>
     12#include <misc/options.h>
    1313#include <omalloc/omalloc.h>
    1414#include <kernel/polys.h>
    … …  
    1818#include <kernel/stairc.h>
    1919#include <kernel/intvec.h>
    20 #include <kernel/numbers.h>
     20#include <coeffs/numbers.h>
    2121#include <kernel/ideals.h>
    2222#include <kernel/intvec.h>

  • kernel/syz0.cc

    r4ecc5a4 r0f401f  
    99
    1010#include <kernel/mod2.h>
    11 #include <kernel/options.h>
     11#include <misc/options.h>
    1212#include <omalloc/omalloc.h>
    1313#include <kernel/polys.h>
    … …  
    1818//#include "cntrlc.h"
    1919#include <kernel/intvec.h>
    20 #include <kernel/numbers.h>
     20#include <coeffs/numbers.h>
    2121#include <kernel/ideals.h>
    2222#include <kernel/intvec.h>

  • kernel/syz1.cc

    r4ecc5a4 r0f401f  
    99#include <kernel/mod2.h>
    1010#include <omalloc/mylimits.h>
    11 #include <kernel/options.h>
     11#include <misc/options.h>
    1212#include <omalloc/omalloc.h>
    1313#include <kernel/polys.h>
    … …  
    1818//#include "cntrlc.h"
    1919#include <kernel/intvec.h>
    20 #include <kernel/numbers.h>
     20#include <coeffs/numbers.h>
    2121#include <kernel/modulop.h>
    2222#include <kernel/ideals.h>

  • kernel/syz2.cc

    r4ecc5a4 r0f401f  
    99#include <kernel/mod2.h>
    1010#include <omalloc/mylimits.h>
    11 #include <kernel/options.h>
     11#include <misc/options.h>
    1212#include <omalloc/omalloc.h>
    1313#include <kernel/syz.h>
    … …  
    1919//#include "cntrlc.h"
    2020#include <kernel/intvec.h>
    21 #include <kernel/numbers.h>
     21#include <coeffs/numbers.h>
    2222#include <kernel/modulop.h>
    2323#include <kernel/ideals.h>

  • kernel/syz3.cc

    r4ecc5a4 r0f401f  
    99#include <kernel/mod2.h>
    1010#include <omalloc/mylimits.h>
    11 #include <kernel/options.h>
     11#include <misc/options.h>
    1212#include <omalloc/omalloc.h>
    1313#include <kernel/polys.h>
    … …  
    1818//#include "cntrlc.h"
    1919#include <kernel/intvec.h>
    20 #include <kernel/numbers.h>
     20#include <coeffs/numbers.h>
    2121#include <kernel/modulop.h>
    2222#include <kernel/ideals.h>

  • kernel/tgb.cc

    r4ecc5a4 r0f401f  
    1616///@TODO: no tail reductions in syz comp
    1717#include <kernel/mod2.h>
    18 #include <kernel/options.h>
     18#include <misc/options.h>
    1919#include <kernel/tgb.h>
    2020#include <kernel/tgb_internal.h>

  • kernel/tgb_internal.h

    r4ecc5a4 r0f401f  
    1515#include <kernel/ring.h>
    1616#include <kernel/febase.h>
    17 #include <kernel/options.h>
     17#include <misc/options.h>
    1818#include <kernel/polys.h>
    1919#include <stdlib.h>

  • kernel/tgbgauss.cc

    r4ecc5a4 r0f401f  
    77*/
    88#include <kernel/mod2.h>
    9 #include <kernel/options.h>
     9#include <misc/options.h>
    1010#include <kernel/tgbgauss.h>
    1111#include <omalloc/omalloc.h>

  • kernel/units.cc

    r4ecc5a4 r0f401f  
    1010#include <kernel/structs.h>
    1111#include <kernel/febase.h>
    12 #include <kernel/numbers.h>
     12#include <coeffs/numbers.h>
    1313#include <kernel/polys.h>
    1414#include <kernel/ideals.h>

  • kernel/walkMain.cc

    r4ecc5a4 r0f401f  
    99#include <string.h>
    1010#include <kernel/mod2.h>
    11 #include <kernel/options.h>
     11#include <misc/options.h>
    1212#include <kernel/intvec.h>
    1313#include <kernel/int64vec.h>

  • omalloc/omalloc.c

    r4ecc5a4 r0f401f  
    1414#define OMALLOC_C
    1515
    16 #include <omalloc.h>
     16#include <omalloc/omalloc.h>
    1717
    1818#ifdef OM_MALLOC_MARK_AS_STATIC
Note: See TracChangeset for help on using the changeset viewer.