Changeset cc94f7e in git for libpolys


Ignore:
Timestamp:
Aug 10, 2016, 12:41:43 PM (8 years ago)
Author:
Adi Popescu <adi_popescum@…>
Branches:
(u'spielwiese', '5b153614cbc72bfa198d75b1e9e33dab2645d9fe')
Children:
d5d857d04cf9046b2cdd0a2ce1fae1415473c269
Parents:
e40da9f8133273ff0b3617f2e95f7bedfa0266bc41b9d0148bbf61fb89cd0f1b5c74a160774f24aa
Message:
Merge branch 'spielwiese' of github.com:Singular/Sources into SigDrop

Conflicts:
	kernel/GBEngine/kstd2.cc
Location:
libpolys
Files:
38 edited
1 moved

Legend:

Unmodified
Added
Removed
  • libpolys/coeffs/AEp.h

    re40da9f rcc94f7e  
    22#define AEP_H
    33
    4 #include <misc/auxiliary.h>
     4#include <singularconfig.h>
    55#include "si_gmp.h"
    66
  • libpolys/coeffs/bigintmat.cc

    re40da9f rcc94f7e  
    16771677#if 0
    16781678    char * s;
    1679     ::Print("mat over Z is \n");
     1679    ::PrintS("mat over Z is \n");
    16801680    ::Print("%s\n", s = nCoeffString(basecoeffs()));
    16811681    omFree(s);
     
    17441744              // get the gcd in position and the 0 in the other:
    17451745#ifdef CF_DEB
    1746               ::Print("applying trafo\n");
     1746              ::PrintS("applying trafo\n");
    17471747              StringSetS("");
    17481748              n_Write(co1, basecoeffs()); StringAppendS("\t");
     
    18061806
    18071807#if 0
    1808     ::Print("hnf over Z is \n");
     1808    ::PrintS("hnf over Z is \n");
    18091809    Print();
    18101810    ::Print("\n(%d x %d)\n", rows(), cols());
     
    19651965  //b can have multiple columns.
    19661966#if 0
    1967   Print("reduce_mod_howell: A:\n");
     1967  PrintS("reduce_mod_howell: A:\n");
    19681968  A->Print();
    1969   Print("\nb:\n");
     1969  PrintS("\nb:\n");
    19701970  b->Print();
    19711971#endif
     
    19811981
    19821982#if 0
    1983     Print("\nx:\n");
     1983    PrintS("\nx:\n");
    19841984    x->Print();
    1985     Print("\neps:\n");
     1985    PrintS("\neps:\n");
    19861986    eps->Print();
    1987     Print("\n****************************************\n");
     1987    PrintS("\n****************************************\n");
    19881988#endif
    19891989    return;
     
    20362036  delete B;
    20372037#if 0
    2038   Print("\nx:\n");
     2038  PrintS("\nx:\n");
    20392039  x->Print();
    2040   Print("\neps:\n");
     2040  PrintS("\neps:\n");
    20412041  eps->Print();
    2042   Print("\n****************************************\n");
     2042  PrintS("\n****************************************\n");
    20432043#endif
    20442044}
     
    20942094        n_InpMult(den, dz, Z);
    20952095#if 0
    2096         Print("den increasing to ");
     2096        PrintS("den increasing to ");
    20972097        n_Print(den, Z);
    2098         Print("\n");
     2098        PrintLn();
    20992099#endif
    21002100      }
     
    21082108#if 0
    21092109  L->Print();
    2110   Print("\n * 1/");
     2110  PrintS("\n * 1/");
    21112111  n_Print(den, Z);
    2112   Print("\n");
     2112  PrintLn();
    21132113#endif
    21142114  return den;
     
    24292429  x->simplifyContentDen(&den);
    24302430#if 0
    2431   Print("sol = 1/");
     2431  PrintS("sol = 1/");
    24322432  n_Print(den, R);
    2433   Print(" *\n");
     2433  PrintS(" *\n");
    24342434  x->Print();
    2435   Print("\n");
     2435  PrintLn();
    24362436#endif
    24372437  return den;
     
    24412441{
    24422442#if 0
    2443   Print("Solve Ax=b for A=\n");
     2443  PrintS("Solve Ax=b for A=\n");
    24442444  A->Print();
    2445   Print("\nb = \n");
     2445  PrintS("\nb = \n");
    24462446  b->Print();
    2447   Print("\nx = \n");
     2447  PrintS("\nx = \n");
    24482448  x->Print();
    2449   Print("\n");
     2449  PrintLn();
    24502450#endif
    24512451
     
    25652565      Print("\n2:x: %ld\n", x);
    25662566      x->Print();
    2567       Print("\n");
     2567      PrintLn();
    25682568#endif
    25692569    }
     
    25862586    }
    25872587#if 0
    2588     Print("Diag ? %d\n", diag);
     2588    PrintS("Diag ? %d\n", diag);
    25892589    a->Print();
    2590     Print("\n");
     2590    PrintLn();
    25912591#endif
    25922592    if (diag) break;
     
    26112611{
    26122612#if 0
    2613   Print("Kernel of ");
     2613  PrintS("Kernel of ");
    26142614  a->Print();
    2615   Print(" modulo ");
     2615  PrintS(" modulo ");
    26162616  n_Print(p, q);
    2617   Print("\n");
     2617  PrintLn();
    26182618#endif
    26192619
     
    26222622  diagonalForm(m, &U, &V);
    26232623#if 0
    2624   Print("\ndiag form: ");
     2624  PrintS("\ndiag form: ");
    26252625  m->Print();
    2626   Print("\nU:\n");
     2626  PrintS("\nU:\n");
    26272627  U->Print();
    2628   Print("\nV:\n");
     2628  PrintS("\nV:\n");
    26292629  V->Print();
    2630   Print("\n");
     2630  PrintLn();
    26312631#endif
    26322632
  • libpolys/coeffs/coeffs.h

    re40da9f rcc94f7e  
    1010#define COEFFS_H
    1111
    12 #include <misc/auxiliary.h>
     12# include <misc/auxiliary.h>
    1313#include <omalloc/omalloc.h>
    1414
  • libpolys/coeffs/ffields.cc

    re40da9f rcc94f7e  
    633633  if (fftable[i]==0)
    634634  {
    635 #ifndef SING_NDEBUG
    636     Warn("illegal GF-table size: %d", c);
    637 #endif
     635    // illegal GF-table size: c
    638636    return;
    639637  }
     
    954952  if( r->m_nfPlus1Table == NULL )
    955953  {
    956 #ifndef SING_NDEBUG
    957     Warn("Sorry: cannot init lookup table!");
    958 #endif
    959954    return TRUE;
    960955  }
  • libpolys/coeffs/flintcf_Q.cc

    re40da9f rcc94f7e  
    77#include <ctype.h> /* isdigit*/
    88
    9 #ifdef HAVE_CONFIG_H
    10 #include "libpolysconfig.h"
    11 #endif /* HAVE_CONFIG_H */
    129#include <misc/auxiliary.h>
    1310
     
    7168static void CoeffWrite(const coeffs r, BOOLEAN details)
    7269{
    73   Print("// coefficients: flint fmpq_poly\n");
     70  PrintS("// coefficients: flint fmpq_poly\n");
    7471}
    7572static BOOLEAN CoeffIsEqual(const coeffs r, n_coeffType n, void * parameter)
  • libpolys/coeffs/flintcf_Zn.cc

    re40da9f rcc94f7e  
    77#include <ctype.h> /* isdigit*/
    88
    9 #ifdef HAVE_CONFIG_H
    10 #include "libpolysconfig.h"
    11 #endif /* HAVE_CONFIG_H */
    129#include <misc/auxiliary.h>
    1310
  • libpolys/coeffs/flintcf_Zn.h

    re40da9f rcc94f7e  
    1010#define FLINTCF_ZN_H
    1111
     12#include <singularconfig.h>
    1213#include <misc/auxiliary.h>
     14
    1315#ifdef SINGULAR_4_1
    1416#ifdef HAVE_FLINT
  • libpolys/coeffs/gnumpc.h

    re40da9f rcc94f7e  
    77* ABSTRACT: computations with GMP floating-point numbers
    88*/
     9#include <singularconfig.h>
    910#include <misc/auxiliary.h>
    1011
  • libpolys/coeffs/gnumpfl.h

    re40da9f rcc94f7e  
    88*/
    99
     10#include <singularconfig.h>
    1011#include <misc/auxiliary.h>
     12
    1113
    1214struct n_Procs_s; typedef struct  n_Procs_s  *coeffs;
  • libpolys/coeffs/longrat.cc

    re40da9f rcc94f7e  
    7272void     nlWrite(number a, const coeffs r);
    7373
    74 number   nlGetDenom(number &n, const coeffs r);
    75 number   nlGetNumerator(number &n, const coeffs r);
    7674void     nlCoeffWrite(const coeffs r, BOOLEAN details);
    7775number   nlChineseRemainder(number *x, number *q,int rl, const coeffs C);
  • libpolys/coeffs/longrat.h

    re40da9f rcc94f7e  
    1313
    1414struct snumber; typedef struct snumber  *number;
     15
     16number   nlGetDenom(number &n, const coeffs r); /*for SAGE,, better: n_GetDenom */
     17number   nlGetNumerator(number &n, const coeffs r); /*for SAGE, better: n_GetNumerator*/
    1518
    1619/*-----------------------------------------------------------------*/
  • libpolys/coeffs/numbers.cc

    re40da9f rcc94f7e  
    261261{
    262262  CanonicalForm term(0);
    263   Werror("no conversion to factory");
     263  WerrorS("no conversion to factory");
    264264  return term;
    265265}
     
    267267static number ndConvFactoryNSingN( const CanonicalForm, const coeffs)
    268268{
    269   Werror("no conversion from factory");
     269  WerrorS("no conversion from factory");
    270270  return NULL;
    271271}
  • libpolys/coeffs/rintegers.cc

    re40da9f rcc94f7e  
    3737BOOLEAN nrzGreaterZero (number k, const coeffs r);
    3838number  nrzMult        (number a, number b, const coeffs r);
    39 number  nrzInit        (long i, const coeffs r);
    4039long    nrzInt         (number &n, const coeffs r);
    4140number  nrzAdd         (number a, number b, const coeffs r);
     
    14121411  number two = nrzInit(2, R);
    14131412#if 0
    1414   Print("Farey start with ");
     1413  PrintS("Farey start with ");
    14151414  n_Print(r, R);
    1416   Print(" mod ");
     1415  PrintS(" mod ");
    14171416  n_Print(N, R);
    1418   Print("\n");
     1417  PrintLn();
    14191418#endif
    14201419  while (1)
  • libpolys/coeffs/rintegers.h

    re40da9f rcc94f7e  
    88*/
    99#include <misc/auxiliary.h>
    10 #include <coeffs/coeffs.h>
    1110
    1211#ifdef HAVE_RINGS
     
    2625BOOLEAN nrzInitChar    (coeffs r,  void * parameter);
    2726
    28 // will be reused by rmodulon.cc
    29 void    nrzWrite       (number a, const coeffs r);
     27void    nrzWrite       (number a, const coeffs r); /*for rmodulon.cc*/
     28
     29number  nrzInit        (long i, const coeffs r); /*for SAGE, better: n_Init*/
    3030
    3131#endif
  • libpolys/coeffs/rmodulo2m.h

    re40da9f rcc94f7e  
    1717
    1818BOOLEAN nr2mInitChar    (coeffs r, void*);
     19number  nr2mMapZp       (number from, const coeffs /*src*/, const coeffs dst);
     20/*for SAGE, better: use the result of n_SetMap*/
    1921
    2022#endif
  • libpolys/coeffs/rmodulon.cc

    re40da9f rcc94f7e  
    446446#endif
    447447  nrnDelete(&xx, r);
    448   if (!nrnIsOne(ui, r)) {
     448  if (!nrnIsOne(ui, r))
     449  {
    449450#ifdef CF_DEB
    450     Print("Scaling\n");
     451    PrintS("Scaling\n");
    451452#endif
    452453    number uii = nrnInvers(ui, r);
  • libpolys/coeffs/rmodulon.h

    re40da9f rcc94f7e  
    88*/
    99#include <misc/auxiliary.h>
     10#include <coeffs/coeffs.h>
    1011
    1112struct n_Procs_s; typedef struct  n_Procs_s  *coeffs;
     
    1920
    2021BOOLEAN nrnInitChar    (coeffs r, void*);
     22number nrnMapGMP(number from, const coeffs /*src*/, const coeffs dst);/*for SAGE*/
     23nMapFunc nrnSetMap(const coeffs src, const coeffs dst);/* for SAGE, better: n_setMap*/
     24
    2125
    2226#endif
  • libpolys/configure.ac

    re40da9f rcc94f7e  
    147147AC_CONFIG_FILES([polys/Makefile])
    148148AC_CONFIG_FILES([tests/Makefile])
    149 AC_CONFIG_FILES([libpolys-config libpolys.pc  misc/auxiliary.h])
     149AC_CONFIG_FILES([libpolys-config libpolys.pc])
    150150AC_OUTPUT
  • libpolys/misc/Makefile.am

    re40da9f rcc94f7e  
    1313libmisc_la_includedir = $(includedir)/singular/misc
    1414libmisc_la_include_HEADERS = mylimits.h options.h intvec.h int64vec.h \
    15                              sirandom.h prime.h
     15                             sirandom.h prime.h auxiliary.h
    1616
    17 nodist_libmisc_la_include_HEADERS = auxiliary.h
    18 nodist_libmisc_la_SOURCES   = auxiliary.h
    19 
  • libpolys/misc/auxiliary.h

    re40da9f rcc94f7e  
    1919/* please include libpolysconfig.h exclusively via <misc/auxiliary.h> and before any other header */
    2020#include "libpolysconfig.h"
    21 
    22 // ----------------- which parts/extensions of Singular to build
    23 #ifndef HAVE_RINGS
    24 #undef HAVE_RINGS
    25 #endif
    26 
    27 #ifndef HAVE_PLURAL
    28 #undef HAVE_PLURAL
    29 #endif
    30 
    31 #ifndef HAVE_DL
    32 #undef HAVE_DL
    33 #endif
    34 
    35 #ifndef HAVE_NTL
    36 #undef HAVE_NTL
    37 #endif
    38 
    39 /* letterplace gb:*/
    40 #ifndef HAVE_SHIFTBBA
    41 #undef HAVE_SHIFTBBA
    42 #endif
    43 
    44 #ifndef HAVE_POLYEXTENSIONS
    45 #undef HAVE_POLYEXTENSIONS
    46 #endif
    47 
    48 #ifndef DISABLE_GMP_CPP
    49 #undef DISABLE_GMP_CPP
    50 #endif
    51 
    52 #ifndef SINGULAR
    53 #undef SINGULAR
    54 #endif
    55 
    56 #ifndef NOSTREAMIO
    57 #undef NOSTREAMIO
    58 #endif
    5921
    6022/* the following cunstruct is to make it painless to add -DHAVE_NUMSTATS to CPPFLAGS for configure */
     
    6325#undef HAVE_NUMSTATS
    6426#endif /* HAVE_NUMSTATS */
    65 // ----------------  end of parts/extensions
    6627
    6728// ---------------- Singular standard types etc.
     
    174135
    175136// ---------------- defines which depend on the settings above
    176 
    177 #ifndef HAVE_MULT_MOD
    178 #undef HAVE_MULT_MOD
    179 #endif
    180 
    181 #ifndef HAVE_DIV_MOD
    182 #undef HAVE_DIV_MOD
    183 #endif
    184 
    185 #ifndef HAVE_GENERIC_ADD
    186 #undef HAVE_GENERIC_ADD
    187 #endif
    188137
    189138/*******************************************************************
  • libpolys/misc/int64vec.h

    re40da9f rcc94f7e  
    88*/
    99#include <string.h>
     10#include <misc/auxiliary.h>
    1011#include <omalloc/omallocClass.h>
    11 #include <misc/auxiliary.h>
    1212#include <misc/intvec.h>
    1313
  • libpolys/polys/ext_fields/algext.cc

    re40da9f rcc94f7e  
    14971497
    14981498  assume( A != NULL );
    1499   Print("// polynomial ring as coefficient ring :\n");
     1499  PrintS("// polynomial ring as coefficient ring :\n");
    15001500  rWrite(A);
    15011501  PrintLn();
  • libpolys/polys/ext_fields/transext.cc

    re40da9f rcc94f7e  
    216216      {
    217217        Print("ERROR in %s:%d: constant den. poly / Zp\n",f,l);
    218         Print("NUM: ");  p_Write(num, ntRing);
    219         Print("DEN: ");  p_Write(den, ntRing);
     218        PrintS("NUM: ");  p_Write(num, ntRing);
     219        PrintS("DEN: ");  p_Write(den, ntRing);
    220220        return FALSE;
    221221      }
     
    224224      {
    225225        Print("ERROR in %s:%d: non-monic den. poly / Zp\n",f,l);
    226         Print("NUM: ");  p_Write(num, ntRing);
    227         Print("DEN: ");  p_Write(den, ntRing);
     226        PrintS("NUM: ");  p_Write(num, ntRing);
     227        PrintS("DEN: ");  p_Write(den, ntRing);
    228228        return FALSE;
    229229      }
     
    238238        {
    239239          Print("ERROR in %s:%d: 1 != GCD between num. & den. poly\n",f,l);
    240           Print("GCD: ");  p_Write(gcd, ntRing);
    241           Print("NUM: ");  p_Write(num, ntRing);
    242           Print("DEN: ");  p_Write(den, ntRing);
     240          PrintS("GCD: ");  p_Write(gcd, ntRing);
     241          PrintS("NUM: ");  p_Write(num, ntRing);
     242          PrintS("DEN: ");  p_Write(den, ntRing);
    243243          return FALSE;
    244244        }
  • libpolys/polys/kbuckets.cc

    re40da9f rcc94f7e  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 //#include <kernel/mod2.h>
    5 
    6 
    7 
    84
    95#include <omalloc/omalloc.h>
  • libpolys/polys/matpol.cc

    re40da9f rcc94f7e  
    699699*    for(i=1;i<=c;i++)
    700700*    {
    701 *      if(MATELEM(a,j,i)!=NULL) Print("X");
    702 *      else Print("0");
     701*      if(MATELEM(a,j,i)!=NULL) PrintS("X");
     702*      else PrintS("0");
    703703*    }
    704 *    Print("\n");
     704*    PrintLn();
    705705*  }
    706706*}
  • libpolys/polys/monomials/p_polys.cc

    re40da9f rcc94f7e  
    291291          p->exp[o->data.wp64.place]=a_1;
    292292          p->exp[o->data.wp64.place+1]=a_0;
    293 //            if(p_Setm_error) Print("***************************\n
    294 //                                    ***************************\n
    295 //                                    **WARNING: overflow error**\n
    296 //                                    ***************************\n
    297 //                                    ***************************\n");
     293//            if(p_Setm_error) PrintS("***************************\n"
     294//                                    "***************************\n"
     295//                                    "**WARNING: overflow error**\n"
     296//                                    "***************************\n"
     297//                                    "***************************\n");
    298298          break;
    299299        }
     
    38943894  {
    38953895    assume (FALSE);
    3896     Werror("Number permutation is not implemented for this data yet!");
     3896    WerrorS("Number permutation is not implemented for this data yet!");
    38973897    return NULL;
    38983898  }
  • libpolys/polys/monomials/p_polys.h

    r41b9d0 rcc94f7e  
    14981498}
    14991499
    1500 #ifdef HAVE_RINGS
    15011500// The coefficient will be compared in absolute value
    15021501static inline int p_LtCmp(poly p, poly q, const ring r)
     
    15241523  return res;
    15251524}
    1526 #endif
     1525
     1526// The coefficient will be compared in absolute value
     1527static inline int p_LtCmpNoAbs(poly p, poly q, const ring r)
     1528{
     1529  int res = p_LmCmp(p,q,r);
     1530  if(res == 0)
     1531  {
     1532    if(p_GetCoeff(p,r) == NULL || p_GetCoeff(q,r) == NULL)
     1533      return res;
     1534    number pc = p_GetCoeff(p,r);
     1535    number qc = p_GetCoeff(q,r);
     1536    if(n_Greater(pc,qc,r->cf))
     1537      res = 1;
     1538    if(n_Greater(qc,pc,r->cf))
     1539      res = -1;
     1540    if(n_Equal(pc,qc,r->cf))
     1541      res = 0;
     1542  }
     1543  return res;
     1544}
    15271545
    15281546#ifdef HAVE_RINGS
  • libpolys/polys/monomials/ring.cc

    re40da9f rcc94f7e  
    40864086      else
    40874087      {
    4088         Print("{");
     4088        PrintS("{");
    40894089        for( i=0; i <= limit; i++ )
    40904090          Print("%d ", syz_index[i]);
    4091         Print("}");
     4091        PrintS("}");
    40924092      }
    40934093
     
    42114211  {
    42124212      PrintLn();
    4213       Print("pFDeg   : ");
     4213      PrintS("pFDeg   : ");
    42144214#define pFDeg_CASE(A) if(r->pFDeg == A) PrintS( "" #A "" )
    42154215      pFDeg_CASE(p_Totaldegree); else
     
    42244224    PrintLn();
    42254225  }
    4226   Print("pSetm:");
     4226  PrintS("pSetm:");
    42274227  void p_Setm_Dummy(poly p, const ring r);
    42284228  void p_Setm_TotalDegree(poly p, const ring r);
  • libpolys/polys/nc/ncSAFormula.cc

    re40da9f rcc94f7e  
    5252{
    5353#if OUTPUT
    54   Print("ncInitSpecialPowersMultiplication(ring), ring: \n");
     54  PrintS("ncInitSpecialPowersMultiplication(ring), ring: \n");
    5555  rWrite(r, TRUE);
    5656  PrintLn();
     
    8484{
    8585#if OUTPUT
    86   Print("AreCommutingVariables(ring, k: %d, i: %d)!", j, i);
    87   PrintLn();
     86  Print("AreCommutingVariables(ring, k: %d, i: %d)!\n", j, i);
    8887#endif
    8988
     
    136135{
    137136#if OUTPUT
    138   Print("AnalyzePair(ring, i: %d, j: %d):", i, j);
    139   PrintLn();
     137  Print("AnalyzePair(ring, i: %d, j: %d):\n", i, j);
    140138#endif
    141139
     
    220218{
    221219#if OUTPUT
    222   Print("CFormulaPowerMultiplier::CFormulaPowerMultiplier(ring)!");
     220  PrintS("CFormulaPowerMultiplier::CFormulaPowerMultiplier(ring)!");
    223221  PrintLn();
    224222#endif
     
    237235{
    238236#if OUTPUT
    239   Print("CFormulaPowerMultiplier::~CFormulaPowerMultiplier()!");
     237  PrintS("CFormulaPowerMultiplier::~CFormulaPowerMultiplier()!");
    240238  PrintLn();
    241239#endif
     
    263261{
    264262#if OUTPUT
    265   Print("ncSA_1xy0x0y0(var(%d)^{%d}, var(%d)^{%d}, r)!", j, m, i, n);
    266   PrintLn();
     263  Print("ncSA_1xy0x0y0(var(%d)^{%d}, var(%d)^{%d}, r)!\n", j, m, i, n);
    267264#endif
    268265
     
    281278{
    282279#if OUTPUT
    283   Print("ncSA_{M = -1}xy0x0y0(var(%d)^{%d}, var(%d)^{%d}, r)!", j, m, i, n);
    284   PrintLn();
     280  Print("ncSA_{M = -1}xy0x0y0(var(%d)^{%d}, var(%d)^{%d}, r)!\n", j, m, i, n);
    285281#endif
    286282
     
    301297{
    302298#if OUTPUT
    303   Print("ncSA_Qxy0x0y0(var(%d)^{%d}, var(%d)^{%d}, Q, r)!", j, m, i, n);
    304   PrintLn();
     299  Print("ncSA_Qxy0x0y0(var(%d)^{%d}, var(%d)^{%d}, Q, r)!\n", j, m, i, n);
    305300#endif
    306301
     
    350345{
    351346#if OUTPUT
    352   Print("ncSA_1xy0x0yG(var(%d)^{%d}, var(%d)^{%d}, G, r)!", j, m, i, n);
    353   PrintLn();
     347  Print("ncSA_1xy0x0yG(var(%d)^{%d}, var(%d)^{%d}, G, r)!\n", j, m, i, n);
    354348  number t = n_Copy(m_g, r);
    355349  PrintS("Parameter G: "); n_Write(t, r);
     
    450444{
    451445#if OUTPUT
    452   Print("ncSA_1xy0x0yT2(var(%d)^{%d}, var(%d)^{%d}, t: var(%d), r)!", j, m, i, n, m_k);
    453   PrintLn();
     446  Print("ncSA_1xy0x0yT2(var(%d)^{%d}, var(%d)^{%d}, t: var(%d), r)!\n", j, m, i, n, m_k);
    454447#endif
    455448
     
    633626{
    634627#if OUTPUT
    635   Print("ncSA_1xyAx0y0(var(%d)^{%d}, var(%d)^{%d}, A, r)!", j, m, i, n);
    636   PrintLn();
     628  Print("ncSA_1xyAx0y0(var(%d)^{%d}, var(%d)^{%d}, A, r)!\n", j, m, i, n);
    637629  number t = n_Copy(m_shiftCoef, r);
    638630  PrintS("Parameter A: "); n_Write(t, r);
     
    646638{
    647639#if OUTPUT
    648   Print("ncSA_1xy0xBy0(var(%d)^{%d}, var(%d)^{%d}, B, r)!", j, m, i, n);
    649   PrintLn();
     640  Print("ncSA_1xy0xBy0(var(%d)^{%d}, var(%d)^{%d}, B, r)!\n", j, m, i, n);
    650641  number t = n_Copy(m_shiftCoef, r);
    651642  PrintS("Parameter B: "); n_Write(t, r);
     
    664655{
    665656#if OUTPUT
    666   Print("ncSA_Multiply(type: %d, ring, (var(%d)^{%d} * var(%d)^{%d}, r)!", (int)type, j, m, i, n);
    667   PrintLn();
     657  Print("ncSA_Multiply(type: %d, ring, (var(%d)^{%d} * var(%d)^{%d}, r)!\n", (int)type, j, m, i, n);
    668658#endif
    669659
  • libpolys/polys/nc/old.gring.cc

    re40da9f rcc94f7e  
    407407        if (side)
    408408        {
    409           Print("gnc_p_Mult_mm: Multiplication in the left module from the right");
     409          PrintS("gnc_p_Mult_mm: Multiplication in the left module from the right");
    410410        }
    411411#endif
     
    14651465  {
    14661466#ifdef PDEBUG
    1467     Werror("gnc_ReduceSpolyNew: different non-zero components!");
     1467    WerrorS("gnc_ReduceSpolyNew: different non-zero components!");
    14681468#endif
    14691469    return(NULL);
     
    16221622  p_Test(p2, r);
    16231623#if MYTEST
    1624   Print("p1: "); p_Write(p1, r);
    1625   Print("p2: "); p_Write(p2, r);
     1624  PrintS("p1: "); p_Write(p1, r);
     1625  PrintS("p2: "); p_Write(p2, r);
    16261626#endif
    16271627#endif
     
    16331633  {
    16341634#ifdef PDEBUG
    1635     Werror("gnc_CreateSpolyNew: different non-zero components!");
     1635    WerrorS("gnc_CreateSpolyNew: different non-zero components!");
    16361636    assume(0);
    16371637#endif
     
    16751675#ifdef PDEBUG
    16761676#if MYTEST
    1677   Print("m1: "); pWrite(m1);
    1678   Print("m2: "); pWrite(m2);
     1677  PrintS("m1: "); pWrite(m1);
     1678  PrintS("m2: "); pWrite(m2);
    16791679#endif
    16801680#endif
     
    17231723
    17241724#if MYTEST
    1725   Print("M1: "); pWrite(M1);
    1726   Print("M2: "); pWrite(M2);
     1725  PrintS("M1: "); pWrite(M1);
     1726  PrintS("M2: "); pWrite(M2);
    17271727#endif
    17281728#endif
     
    17311731  {
    17321732#ifdef PDEBUG
    1733        Print("\np1 = ");
     1733       PrintS("\np1 = ");
    17341734       p_Write(p1, r);
    17351735
    1736        Print("m1 = ");
     1736       PrintS("m1 = ");
    17371737       p_Write(m1, r);
    17381738
    1739        Print("p2 = ");
     1739       PrintS("p2 = ");
    17401740       p_Write(p2, r);
    17411741
    1742        Print("m2 = ");
     1742       PrintS("m2 = ");
    17431743       p_Write(m2, r);
    17441744
    1745        Werror("ERROR in nc_CreateSpoly: result of multiplication is Zero!\n");
     1745       WerrorS("ERROR in nc_CreateSpoly: result of multiplication is Zero!\n");
    17461746#endif
    17471747       return(NULL);
     
    17901790
    17911791#if MYTEST
    1792   Print("M1: "); pWrite(M1);
    1793   Print("M2: "); pWrite(M2);
     1792  PrintS("M1: "); pWrite(M1);
     1793  PrintS("M2: "); pWrite(M2);
    17941794#endif
    17951795#endif
     
    18021802
    18031803#if MYTEST
    1804   Print("M2: "); pWrite(M2);
     1804  PrintS("M2: "); pWrite(M2);
    18051805#endif
    18061806
     
    18311831
    18321832#if MYTEST
    1833   Print("M1: "); pWrite(M1);
     1833  PrintS("M1: "); pWrite(M1);
    18341834#endif
    18351835
     
    18421842
    18431843#if MYTEST
    1844   Print("M2: "); pWrite(M2);
     1844  PrintS("M2: "); pWrite(M2);
    18451845#endif
    18461846
     
    18601860
    18611861#if MYTEST
    1862   Print("M1: "); pWrite(M1);
     1862  PrintS("M1: "); pWrite(M1);
    18631863#endif
    18641864
     
    18721872
    18731873#if MYTEST
    1874   Print("M2: "); pWrite(M2);
     1874  PrintS("M2: "); pWrite(M2);
    18751875#endif
    18761876
     
    19501950  {
    19511951#ifdef PDEBUG
    1952     Werror("nc_CreateShortSpoly: wrong module components!"); // !!!!
     1952    WerrorS("nc_CreateShortSpoly: wrong module components!"); // !!!!
    19531953#endif
    19541954    return(NULL);
     
    20152015  const ring r = b->bucket_ring;
    20162016#ifdef PDEBUG
    2017 //   Print(">*");
     2017//   PrintS(">*");
    20182018#endif
    20192019
    20202020#ifdef KDEBUG
    2021   if( !kbTest(b) )Werror("nc_kBucketPolyRed: broken bucket!");
     2021  if( !kbTest(b) ) WerrorS("nc_kBucketPolyRed: broken bucket!");
    20222022#endif
    20232023
     
    20252025  p_Test(p, r);
    20262026#if MYTEST
    2027   Print("p: "); p_Write(p, r);
     2027  PrintS("p: "); p_Write(p, r);
    20282028#endif
    20292029#endif
     
    20412041
    20422042#if MYTEST
    2043   Print("pLmB: "); p_Write(pLmB, r);
     2043  PrintS("pLmB: "); p_Write(pLmB, r);
    20442044#endif
    20452045#endif
     
    20512051  p_Test(m, r);
    20522052#if MYTEST
    2053   Print("m: "); p_Write(m, r);
     2053  PrintS("m: "); p_Write(m, r);
    20542054#endif
    20552055#endif
     
    20792079#ifdef PDEBUG
    20802080  p_Test(pp, r);
    2081 //   Print("PP: "); pWrite(pp);
     2081//   PrintS("PP: "); pWrite(pp);
    20822082#endif
    20832083
     
    20862086
    20872087#ifdef PDEBUG
    2088 //   Print("*>");
     2088//   PrintS("*>");
    20892089#endif
    20902090}
     
    25982598//  {
    25992599//#ifdef PDEBUF
    2600 //    Werror("nc_p_CopyGet call not in currRing");
     2600//    WerrorS("nc_p_CopyGet call not in currRing");
    26012601//#endif
    26022602//    return(NULL);
     
    26192619//  {
    26202620//#ifdef PDEBUF
    2621 //    Werror("nc_p_CopyGet call not in currRing");
     2621//    WerrorS("nc_p_CopyGet call not in currRing");
    26222622//#endif
    26232623//    return(NULL);
     
    28792879    if (!p_IsConstant(CN,curr))
    28802880    {
    2881       Werror("Incorrect input : non-constants are not allowed as coefficients (first argument)");
     2881      WerrorS("Incorrect input : non-constants are not allowed as coefficients (first argument)");
    28822882      return TRUE;
    28832883    }
     
    28872887    if (n_IsZero(nN, curr))
    28882888    {
    2889       Werror("Incorrect input : zero coefficients are not allowed");
     2889      WerrorS("Incorrect input : zero coefficients are not allowed");
    28902890
    28912891//      if( currRing != save )
     
    29452945        // find also illegal pN
    29462946        {
    2947           Werror("Incorrect input : matrix of coefficients contains zeros in the upper triangle");
     2947          WerrorS("Incorrect input : matrix of coefficients contains zeros in the upper triangle");
    29482948
    29492949//        if( currRing != save )
     
    30463046    if( bDnew ) mp_Delete( &D, r );
    30473047
    3048     Werror("Matrix of polynomials violates the ordering condition");
     3048    WerrorS("Matrix of polynomials violates the ordering condition");
    30493049
    30503050//    if( currRing != save )
     
    33863386    if ((shift<0) || (shift > rVar(srcRing))) // ???
    33873387    {
    3388       Werror("bad shifts in p_CopyEmbed");
     3388      WerrorS("bad shifts in p_CopyEmbed");
    33893389      return(0);
    33903390    }
  • libpolys/polys/nc/sca.cc

    re40da9f rcc94f7e  
    385385
    386386#ifdef PDEBUG
    387 //  Print("sca_p_Mult_mm\n"); // !
     387//  PrintS("sca_p_Mult_mm\n"); // !
    388388
    389389  p_Test(pPoly, rRing);
     
    471471
    472472#ifdef PDEBUG
    473 //  Print("sca_pp_Mult_mm\n"); // !
     473//  PrintS("sca_pp_Mult_mm\n"); // !
    474474
    475475  p_Test(pPoly, rRing);
     
    581581
    582582#ifdef PDEBUG
    583 //  Print("sca_mm_Mult_pp\n"); // !
     583//  PrintS("sca_mm_Mult_pp\n"); // !
    584584
    585585  p_Test(pPoly, rRing);
     
    14601460
    14611461#if 0
    1462   Print("m_KillSquares, m = "); // !
     1462  PrintS("m_KillSquares, m = "); // !
    14631463  p_Write(m, r);
    14641464#endif
     
    14871487
    14881488#if 0
    1489   Print("p_KillSquares, p = "); // !
     1489  PrintS("p_KillSquares, p = "); // !
    14901490  p_Write(p, r);
    14911491#endif
     
    15191519  p_Test(pResult, r);
    15201520#if 0
    1521   Print("p_KillSquares => "); // !
     1521  PrintS("p_KillSquares => "); // !
    15221522  p_Write(pResult, r);
    15231523#endif
  • libpolys/polys/sbuckets.cc

    re40da9f rcc94f7e  
    99 *  Created: 9/00
    1010 *******************************************************************/
    11 //#include <kernel/mod2.h>
    12 
    1311#include <omalloc/omalloc.h>
    14 
    15 
    16 
    1712
    1813#include <misc/auxiliary.h>
  • libpolys/polys/simpleideals.cc

    r41b9d0 rcc94f7e  
    469469  if (nolex)
    470470  {
    471     int r=p_LmCmp(a,b,R);
     471    int r=p_LtCmp(a,b,R);
     472    return r;
     473    #if 0
    472474    if (r!=0) return r;
    473475    number h=n_Sub(pGetCoeff(a),pGetCoeff(b),R->cf);
     
    475477    n_Delete(&h, R->cf);
    476478    return r;
     479    #endif
    477480  }
    478481  int l=rVar(R);
     
    651654}
    652655
     656/// insert p into I on position pos
     657BOOLEAN idInsertPolyOnPos (ideal I, poly p,int pos)
     658{
     659  if (p==NULL) return FALSE;
     660  assume (I != NULL);
     661
     662  int j = IDELEMS(I) - 1;
     663
     664  while ((j >= 0) && (I->m[j] == NULL)) j--;
     665  j++;
     666  if (j==IDELEMS(I))
     667  {
     668    pEnlargeSet(&(I->m),IDELEMS(I),IDELEMS(I)+1);
     669    IDELEMS(I)+=1;
     670  }
     671  for(j = IDELEMS(I)-1;j>pos;j--)
     672    I->m[j] = I->m[j-1];
     673  I->m[pos]=p;
     674  return TRUE;
     675}
     676
    653677
    654678/*! insert h2 into h1 depending on the two boolean parameters:
  • libpolys/polys/templates/p_Procs_Set.h

    re40da9f rcc94f7e  
    1515
    1616#include <reporter/reporter.h>
    17 #include <libpolys/libpolysconfig.h>
     17#include <misc/auxiliary.h>
    1818
    1919// extract p_Procs properties from a ring
  • libpolys/polys/weight0.c

    re40da9f rcc94f7e  
    66* ABSTRACT:
    77*/
    8 
    9 
    10 
    11 
    128
    139#include <misc/auxiliary.h>
  • libpolys/reporter/s_buff.cc

    re40da9f rcc94f7e  
    99#include <signal.h>
    1010
    11 //#include <kernel/mod2.h>
    1211#include <gmp.h>
    1312
  • libpolys/tests/coeffs_test.h

    re40da9f rcc94f7e  
    1 
    2 
    3 
    41#include <misc/auxiliary.h>
    52#include <omalloc/omalloc.h>
  • libpolys/tests/common.h

    re40da9f rcc94f7e  
    88#include <cxxtest/TestSuite.h>
    99#include <cxxtest/GlobalFixture.h>
    10 
    11 
    12 
    13 
    1410
    1511#include <misc/auxiliary.h>
  • libpolys/tests/simple_test.h

    re40da9f rcc94f7e  
    1 
    2 
    3 
    41#include <misc/auxiliary.h>
    52
Note: See TracChangeset for help on using the changeset viewer.