Changeset dc4782 in git


Ignore:
Timestamp:
Nov 25, 2013, 4:49:42 PM (9 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', '48f1dd268d0ff74ef2f7dccbf02545425002ddcc')
Children:
98e588265496a69b639a1e37bf39d39134a6df5f
Parents:
7bb7da5db82ebe13b1923654fb861e84c6c3ec65
Message:
chg: factory/libfac is not optional, removing HAVE_FACTORY/HAVE_LIBFAC
Files:
52 edited

Legend:

Unmodified
Added
Removed
  • Singular/claptmpl.cc

    r7bb7da5 rdc4782  
    1313//#include <vector>
    1414//using namespace std;
    15 #ifdef HAVE_FACTORY
    1615  #define SINGULAR 1
    1716  #include <factory/factory.h>
     
    2625  template class List<fglmDelem>;
    2726  template class ListIterator<fglmDelem>;
    28 #endif
    2927
    3028// ----------------------------------------------------------------------------
  • Singular/extra.cc

    r7bb7da5 rdc4782  
    1414#include <misc/auxiliary.h>
    1515
    16 #ifdef HAVE_FACTORY
    17 // #define SI_DONT_HAVE_GLOBAL_VARS
     16#define SI_DONT_HAVE_GLOBAL_VARS
    1817#include <factory/factory.h>
    19 #endif
    2018
    2119
     
    148146#endif
    149147
    150 #ifdef HAVE_FACTORY
    151 #define SI_DONT_HAVE_GLOBAL_VARS
    152 
    153 #ifdef HAVE_LIBFAC
    154 //#include <factory/libfac/libfac.h>
    155 #endif
    156 
    157148#include <polys/clapconv.h>
    158149#include <kernel/kstdfac.h>
    159 #endif
    160150
    161151#include <polys/clapsing.h>
     
    437427            TEST_FOR("DLD")
    438428          #endif
    439           #ifdef HAVE_FACTORY
    440             TEST_FOR("factory")
     429            //TEST_FOR("factory")
    441430            //TEST_FOR("libfac")
    442           #endif
    443431          #ifdef HAVE_READLINE
    444432            TEST_FOR("readline")
     
    636624          siRandomStart=(int)((long)h->Data());
    637625          siSeed=siRandomStart;
    638   #ifdef HAVE_FACTORY
    639626          factoryseed(siRandomStart);
    640   #endif
    641627          return FALSE;
    642628        }
     
    980966  /*==================== neworder =============================*/
    981967  // should go below
    982   #ifdef HAVE_FACTORY
    983968      if(strcmp(sys_cmd,"neworder")==0)
    984969      {
    985 #if defined(HAVE_LIBFAC)
    986970        if ((h!=NULL) &&(h->Typ()==IDEAL_CMD))
    987971        {
     
    992976        else
    993977          WerrorS("ideal expected");
    994 #else
    995   Werror("Sorry: not yet re-factored: see libpolys/polys/clapsing.cc");
    996   return FALSE;
    997 #endif
    998       }
    999       else
    1000   #endif
     978      }
     979      else
    1001980  //#ifndef HAVE_DYNAMIC_LOADING
    1002981  /*==================== pcv ==================================*/
     
    26882667//       else
    26892668  /*==================== isSqrFree =============================*/
    2690   #ifdef HAVE_FACTORY
    26912669      if(strcmp(sys_cmd,"isSqrFree")==0)
    26922670      {
     
    27012679      }
    27022680      else
    2703   #endif
    27042681  /*==================== pDivStat =============================*/
    27052682  #if defined(PDEBUG) || defined(PDIV_DEBUG)
     
    27482725      else
    27492726  #endif
    2750   #ifdef HAVE_FACTORY
    27512727  /*==================== fastcomb =============================*/
    27522728      if(strcmp(sys_cmd,"fastcomb")==0)
     
    27912767      }
    27922768      else
    2793   #endif
    27942769  #if 0 /* debug only */
    27952770  /*==================== listall ===================================*/
     
    35963571      else
    35973572  /*==================== gcd-varianten =================*/
    3598   #ifdef HAVE_FACTORY
    35993573      if (strcmp(sys_cmd, "gcd") == 0)
    36003574      {
     
    36333607      }
    36343608      else
    3635   #endif
    36363609  /*==================== subring =================*/
    36373610      if (strcmp(sys_cmd, "subring") == 0)
     
    36483621      else
    36493622  /*==================== HNF =================*/
    3650   #ifdef HAVE_FACTORY
    36513623  #ifdef HAVE_NTL
    36523624      if (strcmp(sys_cmd, "HNF") == 0)
     
    37223694      }
    37233695      else
    3724       #endif
    37253696  /*================= probIrredTest ======================*/
    37263697      if (strcmp (sys_cmd, "probIrredTest") == 0)
  • Singular/feOpt.cc

    r7bb7da5 rdc4782  
    1414#include <stdlib.h>
    1515
    16 #ifdef HAVE_FACTORY
    1716#define SI_DONT_HAVE_GLOBAL_VARS
    1817#include <factory/factory.h>
    19 #endif
    2018
    2119#define FE_OPT_STRUCTURE
     
    260258                                          (feOptSpec[FE_OPT_RANDOM].value));
    261259        siSeed=siRandomStart;
    262 #ifdef HAVE_FACTORY
    263260        factoryseed(siRandomStart);
    264 #endif
    265261        return NULL;
    266262
  • Singular/fglm.cc

    r7bb7da5 rdc4782  
    2020#endif /* HAVE_CONFIG_H */
    2121#include <kernel/mod2.h>
    22 
    23 #ifdef HAVE_FACTORY
    24 
    2522
    2623#include <omalloc/omalloc.h>
     
    496493    return FALSE;
    497494}
    498 #endif
    499495// ----------------------------------------------------------------------------
    500496// Local Variables: ***
  • Singular/fglm.h

    r7bb7da5 rdc4782  
    11#ifndef SINGULAR_FGLM_H
    22#define SINGULAR_FGLM_H
    3 
    4 #ifdef HAVE_FACTORY
    53
    64#include <misc/auxiliary.h>
     
    3634ideal fglmhomProc(leftv first, leftv second);
    3735
    38 
    39 #endif // #ifdef HAVE_FACTORY
    40 
    4136#endif // #ifndef SINGULAR_FGLM_H
  • Singular/grammar.cc

    r7bb7da5 rdc4782  
    237237    Werror("leaving %s",VoiceName());
    238238  }
    239 #ifdef HAVE_FACTORY
    240239  // libfac:
    241 #ifdef HAVE_LIBFAC
    242   //extern int libfac_interruptflag;
     240  extern int libfac_interruptflag;
    243241  libfac_interruptflag=0;
    244 #endif // #ifdef HAVE_LIBFAC
    245 #endif
    246242}
    247243
  • Singular/grammar.y

    r7bb7da5 rdc4782  
    173173    Werror("leaving %s",VoiceName());
    174174  }
    175 #ifdef HAVE_FACTORY
    176175  // libfac:
    177 #ifdef HAVE_LIBFAC
    178   //extern int libfac_interruptflag;
     176  extern int libfac_interruptflag;
    179177  libfac_interruptflag=0;
    180 #endif // #ifdef HAVE_LIBFAC
    181 #endif
    182178}
    183179
  • Singular/interpolation.cc

    r7bb7da5 rdc4782  
    88#include <kernel/mod2.h>
    99#include <misc/options.h>
    10 #ifdef HAVE_FACTORY
    1110#define SI_DONT_HAVE_GLOBAL_VARS
    1211#  include <factory/factory.h>
    13 #endif /* HAVE_FACTORY */
    1412
    1513#include <misc/intvec.h>
     
    10421040#endif
    10431041
    1044 #ifdef HAVE_FACTORY
    10451042static modp_number TakePrime (modp_number /*p*/)  // takes "previous" (smaller) prime
    1046 #else
    1047 static modp_number TakePrime (modp_number p)  // takes "previous" (smaller) prime
    1048 #endif
    1049 {
    1050 #ifdef HAVE_FACTORY
     1043{
    10511044    myp_index--;
    10521045    return cf_getSmallPrime(myp_index);
    1053 #else
    1054     return IsPrime(p-1);
    1055 #endif
    10561046}
    10571047
     
    16361626  bool correct_gen=false;
    16371627  if (only_modp) modp_cycles=1;
    1638   #ifdef HAVE_FACTORY
    16391628  myp_index=cf_getNumSmallPrimes ();
    1640   #endif
    16411629
    16421630  while ((!correct_gen)&&(myp_index>1))
  • Singular/iparith.cc

    r7bb7da5 rdc4782  
    6868#include <Singular/linearAlgebra_ip.h>
    6969
    70 #ifdef HAVE_FACTORY
    7170#  include <factory/factory.h>
    7271#  include <polys/clapsing.h>
     
    7473#  include <kernel/fglm.h>
    7574#  include <Singular/fglm.h>
    76 #endif /* HAVE_FACTORY */
    7775
    7876#include <Singular/interpolation.h>
     
    12151213  { /* This means that q != 0 consists of at least two terms.
    12161214       Moreover, currRing is over a field. */
    1217 #ifdef HAVE_FACTORY
    12181215    if(pGetComp(p)==0)
    12191216    {
     
    12531250      res->data=(void *)p;
    12541251    }
    1255 #else /* HAVE_FACTORY */
    1256     WerrorS("division only by a monomial");
    1257     return TRUE;
    1258 #endif /* HAVE_FACTORY */
    12591252  }
    12601253  else
     
    12971290      if (pNext(q)!=NULL)
    12981291      {
    1299       #ifdef HAVE_FACTORY
    13001292        MATELEM(mm,i,j) = singclap_pdivide( MATELEM(m,i,j) ,
    13011293                                           q /*(poly)(v->Data())*/, currRing );
    1302 #else /* HAVE_FACTORY */
    1303         WerrorS("division only by a monomial");
    1304         return TRUE;
    1305 #endif /* HAVE_FACTORY */
    13061294      }
    13071295      else
     
    16451633  return FALSE;
    16461634}
    1647 #ifdef HAVE_FACTORY
    16481635static BOOLEAN jjCHINREM_BI(leftv res, leftv u, leftv v)
    16491636{
     
    16691656  return FALSE;
    16701657}
    1671 #endif
    16721658#if 0
    16731659static BOOLEAN jjCHINREM_P(leftv res, leftv u, leftv v)
     
    17331719}
    17341720#endif
    1735 #ifdef HAVE_FACTORY
    17361721static BOOLEAN jjCHINREM_ID(leftv res, leftv u, leftv v)
    17371722{
     
    18671852  return FALSE;
    18681853}
    1869 #endif
    18701854static BOOLEAN jjCOEF(leftv res, leftv u, leftv v)
    18711855{
     
    21182102  return FALSE;
    21192103}
    2120 #ifdef HAVE_FACTORY
    21212104static BOOLEAN jjEXTGCD_P(leftv res, leftv u, leftv v)
    21222105{
     
    22052188  return FALSE;
    22062189}
    2207 #endif /* HAVE_FACTORY */
    22082190static BOOLEAN jjFAREY_BI(leftv res, leftv u, leftv v)
    22092191{
     
    23672349static BOOLEAN jjGCD_BI(leftv res, leftv u, leftv v)
    23682350{
    2369 #ifdef HAVE_FACTORY
    23702351  number n1 = (number) u->CopyD();
    23712352  number n2 = (number) v->CopyD();
     
    23772358  res->data = g;
    23782359  return FALSE;
    2379 #else
    2380   number a=(number) u->Data();
    2381   number b=(number) v->Data();
    2382   if (n_IsZero(a,coeffs_BIGINT))
    2383   {
    2384     if (n_IsZero(b,coeffs_BIGINT)) res->data=(char *)n_Init(1,coeffs_BIGINT);
    2385     else                           res->data=(char *)n_Copy(b,coeffs_BIGINT);
    2386   }
    2387   else
    2388   {
    2389     if (n_IsZero(b,coeffs_BIGINT))  res->data=(char *)n_Copy(a,coeffs_BIGINT);
    2390     else res->data=(char *)n_Gcd(a, b, coeffs_BIGINT);
    2391   }
    2392   return FALSE;
    2393 #endif
    23942360}
    23952361static BOOLEAN jjGCD_N(leftv res, leftv u, leftv v)
     
    24092375  return FALSE;
    24102376}
    2411 #ifdef HAVE_FACTORY
    24122377static BOOLEAN jjGCD_P(leftv res, leftv u, leftv v)
    24132378{
     
    24162381  return FALSE;
    24172382}
    2418 #endif /* HAVE_FACTORY */
    24192383static BOOLEAN jjHILBERT2(leftv res, leftv u, leftv v)
    24202384{
     
    33303294  return FALSE;
    33313295}
    3332 #ifdef HAVE_FACTORY
    33333296extern int singclap_factorize_retry;
    33343297static BOOLEAN jjSQR_FREE2(leftv res, leftv u, leftv dummy)
     
    33793342  return FALSE;
    33803343}
    3381 #endif
    33823344static BOOLEAN jjSTATUS2(leftv res, leftv u, leftv v)
    33833345{
     
    38243786  else if (rField_is_Zp_a(r) && (r->cf->type==n_algExt))
    38253787  {
    3826 #ifdef HAVE_FACTORY
    38273788    extern int ipower ( int b, int n ); /* factory/cf_util */
    38283789    elems=ipower(r->cf->ch,r->cf->extRing->pFDeg(r->cf->extRing->qideal->m[0],r->cf->extRing));
    3829 #else
    3830     elems=(int)pow((double) r->cf->ch,(double)r->cf->extRing->pFDeg(r->cf->extRing->qideal->m[0],r->cf->extRing));
    3831 #endif
    38323790  }
    38333791  res->data = (char *)(long)elems;
     
    39203878}
    39213879
    3922 
    3923 
    3924 
    3925 #ifdef HAVE_FACTORY
    39263880static BOOLEAN jjDET(leftv res, leftv v)
    39273881{
     
    39833937  return FALSE;
    39843938}
    3985 #endif
    39863939static BOOLEAN jjDIM(leftv res, leftv v)
    39873940{
     
    40554008  return yyparse();
    40564009}
    4057 #ifdef HAVE_FACTORY
    40584010static BOOLEAN jjFACSTD(leftv res, leftv v)
    40594011{
     
    41124064  return FALSE;
    41134065}
    4114 #endif
    41154066static BOOLEAN jjGETDUMP(leftv, leftv v)
    41164067{
     
    50104961  return FALSE;
    50114962}
    5012 #ifdef HAVE_FACTORY
    50134963static BOOLEAN jjSQR_FREE(leftv res, leftv u)
    50144964{
     
    50274977  return FALSE;
    50284978}
    5029 #endif
    50304979#if 1
    50314980static BOOLEAN jjSYZYGY(leftv res, leftv v)
     
    53575306        case (int)jjidElem:       dArith1[i].p=(proc1)idElem; break;
    53585307        case (int)jjidVec2Ideal:  dArith1[i].p=(proc1)idVec2Ideal; break;
    5359 #ifndef HAVE_FACTORY
    53605308        case (int)jjmpDetBareiss: dArith1[i].p=(proc1)mpDetBareiss; break;
    5361 #endif
    53625309        case (int)jjidFreeModule: dArith1[i].p=(proc1)idFreeModule; break;
    53635310        case (int)jjrCharStr:     dArith1[i].p=(proc1)rCharStr; break;
     
    75367483                                                optional: all 4 optional args
    75377484     (The defaults are xIndex = 1, yIndex = 2, f0 and g0 polynomials as found
    7538       by singclap_factorize in the case that HAVE_FACTORY is defined and h(0, y)
     7485      by singclap_factorize and h(0, y)
    75397486      has exactly two distinct monic factors [possibly with exponent > 1].)
    75407487     result:
     
    76257572  if (factorsGiven == 0)
    76267573  {
    7627 #ifdef HAVE_FACTORY
    76287574    poly h0 = pSubst(pCopy(h), xIndex, NULL);
    76297575    intvec* v = NULL;
     
    76447590    g0 = pPower(pCopy(i->m[2]), (*v)[2]);
    76457591    idDelete(&i);
    7646 #else
    7647     WerrorS("cannot factorize h(0,y) due to missing module 'factory'");
    7648     return TRUE;
    7649 #endif
    76507592  }
    76517593
  • Singular/ipshell.cc

    r7bb7da5 rdc4782  
    1515#include <misc/mylimits.h>
    1616
    17 #ifdef HAVE_FACTORY
    1817#define SI_DONT_HAVE_GLOBAL_VARS
    1918#include <factory/factory.h>
    20 #endif
    2119
    2220#include <Singular/maps_ip.h>
     
    567565{
    568566  unsigned i,j=0 /*only to avoid compiler warnings*/;
    569 #ifdef HAVE_FACTORY
    570567  if (p<=32749) // max. small prime in factory
    571568  {
     
    584581    else     return cf_getSmallPrime(i-1);
    585582  }
    586 #endif
    587 #ifdef HAVE_FACTORY
    588583  unsigned end_i=cf_getNumSmallPrimes()-1;
    589 #else
    590   unsigned end_i=p/2;
    591 #endif
    592584  unsigned end_p=(unsigned)sqrt((double)p);
    593585restart:
    594586  for (i=0; i<end_i; i++)
    595587  {
    596 #ifdef HAVE_FACTORY
    597588    j=cf_getSmallPrime(i);
    598 #else
    599     if (i==0) j=2;
    600     else j=2*i-1;
    601 #endif
    602589    if ((p%j) == 0)
    603590    {
    604     #ifdef HAVE_FACTORY
    605591      if (p<=32751) return iiIsPrime0(p-2);
    606     #endif
    607592      p-=2;
    608593      goto restart;
     
    610595    if (j > end_p) return p;
    611596  }
    612 #ifdef HAVE_FACTORY
    613597  if (i>=end_i)
    614598  {
     
    624608    }
    625609  }
    626 #endif
    627610  return p;
    628611}
     
    28872870BOOLEAN jjRESULTANT(leftv res, leftv u, leftv v, leftv w)
    28882871{
    2889 #ifdef HAVE_FACTORY
    28902872  res->data=singclap_resultant((poly)u->CopyD(),(poly)v->CopyD(),
    28912873                  (poly)w->CopyD(), currRing);
    28922874  return errorreported;
    2893 #else
    2894   Werror("Sorry: not yet re-factored: see libpolys/polys/clapsing.cc");
    2895   return FALSE;
    2896 #endif
    28972875}
    28982876
    28992877BOOLEAN jjCHARSERIES(leftv res, leftv u)
    29002878{
    2901 #if defined(HAVE_FACTORY) && defined(HAVE_LIBFAC)
    29022879  res->data=singclap_irrCharSeries((ideal)u->Data(), currRing);
    29032880  return (res->data==NULL);
    2904 #else
    2905   Werror("Sorry: not yet re-factored: see libpolys/polys/clapsing.cc");
    2906   return FALSE;
    2907 #endif
    29082881}
    29092882
  • Singular/libparse.cc

    r7bb7da5 rdc4782  
    10631063#include <Singular/utils.h>
    10641064
    1065 # ifdef HAVE_FACTORY
    10661065int initializeGMP(){ return 1; } // NEEDED FOR MAIN APP. LINKING!!!
    10671066int mmInit(void) {return 1; } // ? due to SINGULAR!!!...???
    1068 # endif
    10691067
    10701068  #define HAVE_LIBPARSER
  • Singular/libparse.ll

    r7bb7da5 rdc4782  
    1111  #include <Singular/utils.h>
    1212
    13 # ifdef HAVE_FACTORY
    1413  int initializeGMP(){ return 1; } // NEEDED FOR MAIN APP. LINKING!!!
    1514  int mmInit(void) {return 1; } // ? due to SINGULAR!!!...???
    16 # endif
    1715
    1816  #define HAVE_LIBPARSER
  • Singular/misc_ip.cc

    r7bb7da5 rdc4782  
    2020#include <Singular/si_signals.h>
    2121
    22 #ifdef HAVE_FACTORY
    2322#define SI_DONT_HAVE_GLOBAL_VARS
    2423#include <factory/factory.h>
    25 #endif
    2624
    2725#ifdef HAVE_SIMPLEIPC
     
    11631161void siInit(char *name)
    11641162{
    1165 #ifdef HAVE_FACTORY
    11661163// factory default settings: -----------------------------------------------
    11671164  On(SW_USE_NTL);
     
    11751172  Off(SW_USE_NTL_SORT); // may be changed by an command line option
    11761173  factoryError=WerrorS;
    1177 #endif
    11781174
    11791175// memory initialization: -----------------------------------------------
     
    12291225  initRTimer();
    12301226  siSeed=t;
    1231 #ifdef HAVE_FACTORY
    12321227  factoryseed(t);
    1233 #endif
    12341228  siRandomStart=t;
    12351229  feOptSpec[FE_OPT_RANDOM].value = (void*) ((long)siRandomStart);
     
    12671261/*
    12681262#ifdef LIBSINGULAR
    1269 #ifdef HAVE_FACTORY
    12701263// the init routines of factory need mmInit
    12711264int mmInit( void )
     
    12741267}
    12751268#endif
    1276 #endif
    12771269*/
  • Singular/table.h

    r7bb7da5 rdc4782  
    4747,{D(jjCHAR),       CHARACTERISTIC_CMD, INT_CMD,     RING_CMD      , ALLOW_PLURAL |ALLOW_RING}
    4848,{D(jjCHAR),       CHARACTERISTIC_CMD, INT_CMD,     QRING_CMD     , ALLOW_PLURAL |ALLOW_RING}
    49 #ifdef HAVE_FACTORY
    5049,{D(jjCHARSERIES), CHAR_SERIES_CMD, MATRIX_CMD,     IDEAL_CMD     , NO_PLURAL |NO_RING}
    51 #else
    52 ,{  jjWRONG ,      CHAR_SERIES_CMD, MATRIX_CMD,     IDEAL_CMD     , NO_PLURAL |NO_RING}
    53 #endif
    5450,{D(jjrCharStr),   CHARSTR_CMD,     XS(STRING_CMD), RING_CMD      , ALLOW_PLURAL |ALLOW_RING}
    5551,{D(jjrCharStr),   CHARSTR_CMD,     XS(STRING_CMD), QRING_CMD     , ALLOW_PLURAL |ALLOW_RING}
     
    8783,{D(jjDENOMINATOR),DENOMINATOR_CMD, NUMBER_CMD,     NUMBER_CMD    , ALLOW_PLURAL |ALLOW_RING}
    8884,{D(jjNUMERATOR),  NUMERATOR_CMD,   NUMBER_CMD,     NUMBER_CMD    , ALLOW_PLURAL |ALLOW_RING}
    89 #ifdef HAVE_FACTORY
    9085,{D(jjDET_BI),     DET_CMD,         BIGINT_CMD,     BIGINTMAT_CMD , ALLOW_PLURAL |ALLOW_RING}
    9186,{D(jjDET_I),      DET_CMD,         INT_CMD,        INTMAT_CMD    , ALLOW_PLURAL |ALLOW_RING}
    9287,{D(jjDET),        DET_CMD,         POLY_CMD,       MATRIX_CMD    , NO_PLURAL |ALLOW_RING}
    9388,{D(jjDET_S),      DET_CMD,         POLY_CMD,       MODUL_CMD     , NO_PLURAL |NO_RING}
    94 #else
    95 ,{  jjWRONG ,      DET_CMD,         INT_CMD,        INTMAT_CMD    , ALLOW_PLURAL |NO_RING}
    96 ,{D(jjmpDetBareiss),DET_CMD,        XS(POLY_CMD),   MATRIX_CMD    , NO_PLURAL |ALLOW_RING}
    97 #endif
    9889,{D(jjDIM),        DIM_CMD,         INT_CMD,        IDEAL_CMD     , ALLOW_PLURAL |ALLOW_RING}
    9990,{D(jjDIM),        DIM_CMD,         INT_CMD,        MODUL_CMD     , ALLOW_PLURAL |ALLOW_RING}
     
    10394,{D(jjEXECUTE),    EXECUTE_CMD,     NONE,           STRING_CMD    , ALLOW_PLURAL |ALLOW_RING}
    10495,{D(jjERROR),      ERROR_CMD,       NONE,           STRING_CMD    , ALLOW_PLURAL |ALLOW_RING}
    105 #ifdef HAVE_FACTORY
    10696,{D(jjFAC_P),      FAC_CMD,         LIST_CMD,       POLY_CMD      , NO_PLURAL |NO_RING}
    107 #else
    108 ,{  jjWRONG ,      FAC_CMD,         LIST_CMD,       POLY_CMD      , NO_PLURAL |NO_RING}
    109 #endif
    110 #ifdef HAVE_FACTORY
    11197,{D(findUniProc),  FINDUNI_CMD,     IDEAL_CMD,      IDEAL_CMD     , NO_PLURAL |NO_RING}
    112 #else
    113 ,{  jjWRONG ,      FINDUNI_CMD,     IDEAL_CMD,      IDEAL_CMD     , ALLOW_PLURAL |ALLOW_RING}
    114 #endif
    11598,{D(jjidFreeModule),FREEMODULE_CMD, XS(MODUL_CMD),  INT_CMD       , ALLOW_PLURAL |ALLOW_RING}
    116 #ifdef HAVE_FACTORY
    11799,{D(jjFACSTD),     FACSTD_CMD,      LIST_CMD,       IDEAL_CMD     , NO_PLURAL |NO_RING}
    118 #else
    119 ,{  jjWRONG ,      FACSTD_CMD,      LIST_CMD,       IDEAL_CMD     , NO_PLURAL |NO_RING}
    120 #endif
    121100,{D(jjGETDUMP),    GETDUMP_CMD,     NONE,           LINK_CMD      , ALLOW_PLURAL |ALLOW_RING}
    122101,{D(jjHIGHCORNER), HIGHCORNER_CMD,  POLY_CMD,       IDEAL_CMD     , NO_PLURAL |ALLOW_RING}
     
    250229,{D(jjSort_Id),    SORTVEC_CMD,     INTVEC_CMD,     IDEAL_CMD     , ALLOW_PLURAL |ALLOW_RING}
    251230,{D(jjSort_Id),    SORTVEC_CMD,     INTVEC_CMD,     MODUL_CMD     , ALLOW_PLURAL |ALLOW_RING}
    252 #ifdef HAVE_FACTORY
    253231,{D(jjSQR_FREE),   SQR_FREE_CMD,    LIST_CMD,      POLY_CMD      , NO_PLURAL |NO_RING}
    254 #else
    255 ,{  jjWRONG ,      SQR_FREE_CMD,    LIST_CMD,      POLY_CMD      , NO_PLURAL |NO_RING}
    256 #endif
    257232,{D(jjSTD),        STD_CMD,         IDEAL_CMD,      IDEAL_CMD     , ALLOW_PLURAL |ALLOW_RING}
    258233,{D(jjSTD),        STD_CMD,         MODUL_CMD,      MODUL_CMD     , ALLOW_PLURAL |ALLOW_RING}
     
    498473,{D(jjBRACKET),   BRACKET_CMD,    POLY_CMD,       POLY_CMD,   POLY_CMD, ALLOW_PLURAL | NO_RING}
    499474#endif
    500 #ifdef HAVE_FACTORY
    501475,{D(jjCHINREM_BI),CHINREM_CMD,    BIGINT_CMD,     INTVEC_CMD, INTVEC_CMD, ALLOW_PLURAL |ALLOW_RING}
    502476//,{D(jjCHINREM_P), CHINREM_CMD,    POLY_CMD,       LIST_CMD,   INTVEC_CMD, ALLOW_PLURAL}
    503477,{D(jjCHINREM_ID),CHINREM_CMD,    ANY_TYPE/*set by p*/,LIST_CMD,INTVEC_CMD, ALLOW_PLURAL |NO_RING}
    504478,{D(jjCHINREM_ID),CHINREM_CMD,    ANY_TYPE/*set by p*/,LIST_CMD,LIST_CMD, ALLOW_PLURAL |NO_RING}
    505 #else
    506 ,{  jjWRONG2 ,    CHINREM_CMD,    BIGINT_CMD,     INTVEC_CMD, INTVEC_CMD, ALLOW_PLURAL |ALLOW_RING}
    507 #endif
    508479,{D(jjCOEF),      COEF_CMD,       MATRIX_CMD,     POLY_CMD,   POLY_CMD, ALLOW_PLURAL |ALLOW_RING}
    509480,{D(jjCOEFFS_Id), COEFFS_CMD,     MATRIX_CMD,     IDEAL_CMD,  POLY_CMD, ALLOW_PLURAL |ALLOW_RING}
     
    534505,{D(jjEXTGCD_I),  EXTGCD_CMD,     LIST_CMD,       INT_CMD,    INT_CMD, ALLOW_PLURAL |ALLOW_RING}
    535506,{D(jjEXTGCD_BI), EXTGCD_CMD,     LIST_CMD,       BIGINT_CMD, BIGINT_CMD, ALLOW_PLURAL |ALLOW_RING}
    536 #ifdef HAVE_FACTORY
    537507,{D(jjEXTGCD_P),  EXTGCD_CMD,     LIST_CMD,       POLY_CMD,   POLY_CMD, NO_PLURAL |NO_RING}
    538508,{D(jjFAC_P2),     FAC_CMD,        IDEAL_CMD,      POLY_CMD,   INT_CMD, NO_PLURAL |NO_RING}
    539509,{D(jjFACSTD2),   FACSTD_CMD,     LIST_CMD,       IDEAL_CMD,  IDEAL_CMD, NO_PLURAL |NO_RING}
    540 #else
    541 ,{  jjWRONG2 ,    EXTGCD_CMD,     LIST_CMD,       POLY_CMD,   POLY_CMD, NO_PLURAL |NO_RING}
    542 ,{  jjWRONG2 ,    FAC_CMD,        IDEAL_CMD,      POLY_CMD,   INT_CMD, NO_PLURAL |NO_RING}
    543 ,{  jjWRONG2 ,    FACSTD_CMD,     LIST_CMD,       IDEAL_CMD,  IDEAL_CMD, NO_PLURAL |NO_RING}
    544 #endif
    545510,{D(jjFAREY_BI),  FAREY_CMD,      NUMBER_CMD,     BIGINT_CMD,  BIGINT_CMD, ALLOW_PLURAL |NO_RING}
    546511,{D(jjFAREY_ID),   FAREY_CMD,     ANY_TYPE/*set by p*/,IDEAL_CMD,BIGINT_CMD, ALLOW_PLURAL |NO_RING}
     
    549514,{D(jjFETCH),     FETCH_CMD,      ANY_TYPE/*set by p*/,RING_CMD,  ANY_TYPE, ALLOW_PLURAL |ALLOW_RING}
    550515,{D(jjFETCH),     FETCH_CMD,      ANY_TYPE/*set by p*/,QRING_CMD, ANY_TYPE, ALLOW_PLURAL |ALLOW_RING}
    551 #ifdef HAVE_FACTORY
    552516,{D(fglmProc),    FGLM_CMD,       IDEAL_CMD,      RING_CMD,   DEF_CMD, NO_PLURAL |NO_RING}
    553517,{D(fglmProc),    FGLM_CMD,       IDEAL_CMD,      QRING_CMD,  DEF_CMD, NO_PLURAL |NO_RING}
    554518,{D(fglmQuotProc),FGLMQUOT_CMD,   IDEAL_CMD,      IDEAL_CMD,  POLY_CMD, NO_PLURAL |NO_RING}
    555 #else
    556 ,{  jjWRONG2 ,    FGLM_CMD,       IDEAL_CMD,      RING_CMD,   DEF_CMD, NO_PLURAL |NO_RING}
    557 ,{  jjWRONG2 ,    FGLM_CMD,       IDEAL_CMD,      QRING_CMD,  DEF_CMD, NO_PLURAL |NO_RING}
    558 ,{  jjWRONG2 ,    FGLMQUOT_CMD,   IDEAL_CMD,      POLY_CMD,   IDEAL_CMD, NO_PLURAL |NO_RING}
    559 #endif
    560519,{D(jjFIND2),     FIND_CMD,       INT_CMD,        STRING_CMD, STRING_CMD, ALLOW_PLURAL |ALLOW_RING}
    561520,{D(jjFWALK),     FWALK_CMD,      IDEAL_CMD,      RING_CMD,   DEF_CMD, NO_PLURAL |NO_RING}
     
    563522,{D(jjGCD_N),     GCD_CMD,        NUMBER_CMD,     NUMBER_CMD, NUMBER_CMD, ALLOW_PLURAL |ALLOW_RING}
    564523,{D(jjGCD_BI),    GCD_CMD,        BIGINT_CMD,     BIGINT_CMD, BIGINT_CMD, ALLOW_PLURAL |ALLOW_RING}
    565 #if defined(HAVE_FACTORY)
    566524,{D(jjGCD_P),     GCD_CMD,        POLY_CMD,       POLY_CMD,   POLY_CMD, NO_PLURAL |NO_RING}
    567 #else
    568 ,{  jjWRONG2 ,    GCD_CMD,        POLY_CMD,       POLY_CMD,   POLY_CMD, NO_PLURAL |NO_RING}
    569 #endif
    570525,{D(jjHILBERT2),  HILBERT_CMD,    INTVEC_CMD,     IDEAL_CMD,  INT_CMD, NO_PLURAL | ALLOW_RING | NO_ZERODIVISOR}
    571526,{D(jjHILBERT2),  HILBERT_CMD,    INTVEC_CMD,     MODUL_CMD,  INT_CMD, NO_PLURAL | ALLOW_RING | NO_ZERODIVISOR}
     
    650605,{D(jjRES),       RES_CMD,        RESOLUTION_CMD, IDEAL_CMD,  INT_CMD, ALLOW_PLURAL |ALLOW_RING}
    651606,{D(jjRES),       RES_CMD,        RESOLUTION_CMD, MODUL_CMD,  INT_CMD, ALLOW_PLURAL |ALLOW_RING}
    652 #ifdef HAVE_FACTORY
    653607,{D(jjSQR_FREE2), SQR_FREE_CMD,   IDEAL_CMD,      POLY_CMD,   INT_CMD, NO_PLURAL |ALLOW_RING}
    654 #else
    655 ,{  jjWRONG2 ,    SQR_FREE_CMD,   IDEAL_CMD,      POLY_CMD,   INT_CMD, NO_PLURAL |ALLOW_RING}
    656 #endif
    657608,{D(jjSTATUS2),   STATUS_CMD,     STRING_CMD,     LINK_CMD,   STRING_CMD, ALLOW_PLURAL |ALLOW_RING}
    658609,{D(jjSTATUS2L),  STATUS_CMD,     INT_CMD,        LIST_CMD,   INT_CMD, ALLOW_PLURAL |ALLOW_RING}
     
    758709,{D(jjRES3),           RES_CMD,    NONE,       MODUL_CMD,  INT_CMD,    ANY_TYPE, ALLOW_PLURAL |ALLOW_RING}
    759710#endif
    760 #ifdef HAVE_FACTORY
    761711,{D(jjRESULTANT),      RESULTANT_CMD, POLY_CMD,POLY_CMD,   POLY_CMD,   POLY_CMD, NO_PLURAL |ALLOW_RING}
    762 #else
    763 ,{  jjWRONG3 ,         RESULTANT_CMD, POLY_CMD,POLY_CMD,   POLY_CMD,   POLY_CMD, NO_PLURAL |ALLOW_RING}
    764 #endif
    765712,{D(jjRING3),          RING_CMD,   RING_CMD,   DEF_CMD,    DEF_CMD,    DEF_CMD, ALLOW_PLURAL |ALLOW_RING}
    766713#ifdef OLD_RES
  • Singular/test.cc

    r7bb7da5 rdc4782  
    11#include <misc/auxiliary.h>
    22
    3 #ifdef HAVE_FACTORY
    43#include <factory/factory.h> // :(
    5 #endif
    64
    75#include <omalloc/omalloc.h>
     
    5048
    5149
    52 #ifdef HAVE_FACTORY
    5350int initializeGMP(){ return 1; } // NEEDED FOR MAIN APP. LINKING!!!
    5451int mmInit(void) {return 1; } // ? due to SINGULAR!!!...???
    55 #endif
    5652
    5753
  • Singular/tesths.cc

    r7bb7da5 rdc4782  
    1717#include <misc/options.h>
    1818
    19 #ifdef HAVE_FACTORY
    2019#define SI_DONT_HAVE_GLOBAL_VARS
    2120#include <factory/factory.h>
    22 #endif
    2321
    2422#include <kernel/febase.h>
     
    6361#if ! defined(LIBSINGULAR)
    6462
    65 #ifdef HAVE_FACTORY
    6663int initializeGMP(){ return 1; }
    67 #endif
    6864
    6965int mmInit( void )
     
    159155  else
    160156  {
    161 #ifdef HAVE_FACTORY
    162157    if (feOptValue(FE_OPT_SORT)) On(SW_USE_NTL_SORT);
    163 #endif
    164158#ifdef HAVE_SDB
    165159    sdb_flags = 0;
  • Singular/walk.cc

    r7bb7da5 rdc4782  
    9090#include <polys/monomials/ring.h>
    9191//#include <polys/ext_fields/longalg.h>
    92 #ifdef HAVE_FACTORY
    9392#include <polys/clapsing.h>
    94 #endif
    9593
    9694#include <coeffs/mpr_complex.h>
  • kernel/fglm.h

    r7bb7da5 rdc4782  
    1212#ifndef FGLM_H
    1313#define FGLM_H
    14 
    15 #ifdef HAVE_FACTORY
    1614
    1715#include <kernel/polys.h>
     
    8684
    8785#endif
    88 #endif
  • kernel/fglmcomb.cc

    r7bb7da5 rdc4782  
    1313#include <kernel/mod2.h>
    1414
    15 #ifdef HAVE_FACTORY
    1615#define SI_DONT_HAVE_GLOBAL_VARS
    1716#include <factory/factory.h>
     
    554553}
    555554
    556 #endif
    557555// Local Variables: ***
    558556// compile-command: "make Singular" ***
  • kernel/fglmgauss.cc

    r7bb7da5 rdc4782  
    1414#include <kernel/mod2.h>
    1515
    16 #ifdef  HAVE_FACTORY
    1716#include <kernel/structs.h>
    1817#include <coeffs/numbers.h>
     
    211210// fold-internal-margins: nil ***
    212211// End: ***
    213 #endif // HAVE_FACTORY
  • kernel/fglmvec.cc

    r7bb7da5 rdc4782  
    1717#include <kernel/mod2.h>
    1818
    19 #ifdef HAVE_FACTORY
    2019#include <omalloc/omalloc.h>
    2120#include <kernel/structs.h>
     
    532531}
    533532
    534 #endif
    535533// ----------------------------------------------------------------------------
    536534// Local Variables: ***
  • kernel/fglmzero.cc

    r7bb7da5 rdc4782  
    2424
    2525
    26 #ifdef HAVE_FACTORY
    2726// assumes, that NOSTREAMIO is set in factoryconf.h, which is included
    2827// by templates/list.h.
     
    12531252
    12541253
    1255 #endif
    1256 
    12571254// ----------------------------------------------------------------------------
    12581255// Local Variables: ***
  • kernel/ideals.cc

    r7bb7da5 rdc4782  
    23642364#include <polys/clapsing.h>
    23652365
    2366 #ifdef HAVE_FACTORY
    23672366#if 0
    23682367poly id_GCD(poly f, poly g, const ring r)
     
    23982397}
    23992398#endif
    2400 #endif
    24012399
    24022400#if 0
     
    24082406* destroys xx
    24092407*/
    2410 #ifdef HAVE_FACTORY
    24112408ideal id_ChineseRemainder(ideal *xx, number *q, int rl, const ring R)
    24122409{
     
    24682465}
    24692466#endif
    2470 #endif
    24712467/* currently unsed:
    24722468ideal idChineseRemainder(ideal *xx, intvec *iv)
  • kernel/kstdfac.cc

    r7bb7da5 rdc4782  
    2222//#include "ipshell.h"
    2323#include <misc/intvec.h>
    24 #ifdef HAVE_FACTORY
    2524#include <polys/clapsing.h>
    26 #endif
    2725#include <kernel/ideals.h>
    2826#include <kernel/timer.h>
    2927#include <kernel/kstdfac.h>
    30 
    31 #ifdef HAVE_FACTORY
    3228
    3329#ifndef NDEBUG
     
    257253  ideal fac=singclap_factorize(pCopy(p),NULL,1,currRing);
    258254  int fac_elems;
    259 #ifndef HAVE_FACTORY
    260   if (fac==NULL)
    261   {
    262     fac=idInit(1,1);
    263     fac->m[0]=pCopy(p);
    264     fac_elems=1;
    265   }
    266   else
    267 #endif
    268     fac_elems=IDELEMS(fac);
     255  fac_elems=IDELEMS(fac);
    269256  rfac=fac;
    270257  fac_copy=idInit(fac_elems,1);
     
    889876  return (strat->Shdl);
    890877}
    891 #endif
    892878
    893879ideal_list kStdfac(ideal F, ideal Q, tHomog h,intvec ** w,ideal D)
    894880{
    895 #ifdef HAVE_FACTORY
    896881  ideal r;
    897882  BOOLEAN b=currRing->pLexOrder,toReset=FALSE;
     
    10401025  if ((delete_w)&&(w!=NULL)&&(*w!=NULL)) delete *w;
    10411026  return L;
    1042 #else
    1043   return NULL;
    1044 #endif
    10451027}
  • kernel/misc.cc

    r7bb7da5 rdc4782  
    1111#include <kernel/mod2.h>
    1212
    13 #ifdef HAVE_FACTORY
    1413#define SI_DONT_HAVE_GLOBAL_VARS
    1514#  include <factory/factory.h>
    1615/* libfac version strings */
    17 #ifdef HAVE_LIBFAC
    18 //  extern const char * libfac_version;
    19 //  extern const char * libfac_date;
    20 #endif // #ifdef HAVE_LIBFAC
    21 #endif
    2216
    2317#include <coeffs/si_gmp.h>
  • kernel/test.cc

    r7bb7da5 rdc4782  
    66#include <omalloc/omalloc.h>
    77#include <misc/auxiliary.h>
    8 #ifdef HAVE_FACTORY
    98#include <factory/factory.h> // :(
    10 #endif
    119
    1210#include <misc/intvec.h>
     
    5351
    5452
    55 #ifdef HAVE_FACTORY
    5653// The following are needed due to FACTORY (e.g. initCanonicalForm)
    5754int initializeGMP(){ return 1; }
    5855int mmInit(void) {return 1; }
    59 #endif
    6056
    6157// // TODO: DUE to the use of HALT in npolygon.cc :(((
  • libpolys/coeffs/OPAE.cc

    r7bb7da5 rdc4782  
    99#include <misc/auxiliary.h>
    1010
    11 #ifdef HAVE_FACTORY
    1211#include <factory/factory.h>
    13 #endif
    1412
    1513#include <string.h>
  • libpolys/coeffs/OPAEQ.cc

    r7bb7da5 rdc4782  
    99#include <misc/auxiliary.h>
    1010
    11 #ifdef HAVE_FACTORY
    1211#include <factory/factory.h>
    13 #endif
    1412
    1513#include <string.h>
  • libpolys/coeffs/OPAEp.cc

    r7bb7da5 rdc4782  
    99#include <misc/auxiliary.h>
    1010
    11 #ifdef HAVE_FACTORY
    1211#include <factory/factory.h>
    13 #endif
    1412
    1513#include <string.h>
  • libpolys/coeffs/coeffs.h

    r7bb7da5 rdc4782  
    1616#include <coeffs/Enumerator.h>
    1717
    18 #ifdef HAVE_FACTORY
    1918class CanonicalForm;
    20 #endif
    2119
    2220enum n_coeffType
     
    218216   nCoeffsEnumeratorFunc cfClearDenominators;
    219217
    220 #ifdef HAVE_FACTORY
    221218   number (*convFactoryNSingN)( const CanonicalForm n, const coeffs r);
    222219   CanonicalForm (*convSingNFactoryN)( number n, BOOLEAN setChar, const coeffs r );
    223 #endif
    224 
    225220
    226221#ifdef LDEBUG
  • libpolys/coeffs/ffields.cc

    r7bb7da5 rdc4782  
    579579}
    580580
    581 #ifdef HAVE_FACTORY
    582581int gf_tab_numdigits62 ( int q );
    583582int convertback62 ( char * p, int n );
    584 #else
    585 static int gf_tab_numdigits62 ( int q )
    586 {
    587     if ( q < 62 )          return 1;
    588     else  if ( q < 62*62 ) return 2;
    589     /*else*/               return 3;
    590 }
    591 
    592 static int convback62 ( char c )
    593 {
    594     if ( c >= '0' && c <= '9' )
    595         return int(c) - int('0');
    596     else  if ( c >= 'A' && c <= 'Z' )
    597         return int(c) - int('A') + 10;
    598     else
    599         return int(c) - int('a') + 36;
    600 }
    601 
    602 static int convertback62 ( char * p, int n )
    603 {
    604     int r = 0;
    605     for ( int j = 0; j < n; j++ )
    606         r = r * 62 + convback62( p[j] );
    607     return r;
    608 }
    609 #endif
    610583
    611584int nfMinPoly[16];
  • libpolys/coeffs/longrat.cc

    r7bb7da5 rdc4782  
    1111#include <misc/auxiliary.h>
    1212
    13 #ifdef HAVE_FACTORY
    1413#include <factory/factory.h>
    15 #endif
    1614
    1715#include <coeffs/longrat.h>
     
    260258#endif
    261259
    262 #ifdef HAVE_FACTORY
    263260CanonicalForm nlConvSingNFactoryN( number n, BOOLEAN setChar, const coeffs /*r*/ )
    264261{
     
    327324  }
    328325}
    329 #endif
     326
    330327number nlRInit (long i);
    331328
     
    26092606// elemenst in the array are x[0..(rl-1)], q[0..(rl-1)]
    26102607{
    2611 #ifdef HAVE_FACTORY
    26122608  setCharacteristic( 0 ); // only in char 0
    26132609  Off(SW_RATIONAL);
     
    26362632  }
    26372633  return n;
    2638 #else
    2639   WerrorS("not implemented");
    2640   return nlInit(0,CF);
    2641 #endif
    26422634}
    26432635number   nlChineseRemainder(number *x, number *q,int rl, const coeffs C)
     
    28992891  r->cfDBTest=nlDBTest;
    29002892#endif
    2901 #ifdef HAVE_FACTORY
    29022893  r->convSingNFactoryN=nlConvSingNFactoryN;
    29032894  r->convFactoryNSingN=nlConvFactoryNSingN;
    2904 #endif
    29052895
    29062896  // the variables: general stuff (required)
  • libpolys/coeffs/modulop.cc

    r7bb7da5 rdc4782  
    1111#include <misc/auxiliary.h>
    1212
    13 #ifdef HAVE_FACTORY
    1413#include <factory/factory.h>
    15 #endif
    1614
    1715#include <string.h>
     
    407405  return (n==n_Zp) && (r->ch==(int)(long)parameter);
    408406}
    409 #ifdef HAVE_FACTORY
    410407CanonicalForm npConvSingNFactoryN( number n, BOOLEAN setChar, const coeffs r )
    411408{
     
    427424  }
    428425}
    429 #endif
    430 
    431426
    432427BOOLEAN npInitChar(coeffs r, void* p)
     
    503498#endif
    504499
    505 #ifdef HAVE_FACTORY
    506500  r->convSingNFactoryN=npConvSingNFactoryN;
    507501  r->convFactoryNSingN=npConvFactoryNSingN;
    508 #endif
    509502
    510503  // the variables:
     
    682675#endif
    683676
    684 #ifdef HAVE_FACTORY
    685677number npMapCanonicalForm (number a, const coeffs /*src*/, const coeffs dst)
    686678{
     
    689681  return (number) (f.intval());
    690682}
    691 #endif
    692683
    693684nMapFunc npSetMap(const coeffs src, const coeffs dst)
     
    722713    return npMapLongR;
    723714  }
    724 #ifdef HAVE_FACTORY
    725715  if (nCoeff_is_CF (src))
    726716  {
    727717    return npMapCanonicalForm;
    728718  }
    729 #endif
    730719  return NULL;      /* default */
    731720}
  • libpolys/coeffs/mpr_global.h

    r7bb7da5 rdc4782  
    5050#endif
    5151
    52 #if defined(mprDEBUG_STICKY) && defined(HAVE_FACTORY)
     52#if defined(mprDEBUG_STICKY)
    5353// call 'option(prot);' to get status informations
    5454#define mprSTICKYPROT(msg) if (BTEST1(OPT_PROT)) Print(msg)
  • libpolys/coeffs/numbers.cc

    r7bb7da5 rdc4782  
    1515#include <misc/auxiliary.h>
    1616
    17 #ifdef HAVE_FACTORY
    1817#include <factory/factory.h>
    19 #endif
    20 
    2118
    2219#include "coeffs.h"
     
    230227#endif
    231228
    232 #ifdef HAVE_FACTORY
    233229CanonicalForm ndConvSingNFactoryN( number, BOOLEAN /*setChar*/, const coeffs)
    234230{
     
    243239  return NULL;
    244240}
    245 #endif
    246241
    247242number  ndInit_bigint(number, const coeffs, const coeffs)
  • libpolys/coeffs/si_gmp.h

    r7bb7da5 rdc4782  
    44#include <stddef.h>
    55
    6 #ifdef HAVE_FACTORY
    76// just assume that factory have been built (cplusplus.h!)
    87// instead of duplicating cf_gmp.h here for now...
    98#include <factory/cf_gmp.h>
    10 #else
    11 #include <gmp.h>
    12 #endif
    139
    1410#ifndef mpz_size1
  • libpolys/coeffs/test.cc

    r7bb7da5 rdc4782  
    44#include <misc/auxiliary.h>
    55
    6 #ifdef HAVE_FACTORY
    76#include <factory/factory.h>
    8 #endif
    97
    108#include <omalloc/omalloc.h>
     
    2725
    2826
    29 #ifdef HAVE_FACTORY
    3027int initializeGMP(void){ return 1; }
    3128int mmInit(void) {return 1; } // ? due to SINGULAR!!!...???
    32 #endif
    3329
    3430#include <iostream>
  • libpolys/polys/clapconv.cc

    r7bb7da5 rdc4782  
    1313#include <misc/auxiliary.h>
    1414
    15 #ifdef HAVE_FACTORY
    1615#define SI_DONT_HAVE_GLOBAL_VARS
    1716#include <factory/factory.h>
     
    452451
    453452#endif
    454 #endif /* HAVE_FACTORY */
  • libpolys/polys/clapconv.h

    r7bb7da5 rdc4782  
    1010#ifndef INCL_SINGCONV_H
    1111#define INCL_SINGCONV_H
    12 
    13 #ifdef HAVE_FACTORY
    1412
    1513#include <polys/monomials/ring.h>
     
    3432poly convFactoryPSingTrP ( const CanonicalForm & f, const ring r );
    3533
    36 #endif /* HAVE_FACTORY */
    37 
    3834#endif /* INCL_SINGCONV_H */
  • libpolys/polys/clapsing.cc

    r7bb7da5 rdc4782  
    1515#include <misc/auxiliary.h>
    1616
    17 #ifdef HAVE_FACTORY
    18 
    1917#define SI_DONT_HAVE_GLOBAL_VARS
    2018
     
    2422#include <factory/factory.h>
    2523
    26 #ifdef HAVE_LIBFAC
    2724#    include <factory/libfac/libfac.h>
    28 #endif
    2925
    3026
     
    767763}
    768764
    769 #ifdef HAVE_FACTORY
    770765int singclap_factorize_retry;
    771 #endif
    772766
    773767ideal singclap_factorize ( poly f, intvec ** v , int with_exps, const ring r)
     
    13851379}
    13861380
    1387 #ifdef HAVE_LIBFAC
    13881381matrix singclap_irrCharSeries ( ideal I, const ring r)
    13891382{
     
    15601553  return s;
    15611554}
    1562 #endif /*HAVE_LIBFAC*/
    15631555
    15641556BOOLEAN singclap_isSqrFree(poly f, const ring r)
     
    18371829#endif /* HAVE_NTL */
    18381830
    1839 
    1840 #endif /* HAVE_FACTORY */
  • libpolys/polys/clapsing.h

    r7bb7da5 rdc4782  
    99#ifndef INCL_FACTORYSING_H
    1010#define INCL_FACTORYSING_H
    11 
    12 #ifdef HAVE_FACTORY
    1311
    1412class bigintmat;
     
    6462BOOLEAN singclap_isSqrFree(poly f, const ring r);
    6563
    66 # ifdef HAVE_LIBFAC
    6764 matrix singclap_irrCharSeries ( ideal I, const ring r);
    6865 char* singclap_neworder ( ideal I, const ring r);
    69 # endif
    7066
    7167poly singclap_det( const matrix m, const ring r );
     
    7672
    7773
    78 #endif /* HAVE_FACTORY */
    79 
    8074#endif /* INCL_FACTORYSING_H */
    8175
  • libpolys/polys/ext_fields/algext.cc

    r7bb7da5 rdc4782  
    4848#include <polys/PolyEnumerator.h>
    4949
    50 #ifdef HAVE_FACTORY
    5150#include <factory/factory.h>
    5251#include <polys/clapconv.h>
    5352#include <polys/clapsing.h>
    54 #endif
    55 
    5653
    5754#include <polys/ext_fields/algext.h>
     
    800797}
    801798
    802 #ifdef HAVE_FACTORY
    803799number naConvFactoryNSingN( const CanonicalForm n, const coeffs cf)
    804800{
     
    814810  return convSingPFactoryP((poly)n,naRing);
    815811}
    816 #endif
    817 
    818812
    819813/* IMPORTANT NOTE: Since an algebraic field extension is again a field,
     
    14091403  cf->cfInvers       = naInvers;
    14101404  cf->cfIntDiv       = naDiv; // ???
    1411 #ifdef HAVE_FACTORY
    14121405  cf->convFactoryNSingN=naConvFactoryNSingN;
    14131406  cf->convSingNFactoryN=naConvSingNFactoryN;
    1414 #endif
    14151407  cf->cfParDeg = naParDeg;
    14161408
  • libpolys/polys/ext_fields/transext.cc

    r7bb7da5 rdc4782  
    5757#include <polys/simpleideals.h>
    5858
    59 #ifdef HAVE_FACTORY
    6059#include <polys/clapsing.h>
    6160#include <polys/clapconv.h>
    6261#include <factory/factory.h>
    63 #endif
    6462
    6563#include <polys/ext_fields/transext.h>
     
    13761374  }*/
    13771375
    1378 #ifdef HAVE_FACTORY
    13791376  /* here we assume: NUM(f), DEN(f) !=NULL, in Z_a reqp. Z/p_a */
    13801377  poly pGcd = singclap_gcd_and_divide(NUM(f), DEN(f), ntRing);
     
    14441441      }
    14451442    }
    1446 #endif /* HAVE_FACTORY */
    1447 
    14481443  ntTest(a); // !!!!
    14491444}
     
    15561551  fraction fb = (fraction)b;
    15571552  if ((b==NULL)||(DEN(fb)==NULL)) return ntCopy(a,cf);
    1558 #ifdef HAVE_FACTORY
    15591553  fraction fa = (fraction)a;
    15601554  /* singclap_gcd destroys its arguments; we hence need copies: */
     
    16361630    return (number)result;
    16371631
    1638 #else
    1639   Print("// factory needed: transext.cc:ntLcm\n");
    1640   return NULL;
    1641 #endif /* HAVE_FACTORY */
    16421632  return NULL;
    16431633}
     
    16491639  if (a==NULL) return ntCopy(b,cf);
    16501640  if (b==NULL) return ntCopy(a,cf);
    1651 #ifdef HAVE_FACTORY
    16521641  fraction fa = (fraction)a;
    16531642  fraction fb = (fraction)b;
     
    17121701  ntTest((number)result); // !!!!
    17131702  return (number)result;
    1714 #else
    1715   Print("// factory needed: transext.cc:ntGcd\n");
    1716   return NULL;
    1717 #endif /* HAVE_FACTORY */
    17181703}
    17191704
     
    20452030    rDelete(cf->extRing);
    20462031}
    2047 #ifdef HAVE_FACTORY
    20482032number ntConvFactoryNSingN( const CanonicalForm n, const coeffs cf)
    20492033{
     
    20662050  return convSingPFactoryP(NUM(f),ntRing);
    20672051}
    2068 #endif
    20692052
    20702053static int ntParDeg(number a, const coeffs cf)
     
    24262409    cf->cfWriteShort = ntWriteLong;
    24272410
    2428 #ifndef HAVE_FACTORY
    2429   PrintS("// Warning: The 'factory' module is not available.\n");
    2430   PrintS("//          Hence gcd's cannot be cancelled in any\n");
    2431   PrintS("//          computed fraction!\n");
    2432 #else
    24332411  cf->convFactoryNSingN =ntConvFactoryNSingN;
    24342412  cf->convSingNFactoryN =ntConvSingNFactoryN;
    2435 #endif
    24362413  cf->cfParDeg = ntParDeg;
    24372414
  • libpolys/polys/monomials/p_polys.cc

    r7bb7da5 rdc4782  
    5757
    5858#include "coeffrings.h"
    59 #ifdef HAVE_FACTORY
    6059#include "clapsing.h"
    61 #endif
    6260
    6361#define ADIDEBUG 0
     
    24162414//    }
    24172415//    nDelete(&h);
    2418 //#ifdef HAVE_FACTORY
    24192416//    if ( (nGetChar() == 1) || (nGetChar() < 0) ) /* Q[a],Q(a),Zp[a],Z/p(a) */
    24202417//    {
     
    24232420//      pTest(ph);
    24242421//    }
    2425 //#endif
    24262422//  }
    24272423//}
     
    24752471    }
    24762472    n_Delete(&h,r->cf);
    2477 #ifdef HAVE_FACTORY
    24782473    //if ( (n_GetChar(r) == 1) || (n_GetChar(r) < 0) ) /* Q[a],Q(a),Zp[a],Z/p(a) */
    24792474    //{
     
    24812476    //  if(!n_GreaterZero(pGetCoeff(ph),r)) ph = p_Neg(ph,r);
    24822477    //}
    2483 #endif
    24842478  }
    24852479}
  • libpolys/polys/operations/p_Mult_q.cc

    r7bb7da5 rdc4782  
    1313#include <misc/auxiliary.h>
    1414
    15 #ifdef HAVE_FACTORY
    1615#include <factory/factory.h>
    17 #endif
    1816
    1917#include <misc/options.h>
  • libpolys/polys/templates/p_Procs_Dynamic.cc

    r7bb7da5 rdc4782  
    1313#include <misc/auxiliary.h>
    1414
    15 #ifdef HAVE_FACTORY
    1615#include <factory/factory.h>
    17 #endif
    1816
    1917#include <reporter/reporter.h>
  • libpolys/polys/templates/p_Procs_Lib.cc

    r7bb7da5 rdc4782  
    2020#include <misc/auxiliary.h>
    2121
    22 #ifdef HAVE_FACTORY
    2322#include <factory/factory.h>
    24 #endif
    2523
    2624#include <polys/monomials/p_polys.h>
  • libpolys/polys/templates/p_Procs_Static.cc

    r7bb7da5 rdc4782  
    1313#include <misc/auxiliary.h>
    1414
    15 #ifdef HAVE_FACTORY
    1615#include <factory/factory.h>
    17 #endif
    1816
    1917// #include <polys/structs.h>
  • libpolys/tests/common.h

    r7bb7da5 rdc4782  
    3232#include <polys/nc/gb_hack.h>
    3333
    34 #ifdef HAVE_FACTORY
    3534int initializeGMP(){ return 1; } // due to Factory...
    3635int mmInit(void) {return 1; } // ? due to SINGULAR!!!...???
    37 #endif
    3836
    3937// #pragma GCC diagnostic ignored "-Wwrite-strings"
  • numeric/mpr_base.cc

    r7bb7da5 rdc4782  
    2727#include <polys/sparsmat.h>
    2828
    29 #ifdef HAVE_FACTORY
    3029#include <polys/clapsing.h>
    31 #endif
    3230
    3331#include <kernel/febase.h>
     
    25752573
    25762574  // evaluate determinant of matrix m using factory singclap_det
    2577 #ifdef HAVE_FACTORY
    25782575  poly res= singclap_det( m, currRing );
    2579 #else
    2580   poly res= NULL;
    2581 #endif
    25822576
    25832577  // avoid errors for det==0
     
    26392633  }
    26402634
    2641 #ifdef HAVE_FACTORY
    26422635  poly res= singclap_det( mat, currRing );
    2643 #else
    2644   poly res= NULL;
    2645 #endif
    26462636
    26472637  number numres;
     
    27132703    break;
    27142704  case denseResMat:
    2715 #ifdef HAVE_FACTORY
    27162705    resMat= new resMatrixDense( gls );
    27172706    break;
    2718 #endif
    27192707  default:
    27202708    WerrorS("uResultant::uResultant: Unknown resultant matrix type choosen!");
  • standalone.test/test.cc

    r7bb7da5 rdc4782  
    88#include <resources/feResource.h>
    99
    10 #ifdef HAVE_FACTORY
    1110// int initializeGMP(){ return 1; }
    1211int mmInit(void) {return 1; }
    13 #endif
    1412
    1513#include <polys/monomials/ring.h>
  • standalone.test/tt.cc

    r7bb7da5 rdc4782  
    44#include <unistd.h>
    55
    6 #ifdef HAVE_FACTORY
    76int mmInit(void) {return 1; } // ? due to SINGULAR!!!...???
    8 #endif
    97
    108
Note: See TracChangeset for help on using the changeset viewer.