Changeset 1d1f93 in git


Ignore:
Timestamp:
Feb 9, 2015, 10:12:09 AM (9 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'spielwiese', '8e0ad00ce244dfd0756200662572aef8402f13d5')
Children:
d0e7cfba749eb576b61120883b3ef1f167e2d2a6
Parents:
2f05b5d1e37c6c725c53ad68296b934d1e5983c888615dbd0782deeb4def60eef9657a8fa5c30e4d
Message:
Merge pull request #692 from jgmbenoit/debian/source-typo

correct some spelling errors:
Files:
38 added
1 deleted
70 edited

Legend:

Unmodified
Added
Removed

  • .gdbinit

    r88615db r1d1f93  
    33#break omReportError # use in case of problems with omaloc
    44#break dPolyReportError # use in case of problems with polynomial arithmetic
    5              
     5
    66
    77

  • IntegerProgramming/binomial.cc

    r2f05b5 r1d1f93  
    301301    {
    302302      cerr<<"\nWARNING: binomial& binomial::operator=(const binomial&):\n"
    303         "assigment from corrupt binomial"<<endl;
     303        "assignment from corrupt binomial"<<endl;
    304304      exponent_vector=NULL;
    305305      return (*this);

  • IntegerProgramming/binomial.h

    r2f05b5 r1d1f93  
    115115
    116116
    117 // assigment and access operators
     117// assignment and access operators
    118118
    119119  binomial& operator=(const binomial&);

  • IntegerProgramming/list.cc

    r2f05b5 r1d1f93  
    963963
    964964
    965 ////////////////////////// assigment ///////////////////////////////////////
     965////////////////////////// assignment ///////////////////////////////////////
    966966
    967967

  • Singular/LIB/algemodstd.lib

    r88615db r1d1f93  
    296296{
    297297    /*
    298      * compare the size of ideals in the list and 
     298     * compare the size of ideals in the list and
    299299     * check the corresponding leading monomials
    300300     * size(L)>=2

  • Singular/LIB/gradedModules.lib

    r88615db r1d1f93  
    44info="
    55LIBRARY: gradedModules.lib     Operations with graded modules/matrices/resolutions
    6 AUTHOR:  Oleksandr Motsak <U@D>, where U=motsak, D=mathematik.uni-kl.de
    7          Hanieh Keneshlou <hkeneshlou@yahoo.com>
     6AUTHORS:  Oleksandr Motsak <U@D>, where U=motsak, D=mathematik.uni-kl.de
     7@*         Hanieh Keneshlou <hkeneshlou@yahoo.com>
    88KEYWORDS: graded modules, graded homomorphisms, syzygies
    99OVERVIEW:

  • Singular/LIB/grobcov.lib

    r2f05b5 r1d1f93  
    30843084//    where the w_l=(n_l1,..,n_ls) are intvec of length size(L), where
    30853085//    n_lt fixes which element of (v_t1,..,v_tk_t) is to be
    3086 //    choosen to form the tth (Q,P) for the lth element of the sheaf
     3086//    chosen to form the tth (Q,P) for the lth element of the sheaf
    30873087//    representing the I-regular function.
    30883088// The selection is done to obtian the minimal number of elements

  • Singular/LIB/normal.lib

    r2f05b5 r1d1f93  
    186186    if ( typeof(#[i]) == "string" )
    187187    {
    188 //--------------------------- choosen methods -----------------------
     188//--------------------------- chosen methods -----------------------
    189189      if ( (#[i]=="isprim") or (#[i]=="isPrim") )
    190190      {decomp = 0;}
    … …  
    57255725   }
    57265726
    5727    //--------------------------- choosen methods -----------------------
     5727   //--------------------------- chosen methods -----------------------
    57285728   // "withGens": computes algebra generators for each irreducible component
    57295729   // ### the extra code for withGens should be incorporated in the general case

  • Singular/LIB/primdec.lib

    r88615db r1d1f93  
    665665          if(deg(act[1][1])>0)
    666666          {
     667            l[s+2]=ideal(0);
    667668            l[s+1]=std(l[2*i-1],act[2]);
    668669            if(homog(l[s+1])==1)
    … …  
    670671              l[s+2]=maxideal(1);
    671672            }
    672             else
    673             {
    674               l[s+2]=ideal(0);
    675             }
     673            //else { l[s+2]=ideal(0); }
    676674            keepprime[s div 2+1]=interred(keepprime[i]+ideal(@f));
    677675            if(homog(keepprime[s div 2+1])==1)
    … …  
    28112809   int n=nvars(R);
    28122810
    2813    def op = option(get);
     2811   intvec op = option(get);
    28142812
    28152813//---Anfang Provisorium

  • Singular/LIB/surf.lib

    r2f05b5 r1d1f93  
    177177    surf_call = "singularsurf ";
    178178    surf_call = surf_call + l + " >/dev/null 2>&1";
    179     "Close window to exit from `singularurf`.";
     179    "Close window to exit from `singularsurf`.";
    180180
    181181    i = system("sh", surf_call);

  • Singular/LIB/tst.lib

    r88615db r1d1f93  
    235235    if (!defined(prefix))
    236236    {
    237       def prefix = tst_status_counter;
     237      int prefix = tst_status_counter;
    238238    }
    239239    tst_status_out(prefix, "tst_memory_0", memory(0));

  • Singular/dyn_modules/gfanlib/Makefile.am

    r88615db r1d1f93  
    11ACLOCAL_AMFLAGS = -I ../../m4
    22
    3 SOURCES = bbcone.cc bbcone.h bbfan.cc bbfan.h bbpolytope.cc bbpolytope.h gfan.h gitfan.cc gitfan.h gfanlib.cc
     3SOURCES = singularWishlist.h gfanlib_exceptions.h callgfanlib_conversion.cc callgfanlib_conversion.h bbcone.cc bbcone.h bbfan.cc bbfan.h bbpolytope.cc bbpolytope.h gfan.h gitfan.cc gitfan.h std_wrapper.cc std_wrapper.h tropicalVarietyOfPolynomials.h tropicalVarietyOfPolynomials.cc ppinitialReduction.cc ppinitialReduction.h containsMonomial.cc containsMonomial.h adjustWeights.cc adjustWeights.h tropicalStrategy.cc tropicalStrategy.h initial.cc initial.h witness.cc witness.h lift.cc lift.h flip.cc flip.h tropicalCurves.cc tropicalCurves.h groebnerCone.cc groebnerCone.h startingCone.cc startingCone.h tropicalTraversal.cc tropicalTraversal.h tropicalVarietyOfIdeals.cc tropicalVarietyOfIdeals.h tropicalVariety.cc tropicalVariety.h tropical.cc tropical.h gfanlib.cc
    44
    5 MY_CPPFLAGS = -I${top_srcdir} -I${top_builddir} \
     5MY_CPPFLAGS = -I${srcdir} -I${top_srcdir} -I${top_builddir} \
    66-I${top_srcdir}/libpolys -I${top_builddir}/libpolys \
    77${FACTORY_INCLUDES} ${RESOURCES_INCLUDES} ${OMALLOC_INCLUDES} \
    … …  
    99
    1010if SI_BUILTIN_GFANLIB
     11if HAVE_GFANLIB
    1112  noinst_LTLIBRARIES=gfanlib.la
     13endif
    1214##  moduledir = $(libdir)/singular
    1315  P_PROCS_CPPFLAGS_COMMON = -DSTATIC_VERSION
    1416  P_PROCS_MODULE_LDFLAGS  = -module
    1517else
     18if HAVE_GFANLIB
    1619  module_LTLIBRARIES=gfanlib.la
     20endif
    1721  moduledir = $(libexecdir)/singular/MOD
    1822  P_PROCS_CPPFLAGS_COMMON = -DDYNAMIC_VERSION
    … …  
    2529gfanlib_la_CPPFLAGS = ${MY_CPPFLAGS} ${P_PROCS_CPPFLAGS_COMMON} ${CDDGMPCPPFLAGS}
    2630gfanlib_la_LDFLAGS  = ${P_PROCS_MODULE_LDFLAGS}
     31
     32# forcefully enable exceptions for polymake
     33CXXFLAGS+= $(FEXCEPTIONSFRTTI_CXXFLAGS)
    2734
    2835if HAVE_GFANLIB

  • Singular/dyn_modules/gfanlib/bbcone.cc

    r88615db r1d1f93  
    99#include <coeffs/longrat.h>
    1010
    11 #include <Singular/ipid.h>
    1211#include <Singular/ipid.h>
    1312#include <Singular/ipshell.h>
    1413#include <Singular/blackbox.h>
    1514
    16 // #include <omalloc/omalloc.h>
    17 // #include <kernel/intvec.h>
    18 // #include <kernel/longrat.h>
    19 // #include <Singular/lists.h>
    20 // #include <Singular/subexpr.h>
     15#include <callgfanlib_conversion.h>
     16#include <sstream>
    2117
    2218#include <gfanlib/gfanlib.h>
    2319#include <gfanlib/gfanlib_q.h>
    2420
    25 #include "bbfan.h"
    26 #include "bbpolytope.h"
    27 
    28 
    29 #include <sstream>
     21#include <bbfan.h>
     22#include <bbpolytope.h>
    3023
    3124int coneID;
    32 
    33 number integerToNumber(const gfan::Integer &I)
    34 {
    35   mpz_t i;
    36   mpz_init(i);
    37   I.setGmp(i);
    38   long m = 268435456;
    39   if(mpz_cmp_si(i,m))
    40   {
    41     int temp = (int) mpz_get_si(i);
    42     return n_Init(temp,coeffs_BIGINT);
    43   }
    44   else
    45     return n_InitMPZ(i,coeffs_BIGINT);
    46 }
    47 
    48 bigintmat* zVectorToBigintmat(const gfan::ZVector &zv)
    49 {
    50   int d=zv.size();
    51   bigintmat* bim = new bigintmat(1,d,coeffs_BIGINT);
    52   for(int i=1;i<=d;i++)
    53   {
    54     number temp = integerToNumber(zv[i-1]);
    55     bim->set(1,i,temp);
    56     n_Delete(&temp,coeffs_BIGINT);
    57   }
    58   return bim;
    59 }
    60 
    61 bigintmat* zMatrixToBigintmat(const gfan::ZMatrix &zm)
    62 {
    63   int d=zm.getHeight();
    64   int n=zm.getWidth();
    65   bigintmat* bim = new bigintmat(d,n,coeffs_BIGINT);
    66   for(int i=1;i<=d;i++)
    67     for(int j=1; j<=n; j++)
    68     {
    69       number temp = integerToNumber(zm[i-1][j-1]);
    70       bim->set(i,j,temp);
    71       n_Delete(&temp,coeffs_BIGINT);
    72     }
    73   return bim;
    74 }
    75 
    76 gfan::Integer* numberToInteger(const number &n)
    77 {
    78   if (SR_HDL(n) & SR_INT)
    79     return new gfan::Integer(SR_TO_INT(n));
    80   else
    81     return new gfan::Integer(n->z);
    82 }
    83 
    84 gfan::ZMatrix* bigintmatToZMatrix(const bigintmat &bim)
    85 {
    86   int d=bim.rows();
    87   int n=bim.cols();
    88   gfan::ZMatrix* zm = new gfan::ZMatrix(d,n);
    89   for(int i=0;i<d;i++)
    90     for(int j=0;j<n;j++)
    91     {
    92       number temp = BIMATELEM(bim, i+1, j+1);
    93       gfan::Integer* gi = numberToInteger(temp);
    94       (*zm)[i][j] = *gi;
    95       delete gi;
    96     }
    97   return zm;
    98 }
    99 
    100 gfan::ZVector* bigintmatToZVector(const bigintmat &bim)
    101 {
    102   gfan::ZVector* zv=new gfan::ZVector(bim.cols());
    103   for(int j=0; j<bim.cols(); j++)
    104   {
    105     number temp = BIMATELEM(bim, 1, j+1);
    106     gfan::Integer* gi = numberToInteger(temp);
    107     (*zv)[j] = *gi;
    108     n_Delete(&temp,coeffs_BIGINT);
    109     delete gi;
    110   }
    111   return zv;
    112 }
    113 
    114 char* toString(gfan::ZMatrix const &zm)
    115 {
    116   bigintmat* bim = zMatrixToBigintmat(zm);
    117   char* s = bim->StringAsPrinted();
    118   if (s==NULL)
    119     s = (char*) omAlloc0(sizeof(char));
    120   delete bim;
    121   return s;
    122 }
    12325
    12426std::string toString(const gfan::ZCone* const c)
    … …  
    199101      delete zd;
    200102    }
    201     gfan::ZCone* zc = (gfan::ZCone*)r->Data();
    202     newZc = new gfan::ZCone(*zc);
     103    newZc = (gfan::ZCone*)r->CopyD();
    203104  }
    204105  else if (r->Typ()==INT_CMD)
    … …  
    1055956gfan::ZVector randomPoint(const gfan::ZCone* zc)
    1056957{
     958  gfan::ZVector rp = gfan::ZVector(zc->ambientDimension());
     959
    1057960  gfan::ZMatrix rays = zc->extremeRays();
    1058   gfan::ZVector rp = gfan::ZVector(zc->ambientDimension());
    1059961  for (int i=0; i<rays.getHeight(); i++)
    1060962  {
    … …  
    1062964    rp = rp + n * rays[i];
    1063965  }
     966
     967  gfan::ZMatrix lins = zc->generatorsOfLinealitySpace();
     968  for (int i=0; i<lins.getHeight(); i++)
     969  {
     970    int n = siRand();
     971    rp = rp + n * lins[i];
     972  }
     973
    1064974  return rp;
    1065975}
    … …  
    15931503}
    15941504
    1595 gfan::ZVector intStar2ZVector(const int d, const int* i)
    1596 {
    1597   gfan::ZVector zv(d);
    1598   for(int j=0; j<d; j++)
    1599     zv[j]=i[j+1];
    1600   return zv;
    1601 }
    1602 
    1603 BOOLEAN maximalGroebnerCone(leftv res, leftv args)
    1604 {
    1605   leftv u = args;
    1606   if ((u != NULL) && (u->Typ() == IDEAL_CMD))
    1607   {
    1608     leftv v = u->next;
    1609     if (v == NULL)
    1610     {
    1611       int n = currRing->N;
    1612       ideal I = (ideal) u->Data();
    1613       poly g = NULL;
    1614       int* leadexpv = (int*) omAlloc((n+1)*sizeof(int));
    1615       int* tailexpv = (int*) omAlloc((n+1)*sizeof(int));
    1616       gfan::ZVector leadexpw = gfan::ZVector(n);
    1617       gfan::ZVector tailexpw = gfan::ZVector(n);
    1618       gfan::ZMatrix inequalities = gfan::ZMatrix(0,n);
    1619       for (int i=0; i<IDELEMS(I); i++)
    1620       {
    1621         g = (poly) I->m[i]; pGetExpV(g,leadexpv);
    1622         leadexpw = intStar2ZVector(n, leadexpv);
    1623         pIter(g);
    1624         while (g != NULL)
    1625         {
    1626           pGetExpV(g,tailexpv);
    1627           tailexpw = intStar2ZVector(n, tailexpv);
    1628           inequalities.appendRow(leadexpw-tailexpw);
    1629           pIter(g);
    1630         }
    1631       }
    1632       gfan::ZCone* gCone = new gfan::ZCone(inequalities,gfan::ZMatrix(0, inequalities.getWidth()));
    1633       omFreeSize(leadexpv,(n+1)*sizeof(int));
    1634       omFreeSize(tailexpv,(n+1)*sizeof(int));
    1635 
    1636       res->rtyp = coneID;
    1637       res->data = (void*) gCone;
    1638       return FALSE;
    1639     }
    1640   }
    1641   WerrorS("maximalGroebnerCone: unexpected parameters");
    1642   return TRUE;
    1643 }
    1644 
    16451505
    16461506lists listOfFacets(const gfan::ZCone &zc)
    … …  
    16961556
    16971557
    1698 poly initial(poly p)
    1699 {
    1700   poly g = p;
    1701   poly h = p_Head(g,currRing);
    1702   poly f = h;
    1703   long d = p_Deg(g,currRing);
    1704   pIter(g);
    1705   while ((g != NULL) && (p_Deg(g,currRing) == d))
    1706   {
    1707     pNext(h) = p_Head(g,currRing);
    1708     pIter(h);
    1709     pIter(g);
    1710   }
    1711   return(f);
    1712 }
    1713 
    1714 
    1715 BOOLEAN initial(leftv res, leftv args)
    1716 {
    1717   leftv u = args;
    1718   if ((u != NULL) && (u->Typ() == POLY_CMD))
    1719   {
    1720     leftv v = u->next;
    1721     if (v == NULL)
    1722     {
    1723       poly p = (poly) u->Data();
    1724       res->rtyp = POLY_CMD;
    1725       res->data = (void*) initial(p);
    1726       return FALSE;
    1727     }
    1728   }
    1729   if ((u != NULL) && (u->Typ() == IDEAL_CMD))
    1730   {
    1731     leftv v = u->next;
    1732     if (v == NULL)
    1733     {
    1734       ideal I = (ideal) u->Data();
    1735       ideal inI = idInit(IDELEMS(I));
    1736       poly g;
    1737       for (int i=0; i<IDELEMS(I); i++)
    1738       {
    1739         g = (poly) I->m[i];
    1740         inI->m[i]=initial(g);
    1741       }
    1742       res->rtyp = IDEAL_CMD;
    1743       res->data = (void*) inI;
    1744       return FALSE;
    1745     }
    1746   }
    1747   WerrorS("initial: unexpected parameters");
    1748   return TRUE;
    1749 }
    1750 
    1751 
    1752 BOOLEAN homogeneitySpace(leftv res, leftv args)
    1753 {
    1754   leftv u = args;
    1755   if ((u != NULL) && (u->Typ() == IDEAL_CMD))
    1756   {
    1757     leftv v = u->next;
    1758     if (v == NULL)
    1759     {
    1760       int n = currRing->N;
    1761       ideal I = (ideal) u->Data();
    1762       poly g;
    1763       int* leadexpv = (int*) omAlloc((n+1)*sizeof(int));
    1764       int* tailexpv = (int*) omAlloc((n+1)*sizeof(int));
    1765       gfan::ZVector leadexpw = gfan::ZVector(n);
    1766       gfan::ZVector tailexpw = gfan::ZVector(n);
    1767       gfan::ZMatrix equations = gfan::ZMatrix(0,n);
    1768       for (int i=0; i<IDELEMS(I); i++)
    1769       {
    1770         g = (poly) I->m[i]; pGetExpV(g,leadexpv);
    1771         leadexpw = intStar2ZVector(n, leadexpv);
    1772         pIter(g);
    1773         while (g != NULL)
    1774         {
    1775           pGetExpV(g,tailexpv);
    1776           tailexpw = intStar2ZVector(n, tailexpv);
    1777           equations.appendRow(leadexpw-tailexpw);
    1778           pIter(g);
    1779         }
    1780       }
    1781       gfan::ZCone* gCone = new gfan::ZCone(gfan::ZMatrix(0, equations.getWidth()),equations);
    1782       omFreeSize(leadexpv,(n+1)*sizeof(int));
    1783       omFreeSize(tailexpv,(n+1)*sizeof(int));
    1784 
    1785       res->rtyp = coneID;
    1786       res->data = (void*) gCone;
    1787       return FALSE;
    1788     }
    1789   }
    1790   WerrorS("homogeneitySpace: unexpected parameters");
    1791   return TRUE;
    1792 }
    1793 
    1794 
    1795 BOOLEAN groebnerCone(leftv res, leftv args)
    1796 {
    1797   leftv u = args;
    1798   if ((u != NULL) && (u->Typ() == IDEAL_CMD))
    1799   {
    1800     leftv v = u->next;
    1801     if (v == NULL)
    1802     {
    1803       int n = currRing->N;
    1804       ideal I = (ideal) u->Data();
    1805       poly g = NULL;
    1806       int* leadexpv = (int*) omAlloc((n+1)*sizeof(int));
    1807       int* tailexpv = (int*) omAlloc((n+1)*sizeof(int));
    1808       gfan::ZVector leadexpw = gfan::ZVector(n);
    1809       gfan::ZVector tailexpw = gfan::ZVector(n);
    1810       gfan::ZMatrix inequalities = gfan::ZMatrix(0,n);
    1811       gfan::ZMatrix equations = gfan::ZMatrix(0,n);
    1812       long d;
    1813       for (int i=0; i<IDELEMS(I); i++)
    1814       {
    1815         g = (poly) I->m[i]; pGetExpV(g,leadexpv);
    1816         leadexpw = intStar2ZVector(n, leadexpv);
    1817         pIter(g);
    1818         d = p_Deg(g,currRing);
    1819         while ((g != NULL) && (p_Deg(g,currRing) == d))
    1820         {
    1821           pGetExpV(g,tailexpv);
    1822           tailexpw = intStar2ZVector(n, tailexpv);
    1823           equations.appendRow(leadexpw-tailexpw);
    1824           pIter(g);
    1825         }
    1826 
    1827         if (g != NULL)
    1828         {
    1829           while (g != NULL)
    1830           {
    1831             pGetExpV(g,tailexpv);
    1832             tailexpw = intStar2ZVector(n, tailexpv);
    1833             inequalities.appendRow(leadexpw-tailexpw);
    1834             pIter(g);
    1835           }
    1836         }
    1837       }
    1838       gfan::ZCone* gCone = new gfan::ZCone(inequalities,equations);
    1839       omFreeSize(leadexpv,(n+1)*sizeof(int));
    1840       omFreeSize(tailexpv,(n+1)*sizeof(int));
    1841 
    1842       res->rtyp = coneID;
    1843       res->data = (void*) gCone;
    1844       return FALSE;
    1845     }
    1846   }
    1847   WerrorS("groebnerCone: unexpected parameters");
    1848   return TRUE;
    1849 }
    1850 
    18511558/***
    18521559 * Given a cone and a point in its boundary,
    18531560 * returns the inner normal vector of a facet
    18541561 * containing the point.
     1562 * Unless the point is in the relative interior of the facet
     1563 * the facet is not unique.
    18551564 * In case no facet contains the point,
    18561565 * then 0 is returned.
    … …  
    19031612  WerrorS("facetContaining: unexpected parameters");
    19041613  return TRUE;
     1614}
     1615
     1616
     1617/***
     1618 * Computes a relative interior point for each facet of zc
     1619 **/
     1620gfan::ZMatrix interiorPointsOfFacets(const gfan::ZCone &zc, const std::set<gfan::ZVector> &exceptThese)
     1621{
     1622  gfan::ZMatrix inequalities = zc.getFacets();
     1623  gfan::ZMatrix equations = zc.getImpliedEquations();
     1624  int r = inequalities.getHeight();
     1625  int c = inequalities.getWidth();
     1626
     1627  /* our cone has r facets, if r==0 return empty matrices */
     1628  gfan::ZMatrix relativeInteriorPoints = gfan::ZMatrix(0,c);
     1629  if (r==0) return relativeInteriorPoints;
     1630
     1631  /* next we iterate over each of the r facets,
     1632   * build the respective cone and add it to the list
     1633   * this is the i=0 case */
     1634  gfan::ZMatrix newInequalities = inequalities.submatrix(1,0,r,c);
     1635  gfan::ZMatrix newEquations = equations;
     1636  newEquations.appendRow(inequalities[0]);
     1637  gfan::ZCone facet = gfan::ZCone(newInequalities,newEquations);
     1638  facet.canonicalize();
     1639  gfan::ZVector interiorPoint = facet.getRelativeInteriorPoint();
     1640  if (exceptThese.count(interiorPoint)==0)
     1641    relativeInteriorPoints.appendRow(interiorPoint);
     1642
     1643  /* these are the cases i=1,...,r-2 */
     1644  for (int i=1; i<r-1; i++)
     1645  {
     1646    newInequalities = inequalities.submatrix(0,0,i,c);
     1647    newInequalities.append(inequalities.submatrix(i+1,0,r,c));
     1648    newEquations = equations;
     1649    newEquations.appendRow(inequalities[i]);
     1650    facet = gfan::ZCone(newInequalities,newEquations);
     1651    facet.canonicalize();
     1652    interiorPoint = facet.getRelativeInteriorPoint();
     1653    if (exceptThese.count(interiorPoint)==0)
     1654      relativeInteriorPoints.appendRow(interiorPoint);
     1655  }
     1656
     1657  /* this is the i=r-1 case */
     1658  newInequalities = inequalities.submatrix(0,0,r-1,c);
     1659  newEquations = equations;
     1660  newEquations.appendRow(inequalities[r-1]);
     1661  facet = gfan::ZCone(newInequalities,newEquations);
     1662  facet.canonicalize();
     1663  interiorPoint = facet.getRelativeInteriorPoint();
     1664  if (exceptThese.count(interiorPoint)==0)
     1665    relativeInteriorPoints.appendRow(interiorPoint);
     1666
     1667  return relativeInteriorPoints;
    19051668}
    19061669
    … …  
    19591722  p->iiAddCproc("","listContainsCone",FALSE,containsCone);
    19601723  p->iiAddCproc("","listOfFacets",FALSE,listOfFacets);
    1961   p->iiAddCproc("","maximalGroebnerCone",FALSE,maximalGroebnerCone);
    1962   p->iiAddCproc("","groebnerCone",FALSE,groebnerCone);
    1963   p->iiAddCproc("","initial",FALSE,initial);
    1964   p->iiAddCproc("","homogeneitySpace",FALSE,homogeneitySpace);
    19651724  p->iiAddCproc("","facetContaining",FALSE,facetContaining);
    19661725  coneID=setBlackboxStuff(b,"cone");

  • Singular/dyn_modules/gfanlib/bbcone.h

    r88615db r1d1f93  
    1616void bbcone_setup(SModulFunctions* p);
    1717
    18 /***
    19  * Conversion functions for data types
    20  **/
    21 gfan::Integer* numberToInteger(const number &n);
    22 number integerToNumber(const gfan::Integer &I);
    23 bigintmat* zVectorToBigintmat(const gfan::ZVector &zv);
    24 bigintmat* zMatrixToBigintmat(const gfan::ZMatrix &zm);
    25 gfan::ZMatrix* bigintmatToZMatrix(const bigintmat &bim);
    26 gfan::ZVector* bigintmatToZVector(const bigintmat &bim);
    27 
    28 gfan::ZVector intStar2ZVector(const int d, const int* i);
    29 char* toString(gfan::ZMatrix const &m);
    3018std::string toString(const gfan::ZCone* const c);
    3119
    32 /***
    33  * Other functions
    34  **/
    35 int getDimension(gfan::ZCone* zc);
    36 int getCodimension(gfan::ZCone* zc);
    37 int getLinealityDimension(gfan::ZCone* zc);
    3820gfan::ZVector randomPoint(const gfan::ZCone* zc);
    3921gfan::ZCone liftUp(const gfan::ZCone &zc);
     22gfan::ZMatrix interiorPointsOfFacets(const gfan::ZCone &zc, const std::set<gfan::ZVector> &exceptThese=std::set<gfan::ZVector>());
    4023
    4124#endif

  • Singular/dyn_modules/gfanlib/bbfan.cc

    r88615db r1d1f93  
    1111#include <Singular/blackbox.h>
    1212
    13 #include "bbfan.h"
    14 #include "bbcone.h"
    15 #include "gfan.h"
     13#include <callgfanlib_conversion.h>
     14#include <bbfan.h>
     15#include <gfan.h>
    1616#include <sstream>
    17 
    18 // #include <kernel/bigintmat.h>
    19 // #include <omalloc/omalloc.h>
    20 // #include <kernel/longrat.h>
    21 // #include <Singular/subexpr.h>
    22 // #include <Singular/lists.h>
    23 // #include <gfanlib/gfanlib.h>
    24 // #include <gfanlib/gfanlib_zfan.h>
    2517
    2618int fanID;
    … …  
    4638  {
    4739    gfan::ZFan* zf = (gfan::ZFan*)d;
    48     std::string s = zf->toStringJustRaysAndMaximalCones();
     40    std::string s = zf->toString(2+4+8+128);
    4941    return omStrDup(s.c_str());
     42// =======
     43//     std::stringstream s;
     44//     std::string raysAndCones = zf->toStringJustRaysAndMaximalCones();
     45//     s << raysAndCones;
     46//     if (zf->getDimension() >= 0) // <=> zf is not empty
     47//     {
     48//       assert(zf->numberOfConesOfDimension(zf->getDimension()-zf->getLinealityDimension(),0,0));
     49//       gfan::ZCone zc = zf->getCone(zf->getDimension()-zf->getLinealityDimension(),0,0,0);
     50//       gfan::ZMatrix genLinSpace = zc.generatorsOfLinealitySpace();
     51//       char* gens = toString(genLinSpace);
     52//       s << std::endl << "GENERATORS_LINEALITY_SPACE:" << std::endl;
     53//       s << gens;
     54//     }
     55//     std::string sstring = s.str();
     56//     return omStrDup(sstring.c_str());
     57// >>>>>>> status updated 11.03.
    5058  }
    5159}
    … …  
    7785      delete zd;
    7886    }
    79     gfan::ZFan* zf = (gfan::ZFan*) r->Data();
    80     newZf = new gfan::ZFan(*zf);
     87    newZf = (gfan::ZFan*) r->CopyD();
    8188  }
    8289  else if (r->Typ()==INT_CMD)
    … …  
    301308  leftv u=args;
    302309  if ((u != NULL) && (u->Typ() == fanID))
    303     {
    304       gfan::ZFan* zf = (gfan::ZFan*)u->Data();
    305       int d = zf->getAmbientDimension();
    306       int n = 0;
    307 
    308       for (int i=0; i<=d; i++)
    309         n = n + zf->numberOfConesOfDimension(i,0,0);
    310 
    311       res->rtyp = INT_CMD;
    312       res->data = (void*) (long) n;
    313       return FALSE;
    314     }
    315   else
    316     {
    317       WerrorS("check_compatibility: unexpected parameters");
    318       return TRUE;
    319     }
     310  {
     311    gfan::ZFan* zf = (gfan::ZFan*)u->Data();
     312    int d = zf->getAmbientDimension();
     313    int n = 0;
     314
     315    for (int i=0; i<=d; i++)
     316      n = n + zf->numberOfConesOfDimension(i,0,0);
     317
     318    res->rtyp = INT_CMD;
     319    res->data = (void*) (long) n;
     320    return FALSE;
     321  }
     322  WerrorS("ncones: unexpected parameters");
     323  return TRUE;
    320324}
    321325
    … …  
    324328  leftv u=args;
    325329  if ((u != NULL) && (u->Typ() == fanID))
    326     {
    327       gfan::ZFan* zf = (gfan::ZFan*)u->Data();
    328 
    329       int n = 0;
    330       for (int d=0; d<=zf->getAmbientDimension(); d++)
    331         { n = n + zf->numberOfConesOfDimension(d,0,1); }
    332 
    333       res->rtyp = INT_CMD;
    334       res->data = (void*) (long) n;
    335       return FALSE;
    336     }
    337   else
    338     {
    339       WerrorS("nmaxcones: unexpected parameters");
    340       return TRUE;
    341     }
    342 }
    343 
    344 bool isCompatible(gfan::ZFan* zf, gfan::ZCone* zc)
     330  {
     331    gfan::ZFan* zf = (gfan::ZFan*)u->Data();
     332
     333    int n = 0;
     334    for (int d=0; d<=zf->getAmbientDimension(); d++)
     335      n = n + zf->numberOfConesOfDimension(d,0,1);
     336
     337    res->rtyp = INT_CMD;
     338    res->data = (void*) (long) n;
     339    return FALSE;
     340  }
     341  WerrorS("nmaxcones: unexpected parameters");
     342  return TRUE;
     343}
     344
     345bool isCompatible(const gfan::ZFan* zf, const gfan::ZCone* zc)
    345346{
    346347  bool b = (zf->getAmbientDimension() == zc->ambientDimension());
    … …  
    458459    }
    459460  }
    460   // if ((u != NULL) && (u->Typ() == coneID))
    461   // {
    462   //   leftv v=u->next;
    463   //   if ((v != NULL) && (v->Typ() == coneID))
    464   //   {
    465   //     gfan::ZCone* zc = (gfan::ZCone*)u->Data();
    466   //     gfan::ZCone* zd = (gfan::ZCone*)v->Data();
    467   //     res->rtyp = INT_CMD;
    468   //     res->data = (void*) (int) hasFace(zc,zd);
    469   //     return FALSE;
    470   //   }
    471   // }
    472461  WerrorS("containsInCollection: unexpected parameters");
    473462  return TRUE;
    474463}
    475464
    476 // BOOLEAN coneContaining(leftv res, leftv args)
    477 // {
    478 //   leftv u=args;
    479 //   if ((u != NULL) && (u->Typ() == fanID))
    480 //   {
    481 //     if ((v != NULL) && (v->Typ() == BIGINTMAT_CMD))
    482 //     {
    483 //       gfan::ZFan* zf = (gfan::ZFan*)u->Data();
    484 //       bigintmat* vec = (bigintmat*)v->Data();
    485 //     }
    486 //   }
    487 //   WerrorS("coneContaining: unexpected parameters");
    488 //   return TRUE;
    489 // }
     465BOOLEAN coneContaining(leftv res, leftv args)
     466{
     467  leftv u=args;
     468  if ((u != NULL) && (u->Typ() == fanID))
     469  {
     470    leftv v=u->next;
     471    if ((v != NULL) && ((v->Typ() == BIGINTMAT_CMD) || (v->Typ() == INTVEC_CMD)))
     472    {
     473      gfan::ZFan* zf = (gfan::ZFan*)u->Data();
     474      gfan::ZVector* point;
     475      if (v->Typ() == INTVEC_CMD)
     476      {
     477        intvec* w0 = (intvec*) v->Data();
     478        bigintmat* w1 = iv2bim(w0,coeffs_BIGINT);
     479        w1->inpTranspose();
     480        point = bigintmatToZVector(*w1);
     481        delete w1;
     482      }
     483      else
     484      {
     485        bigintmat* w1 = (bigintmat*) v->Data();
     486        point = bigintmatToZVector(*w1);
     487      }
     488      lists L = (lists)omAllocBin(slists_bin);
     489      res->rtyp = LIST_CMD;
     490      res->data = (void*) L;
     491      delete point;
     492      return FALSE;
     493    }
     494  }
     495  WerrorS("coneContaining: unexpected parameters");
     496  return TRUE;
     497}
    490498
    491499BOOLEAN removeCone(leftv res, leftv args)
    … …  
    559567          if (0<=d && d<=zf->getAmbientDimension())
    560568          {
    561             if (0<i && i<=zf->numberOfConesOfDimension(d,oo,mm))
     569            int ld = zf->getLinealityDimension();
     570            if (0<i && i<=zf->numberOfConesOfDimension(d-ld,oo,mm))
    562571            {
    563572              i=i-1;
    564               int ld = zf->getLinealityDimension();
    565573              if (d-ld>=0)
    566574              {
    … …  
    689697}
    690698
    691 BOOLEAN isComplete(leftv res, leftv args)
    692 {
    693   leftv u=args;
    694   if ((u != NULL) && (u->Typ() == fanID))
    695   {
    696     gfan::ZFan* zf = (gfan::ZFan*) u->Data();
    697     int b = zf->isComplete();
    698     res->rtyp = INT_CMD;
    699     res->data = (void*) (long) b;
    700     return FALSE;
    701   }
    702   WerrorS("isComplete: unexpected parameters");
    703   return TRUE;
    704 }
     699// BOOLEAN isComplete(leftv res, leftv args)
     700// {
     701//   leftv u=args;
     702//   if ((u != NULL) && (u->Typ() == fanID))
     703//   {
     704//     gfan::ZFan* zf = (gfan::ZFan*) u->Data();
     705//     int b = zf->isComplete();
     706//     res->rtyp = INT_CMD;
     707//     res->data = (void*) (long) b;
     708//     return FALSE;
     709//   }
     710//   WerrorS("isComplete: unexpected parameters");
     711//   return TRUE;
     712// }
    705713
    706714BOOLEAN fVector(leftv res, leftv args)
    … …  
    866874
    867875
    868 BOOLEAN tropicalVariety(leftv res, leftv args)
    869 {
    870   leftv u=args;
    871   if ((u != NULL) && (u->Typ() == POLY_CMD))
    872   {
    873     int n = rVar(currRing);
    874     gfan::ZFan* zf = new gfan::ZFan(n);
    875     int* expv1 = (int*)omAlloc((n+1)*sizeof(int));
    876     int* expv2 = (int*)omAlloc((n+1)*sizeof(int));
    877     int* expvr = (int*)omAlloc((n+1)*sizeof(int));
    878     gfan::ZVector expw1 = gfan::ZVector(n);
    879     gfan::ZVector expw2 = gfan::ZVector(n);
    880     gfan::ZVector expwr = gfan::ZVector(n);
    881     gfan::ZMatrix eq, ineq;
    882     for (poly s1=(poly)u->Data(); s1!=NULL; pIter(s1))
    883     {
    884       pGetExpV(s1,expv1);
    885       expw1 = intStar2ZVector(n,expv1);
    886       for (poly s2=pNext(s1); s2!=NULL; pIter(s2))
    887       {
    888         pGetExpV(s2,expv2);
    889         expw2 = intStar2ZVector(n,expv2);
    890         eq = gfan::ZMatrix(0,n);
    891         eq.appendRow(expw1-expw2);
    892         ineq = gfan::ZMatrix(0,n);
    893         for (poly r=(poly)u->Data(); r!=NULL; pIter(r))
    894         {
    895           pGetExpV(r,expvr);
    896           expwr = intStar2ZVector(n,expvr);
    897           if ((r!=s1) && (r!=s2))
    898           {
    899             ineq.appendRow(expw1-expwr);
    900           }
    901         }
    902         gfan::ZCone zc = gfan::ZCone(ineq,eq);
    903         zf->insert(zc);
    904       }
    905     }
    906     omFreeSize(expv1,(n+1)*sizeof(int));
    907     omFreeSize(expv2,(n+1)*sizeof(int));
    908     omFreeSize(expvr,(n+1)*sizeof(int));
    909     res->rtyp = fanID;
    910     res->data = (void*) zf;
    911     return FALSE;
    912   }
    913   WerrorS("tropicalVariety: unexpected parameters");
    914   return TRUE;
    915 }
    916 
    917 gfan::ZFan* commonRefinement(gfan::ZFan* zf, gfan::ZFan* zg)
    918 {
    919   assume(zf->getAmbientDimension() == zg->getAmbientDimension());
     876// BOOLEAN tropicalVariety(leftv res, leftv args)
     877// {
     878//   leftv u=args;
     879//   if ((u != NULL) && (u->Typ() == POLY_CMD))
     880//   {
     881//     int n = rVar(currRing);
     882//     gfan::ZFan* zf = new gfan::ZFan(n);
     883//     int* expv1 = (int*)omAlloc((n+1)*sizeof(int));
     884//     int* expv2 = (int*)omAlloc((n+1)*sizeof(int));
     885//     int* expvr = (int*)omAlloc((n+1)*sizeof(int));
     886//     gfan::ZVector expw1 = gfan::ZVector(n);
     887//     gfan::ZVector expw2 = gfan::ZVector(n);
     888//     gfan::ZVector expwr = gfan::ZVector(n);
     889//     gfan::ZMatrix eq, ineq;
     890//     for (poly s1=(poly)u->Data(); s1!=NULL; pIter(s1))
     891//     {
     892//       pGetExpV(s1,expv1);
     893//       expw1 = intStar2ZVector(n,expv1);
     894//       for (poly s2=pNext(s1); s2!=NULL; pIter(s2))
     895//       {
     896//         pGetExpV(s2,expv2);
     897//         expw2 = intStar2ZVector(n,expv2);
     898//         eq = gfan::ZMatrix(0,n);
     899//         eq.appendRow(expw1-expw2);
     900//         ineq = gfan::ZMatrix(0,n);
     901//         for (poly r=(poly)u->Data(); r!=NULL; pIter(r))
     902//         {
     903//           pGetExpV(r,expvr);
     904//           expwr = intStar2ZVector(n,expvr);
     905//           if ((r!=s1) && (r!=s2))
     906//           {
     907//             ineq.appendRow(expw1-expwr);
     908//           }
     909//         }
     910//         gfan::ZCone zc = gfan::ZCone(ineq,eq);
     911//         zf->insert(zc);
     912//       }
     913//     }
     914//     omFreeSize(expv1,(n+1)*sizeof(int));
     915//     omFreeSize(expv2,(n+1)*sizeof(int));
     916//     omFreeSize(expvr,(n+1)*sizeof(int));
     917//     res->rtyp = fanID;
     918//     res->data = (void*) zf;
     919//     return FALSE;
     920//   }
     921//   WerrorS("tropicalVariety: unexpected parameters");
     922//   return TRUE;
     923// }
     924
     925gfan::ZFan commonRefinement(gfan::ZFan zf, gfan::ZFan zg)
     926{
     927  assume(zf.getAmbientDimension() == zg.getAmbientDimension());
    920928
    921929  // gather all maximal cones of f and g
    922930  std::list<gfan::ZCone> maximalConesOfF;
    923   for (int d=0; d<=zf->getAmbientDimension(); d++)
    924   {
    925     for (int i=0; i<zf->numberOfConesOfDimension(d,0,1); i++)
    926     {
    927       maximalConesOfF.push_back(zf->getCone(d,i,0,1));
    928     }
    929   }
     931  for (int d=0; d<=zf.getAmbientDimension(); d++)
     932    for (int i=0; i<zf.numberOfConesOfDimension(d,0,1); i++)
     933      maximalConesOfF.push_back(zf.getCone(d,i,0,1));
    930934
    931935  std::list<gfan::ZCone> maximalConesOfG;
    932   for (int d=0; d<=zg->getAmbientDimension(); d++)
    933   {
    934     for (int i=0; i<zg->numberOfConesOfDimension(d,0,1); i++)
    935     {
    936       maximalConesOfG.push_back(zg->getCone(d,i,0,1));
    937     }
    938   }
     936  for (int d=0; d<=zg.getAmbientDimension(); d++)
     937    for (int i=0; i<zg.numberOfConesOfDimension(d,0,1); i++)
     938      maximalConesOfG.push_back(zg.getCone(d,i,0,1));
    939939
    940940  // construct a new fan out of their intersections
    941   gfan::ZFan* zr = new gfan::ZFan(zf->getAmbientDimension());
     941  gfan::ZFan zr = gfan::ZFan(zf.getAmbientDimension());
    942942  for (std::list<gfan::ZCone>::iterator itf=maximalConesOfF.begin();
    943943       itf != maximalConesOfF.end(); itf++)
    944   {
    945944    for (std::list<gfan::ZCone>::iterator itg=maximalConesOfG.begin();
    946945         itg != maximalConesOfG.end(); itg++)
    947     {
    948       zr->insert(intersection(*itf,*itg));
    949     }
    950   }
     946      zr.insert(intersection(*itf,*itg));
    951947
    952948  return zr;
    … …  
    963959      gfan::ZFan* zf = (gfan::ZFan*) u->Data();
    964960      gfan::ZFan* zg = (gfan::ZFan*) v->Data();
    965       gfan::ZFan* zr = commonRefinement(zf,zg);
     961      gfan::ZFan* zr = new gfan::ZFan(commonRefinement(*zf,*zg));
    966962      res->rtyp = fanID;
    967963      res->data = (void*) zr;
    … …  
    10581054  p->iiAddCproc("","fVector",FALSE,fVector);
    10591055  p->iiAddCproc("","containsInCollection",FALSE,containsInCollection);
    1060   p->iiAddCproc("","tropicalVariety",FALSE,tropicalVariety);
     1056  // p->iiAddCproc("","tropicalVariety",FALSE,tropicalVariety);
    10611057  p->iiAddCproc("","commonRefinement",FALSE,commonRefinement);
    10621058  // iiAddCproc("","grFan",FALSE,grFan);
    … …  
    10661062
    10671063#endif
     1064// gfan::ZFan commonRefinementCompleteFans(const gfan::ZFan &zf, const gfan::ZFan &zg)
     1065// {
     1066//   assume(zf->getAmbientDimension() == zg->getAmbientDimension());
     1067
     1068//   gfan::ZFan zfg = gfan::ZFan(zf->getAmbientDimension());
     1069//   int d = zf->getAmbientDimension();
     1070//   for (int i=0; i<zf->numberOfConesOfDimension(d,0,1); i++)
     1071//     for (int j=0; j<zg->numberOfConesOfDimension(d,0,1); j++)
     1072//     {
     1073//       gfan::ZCone zc = intersection(zf->getCone(d,i,0,1),zg->getCone(d,j,0,1));
     1074//       if (zc.dimension()==d) zgf.insert(zc);
     1075//     }
     1076
     1077//   return zfg;
     1078// }

  • Singular/dyn_modules/gfanlib/bbfan.h

    r88615db r1d1f93  
    1414void bbfan_setup(SModulFunctions* p);
    1515
     16bool isCompatible(const gfan::ZFan* zf, const gfan::ZCone* zc);
     17
    1618int getAmbientDimension(gfan::ZFan* zf);
    1719int getCodimension(gfan::ZFan* zf);
    … …  
    2123gfan::Matrix<gfan::Integer> rays(const gfan::ZFan* const zf);
    2224
     25gfan::ZFan commonRefinement(gfan::ZFan zf, gfan::ZFan zg);
    2326#endif
    2427#endif

  • Singular/dyn_modules/gfanlib/bbpolytope.cc

    r88615db r1d1f93  
    99#include <coeffs/bigintmat.h>
    1010
    11 #include <bbcone.h>
     11#include <callgfanlib_conversion.h>
    1212#include <sstream>
    13 
    14 // #include <omalloc/omalloc.h>
    15 // #include <kernel/longrat.h>
    16 // #include <Singular/subexpr.h>
    17 // #include <gfanlib/gfanlib.h>
    18 // #include <kernel/ring.h>
    19 // #include <kernel/polys.h>
    2013
    2114#include <gfanlib/gfanlib.h>

  • Singular/dyn_modules/gfanlib/bbpolytope.h

    r88615db r1d1f93  
    1919int getDimension(gfan::ZCone* zc);
    2020
     21gfan::ZVector intStar2ZVectorWithLeadingOne(const int d, const int* i);
     22
    2123#endif
    2224#endif

  • Singular/dyn_modules/gfanlib/gfanlib.cc

    r88615db r1d1f93  
    77#include <bbpolytope.h>
    88#include <gitfan.h>
     9#include <tropical.h>
    910
    1011#include <Singular/ipid.h>
    … …  
    2324  bbpolytope_setup(p);
    2425  gitfan_setup(p);
     26  tropical_setup(p);
    2527  return MAX_TOK;
    2628}

  • Singular/dyn_modules/gfanlib/gitfan.cc

    r88615db r1d1f93  
    1414#if HAVE_GFANLIB
    1515
     16#include <callgfanlib_conversion.h>
    1617#include <bbcone.h>
    1718#include <bbfan.h>

  • Singular/dyn_modules/syzextra/syzextra.cc

    r88615db r1d1f93  
    17941794  {
    17951795    if( UNLIKELY(OPT__TAILREDSYZ && OPT__PROT) )
    1796     { 
     1796    {
    17971797      ++ m_stat[5]; // PrintS("%"); // check LCM !
    17981798#ifndef SING_NDEBUG
    1799       if( OPT__DEBUG ) 
    1800       { 
    1801         PrintS("\nTT,%:"); dPrint(multiplier, r, r, 0); 
    1802         PrintS(",  *  :"); dPrint(tail, r, r, 0); 
    1803         PrintLn(); 
     1799      if( OPT__DEBUG )
     1800      {
     1801        PrintS("\nTT,%:"); dPrint(multiplier, r, r, 0);
     1802        PrintS(",  *  :"); dPrint(tail, r, r, 0);
     1803        PrintLn();
    18041804      }
    18051805#endif
    … …  
    19661966  if( s == NULL ) // No Reducer?
    19671967  {
    1968     if( UNLIKELY( OPT__TAILREDSYZ && OPT__PROT) ) 
    1969     { 
     1968    if( UNLIKELY( OPT__TAILREDSYZ && OPT__PROT) )
     1969    {
    19701970      ++ m_stat[5]; // PrintS("%"); // check LCM !
    19711971#ifndef SING_NDEBUG
    1972       if( OPT__DEBUG ) 
    1973       { 
    1974         PrintS("\n%: RedTail("); dPrint(multiplier, r, r, 0); 
    1975         PrintS(" * : "); dPrint(term4reduction, r,r,0 ); 
     1972      if( OPT__DEBUG )
     1973      {
     1974        PrintS("\n%: RedTail("); dPrint(multiplier, r, r, 0);
     1975        PrintS(" * : "); dPrint(term4reduction, r,r,0 );
    19761976        PrintS(", {  "); dPrint(syztermCheck,r,r,0 );
    1977         PrintS("  }) ");  PrintLn(); 
     1977        PrintS("  }) ");  PrintLn();
    19781978      }
    19791979#endif

  • Singular/fevoices.cc

    r2f05b5 r1d1f93  
    8888
    8989/*2
    90 * init a new voice similiar to the current
     90* init a new voice similar to the current
    9191*/
    9292void Voice::Next()

  • Singular/fglm.cc

    r2f05b5 r1d1f93  
    172172        if ( pperm[k] >= 0 )
    173173        {
    174             WerrorS( "paramater names do not agree" );
     174            WerrorS( "parameter names do not agree" );
    175175            state= FglmIncompatibleRings;
    176176        }

  • Singular/ipassign.cc

    r2f05b5 r1d1f93  
    16991699      if(like_lists)
    17001700      {
    1701         if (traceit&TRACE_ASSIGN) PrintS("assign list[..]=...or similiar\n");
     1701        if (traceit&TRACE_ASSIGN) PrintS("assign list[..]=...or similar\n");
    17021702        if (like_lists==1)
    17031703        {
    … …  
    17351735      return (bb==NULL) || bb->blackbox_Assign(l,r);
    17361736    }
    1737     // end of handling elems of list and similiar
     1737    // end of handling elems of list and similar
    17381738    rl=r->listLength();
    17391739    if (rl==1)

  • Singular/ipshell.cc

    r88615db r1d1f93  
    11381138  else
    11391139  {
    1140     //if (name->rtyp!=0)
    1141     //{
    1142     //  Warn("`%s` is already in use",name->name);
    1143     //}
     1140    if (TEST_V_ALLWARN
     1141    && (name->rtyp!=0)
     1142    && (name->rtyp!=IDHDL)
     1143    && (currRingHdl!=NULL) && (IDLEV(currRingHdl)==myynest))
     1144    {
     1145      Warn("`%s` is %s in %s:%d:%s",name->name,Tok2Cmdname(name->rtyp),
     1146      currentVoice->filename,yylineno,my_yylinebuf);
     1147    }
    11441148    {
    11451149      sy->data = (char *)enterid(id,lev,t,root,init_b);

  • Singular/maps_ip.cc

    r88615db r1d1f93  
    2222#include <polys/ext_fields/transext.h>
    2323
    24 //#include <libpolys/polys/ext_fields/longtrans.h>
     24//#include <polys/ext_fields/longtrans.h>
    2525// #include <kernel/longalg.h>
    2626

  • Singular/number2.h

    r88615db r1d1f93  
    22#define NUMBER2_H
    33
    4 #include <libpolys/misc/auxiliary.h>
     4#include <misc/auxiliary.h>
    55
    66#ifdef SINGULAR_4_1

  • Singular/subexpr.cc

    r88615db r1d1f93  
    16511651          v->name = id;
    16521652        }
    1653         if (TEST_V_ALLWARN /*&& (myynest>0)*/
    1654         && ((r_IsRingVar(id, currRing->names,currRing->N)>=0)
    1655           || ((n_NumberOfParameters(currRing->cf)>0)
    1656              &&(r_IsRingVar(id, (char**)n_ParameterNames(currRing->cf),
    1657                                 n_NumberOfParameters(currRing->cf))>=0))))
    1658         {
    1659         // WARNING: do not use ring variable names in procedures
    1660           Warn("use of variable >>%s<< in a procedure in line %s",id,my_yylinebuf);
    1661         }
     1653        //if (TEST_V_ALLWARN /*&& (myynest>0)*/
     1654        //&& ((r_IsRingVar(id, currRing->names,currRing->N)>=0)
     1655        //  || ((n_NumberOfParameters(currRing->cf)>0)
     1656        //     &&(r_IsRingVar(id, (char**)n_ParameterNames(currRing->cf),
     1657        //                        n_NumberOfParameters(currRing->cf))>=0))))
     1658        //{
     1659        //// WARNING: do not use ring variable names in procedures
     1660        //  Warn("use of variable >>%s<< in a procedure in line %s",id,my_yylinebuf);
     1661        //}
    16621662        return;
    16631663      }

  • Tst/Manual/wurzel.res.gz.uu

    r88615db r1d1f93  
    1 begin 664 wurzel.res.gz
    2 M'XL("$3I)5$``W=U<GIE;"YR97,`79'-<H(P%(7W/L49IPMM*88?!>N81:<;
    3 M9ZP+Y`4B1,T0DDS`J>W3%ZB"TVW.^7+SW>S3C\T.@$>QW;QCS(J*%<R5XC!>
    4 MC?:WT*>P0IV08`WB7)W<#%E`D?,CTO77Q?YP.8D6_C+T_)@LO9AXA$R':D@Q
    5 MFR&%J*"5_`938,98?14EJX563G.3X2IO1VF%P)\MPH.H>W[NMCQ3.>HSARB-
    6 MY"57=<="'Z'D)S-;K4Y)CRPZ)#OSK.B@OWDN,FTMSVK%J^I^]M9#D7O33=:6
    7 M,]D(RP?AF$)=R@.WC7/S<#-)G/1!<DF1KD:3V(V".7\AT?2>>(3B_W)>T^>V
    8 53%Q"2%,F0[GYCZ?1+\>>?S.=`0``
     1begin 640 wurzel.res.gz
     2M'XL("//'U%0``W=U<GIE;"YR97,`75%!;L(P$+SG%:NJAZ1-C1T""8WPH>H%
     3MB?80<J],8L`B<2S;"-K7UPF02)QL[<[L[.QLBL_5-P`0"NO5!SQ98U$MMD^9
     4MM[EU(@JN^".DL'Z0>=T+E,+YI/]XC20_(V.9'>!3"L,_1M>A[&C8D3W,G5'0
     5M0NXAAR7@\!)6:NS-*51\!\7RJN(G\V@1DRC%"Y)B@G$P0A,*DPD4(`RTLOX%
     6M)H$II=N+:)@5K0S=),5EU4FU$J;19!YOQ;AOBCH^DQ78`P?1J)HW7-J>"^T.
     7M9/W%U+J5^WR@+'I*>>#EL2==]1"4K=:\M)(;<Z^]WTD$HYO=?*DYJYWA>C1,
     8MW/GEJ=ER[3R[Q96?A\5HDK@,BLSS4Y1,9_P5)\'0<>=^/,Y;\=*!,<(8.S`>
     99P?&8#9FA/M8NNY/Q29`]>_]D?(IS#`(`````
    910`
    1011end

  • Tst/Manual/wurzel.stat

    r88615db r1d1f93  
     11 >> tst_memory_0 :: 1423230963:4012, 64 bit:4.0.1:x86_64-Linux:nepomuck:279304
     21 >> tst_memory_1 :: 1423230963:4012, 64 bit:4.0.1:x86_64-Linux:nepomuck:2243968
     31 >> tst_memory_2 :: 1423230963:4012, 64 bit:4.0.1:x86_64-Linux:nepomuck:2313208
     41 >> tst_timer_1 :: 1423230963:4012, 64 bit:4.0.1:x86_64-Linux:nepomuck:10

  • Tst/Manual/wurzel.tst

    r88615db r1d1f93  
     1LIB "tst.lib";
     2tst_init();
     3
    14LIB "aksaka.lib";
    25ring R = 0,x,dp;
    … …  
    912T;
    10137629412809180100-T*T;
    11 $
     14
     15tst_status(1);$
     16

  • Tst/New/redTail.res.gz.uu

    r88615db r1d1f93  
    11begin 640 redTail.res.gz
    2 M'XL("/>N#%,``W)E9%1A:6PN<F5S`+U538^;,!"]\RM&JQ[,+A",R;?"H>H%
    3 MJ>JAR2W*$AK8!"E+(NQHV5;][QT#L=D-6Z7JMEPP;SPSS_-FS'SQ*?P"`#2`
    4 MS^%'N!%<./OLV\W4F#<6+P`$HRS/!#&GAGQ#$$"1)HLXVSMY^N1P$0NUGP6@
    5 MUKX#AZ/(#KGT[/7J-9](Y_0ARU,X\7B;PK$X/!YUA'XKPL"!(LNW\'7F6B5Q
    6 M'<<WK>2HV0T#R)(TWD,XLTO"S'OOKB2>>5L2W&@W2V8B2#5(%>@VH-QX[VF3
    7 MU:P\TVXVL<:S2N#6-DUC%$`X-<(E75W20-BKX`LN:&&5Y8(06OS5[#4K1/L2
    8 MO:"&AD$3J,U/T1L'T.LU4@`1:;S9:?+4=90)E1#F5)6?8EN<34]QD:,)XXB4
    9 M"R`>NV.M$E`OZ-9:ACQW2_7>%8?3=@=9+N:BB$6Z?>[N!Y`95?A66U%L*RX2
    10 M$F*BI>^.^Q.Z\DC?Y%@XSN6"DX')&1F:=OT8&#$Y;01LBDRD!1*;#&"SB[.\
    11 MA5`CDOK5\ME:ODC*I]2SM7J15$^)8VOQHA?B:?0-\2(I7JV=?:$=;4T#Q6G`
    12 MDVQ@0;1]Z,`/]3%RH*5"@WHH<#U%A<:\SIU864`I((195>+'N*S&"\FU=@V4
    13 M+[2=1RI-@>ZN14H+GBWX;EJ0<+6-N5V9F7=-9N9W9F:2D/I`&C_5QUA7SW??
    14 MN(W>IT-]G)7%^T:^(M)OO)?4]4?]H9P.B@W%.>\8`W8Q!BZFA=M;#)C"NI)@
    15 MC7PY7AH)'!Y@C?G6?\GLM?>5Y?B?!_I#[?_MY>>W+C\?1T#^C^4_]\1Q.J8O
    16 5CI>+CL.=7?$J^6#\`H:-ZC[R!P``
     2M'XL("'L>U50``W)E9%1A:6PN<F5S`+U5SV_:,!2^\U<\53LX;1+L.`0((H=I
     3METC3#H,;HI"1%"+1@&*CIIOVO_<YI'96:$6U;KG$^=ZOS_[><R;3+_$W`&`1
     4M?(T_PY44TMWF/ZY&G4EC\2)`<)$7N236J*/>$$509NDTR;=ND3VX0B92^_,(
     5M]-IW8;>7^:Y0D=WN<2U"%9S=Y44&!Y&L,]B7N_N]R=!K90A<*/-B#=_'U*X(
     6M=5W?LM.]8=>/($^S9`OQV*D(MVZ]FXIXUG5%T-%IEMQ"D!F0:9`VH'*\]8S)
     7M;E:>Y31.O(FL"]"CS=`81!"/.O&,S4]I(.S5\`D7M/#:<D((+?Y\_)(5HCV%
     8MGE!#0]`D:O/3](81=+N-%$!DEJPVACRCKC:A$K)EP:YXMCPD96&-5!J9"0G$
     9MXS>\=0+,B\Y+K3(^-TO]WI2[PWH#>2$GLDQDMGX\WPZ@*NKTK:YBV%5"IB3&
     10M0C.?#GLAFWND9PD\-R'40I#`$IST+>?X=#!C>EA)6)6YS$HD%@:PVB1YT4)8
     11M9Z'D.ZKG&/462CTMGF/$6RCQM#:.T6[QAW8&?46[A=+N*)US(AUK#0/#8<"=
     12MK&!*C+WOPB_],7"AI4*#>JCO<8A*@WEG/?%D`:6`&,;U$=\G53U=2*[E%>A8
     13M:`</=)D2PZE-*AL>;?AIV9`*[<;IN<K<NZ0R]\]6YDA(KY'%;_TQ-(?GTU?N
     14MHH]I4!]'9?JQF2_(]$;TC%%_T.NKX6#83T*(,U/`3Z:`8EFXOL:$&2QK!9;(
     15M5^"5D<+N#I983P$0AM,P"-^0[._8OXR^\,C^PZ89?<^NW]E$__82]5N7J(^C
     169I'[KZM=]$$A>3Y./-\ZGSA/6[0=+&`@`````
    1717`
    1818end

  • Tst/Short/bug_358.tst

    r88615db r1d1f93  
    3838// test lusolve() for the case that the first columns in U are zero.
    3939
    40 matrix B[1][2] = 0,1;   
     40matrix B[1][2] = 0,1;
    4141LD =  ludecomp(B);
    4242P,L,U = LD[1],LD[2],LD[3];

  • Tst/Short/bug_633.res.gz.uu

    r88615db r1d1f93  
    11begin 640 bug_633.res.gz
    2 M'XL("`R_1U0``V)U9U\V,S,N<F5S`$V106^"0!"%[_R*B>D![(BN5-N&N(>F
    3 M%Y*F%WMK&EEDI6L0R.X"ZJ_O8`FXEYW,^_)>]NWVZSWZ!`#&X2-Z@XDUUL]5
    4 M,@F=;:\L.=!RIPIE72]TNALXAZ3.=NL@\`O9^L8*._`!AV%^\J&LK"H+MQ6Z
    5 M\$;3U1VT]KMH=R+R3"9:W.+OT&<.JK!0P08J35,N&YF/\@L'VF:@25^@*S#!
    6 MO8>I&8G7GC#_Q!DO>,4:&VR)JP:.+2@HE2*'B,#SK,5ZV3XRO%QGS0A13R=1
    7 M0?6K"-(8C0KUI`S5=)1[JQKI$H*:WC&?PW1*3]AK*8SL(QC,.`2TA>X<OT\_
    8 MFT7HL,'LKD1&)0[SRK]]1E=X;5SFA?#0!]3D'5,],9D:*T4*Y0'B5!YBYP]/
    9 '2HW)Y`$`````
     2M'XL("`D?U50``V)U9U\V,S,N<F5S`$V106^#,`R%[_P*"^T`G:&DK-TFU!RF
     3M79"F7;K;-%6!1BP5I2@)T/;7SW0(R"66WR<_^7GW]9Y^`@#C\)&^@6N-#4N5
     4MN8FS&Y05!VKN5:6LYR=._P/GD#7%?A/'826[T%AA1S[F,-9/(9QKJ\Z5UPE=
     5M^=/0]0S:A+VUYXJRD)D6=_L9^LQ!519JV$*MJ2IE*\M)?N%`W0(TZ1%Z`C/,
     6M?3R8B7@="/-/7/"*-VRPQ8ZX>N181$8'*4I(";P$'3:K[I'A]1:T$T0YG40-
     7M]:\B2&,Z*923,A334>96M=(C!#7ML5S"8D$KY%H*(P<+!@&'F+K0O^/WZ6<;
     8@)0X;A\U"9!3B6*_#^S'ZP!OC,3^!!^</SC8.9<,!````
    109`
    1110end

  • Tst/Short/bug_tr679.tst

    r88615db r1d1f93  
    6060    L1 = primdecGTZ (I);
    6161    L2 = primdecSY (I);
    62     "equivalent?",primDecsAreEquivalent (L1,L2) ; 
     62    "equivalent?",primDecsAreEquivalent (L1,L2) ;
    6363}
    6464

  • Tst/Short/test_unit_ideal_decomposition.tst

    r88615db r1d1f93  
    9797/////////////////////////////////////////////////////////////////////////////////////////
    9898ring rng1 = 0,(x,y),dp;
    99 ideal I = x+y,x+1,y; 
     99ideal I = x+y,x+1,y;
    100100
    101101list pr = primdecGTZE(I);
    … …  
    159159/////////////////////////////////////////////////////////////////////////////////////////
    160160ring rng2 = 0,(x,y),dp;
    161 ideal I = x+y,x+1,y; 
     161ideal I = x+y,x+1,y;
    162162
    163163if (defined(pr)) {kill pr;}
    164164list pr = primdecGTZE(I);
    165  
     165
    166166testPrimdecUnitOrigBehaviour( primdecGTZ,I );
    167167testPrimdecUnitOrigBehaviour( primdecGTZkeepKomp,I );
    … …  
    181181/////////////////////////////////////////////////////////////////////////////////////////
    182182
    183  
     183
    184184ring rng3 = 0,(x,y),ds;
    185 ideal I = x+y,x+1,y; 
     185ideal I = x+y,x+1,y;
    186186
    187187// illegal ASSUME(0, testPrimaryE(pr,I) );
    … …  
    205205
    206206testPrimdecUnit( primdecGTZ,I ,0);
    207 //testPrimdecUnit( primdecGTZkeepKomp,I ,0);     
     207//testPrimdecUnit( primdecGTZkeepKomp,I ,0);
    208208testPrimdecUnit( minAssGTZ, I ,0);
    209 // testPrimdecUnit( minAssGTZFacSTD, I ,0);       
    210 // testPrimdecUnit( minAssGTZnoFacSTD, I ,0);     
    211 // testPrimdecUnit( minAssGTZGTZ, I ,0);         
    212 // testPrimdecUnit( minAssGTZorigNoFacSTD, I ,0); 
     209// testPrimdecUnit( minAssGTZFacSTD, I ,0);
     210// testPrimdecUnit( minAssGTZnoFacSTD, I ,0);
     211// testPrimdecUnit( minAssGTZGTZ, I ,0);
     212// testPrimdecUnit( minAssGTZorigNoFacSTD, I ,0);
    213213testPrimdecUnit( primdecSY, I ,0);
    214214testPrimdecUnit( primdecSYNoOptimalOrdering, I ,0);
    215215testPrimdecUnit( minAssChar,I ,0);
    216216testPrimdecUnit( minAssCharNoOptimalOrdering,I ,0);
    217 // invalid: testPrimdecUnit( minAssPrimesOrig,I ,0); 
    218 /////////////////////////////////////////////////////////////////////////////////////////
    219 /////////////////////////////////////////////////////////////////////////////////////////
    220  
    221 ring rng4 = (7,a),(x,y,z),dp; 
     217// invalid: testPrimdecUnit( minAssPrimesOrig,I ,0);
     218/////////////////////////////////////////////////////////////////////////////////////////
     219/////////////////////////////////////////////////////////////////////////////////////////
     220
     221ring rng4 = (7,a),(x,y,z),dp;
    222222minpoly = 1*a^2+6*a^1+3*a^0;
    223 ideal I = x+y,x+1,y; 
     223ideal I = x+y,x+1,y;
    224224
    225225testPrimdecUnitNewBehaviour( wDecompE,        I );
    … …  
    250250testPrimdecUnitOrigBehaviour( wDecomp,        I );
    251251testPrimdecUnitOrigBehaviour( primdecGTZ,I );
    252 testPrimdecUnitOrigBehaviour( primdecGTZkeepKomp,I ); 
     252testPrimdecUnitOrigBehaviour( primdecGTZkeepKomp,I );
    253253testMinAssUnitOrigBehaviour ( minAssGTZ, I );
    254 testMinAssUnitOrigBehaviour ( minAssGTZFacSTD, I ); 
    255 testMinAssUnitOrigBehaviour ( minAssGTZnoFacSTD, I ); 
    256 testMinAssUnitOrigBehaviour ( minAssGTZGTZ, I ); 
    257 testMinAssUnitOrigBehaviour ( minAssGTZorigNoFacSTD, I ); 
     254testMinAssUnitOrigBehaviour ( minAssGTZFacSTD, I );
     255testMinAssUnitOrigBehaviour ( minAssGTZnoFacSTD, I );
     256testMinAssUnitOrigBehaviour ( minAssGTZGTZ, I );
     257testMinAssUnitOrigBehaviour ( minAssGTZorigNoFacSTD, I );
    258258testPrimdecUnitOrigBehaviour( primdecSY, I );
    259259testPrimdecUnitOrigBehaviour( primdecSYNoOptimalOrdering, I );
    … …  
    276276/////////////////////////////////////////////////////////////////////////////////////////
    277277/////////////////////////////////////////////////////////////////////////////////////////
    278  
     278
    279279ring rng5 = (7,a),(x,y,z),ds; minpoly = a^2 + a+3;
    280 ideal I = x+y,x+1,y; 
     280ideal I = x+y,x+1,y;
    281281
    282282testPrimdecUnitNewBehaviour( primdecGTZE,I );

  • Tst/Short/zerored.res.gz.uu

    r88615db r1d1f93  
    1 begin 644 zerored.res.gz
    2 M'XL("#^ORU```WIE<F]R960N<F5S`.U7WVL;1Q!^]U]QA#XX.E79^;&SNPWU
    3 M0RF40"DE3E_Z(&@<Q1A<6SB.;>FO[\S>Z?9.TEU-FCX4:C":U?Z:;^?[9D;G
    4 M[WY\\TM557!6_?SFA^K%W=7-Y>7[Q?75^Q>O3\[;23RK[/OJ[4_5]]7IU<W]
    5 MZG)U-Z_$>Y)Y!:WU<EZ=/LTW\ZT:']9E-YU5KUY5O]Y>;VYN_[SZX[J"[[HY
    6 M7E1KG:C6H"=32!X$`7#VM*3:QX`.O8B.<+:I,9$XP.AI]C3;S+8U8H3@@(*N
    7 MJ#W'(`$@S3:Z%R2$@"`ZP!HE,GGV8KNJ[J\&<`&3H$W4C,Q"7CC.MGK`8(CE
    8 MO&W!Y?=Q8<$E.URHN$!878LL_#Q<0(R@U\6O``M="N#1.9=A#8;'884]6%10
    9 MQ1TJ^L^A2F?5=G5W^W;UX?/%ZG0-WZ[QY>L3MYL'=S!/@WD8SN/^O$JDLVFA
    10 M+Y@%<W>HEQ&5@"JAT=A@"ZJ\1K<<$+`("Z0O+!"*%B6N-_KO`S'K0W&=(VCA
    11 MR4$`#!:!_(0QB;>P6MP2!M\$54<>DMM%E#!(;&:JFEV2YOG;KW,T.6E<;$G-
    12 M433:Q?E]FO74`[&OGE%7"%)*K?='W%*:&-IF=(AP]SUF=C7>]9ZF@U,\3OL>
    13 M%V6@ZROC'WH\]+/UK`GA-L/(5N<7PC2U$:>IC31-;>1";?2+8DO+V$_'2?XP
    14 M?YP?82WFP.>-Y\>I/K8Q+D;ICJE/=_26"1YR&J)`B&9KM0!6:_9H+'::VF>/
    15 M.6V)/O:C98T0DEKMIZ4TL8-R\+8U@YA42CYJCK-((L7@,MM]LFRX:1=OF\,[
    16 M`.3&*4_0IWP?`'O/!_XWA'E07WV,&0?ZZ-,(#DSZ""V.3K,%R8Y]VSI&H^>7
    17 M0,-Q;1#UM?'O0^M5C5W4O@013ZN*_+2J2*951:&HBF)7,.Z/:NEB(`1*K?#>
    18 M'=7/<#$?D*ZHAF%0)%01%TM1U@=DM;P^<]('O;"4%$5`+>V+R"=22Q.30UNG
    19 M=5W;L'+?`1,*R9D&75%[GZ?HFNM\Y'P;$U+(MZDK+DW=QN.\8S_H5D9O`\>2
    20 M]FX+UG\<7";3E.`P30F.TY3@5"CA71OCSZ,=Q#`[>NC2ZF^C'<3>%AQ/J)[Z
    21 MU#")Y/9!/[-%UH-E)>?29M(TSW*A;]?,<O&UIBT7MGQ$KFYYH6W14BM<O#D(
    22 M92&.]WWB'/4F"DAQINUW+,D4QS!BZQ;G^)I;G@ABZVI"=\PO&:>8#WV*?4V_
    23 M_OZYXC09_6'#.R";N&DR"A0RR@119$>4CR8RAP8O-F`!I1TI1#$>+*/F?&<0
    24 MEZ'!)#&O"5V'HW;;>STM&]Q-3Y9'7?62FI18ML8W=^G%[:B.&D@S:U*%VY?<
    25 M+6D&^G.!8Y[H3J'!*51.H>Q,%\"=][EZE=:V\;?O;?&UBY@,*\K'P6O[WFM+
    26 MZ;$DV,N/_C"74CB>FR<DV9;_(_:<B`5G;W6_^G3_N\8M1VPWHY7SFY._`/08
    27 &VPX\$0``
     1begin 640 zerored.res.gz
     2M'XL("%#(U%0``WIE<F]R960N<F5S`.U:6VOK1A!^SZ]80A\<RW5V9^\)3:$4
     3MRH%2RLGI2TO3^"(;<1+)M14G]J_O[$K62K:5VSFE%!0(WO7>OAGO]\UH[.M/
     4M/W[XA1#"KLC/'WXXS5?Y\"X9GUZ>7)<#X`?(Z3))Y_/QWB"_(E5;#`FN_BM)
     5MD[QW=GGB7LG5%=G&RVP93X=I_#A<Y:.\FB]K:]60N/W)QY_(=Z27I'D\CY<#
     6MHJ3D:D!8V3H;D-[38#/88F.Z""CT%3D_)[]F=YLTNT]&=X1=5&-F2!8X0!8,
     7M=^;:2J:`,>@_W?!(&@T4I%+8@_XF`LL596`D[S_U-_UM!&"8IHQKG!%)8;32
     8MC-G^!M<RI;4&IK`#$2@CN!12N56D^HL8HQJL`C<0"1!"<:F$Z6]Q@T87PG[;
     9M8)?=MPLJNQC=V05H%U,"H1FAQ.OL8EP`P^/,5S`+J-5,`J74F]7H'C6+L3VS
     10M>+`*=E;Q_YU5O+CJ'^/IPR3N+=BW"T`6X,;?DVFR3E9)EI(L1=NF\2Q)XRG)
     11MUO&23+)X-DLF29SF9)K=CY)T5:R)ET@;DDTF#TMD#TEP\9*,XQERB00J7ES@
     12M7M/?\5SG3G*'&^,EOR"WA,S1@W?Q:'J?H9=[LS-R7NO.STB?S"]OB[/P_;5C
     13M7]N^;M;J<[)8N$EY_)23V3*[)[>7MR7,44[R['.<DMNS9[8,[JF<)@Z<QCNG
     14MO>0TV70:%$ZCU;@*PLKT$+GFI75YJ*PM>LK,3HT;2P"%N'7)@50%"09:EV"F
     15MN'%\%M$&_Z7F0B"E1.2Y[HCLZ<I`.ZYZLAFKI!,`QW`+6A;TQYYDENZXST$K
     16M4XR02%"K"J*6;WO>"XL,=E,B813J0@4>]@6IIK,`=9UMA<*9M;9$?P06"HJS
     17MMN@=6KA['[P.%>AJKJG,"8CY/N*@H2#J&OJ%B)LX2V3%1[CU9OA6P"7;13#-
     18MD+<ITM>3VG-AG,SQ=B$+R.Z2P8"IBOY#,MX0^L7,9I[9Z</]&*7C[Y+@3D(*
     19M?D]'^>@/]N=_3FM0[5K8^>X%W^FCDMCY[C6^,R%<@!U6;4[+*+`Z'CC6@\?!
     20MD4C`O9CZA=?'PT?;0ABVAA#.ZR$$I,O#UCX)Y)H#N#;FZDQ@J__H(@/%Q+K_
     21MZ)-&A0+VZ'(VK2VVRE>74"JWD1?$;228<N$G9(/%=DX=@1M-?021UN6BFW+R
     22MMM@\&"#:PPB7]3!2-T!(*0[P%R*\1JS2&&\'2"-MBQU@T0FE'54<#);L%'T;
     23M&>,D_SVFJ?9XPW4]WOS[IM5R]MVG]AZ+3)>NOUDJN.W2]3<[3=#VV-0YK<UI
     24M+`0E`=4S3'XT%$T:<43P,FY].AI^]B8?:'8(.D(VGELPH$QN%`8-#0);$E7*
     25MHAY-7)9LE&+8XI'@TG)L8:Y,P<V+&`?#PGD'0AIBA-"-DDYYGN2&%L=)(_QI
     26M@@/7_C2$0NUSIYEVV1:V46II/8U1H>S>:=H53_8/D[3+_=][W27K<O]W^PZZ
     27MW/_=OJO5[Z4H=?.AM5#43-BEK#+]WUH+17M+5'N.+W5=;EW6YJM$^.I;W!5E
     28M?7+I*Q@N6W3(?#VGG-/W-197Q?7U"[^%+V+XB6X)%Y@3!C0'\AC$6-JZ&!]%
     29M8Q13`4Q9UG)Y;P`&!DI8PFNF@R4Y9Z:$:H$>P:5HNVPK5I?MKXGK17<IZ%+F
     30M-S-,'7XMT&5_+SI-="GSVYU6^SY5/:.S:J>S,Y?W47#J8`JM8*#*'BJ$<C)Z
     31M8_`IGCJ%N-&%)"CCY^BJ#HSMLD+]=%/(1E&Y]KVJ'J$BCKKLYLCB+#RX[$4&
     32M==`U(XY)IWM35%.*3@14&#]0[<(;N_"P"_=@*OW;H??UB/`%0(&WCC9@#8+7
     33MK!',NBOXTA6TX0IJ&DJ)FKGKV/HK`AT>\%Z;>VCNEG37^#776`OGJSQ>Y>X"
     34@^&N\&Y&UST@5/]]P/]%X6/78V>4W)_\`:`[>OQPB````
    2835`
    2936end

  • Tst/Short/zerored.stat

    r88615db r1d1f93  
     11 >> tst_memory_0 :: 1423231056:4012, 64 bit:4.0.1:x86_64-Linux:nepomuck:278832
     21 >> tst_memory_1 :: 1423231056:4012, 64 bit:4.0.1:x86_64-Linux:nepomuck:2242304
     31 >> tst_memory_2 :: 1423231056:4012, 64 bit:4.0.1:x86_64-Linux:nepomuck:2293480
     41 >> tst_timer_1 :: 1423231056:4012, 64 bit:4.0.1:x86_64-Linux:nepomuck:3

  • Tst/Short/zerored.tst

    r88615db r1d1f93  
     1LIB"tst.lib";
    12LIB "ringgb.lib";
     3
     4tst_init();
     5
    26ring RG = (integer, 65536, 1, 65536), (x,y,z), dp;
    37// Polynomial 1:
    … …  
    6973//poly f = 1024*x^8*y^2+11264*x^8*y+28672*x^8+45056*x^7*y^2+36864*x^7*y+16384*x^7+40960*x^6*y^2+57344*x^6*y+32768*x^6+30720*x^5*y^2+10240*x^5*y+8192*x^5+35840*x^4*y^2+1024*x^4*y+20480*x^4+30720*x^3*y^2+10240*x^3*y+8192*x^3+4096*x^2*y^2+45056*x^2*y+49152*x^2+40960*x*y^2+57344*x*y+32768*x;
    7074//testZero(f);
    71 $
     75
     76tst_status(1);$

  • gfanlib/gfanlib_matrix.h

    r88615db r1d1f93  
    99#define LIB_ZMATRIX_H_
    1010
     11#include <sstream>
    1112#include <vector>
    1213#include <algorithm>
    … …  
    1920  std::vector<Vector<typ> > rows;
    2021public:
     22  // rowIterator;
     23 // std::vector<Vector<typ> >::iterator rowsBegin(){return rows.begin();}
     24//  std::vector<Vector<typ> >::iterator rowsEnd(){return rows.end();}
    2125  inline int getHeight()const{return height;};
    2226  inline int getWidth()const{return width;};
    … …  
    3236  Matrix():width(0),height(0){
    3337  };
    34   static Matrix rowVectorMatrix(Vector<typ> const &v)
     38  Matrix rowVectorMatrix(Vector<typ> const &v)
    3539  {
    3640    Matrix ret(1,v.size());
    37     for(int i=0;i<v.size();i++)ret[0][i]=v[i];
     41    for(unsigned i=0;i<v.size();i++)ret[0][i]=v[i];
    3842    return ret;
    3943  }
    … …  
    6872    }
    6973  void appendRow(Vector<typ> const &v)
    70     {
    71       assert((int)v.size()==width);
    72       rows.push_back(v);
    73       height++;
    74     }
     74  {
     75    assert((int)v.size()==width);
     76    rows.push_back(v);
     77    height++;
     78  }
     79  void prependRow(Vector<typ> const &v)
     80  {
     81    assert((int)v.size()==width);
     82    rows.insert(rows.begin(),v);
     83    height++;
     84  }
    7585  void eraseLastRow()
    7686  {
    7787    assert(rows.size()>0);
    78     rows.resize(rows.size()-1);
     88    rows.pop_back();
    7989    height--;
    8090  }
    … …  
    184194    return f;
    185195  }
     196
     197  std::string toString()const
     198  {
     199          std::stringstream f;
     200          f<<*this;
     201          return f.str();
     202  }
     203
    186204  /**
    187205     Swaps the i th and the j th row.
    … …  
    296314  }
    297315  /**
    298      Performs a Gauss reduction and returns the number of row swaps
    299      done.  The result is a matrix in row echelon form. The pivots may
     316     Performs a Gauss reduction and returns the number of row swaps (and negative scalings)
     317     done. The result is a matrix in row echelon form. The pivots may
    300318     not be all 1.  In terms of Groebner bases, what is computed is a
    301319     minimal (not necessarily reduced) Groebner basis of the linear
    … …  
    309327  {
    310328    assert(integral || typ::isField());
     329    assert(!makePivotsOne || !integral);
     330
    311331    int retSwaps=0;
    312332    int currentRow=0;
    … …  
    325345            if(makePivotsOne)
    326346              {//THE PIVOT SHOULD BE SET TO ONE IF INTEGRAL IS FALSE
    327                 if(rows[currentRow][i].sign()>=0)
    328                   retSwaps++;
     347                if(rows[currentRow][i].sign()>=0)retSwaps++;
    329348                typ inverse=typ(1)/rows[currentRow][i];
    330349                //                if(!rows[currentRow][i].isOne())
    … …  
    517536  int reduceAndComputeRank()
    518537  {
    519     if (typ::isField())
    520       reduce();
    521     else
    522       reduce(false,true,false);
     538    reduce(false,!typ::isField(),false);
    523539    int ret=0;
    524540    int pivotI=-1;

  • gfanlib/gfanlib_polyhedralfan.cpp

    r88615db r1d1f93  
    398398  std::set<int> indices;
    399399
    400 // for(int j=0;j<rays.getHeight();j++)if(cone.contains(rays[j]))indices.insert(j);
     400  // for(int j=0;j<rays.getHeight();j++)if(cone.contains(rays[j]))indices.insert(j);
    401401
    402402  ZMatrix l=cone.extremeRays(&generatorsOfLinealitySpace);
    … …  
    502502}
    503503
    504 std::string PolyhedralFan::toString(int /*flags*/)const
     504std::string PolyhedralFan::toString(int flags)const
    505505//void PolyhedralFan::printWithIndices(class Printer *p, bool printMultiplicities, SymmetryGroup *sym, bool group, bool ignoreCones, bool xml, bool tPlaneSort, vector<string> const *comments)const
    506506{
    … …  
    862862int PolyhedralFan::dimensionOfLinealitySpace()const
    863863{
    864   if(cones.size()) //slow!
    865     return 0;
    866   else
    867     return cones.begin()->dimensionOfLinealitySpace();
     864  assert(cones.size());//slow!
     865  return cones.begin()->dimensionOfLinealitySpace();
    868866}
    869867

  • gfanlib/gfanlib_polyhedralfan.h

    r88615db r1d1f93  
    2424typedef std::map<int,IntVectorList> IncidenceList;
    2525
    26 class PolyhedralFan ;
    27 
     26class PolyhedralFan;
    2827PolyhedralFan refinement(const PolyhedralFan &a, const PolyhedralFan &b, int cutOffDimension=-1, bool allowASingleConeOfCutOffDimension=false);
    2928
    … …  
    5554  int getMaxDimension()const;
    5655  int getMinDimension()const;
    57 
    58 //   friend PolyhedralFan refinement(const PolyhedralFan &a, const PolyhedralFan &b, int cutOffDimension=-1, bool allowASingleConeOfCutOffDimension=false);
    59 
     56  // friend PolyhedralFan refinement(const PolyhedralFan &a, const PolyhedralFan &b, int cutOffDimension=-1, bool allowASingleConeOfCutOffDimension=false);
    6057  ZMatrix getRays(int dim=1);//This can be called for other dimensions than 1. The term "Rays" still makes sense modulo the common linearity space
    6158  ZMatrix getRelativeInteriorPoints();

  • gfanlib/gfanlib_polymakefile.cpp

    r88615db r1d1f93  
    99
    1010#include <assert.h>
     11#include <stdio.h>
    1112#include <sstream>
    1213#include <istream>
    13 #include <stdio.h>
    1414
    1515using namespace std;
    … …  
    5353  list<int> ret;
    5454  int c=s.peek();
    55   while(((c>='0') && (c<='9')) || (c==' '))
     55  while(((c>='0') && (c<='9'))|| (c==' '))
    5656    {
    5757      //      fprintf(Stderr,"?\n");
    … …  
    171171  else
    172172    {
    173       // fprintf(f,"_application %s\n",application.c_str());
    174       // fprintf(f,"_version 2.2\n");
    175       // fprintf(f,"_type %s\n",type.c_str());
     173      fprintf(f,"_application %s\n",application.c_str());
     174      fprintf(f,"_version 2.2\n");
     175      fprintf(f,"_type %s\n",type.c_str());
    176176
    177177      for(list<PolymakeProperty>::const_iterator i=properties.begin();i!=properties.end();i++)
    … …  
    201201  else
    202202    {
    203       // file << "_application " << application << endl;
    204       // file << "_version 2.2\n";
    205       // file << "_type " << type << endl;
     203      file << "_application " << application << endl;
     204      file << "_version 2.2\n";
     205      file << "_type " << type << endl;
    206206
    207207      for(list<PolymakeProperty>::const_iterator i=properties.begin();i!=properties.end();i++)

  • gfanlib/gfanlib_q.h

    r88615db r1d1f93  
    3131  {
    3232    mpq_init(value);
     33//    mpz_init_set_si(mpq_numref(value), value_);
     34//    mpz_init_set_ui(mpq_denref(value), 1);
    3335    mpz_set_si(mpq_numref(value), value_);
    3436    mpz_set_ui(mpq_denref(value), 1);
    … …  
    4850  {
    4951    mpq_init(value);
     52//    mpz_init_set(mpq_numref(value), value_.value);
     53//    mpz_init_set_ui(mpq_denref(value), 1);
    5054    mpz_set(mpq_numref(value), value_.value);
    5155    mpz_set_ui(mpq_denref(value), 1);
    … …  
    156160    return mpq_sgn(value);
    157161  }
    158   static Rational gcd(Rational const &a, Rational const /*&b*/, Rational /*&s*/, Rational /*t*/)
     162  static Rational gcd(Rational const &a, Rational const /*&b*/, Rational /*&s*/, Rational /*&t*/)
    159163  {
    160164/*    mpz_t r;

  • gfanlib/gfanlib_symmetriccomplex.cpp

    r88615db r1d1f93  
    5959    sum+=vertices[indices[i]];
    6060
    61   int n=sum.size();
     61  unsigned n=sum.size();
    6262  Permutation const &bestPermutation=sortKeyPermutation;
    6363
    64   assert((int)bestPermutation.size()==n);
     64  assert(bestPermutation.size()==n);
    6565
    6666  IntVector indicesNew(indices.size());
    … …  
    8888bool SymmetricComplex::Cone::isSubsetOf(Cone const &c)const
    8989{
    90   int next=0;
     90  unsigned next=0;
    9191  for(unsigned i=0;i<indices.size();i++)
    9292    {
    9393      while(1)
    9494        {
    95           if(next>=(int)c.indices.size())return false;
     95          if(next>=c.indices.size())return false;
    9696          if(indices[i]==c.indices[next])break;
    9797          next++;
    … …  
    183183
    184184
     185int SymmetricComplex::getLinDim()const
     186{
     187        return linealitySpace.getHeight();
     188}
     189
    185190int SymmetricComplex::getMaxDim()const
    186191{
    … …  
    199204}
    200205
    201 
    202 int SymmetricComplex::getLinDim()const
    203 {
    204   ZMatrix zm=linealitySpace;
    205   return zm.reduceAndComputeRank();
    206 }
    207206
    208207bool SymmetricComplex::isMaximal(Cone const &c)const
    … …  
    248247#endif
    249248
    250 void SymmetricComplex::buildConeLists(bool onlyMaximal, bool compressed, std::vector<std::vector<IntVector > >*conelist/*, ZMatrix *multiplicities*/)const
     249void SymmetricComplex::buildConeLists(bool onlyMaximal, bool compressed, std::vector<std::vector<IntVector > >*conelist, std::vector<std::vector<Integer > > *multiplicities)const
    251250{
    252251  int dimLow=this->linealitySpace.getHeight();
    … …  
    254253  if(dimHigh<dimLow)dimHigh=dimLow-1;
    255254  if(conelist)*conelist=std::vector<std::vector<IntVector> >(dimHigh-dimLow+1);
     255  if(multiplicities)*multiplicities=std::vector<std::vector<Integer> >(dimHigh-dimLow+1);
    256256  for(int d=dimLow;d<=dimHigh;d++)
    257257    {
    … …  
    262262          int I=0;
    263263          for(ConeContainer::const_iterator i=cones.begin();i!=cones.end();i++,I++)
    264             if(i->dimension==d)
    265             {
    266               numberOfOrbitsOfThisDimension++;
     264                  if(i->dimension==d)
     265                    {
     266                  numberOfOrbitsOfThisDimension++;
    267267              if(!onlyMaximal || isMaximal(*i))
    268268                {
    … …  
    270270                  // bool isMax=isMaximal(*i);
    271271                  // bool newOrbit=true;
    272                   std::set<std::set<int> > temp;
    273                   for(SymmetryGroup::ElementContainer::const_iterator k=sym.elements.begin();k!=sym.elements.end();k++)
    274                     {
     272                  std::set<std::pair<std::set<int>,Integer> > temp;
     273                    for(SymmetryGroup::ElementContainer::const_iterator k=sym.elements.begin();k!=sym.elements.end();k++)
     274                      {
    275275                        Cone temp1=i->permuted(*k,*this,false);
    276                         temp.insert(temp1.indexSet());
     276                        temp.insert(std::pair<std::set<int>,Integer>(temp1.indexSet(),temp1.multiplicity));
    277277                        if(compressed)break;
    278278                    }
    279                   for(std::set<std::set<int> >::const_iterator j=temp.begin();j!=temp.end();j++)
     279                  for(std::set<std::pair<std::set<int>,Integer> >::const_iterator j=temp.begin();j!=temp.end();j++)
    280280                    {
    281281                      IntVector temp;
    282                       for(std::set<int>::const_iterator k=j->begin();k!=j->end();k++)temp.push_back(*k);
     282                      for(std::set<int>::const_iterator k=j->first.begin();k!=j->first.end();k++)temp.push_back(*k);
    283283                      if(conelist)(*conelist)[d-dimLow].push_back(temp);
     284                      if(multiplicities)(*multiplicities)[d-dimLow].push_back(j->second);
    284285 /*                     if(isMax)if(multiplicities)
    285286                        {
    … …  
    293294                      // newDimension=false;
    294295                    }
    295                 }
    296             }
    297         }
    298     }
    299 
    300 }
    301 
    302 std::string SymmetricComplex::toStringJustCones(int dimLow, int dimHigh, bool onlyMaximal, bool group, std::ostream *multiplicities, bool compressed, bool /*tPlaneSort*/)const
     296              }
     297                    }
     298        }
     299    }
     300
     301}
     302
     303std::string SymmetricComplex::toStringJustCones(int dimLow, int dimHigh, bool onlyMaximal, bool group, std::ostream *multiplicities, bool compressed, bool tPlaneSort)const
    303304{
    304305  std::stringstream ret;
    … …  
    365366
    366367
    367 std::string SymmetricComplex::toStringJustRaysAndMaximalCones(int flags)const
    368 {
    369   PolymakeFile polymakeFile;
    370   polymakeFile.create("NONAME","PolyhedralFan","PolyhedralFan",flags&FPF_xml);
    371   polymakeFile.writeMatrixProperty("RAYS",vertices,true);
    372   polymakeFile.writeStringProperty("MAXIMAL_CONES",toStringJustCones(getMinDim(),getMaxDim(),true,flags&FPF_group, 0,false,flags&FPF_tPlaneSort));
    373 
    374   std::stringstream s;
    375   polymakeFile.writeStream(s);
    376   return s.str();
    377 }
    378 
    379 
    380368ZVector SymmetricComplex::fvector(bool boundedPart)const
    381369{
    … …  
    538526    polymakeFile.writeCardinalProperty("LINEALITY_DIM",linealitySpace.getHeight());
    539527    //    polymakeFile.writeMatrixProperty("RAYS",rays,true,comments);
    540     polymakeFile.writeMatrixProperty("RAYS",vertices,true);
     528        polymakeFile.writeMatrixProperty("RAYS",vertices,true);
    541529    polymakeFile.writeCardinalProperty("N_RAYS",vertices.getHeight());
    542530
    … …  
    606594
    607595
    608     polymakeFile.writeStringProperty("CONES",toStringJustCones(getMinDim(),getMaxDim(),false,flags&FPF_group, 0,false,flags&FPF_tPlaneSort));
    609     polymakeFile.writeStringProperty("MAXIMAL_CONES",toStringJustCones(getMinDim(),getMaxDim(),true,flags&FPF_group, 0,false,flags&FPF_tPlaneSort));
    610     polymakeFile.writeStringProperty("CONES_ORBITS",toStringJustCones(getMinDim(),getMaxDim(),false,flags&FPF_group, 0,true,flags&FPF_tPlaneSort));
    611     polymakeFile.writeStringProperty("MAXIMAL_CONES_ORBITS",toStringJustCones(getMinDim(),getMaxDim(),true,flags&FPF_group, 0,true,flags&FPF_tPlaneSort));
     596    if(flags&FPF_cones)polymakeFile.writeStringProperty("CONES",toStringJustCones(getMinDim(),getMaxDim(),false,flags&FPF_group, 0,false,flags&FPF_tPlaneSort));
     597    std::stringstream multiplicities;
     598    if(flags&FPF_maximalCones)polymakeFile.writeStringProperty("MAXIMAL_CONES",toStringJustCones(getMinDim(),getMaxDim(),true,flags&FPF_group, &multiplicities,false,flags&FPF_tPlaneSort));
     599    if(flags&FPF_conesCompressed)polymakeFile.writeStringProperty("CONES_ORBITS",toStringJustCones(getMinDim(),getMaxDim(),false,flags&FPF_group, 0,true,flags&FPF_tPlaneSort));
     600    if((flags&FPF_conesCompressed) && (flags&FPF_maximalCones))polymakeFile.writeStringProperty("MAXIMAL_CONES_ORBITS",toStringJustCones(getMinDim(),getMaxDim(),true,flags&FPF_group, 0,true,flags&FPF_tPlaneSort));
     601    if(flags&FPF_multiplicities)polymakeFile.writeStringProperty("MULTIPLICITIES",multiplicities.str());
    612602
    613603    if(!sym.isTrivial())
    … …  
    647637            stringstream multiplicities;
    648638            polymakeFile.writeStringProperty("MAXIMAL_CONES",symCom.toString(symCom.getMinDim(),symCom.getMaxDim(),true,flags&FPF_group, &multiplicities,false,flags&FPF_tPlaneSort));
    649             if(flags&FPF_multiplicities)polymakeFile.writeStringProperty("MULTIPLICITIES",multiplicities.str());
    650639  //          log1 fprintf(Stderr,"Done producing list of maximal cones.\n");
    651640          }

  • gfanlib/gfanlib_symmetriccomplex.h

    r88615db r1d1f93  
    3636  class SymmetricComplex{
    3737  int n;
    38   ZMatrix linealitySpace;
     38  ZMatrix linealitySpace; // Has full row rank.
    3939  ZMatrix vertices;
    4040  std::map<ZVector,int> indexMap;
    … …  
    8585  bool isPure()const;
    8686  ZVector fvector(bool boundedPart=false)const;
    87   void buildConeLists(bool onlyMaximal, bool compressed, std::vector<std::vector<IntVector > >*conelist/*, ZMatrix *multiplicities*/)const;
     87  void buildConeLists(bool onlyMaximal, bool compressed, std::vector<std::vector<IntVector > >*conelist, std::vector<std::vector<Integer > > *multiplicities=0)const;
    8888  std::string toStringJustCones(int dimLow, int dimHigh, bool onlyMaximal, bool group, std::ostream *multiplicities=0, bool compressed=false, bool tPlaneSort=false)const;
    89   std::string toStringJustRaysAndMaximalCones(int flags=0)const;
    9089  std::string toString(int flags=0)const;
    9190  bool isSimplicial()const;

  • gfanlib/gfanlib_symmetry.cpp

    r88615db r1d1f93  
    352352  return ret;
    353353}
    354 #if 0
    355 IntegerVector SymmetryGroup::orbitRepresentativeFixing(IntegerVector const &v, IntegerVector const &fixed)const
     354
     355ZVector SymmetryGroup::orbitRepresentativeFixing(ZVector const &v, ZVector const &fixed)const
    356356{
    357357        if(trie){
    358                 return compose(trie->searchStabalizer(v,fixed),v);
    359         }
    360   IntegerVector ret=v;
     358                return trie->searchStabalizer(v,fixed).apply(v);
     359        }
     360  ZVector ret=v;
    361361
    362362  for(ElementContainer::const_iterator i=elements.begin();i!=elements.end();i++)
    363     if(compose(*i,fixed)==fixed)
     363    if(i->apply(fixed)==fixed)
    364364      {
    365         IntegerVector q=compose(*i,v);
     365        ZVector q=i->apply(v);
    366366        if(ret<q)ret=q;
    367367      }
    368368        if(trie){
    369                 IntegerVector temp=compose(trie->searchStabalizer(v,fixed),v);
     369                ZVector temp=trie->searchStabalizer(v,fixed).apply(v);
    370370//              debug<<"Input"<<v;
    371371//              debug<<"Brute"<<ret;
    … …  
    376376  return ret;
    377377}
    378 #endif
    379378
    380379bool Permutation::isPermutation(IntVector const &a)

  • gfanlib/gfanlib_vector.h

    r88615db r1d1f93  
    1414#include <algorithm>
    1515#include <iostream>
     16#include <sstream>
    1617
    1718#include "gfanlib_z.h"
    … …  
    8485  unsigned int size()const{return v.size();};
    8586  void resize(int n){v.resize(n,typ());};
    86   void grow(int i){if(size()<i)resize(i);}
     87  void grow(int i){if((int)size()<i)resize(i);}
    8788  void push_back(typ a)
    8889  {
    … …  
    289290    return f<<")";
    290291  }
     292
     293  std::string toString()const
     294  {
     295          std::stringstream f;
     296          f<<*this;
     297          return f.str();
     298  }
     299
    291300  typ gcd()const
    292301  {
    … …  
    301310    assert(!typ::isField());
    302311    return (*this)/gcd();
     312  }
     313
     314  void debugPrint()const
     315  {
     316    std::stringstream s;
     317    s<<"(";
     318    for(typename std::vector<typ>::const_iterator i=this->v.begin();i!=this->v.end();i++)
     319    {
     320      if(i!=this->v.begin()) s<<",";
     321      s<<*i;
     322    }
     323    s<<")"<<std::endl;
     324    std::cout << s.str();
     325    return;
    303326  }
    304327};
    … …  
    393416
    394417    return ret;
    395 }
    396 
    397 }
    398 
     418};
     419
     420};
    399421
    400422#endif /* LIB_ZVECTOR_H_ */

  • gfanlib/gfanlib_z.h

    r88615db r1d1f93  
    1010
    1111#include <string.h>
     12#include <iostream>
    1213#include <ostream>
    1314
    … …  
    1516#if OLD
    1617#include "gmp.h"
    17 
    18 #if (__GNU_MP_VERSION == 4) && (__GNU_MP_VERSION_MINOR<2)
    19 extern void *  (*__gmp_allocate_func) __GMP_PROTO ((size_t));
    20 extern void *  (*__gmp_reallocate_func) __GMP_PROTO ((void *, size_t, size_t));
    21 extern void    (*__gmp_free_func) __GMP_PROTO ((void *, size_t));
    22 
    23 static inline void
    24 mp_get_memory_functions (void *(**alloc_func) (size_t),
    25                          void *(**realloc_func) (void *, size_t, size_t),
    26                          void (**free_func) (void *, size_t))
    27 {
    28   if (alloc_func != NULL)
    29     *alloc_func = __gmp_allocate_func;
    30 
    31   if (realloc_func != NULL)
    32     *realloc_func = __gmp_reallocate_func;
    33 
    34   if (free_func != NULL)
    35     *free_func = __gmp_free_func;
    36 }
    37 #endif
    3818
    3919namespace gfan{
    … …  
    8969    freefunc(str,strlen(str)+1);
    9070    return f;
     71  }
     72  void debugPrint() const
     73  {
     74    void (*freefunc)(void *, size_t);
     75    mp_get_memory_functions(0,0,&freefunc);
     76    char *str=mpz_get_str(0,10,value);
     77    std::cout << str;
     78    freefunc(str,strlen(str)+1);
     79    return;
    9180  }
    9281  Integer& operator+=(const Integer& a)
    … …  
    351340      return f;
    352341    }
     342    friend void debugPrint(IntegerTemplate const &a)
     343    {
     344      std::cout << a << std::endl;
     345      return;
     346    }
    353347    LimbWord signExtension(LimbWord a)
    354348    {

  • gfanlib/gfanlib_zcone.cpp

    r88615db r1d1f93  
    1010#include <vector>
    1111#include <set>
    12 
    13 
    14 #include "config.h"
    15 
     12#include <sstream>
     13
     14#include <config.h>
    1615#ifdef HAVE_CDD_SETOPER_H
    17 #include "cdd/setoper.h"
    18 #include "cdd/cdd.h"
    19 #elif HAVE_CDDLIB_SETOPER_H
    20 #include "cddlib/setoper.h"
    21 #include "cddlib/cdd.h"
     16#include <cdd/setoper.h>
     17#include <cdd/cdd.h>
    2218#else
    23 #include "setoper.h"
    24 #include "cdd.h"
     19#ifdef HAVE_CDDLIB_SETOPER_H
     20#include <cddlib/setoper.h>
     21#include <cddlib/cdd.h>
     22#else
     23#include <setoper.h>
     24#include <cdd.h>
     25#endif
    2526#endif
    2627
    … …  
    4849    dd_RepresentationType rep=dd_Inequality;
    4950    // dd_boolean found=dd_FALSE, newformat=dd_FALSE, successful=dd_FALSE;
    50     // char command[dd_linelenmax], comsave[dd_linelenmax];
     51    char command[dd_linelenmax], comsave[dd_linelenmax];
    5152    dd_NumberType NT;
    5253
    … …  
    6869      for (j = 1; j < d_input; j++) {
    6970        g[i][j-1].setGmp(mpq_numref(M->matrix[i][j]));
    70         mpz_init_set_ui(mpq_denref(M->matrix[i][j]), 1);
     71        mpz_set_ui(mpq_denref(M->matrix[i][j]), 1);
    7172        mpq_canonicalize(M->matrix[i][j]);
    7273      }
    … …  
    111112  {
    112113    bool ret;
    113     dd_MatrixPtr M=NULL/*,M2=NULL,M3=NULL*/;
     114    // dd_MatrixPtr M=NULL,M2=NULL,M3=NULL;
     115    dd_MatrixPtr M=NULL;
    114116    // dd_colrange d;
    115117    dd_ErrorType err=dd_NoError;
    … …  
    117119    // dd_colset ignoredcols, basiscols;
    118120    // dd_DataFileType inputfile;
    119     // FILE *reading=NULL;
     121    FILE *reading=NULL;
    120122
    121123    cddinitGmp();
    … …  
    336338  {
    337339    cddinitGmp();
     340
    338341    int numberOfEqualities=equations.getHeight();
    339342    int numberOfInequalities=inequalities.getHeight();
    … …  
    451454  void dual(ZMatrix const &inequalities, ZMatrix const &equations, ZMatrix &dualInequalities, ZMatrix &dualEquations)
    452455  {
    453     // int result;
     456    int result;
    454457
    455458    dd_MatrixPtr A=NULL;
    456459    dd_ErrorType err=dd_NoError;
    457460
    458     cddinitGmp();
     461        cddinitGmp();
    459462
    460463    A=ZMatrix2MatrixGmp(inequalities, equations, &err);
    … …  
    475478
    476479    return;
    477    // _L99:
    478    // assert(0);
     480   _L99:
     481    assert(0);
    479482  }
    480483  // this procedure is take from cddio.c.
    … …  
    606609
    607610    return ret;
    608    // _L99:
    609    // assert(0);
    610    // return std::vector<std::vector<int> >();
     611   _L99:
     612    assert(0);
     613    return std::vector<std::vector<int> >();
    611614  }
    612615
    … …  
    702705          QMatrix m=ZToQMatrix(equations);
    703706          m.reduce();
    704           m.REformToRREform(true);
     707          m.REformToRREform();
    705708          ZMatrix inequalities2(0,equations.getWidth());
    706709          for(int i=0;i<inequalities.getHeight();i++)
    … …  
    710713          inequalities=LpSolver::fastNormals(inequalities2);
    711714          goto noFallBack;
    712         // fallBack://alternativ (disabled)
    713         //   lpSolver.removeRedundantRows(inequalities,equations,true);
     715        fallBack://alternativ (disabled)
     716          lpSolver.removeRedundantRows(inequalities,equations,true);
    714717        noFallBack:;
    715718        }
    … …  
    721724      QMatrix equations2=ZToQMatrix(equations);
    722725      equations2.reduce(false,false,true);
    723       equations2.REformToRREform();
     726      equations2.REformToRREform(true);
    724727      for(int i=0;i<inequalities.getHeight();i++)
    725728        {
    … …  
    733736}
    734737
    735 void operator<<(std::ostream &f, ZCone const &c)
     738std::ostream &operator<<(std::ostream &f, ZCone const &c)
    736739{
    737740  f<<"Ambient dimension:"<<c.n<<std::endl;
    … …  
    740743  f<<"Equations:"<<std::endl;
    741744  f<<c.equations<<std::endl;
    742 }
    743 
     745  return f;
     746}
     747
     748std::string ZCone::toString()const
     749{
     750        std::stringstream f;
     751        f<<*this;
     752        return f.str();
     753// =======
     754//   std::stringstream s;
     755//   s<<"AMBIENT_DIM"<<std::endl;
     756//   s<<this->ambientDimension()<<std::endl;
     757
     758//   gfan::ZMatrix i=this->getInequalities();
     759//   if (this->areFacetsKnown())
     760//     s<<"FACETS"<<std::endl;
     761//   else
     762//     s<<"INEQUALITIES"<<std::endl;
     763//   s<<i<<std::endl;
     764
     765//   gfan::ZMatrix e=this->getEquations();
     766//   if (this->areImpliedEquationsKnown())
     767//     s<<"LINEAR_SPAN"<<std::endl;
     768//   else
     769//     s<<"EQUATIONS"<<std::endl;
     770//   s<<e<<std::endl;
     771
     772//   gfan::ZMatrix r=this->extremeRays();
     773//   s<<"RAYS"<<std::endl;
     774//   s<<r<<std::endl;
     775
     776//   gfan::ZMatrix l=this->generatorsOfLinealitySpace();
     777//   s<<"LINEALITY_SPACE"<<std::endl;
     778//   s<<l<<std::endl;
     779
     780//   std::cout << s.str();
     781//   return;
     782// >>>>>>> chg: status update 17.07.
     783}
    744784
    745785ZCone::ZCone(int ambientDimension):
    … …  
    934974ZCone ZCone::givenByRays(ZMatrix const &generators, ZMatrix const &linealitySpace)
    935975{
    936   ZCone dual(generators,linealitySpace);
     976  //rewrite modulo lineality space
     977/*  ZMatrix newGenerators(generators.getHeight(),generators.getWidth());
     978  {
     979    QMatrix l=ZToQMatrix(linealitySpace);
     980    l.reduce();
     981    for(int i=0;i<generators.getHeight();i++)
     982      newGenerators[i]=QToZVectorPrimitive(l.canonicalize(ZToQVector(generators[i])));
     983  }
     984*/
     985//        ZCone dual(newGenerators,linealitySpace);
     986          ZCone dual(generators,linealitySpace);
     987//  dual.findFacets();
     988//  dual.canonicalize();
    937989  ZMatrix inequalities=dual.extremeRays();
     990
     991/*  ZMatrix span=generators;
     992  span.append(linealitySpace);
     993  QMatrix m2Q=ZToQMatrix(span);
     994  ZMatrix equations=QToZMatrixPrimitive(m2Q.reduceAndComputeKernel());
     995*/
    938996  ZMatrix equations=dual.generatorsOfLinealitySpace();
    939 
    940   return ZCone(inequalities,equations,3);
     997//  equations.reduce();equations.removeZeroRows();
     998
     999
     1000  return ZCone(inequalities,equations,PCP_impliedEquationsKnown|PCP_facetsKnown);
    9411001}
    9421002
    … …  
    12231283{
    12241284  if(!contains(f.getRelativeInteriorPoint()))return false;
    1225   ZCone temp1=faceContaining(f.getRelativeInteriorPoint());
    1226   temp1.canonicalize();
     1285  ZCone temp=faceContaining(f.getRelativeInteriorPoint());
     1286  temp.canonicalize();
     1287//  ZCone temp2=*this;
    12271288  ZCone temp2=f;
    12281289  temp2.canonicalize();
    1229   return !(temp2!=temp1);
     1290//  std::cout << temp << std::endl;
     1291//  std::cout << temp2 << std::endl;
     1292
     1293  return !(temp2!=temp);
    12301294}
    12311295

  • gfanlib/gfanlib_zcone.h

    r88615db r1d1f93  
    1010
    1111#include "gfanlib_matrix.h"
     12#include <sstream>
    1213
    1314namespace gfan{
    … …  
    148149     ZMatrix generatorsOfSpan()const;
    149150     /**
    150       * Compute generators of the lineality space of the cone. They are stored as rows of the returned matrix.
     151      * Compute generators of the lineality space of the cone. The returned set of generators is a vector spaces basis. They are stored as rows of the returned matrix.
    151152      */
    152153     ZMatrix generatorsOfLinealitySpace()const;
    … …  
    163164      */
    164165     bool areExtremeRaysKnown()const{return haveExtremeRaysBeenCached;}
     166
    165167     /**
    166168      * Takes the cone to a canonical form. After taking cones to canonical form, two cones are the same
    … …  
    342344     */
    343345    bool hasFace(ZCone const &f)const;
    344   /**
    345    Computes the face of the cone containing v in its relative interior.
    346    The vector MUST be contained in the cone.
    347    */
     346    /**
     347       Computes the face of the cone containing v in its relative interior.
     348       The vector MUST be contained in the cone.
     349    */
    348350    ZCone faceContaining(ZVector const &v)const;
    349351    /**
    … …  
    351353     * The ambient space of the returned cone has dimension newn.
    352354     */
    353    // PolyhedralCone projection(int newn)const;
    354     friend void operator<<(std::ostream &f, ZCone const &c);
     355    // PolyhedralCone projection(int newn)const;
     356    friend std::ostream &operator<<(std::ostream &f, ZCone const &c);
     357    std::string toString()const;
    355358};
    356359
    … …  
    358361
    359362
    360 
    361 
    362363#endif /* LIB_CONE_H_ */

  • gfanlib/gfanlib_zfan.cpp

    r88615db r1d1f93  
    3737  {
    3838    IntVector indices=getConeIndices(dimension,index,orbit,maximal);
    39     return this->complex->makeZCone(indices);
     39    ZCone ret=this->complex->makeZCone(indices);
     40    if(maximal)ret.setMultiplicity(((orbit)?multiplicitiesOrbits:multiplicities)[dimension][index]);
     41    return ret;
    4042  }
    4143  IntVector ZFan::getConeIndices(int dimension, int index, bool orbit, bool maximal)const
    … …  
    5961        complex = new SymmetricComplex(coneCollection->toSymmetricComplex());
    6062        complex->buildConeLists(false,false,&cones);
    61         complex->buildConeLists(true,false,&maximalCones);
     63        complex->buildConeLists(true,false,&maximalCones,&multiplicities);
    6264        complex->buildConeLists(false,true,&coneOrbits);
    63         complex->buildConeLists(true,true,&maximalConeOrbits);
     65        complex->buildConeLists(true,true,&maximalConeOrbits,&multiplicitiesOrbits);
    6466      }
    6567  }
    … …  
    316318    return complex->isPure();
    317319  }
    318   bool ZFan::isComplete()const
    319   {
    320     ensureConeCollection();
    321     if(coneCollection->isEmpty())
    322       return 0;
    323     int ambientdim=coneCollection->getAmbientDimension();
    324     int linealitydim=coneCollection->dimensionOfLinealitySpace();
    325     return (ambientdim==linealitydim);
    326   }
    327320  void ZFan::insert(ZCone const &c)
    328321  {
    … …  
    363356}
    364357
    365 std::string ZFan::toStringJustRaysAndMaximalCones(int flags)const
    366 {
    367   ensureComplex();
    368   return complex->toStringJustRaysAndMaximalCones(flags);
    369 }
    370 
    371358/*int ZFan::getAmbientDimension()const
    372359{

  • gfanlib/gfanlib_zfan.h

    r88615db r1d1f93  
    4242  mutable std::vector<std::vector<IntVector > > cones;
    4343  mutable std::vector<std::vector<IntVector > > maximalCones;
     44  mutable std::vector<std::vector<Integer> > multiplicities; // for maximal cones only
    4445  mutable std::vector<std::vector<IntVector > > coneOrbits;
    4546  mutable std::vector<std::vector<IntVector > > maximalConeOrbits;
     47  mutable std::vector<std::vector<Integer> > multiplicitiesOrbits; // for maximal cones orbits only
    4648
    4749
    … …  
    105107   */
    106108  std::string toString(int flags=0)const;
    107   std::string toStringJustRaysAndMaximalCones(int flags=0)const;
    108109  /**
    109110   * Returns the dimension of the ambient space.
    110111   */
    111112  int getAmbientDimension()const;
     113  /**
     114   * Returns the largest dimension of a cone in the fan. If the fan is empty, then -1 is returned.
     115   */
     116  int getDimension()const;
     117  /**
     118   * Returns the smallest codimension of a cone in the fan. If the fan is empty, then -1 is returned.
     119   */
    112120  int getCodimension()const;
    113   int getDimension()const;
     121  /**
     122   * Returns the dimension of the lineality space of the fan. Notice that the lineality space of the
     123   * empty fan is the ambient space.
     124   */
    114125  int getLinealityDimension()const;
     126  /**
     127   * Returns the f-Vector of the fan.
     128   */
    115129  ZVector getFVector()const;
     130  /**
     131   * Returns true, if the fan is simplicial. False otherwise.
     132   */
    116133  bool isSimplicial()const;
     134  /**
     135   * Returns true, if the fan is pure. False otherwise.
     136   */
    117137  bool isPure()const;
    118   bool isComplete()const;
    119138  /**
    120139   * Inserts c into the fan.
    … …  
    137156  int numberOfConesInCollection()const;
    138157  /**
    139    * Returns the largest dimension of a cone in the fan. If the fan is empty, then -1 is returned.
    140    */
    141   int dimension()const;
    142   /**
    143    * Returns the dimension of the lineality space of the fan. Notice that the lineality space of the
    144    * empty fan is the ambient space.
    145    */
    146   // int getLinealityDimension();
    147   /**
    148158   * Returns the cone in the collection given by the index. It is a mistake to specify an index which
    149159   * is out of range.
    150160   */
    151   ZCone const &getConeInCollection(int index)const;
     161  //  ZCone const &getConeInCollection(int index)const;
    152162  /**
    153163   * Returns the cone in the cone of the fan

  • kernel/GBEngine/kstd1.cc

    r2f05b5 r1d1f93  
    28972897                &olddeg,&reduc,strat, red_result);
    28982898
    2899       /* reduction of the element choosen from L */
     2899      /* reduction of the element chosen from L */
    29002900      red_result = strat->red(&strat->P,strat);
    29012901    }

  • kernel/GBEngine/kstd2.cc

    r2f05b5 r1d1f93  
    14731473                &olddeg,&reduc,strat, red_result);
    14741474
    1475       /* reduction of the element choosen from L */
     1475      /* reduction of the element chosen from L */
    14761476      red_result = strat->red(&strat->P,strat);
    14771477      if (errorreported)  break;
    … …  
    18361836    strat->P = strat->L[strat->Ll];
    18371837    strat->Ll--;
    1838     /* reduction of the element choosen from L */
     1838    /* reduction of the element chosen from L */
    18391839
    18401840    if (!strat->rewCrit2(strat->P.sig, ~strat->P.sevSig, strat->P.GetLmCurrRing(), strat, strat->P.checked+1)) {
    … …  
    26772677      pWrite(strat->P.p);
    26782678#endif
    2679       /* complete reduction of the element choosen from L */
     2679      /* complete reduction of the element chosen from L */
    26802680      red_result = strat->red2(&strat->P,strat);
    26812681      if (errorreported)  break;
    … …  
    30123012                &olddeg,&reduc,strat, red_result);
    30133013
    3014       /* reduction of the element choosen from L */
     3014      /* reduction of the element chosen from L */
    30153015      red_result = strat->red(&strat->P,strat);
    30163016    }

  • kernel/GBEngine/kstdfac.cc

    r2f05b5 r1d1f93  
    589589        message(currRing->pFDeg(strat->P.p,currRing),&olddeg,&reduc,strat, red_result);
    590590    }
    591     /* reduction of the element choosen from L */
     591    /* reduction of the element chosen from L */
    592592    kTest_TS(strat);
    593593    red_result = strat->red(&strat->P,strat);

  • kernel/GBEngine/sca.cc

    r2f05b5 r1d1f93  
    615615              &olddeg,&reduc,strat, red_result);
    616616
    617     // reduction of the element choosen from L
     617    // reduction of the element chosen from L
    618618    red_result = strat->red(&strat->P,strat);
    619619
    … …  
    743743        h.PrepareRed(strat->use_buckets);
    744744
    745         // reduction of the element choosen from L(?)
     745        // reduction of the element chosen from L(?)
    746746        red_result = strat->red(&h,strat);
    747747

  • kernel/fast_mult.cc

    r2f05b5 r1d1f93  
    592592    Werror("not implemented for so small n, recursion fails");//should be length(f)
    593593   if (pLength(f)<=1)
    594     Werror("not implemented for so small lenght of f, recursion fails");
     594    Werror("not implemented for so small length of f, recursion fails");
    595595  //  number null_number=n_Init(0,r);
    596596  number* facult=(number*) omAlloc((n+1)*sizeof(number));

  • kernel/groebner_walk/walkProc.cc

    r2f05b5 r1d1f93  
    118118        if ( pperm[k] >= 0 )
    119119        {
    120             WerrorS( "paramater names do not agree" );
     120            WerrorS( "parameter names do not agree" );
    121121            state= WalkIncompatibleRings;
    122122        }

  • kernel/linear_algebra/linearAlgebra.cc

    r88615db r1d1f93  
    431431       solution space will be. Thus, we start with the possibly too wide
    432432       matrix N and later copy the relevant columns of N into H. */
    433     int nonZeroC  =  0 ; 
     433    int nonZeroC  =  0 ;
    434434    int lastNonZeroC = n + 1;
    435435

  • kernel/numeric/mpr_base.cc

    r2f05b5 r1d1f93  
    14581458      {
    14591459        // this can happen, if the shift vektor or the lift funktions
    1460         // are not generically choosen.
     1460        // are not generically chosen.
    14611461        Werror("resMatrixSparse::createMatrix: Found exponent not in E, id %d, set [%d, %d]!",
    14621462               i,(*E)[i]->rc.set,(*E)[i]->rc.pnt);
    … …  
    27042704    break;
    27052705  default:
    2706     WerrorS("uResultant::uResultant: Unknown resultant matrix type choosen!");
     2706    WerrorS("uResultant::uResultant: Unknown chosen resultant matrix type!");
    27072707  }
    27082708}
    … …  
    27352735    break;
    27362736  default:
    2737     WerrorS("uResultant::extendIdeal: Unknown resultant matrix type choosen!");
     2737    WerrorS("uResultant::extendIdeal: Unknown chosen resultant matrix type!");
    27382738  }
    27392739

  • kernel/numeric/mpr_inout.cc

    r2f05b5 r1d1f93  
    6363  {
    6464  case mprWrongRType:
    65     WerrorS("Unknown resultant matrix type choosen!");
     65    WerrorS("Unknown chosen resultant matrix type!");
    6666    break;
    6767  case mprHasOne:

  • libpolys/coeffs/Enumerator.h

    r2f05b5 r1d1f93  
    5858
    5959  private:
    60     /// disable copy constructor and assigment operator
     60    /// disable copy constructor and assignment operator
    6161    IBaseEnumerator(const IBaseEnumerator&);
    6262    void operator=(const IBaseEnumerator&);
    … …  
    169169/** @class AIterator
    170170 *
    171  * An abstract iterator with virtualized assigment operator and
     171 * An abstract iterator with virtualized assignment operator and
    172172 * constructors.
    173173 *

  • libpolys/coeffs/coeffs.h

    r88615db r1d1f93  
    609609
    610610/// return the quotient of 'a' and 'b', i.e., a/b;
    611 /// raise an error if 'b' is not invertible in r
     611/// raises an error if 'b' is not invertible in r
     612/// exception in Z: raises an error if 'a' is not divisible by 'b'
    612613static FORCE_INLINE number n_Div(number a, number b, const coeffs r)
    613614{ STATISTIC(n_Div); assume(r != NULL); assume(r->cfDiv!=NULL); return r->cfDiv(a,b,r); }

  • libpolys/coeffs/longrat.cc

    r2f05b5 r1d1f93  
    30863086{
    30873087  /* test, if r is an instance of nInitCoeffs(n,parameter) */
    3088   /* if paramater is not needed */
     3088  /* if parameter is not needed */
    30893089  if (n==r->type)
    30903090  {

  • libpolys/coeffs/numbers.cc

    r2f05b5 r1d1f93  
    277277{
    278278  /* test, if r is an instance of nInitCoeffs(n,parameter) */
    279   /* if paramater is not needed */
     279  /* if parameter is not needed */
    280280  return (n==r->type);
    281281}

  • libpolys/polys/templates/p_Procs_Impl.h

    r2f05b5 r1d1f93  
    3131 macros.
    3232
    33  At run-time, a fast proc is set/choosen if found/generated, else
    34  a general proc is set/choosen.
     33 At run-time, a fast proc is set/chosen if found/generated, else
     34 a general proc is set/chosen.
    3535 *******************************************************************/
    3636
    … …  
    396396 *
    397397 * Filters which are applied to field/length/ord, before a proc is
    398  * choosen
     398 * chosen
    399399 *
    400400 *******************************************************************/

  • m4/flags.m4

    r88615db r1d1f93  
    103103 AX_APPEND_COMPILE_FLAGS(${FFLAGS}, [FEXCEPTIONSFRTTI_CXXFLAGS])
    104104 AC_SUBST(FEXCEPTIONSFRTTI_CXXFLAGS)
    105  
     105
    106106 AC_LANG_POP([C++])
    107107

  • m4/gfanlib-check.m4

    r88615db r1d1f93  
    1616 AC_CHECK_HEADERS([setoper.h cdd/setoper.h cddlib/setoper.h])
    1717
    18  if test "x$ac_cv_header_setoper_h" = xno -a "x$ac_cv_header_cdd_setoper_h" = xno -a "x$ac_cv_header_cddlib_setoper_h" = xno; then
    19    AC_MSG_WARN([Note that setoper.h is missing!])
     18 if test "x$ac_cv_header_setoper_h" = xno -a "x$ac_cv_header_cdd_setoper_h" = xno -a "x$ac_cv_header_cddlib_setoper_h" = xno
     19 then
     20        AC_MSG_WARN([Error, setoper.h is missing!])
    2021 fi
    2122
    … …  
    6667  fi
    6768 fi
     69 AC_MSG_RESULT(no)
     70
     71 AC_SUBST(CDDGMPLDFLAGS)
    6872else
    6973 AC_MSG_RESULT(no)
Note: See TracChangeset for help on using the changeset viewer.