Changeset c89014 in git


Ignore:
Timestamp:
Feb 28, 2014, 1:16:39 PM (10 years ago)
Author:
Yue Ren <ren@…>
Branches:
(u'spielwiese', 'e7cc1ebecb61be8b9ca6c18016352af89940b21a')
Children:
9abcc69bfa9583e5dc43e54da730e097deb7ebca
Parents:
11ce35d67cd7bc9ae15a481b763b98e2cba97194
git-author:
Yue Ren <ren@mathematik.uni-kl.de>2014-02-28 14:16:39+02:00
git-committer:
Yue Ren <ren@mathematik.uni-kl.de>2015-02-06 13:47:03+01:00
Message:
status update 28.02.
Files:
5 added
1 deleted
20 edited
2 moved

Legend:

Unmodified
Added
Removed

  • Singular/dyn_modules/gfanlib/Makefile.am

    r11ce35 rc89014  
    11ACLOCAL_AMFLAGS = -I ../../m4
    22
    3 SOURCES = gfanlib_exceptions.h bbcone.cc bbcone.h bbfan.cc bbfan.h bbpolytope.cc bbpolytope.h gfan.h gitfan.cc gitfan.h ppinitialReduction.cc ppinitialReduction.h ttinitialReduction.cc ttinitialReduction.h containsMonomial.cc containsMonomial.h adjustWeights.cc adjustWeights.h tropicalStrategy.cc tropicalStrategy.h initial.cc initial.h witness.cc witness.h tropicalCurves.cc tropicalCurves.h groebnerCone.cc groebnerCone.h neighbours.cc neighbours.h tropical.cc tropical.h gfanlib.cc
     3SOURCES = 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 tropicalVarietyOfPolynomials.h tropicalVarietyOfPolynomials.cc ppinitialReduction.cc ppinitialReduction.h ttinitialReduction.cc ttinitialReduction.h containsMonomial.cc containsMonomial.h adjustWeights.cc adjustWeights.h tropicalStrategy.cc tropicalStrategy.h initial.cc initial.h witness.cc witness.h tropicalCurves.cc tropicalCurves.h groebnerCone.cc groebnerCone.h neighbours.cc neighbours.h startingCone.cc startingCone.h tropical.cc tropical.h gfanlib.cc
    44
    55MY_CPPFLAGS =  -I${top_srcdir} -I${top_builddir} \

  • Singular/dyn_modules/gfanlib/adjustWeights.cc

    r11ce35 rc89014  
    5353gfan::ZVector valued_adjustWeightUnderHomogeneity(const gfan::ZVector e, const gfan::ZVector w)
    5454{
    55   gfan::ZVector v=e-(e[1]/w[1]+1)*w;
     55  gfan::ZVector v=e-(e[0]/w[0]+1)*w;
    5656  gfan::Integer min=1;
    5757  for (unsigned i=1; i<v.size(); i++)

  • Singular/dyn_modules/gfanlib/bbcone.cc

    r11ce35 rc89014  
    1313#include <Singular/blackbox.h>
    1414
     15#include <callgfanlib_conversion.h>
    1516#include <sstream>
    1617
    … …  
    2526
    2627int coneID;
    27 
    28 number integerToNumber(const gfan::Integer &I)
    29 {
    30   mpz_t i;
    31   mpz_init(i);
    32   I.setGmp(i);
    33   long m = 268435456;
    34   if(mpz_cmp_si(i,m))
    35   {
    36     int temp = (int) mpz_get_si(i);
    37     return n_Init(temp,coeffs_BIGINT);
    38   }
    39   else
    40     return n_InitMPZ(i,coeffs_BIGINT);
    41 }
    42 
    43 bigintmat* zVectorToBigintmat(const gfan::ZVector &zv)
    44 {
    45   int d=zv.size();
    46   bigintmat* bim = new bigintmat(1,d,coeffs_BIGINT);
    47   for(int i=1;i<=d;i++)
    48   {
    49     number temp = integerToNumber(zv[i-1]);
    50     bim->set(1,i,temp);
    51     n_Delete(&temp,coeffs_BIGINT);
    52   }
    53   return bim;
    54 }
    55 
    56 bigintmat* zMatrixToBigintmat(const gfan::ZMatrix &zm)
    57 {
    58   int d=zm.getHeight();
    59   int n=zm.getWidth();
    60   bigintmat* bim = new bigintmat(d,n,coeffs_BIGINT);
    61   for(int i=1;i<=d;i++)
    62     for(int j=1; j<=n; j++)
    63     {
    64       number temp = integerToNumber(zm[i-1][j-1]);
    65       bim->set(i,j,temp);
    66       n_Delete(&temp,coeffs_BIGINT);
    67     }
    68   return bim;
    69 }
    70 
    71 gfan::Integer* numberToInteger(const number &n)
    72 {
    73   if (SR_HDL(n) & SR_INT)
    74     return new gfan::Integer(SR_TO_INT(n));
    75   else
    76     return new gfan::Integer(n->z);
    77 }
    78 
    79 gfan::ZMatrix* bigintmatToZMatrix(const bigintmat &bim)
    80 {
    81   int d=bim.rows();
    82   int n=bim.cols();
    83   gfan::ZMatrix* zm = new gfan::ZMatrix(d,n);
    84   for(int i=0;i<d;i++)
    85     for(int j=0;j<n;j++)
    86     {
    87       number temp = BIMATELEM(bim, i+1, j+1);
    88       gfan::Integer* gi = numberToInteger(temp);
    89       (*zm)[i][j] = *gi;
    90       delete gi;
    91     }
    92   return zm;
    93 }
    94 
    95 gfan::ZVector* bigintmatToZVector(const bigintmat &bim)
    96 {
    97   gfan::ZVector* zv=new gfan::ZVector(bim.cols());
    98   for(int j=0; j<bim.cols(); j++)
    99   {
    100     number temp = BIMATELEM(bim, 1, j+1);
    101     gfan::Integer* gi = numberToInteger(temp);
    102     (*zv)[j] = *gi;
    103     n_Delete(&temp,coeffs_BIGINT);
    104     delete gi;
    105   }
    106   return zv;
    107 }
    108 
    109 gfan::ZVector intStar2ZVector(const int d, const int* i)
    110 {
    111   gfan::ZVector zv(d);
    112   for(int j=0; j<d; j++)
    113     zv[j]=i[j+1];
    114   return zv;
    115 }
    116 
    117 int* ZVectorToIntStar(const gfan::ZVector &v, bool &overflow)
    118 {
    119   int* w = (int*) omAlloc(v.size()*sizeof(int));
    120   for (unsigned i=0; i<v.size(); i++)
    121   {
    122     if (!v[i].fitsInInt())
    123     {
    124       omFree(w);
    125       WerrorS("intoverflow converting gfan:ZVector to int*");
    126       overflow = true;
    127       return NULL;
    128     }
    129     w[i]=v[i].toInt();
    130   }
    131   return w;
    132 }
    133 
    134 char* toString(gfan::ZMatrix const &zm)
    135 {
    136   bigintmat* bim = zMatrixToBigintmat(zm);
    137   char* s = bim->StringAsPrinted();
    138   if (s==NULL)
    139     s = (char*) omAlloc0(sizeof(char));
    140   delete bim;
    141   return s;
    142 }
    14328
    14429std::string toString(const gfan::ZCone* const c)

  • Singular/dyn_modules/gfanlib/bbcone.h

    r11ce35 rc89014  
    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 int* ZVectorToIntStar(const gfan::ZVector &v, bool &overflow);
    30 char* toString(gfan::ZMatrix const &m);
    3118std::string toString(const gfan::ZCone* const c);
    3219
    33 /***
    34  * Other functions
    35  **/
    36 int getDimension(gfan::ZCone* zc);
    37 int getCodimension(gfan::ZCone* zc);
    38 int getLinealityDimension(gfan::ZCone* zc);
    3920gfan::ZVector randomPoint(const gfan::ZCone* zc);
    4021gfan::ZCone liftUp(const gfan::ZCone &zc);

  • Singular/dyn_modules/gfanlib/bbfan.cc

    r11ce35 rc89014  
    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;

  • Singular/dyn_modules/gfanlib/bbpolytope.cc

    r11ce35 rc89014  
    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/containsMonomial.cc

    r11ce35 rc89014  
    189189
    190190  ideal J = id_Copy(I,r); bool b; int k = 0;
    191   rChangeCurrRing(r);
     191  if (currRing != r) rChangeCurrRing(r);
    192192  intvec* nullVector = NULL;
    193193  do
    … …  
    201201  } while (!b);
    202202
    203   rChangeCurrRing(origin);
     203  if (currRing != origin) rChangeCurrRing(origin);
    204204  poly monom = NULL;
    205205  if (id_IsConstant(J,r))
    206206  {
    207     monom = p_Init(origin);
     207    monom = p_Init(r);
    208208    for (int i=1; i<=rVar(r); i++)
    209       p_SetExp(monom,i,k,origin);
    210     p_SetCoeff(monom,n_Init(1,origin->cf),origin);
    211     p_Setm(monom,origin);
     209      p_SetExp(monom,i,k,r);
     210    p_SetCoeff(monom,n_Init(1,r->cf),r);
     211    p_Setm(monom,r);
    212212  }
    213213  id_Delete(&M,r);

  • Singular/dyn_modules/gfanlib/containsMonomial.h

    r11ce35 rc89014  
    33
    44#include <libpolys/polys/simpleideals.h>
     5#include <Singular/subexpr.h>
    56#include <gfanlib/gfanlib_vector.h>
    67

  • Singular/dyn_modules/gfanlib/gitfan.cc

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

  • Singular/dyn_modules/gfanlib/groebnerCone.cc

    r11ce35 rc89014  
    44#include <libpolys/polys/monomials/ring.h>
    55#include <kernel/ideals.h>
    6 #include <gfanlib/gfanlib_vector.h>
    7 #include <gfanlib/gfanlib_zcone.h>
     6#include <gfanlib/gfanlib.h>
    87
    9 #include <bbcone.h>
     8#include <callgfanlib_conversion.h>
    109#include <groebnerCone.h>
    1110#include <initial.h>
    … …  
    131130  rDelete(r);
    132131}
     132
     133
     134groebnerConeData maximalGroebnerConeData(ideal I, const ring r)
     135{
     136  int n = rVar(r);
     137  poly g = NULL;
     138  int* leadexpv = (int*) omAlloc((n+1)*sizeof(int));
     139  int* tailexpv = (int*) omAlloc((n+1)*sizeof(int));
     140  gfan::ZVector leadexpw = gfan::ZVector(n);
     141  gfan::ZVector tailexpw = gfan::ZVector(n);
     142  gfan::ZMatrix inequalities = gfan::ZMatrix(0,n);
     143  for (int i=0; i<IDELEMS(I); i++)
     144  {
     145    g = (poly) I->m[i]; pGetExpV(g,leadexpv);
     146    leadexpw = intStar2ZVector(n, leadexpv);
     147    pIter(g);
     148    while (g != NULL)
     149    {
     150      pGetExpV(g,tailexpv);
     151      tailexpw = intStar2ZVector(n, tailexpv);
     152      inequalities.appendRow(leadexpw-tailexpw);
     153      pIter(g);
     154    }
     155  }
     156  omFreeSize(leadexpv,(n+1)*sizeof(int));
     157  omFreeSize(tailexpv,(n+1)*sizeof(int));
     158  gfan::ZCone zc = gfan::ZCone(inequalities,gfan::ZMatrix(0, inequalities.getWidth()));
     159  gfan::ZVector p = zc.getRelativeInteriorPoint();
     160  return groebnerConeData(I,r,zc,p);
     161}

  • Singular/dyn_modules/gfanlib/groebnerCone.h

    r11ce35 rc89014  
    5454};
    5555
    56 typedef std::set<groebnerConeData, groebnerConeData_compare> groebnerConesData;
     56groebnerConeData maximalGroebnerConeData(ideal I, const ring r);
    5757
    58 groebnerConesData groebnerNeighbors(const groebnerConeData sigma);
    59 groebnerConesData tropicalNeighbors(const groebnerConeData sigma);
     58typedef std::set<groebnerConeData,groebnerConeData_compare> setOfGroebnerConeData;
    6059
    6160#endif

  • Singular/dyn_modules/gfanlib/initial.cc

    r11ce35 rc89014  
    1 #include <bbcone.h>
    2 #include <gfanlib/gfanlib_vector.h>
     1#include <gfanlib/gfanlib.h>
     2
     3#include <kernel/ideals.h>
     4#include <Singular/subexpr.h>
    35#include <libpolys/polys/monomials/p_polys.h>
    4 #include <Singular/ipid.h>
     6#include <libpolys/polys/simpleideals.h>
     7
     8#include <callgfanlib_conversion.h>
    59#include <gfanlib_exceptions.h>
     10
    611#include <exception>
    712

  • Singular/dyn_modules/gfanlib/neighbours.cc

    r11ce35 rc89014  
    22#include <gfanlib/gfanlib_zfan.h>
    33#include <Singular/lists.h>
    4 #include <bbcone.h>
     4#include <callgfanlib_conversion.h>
    55#include <bbfan.h>
    66#include <ttinitialReduction.h>
    … …  
    8787  newInequalities = inequalities.submatrix(0,0,r-1,c);
    8888  newEquations = equations;
    89   newEquations.appendRow(inequalities[r]);
     89  newEquations.appendRow(inequalities[r-1]);
    9090  facet = gfan::ZCone(newInequalities,newEquations);
    9191  relativeInteriorPoints.appendRow(facet.getRelativeInteriorPoint());
    92   outerFacetNormals.appendRow(-inequalities[r]);
     92  outerFacetNormals.appendRow(-inequalities[r-1]);
    9393
    9494  return std::make_pair(relativeInteriorPoints,outerFacetNormals);
    9595}
    9696
    97 groebnerConesData groebnerNeighbors(const groebnerConeData sigma)
     97setOfGroebnerConeData groebnerNeighbours(const groebnerConeData sigma, const tropicalStrategy currentCase)
    9898{
     99  bool (*red)(ideal I, ring r);
     100  red = currentCase.reduce;
     101
    99102  gfan::ZCone zc = sigma.getCone();
    100103  std::pair<gfan::ZMatrix, gfan::ZMatrix> facets = interiorPointsAndFacetNormals(zc);
    101104  gfan::ZMatrix interiorPoints = facets.first;
    102105  gfan::ZMatrix facetNormals = facets.second;
    103   groebnerConesData neighbours;
     106  setOfGroebnerConeData neighbours;
    104107
    105108  for (int i=0; i<interiorPoints.getHeight(); i++)
    … …  
    108111    ideal I = flipped.first;
    109112    ring r = flipped.second;
    110     ppreduceInitially(I,r);
     113    red(I,r);
    111114    neighbours.insert(groebnerConeData(I,r));
    112115  }
    … …  
    115118}
    116119
    117 groebnerConesData tropicalNeighbors(const groebnerConeData sigma)
     120setOfGroebnerConeData tropicalNeighbors(const groebnerConeData sigma, const tropicalStrategy currentCase)
    118121{
    119122  gfan::ZCone zc = sigma.getCone();
     123  int d = zc.dimension();
    120124  gfan::ZMatrix interiorPoints = facetInteriorPoints(zc);
    121   groebnerConesData neighbours;
     125  setOfGroebnerConeData neighbours;
     126  bool (*red)(ideal I, ring r);
     127  red = currentCase.reduce;
    122128
    123129  for (int i=0; i<interiorPoints.getHeight(); i++)
    … …  
    127133    ring r = sigma.getRing();
    128134    ideal inI = initial(I,r,w);
    129     gfan::ZFan zf = tropicalCurve(inI,w,r);
    130     gfan::ZMatrix u = rays(&zf);
     135    std::set<gfan::ZCone> C = tropicalCurve(inI,r,d-1,currentCase);
     136    std::set<gfan::ZVector> setOfRays = rays(C);
    131137
    132     for (int j=0; j<u.getHeight(); j++)
     138    for (std::set<gfan::ZVector>::iterator ray = setOfRays.begin(); ray!=setOfRays.end(); ray++)
    133139    {
    134       std::pair<ideal,ring> flipped = flip(I,r,w,u[j]);
     140      std::pair<ideal,ring> flipped = flip(I,r,w,*ray);
    135141      ideal I = flipped.first;
    136142      ring r = flipped.second;
    137       ppreduceInitially(I,r);
     143      red(I,r);
    138144      neighbours.insert(groebnerConeData(I,r));
    139145    }
    … …  
    141147
    142148  return neighbours;
    143 }
    144 
    145 // std::set<gfan::ZCone> tropicalNeighbours(const ideal I, const ring r, const gfan::ZVector w)
    146 void tropicalNeighbours(const ideal I, const ring r, const gfan::ZVector w)
    147 {
    148   ideal inI = initial(I,r,w);
    149   gfan::ZFan zf = tropicalCurve(inI,w,r);
    150   gfan::ZMatrix u = rays(&zf);
    151 
    152   // std::set<gfan::ZCone> neighbours;
    153   for (int j=0; j<u.getHeight(); j++)
    154   {
    155     std::pair<ideal,ring> flipped = flip(I,r,w,u[j]);
    156     ideal I = flipped.first;
    157     ring r = flipped.second;
    158     // ppreduceInitially(I,r);
    159     gfan::ZCone zc = groebnerCone(I,r,1024*w+u[j]);
    160     zc.canonicalize();
    161     std::cout << "extreme rays: " << zc.extremeRays() << std::endl;
    162     // neighbours.insert(zc);
    163   }
    164 
    165   // return neighbours;
    166149}
    167150
    … …  
    173156  bigintmat* wbim = (bigintmat*) v->Data();
    174157  gfan::ZVector* w = bigintmatToZVector(wbim);
    175   (void) tropicalNeighbours(I,currRing,*w);
     158  // (void) tropicalNeighbours(I,currRing,*w);
    176159  // std::set<gfan::ZCone> neighbours = tropicalNeighbours(I,currRing,*w);
    177160  // lists L =  (lists)omAllocBin(slists_bin);

  • Singular/dyn_modules/gfanlib/neighbours.h

    r11ce35 rc89014  
    22#define CALLGFANLIB_NEIGHBOURS_H
    33
    4 // groebnerConesData groebnerNeighbors(const groebnerConeData sigma);
     4#include <groebnerCone.h>
     5#include <tropicalStrategy.h>
     6
     7setOfGroebnerConeData groebnerNeighbours(const groebnerConeData sigma, const tropicalStrategy currentCase);
    58BOOLEAN tropicalNeighbours(leftv res, leftv args);
    69

  • Singular/dyn_modules/gfanlib/startingCone.cc

    r11ce35 rc89014  
    1 #include <bbcone.h>
     1#include <callgfanlib_conversion.h>
    22#include <containsMonomial.h>
    33#include <tropical.h>
    44#include <initial.h>
     5#include <groebnerCone.h>
     6#include <neighbours.h>
     7#include <tropicalStrategy.h>
    58
    69/***
    … …  
    3033  r->block1[1] = r->N;
    3134  r->wvhdl[1]  = ZVectorToIntStar(w,ok);
    32   r->order[2]=ringorder_C;
     35  r->order[2]  = ringorder_C;
    3336  return ok;
    3437}
    … …  
    5053
    5154
    52 gfan::ZVector* tropicalStartingPoint(const gfan::ZCone &zc, const ideal &I, const ring r)
     55gfan::ZVector findTropicalPoint(const groebnerConeData sigma)
    5356{
    54   gfan::ZMatrix ws=zc.extremeRays();
    55   for (int i=0; i<ws.getHeight(); i++)
     57  ideal I = sigma.getIdeal();
     58  ring r = sigma.getRing();
     59  gfan::ZCone zc = sigma.getCone();
     60  gfan::ZMatrix R = zc.extremeRays();
     61  for (int i=0; i<R.getHeight(); i++)
    5662  {
    57     ideal inI = initial(I,currRing,ws[i]);
    58     poly s = checkForMonomialViaSuddenSaturation(inI);
     63    // std::cout << "checking ray generated by " << R[i] << std::endl;
     64    ideal inI = initial(I,r,R[i]);
     65    poly s = checkForMonomialViaSuddenSaturation(inI,r);
    5966    id_Delete(&inI,r);
    6067    if (s == NULL)
    61       return new gfan::ZVector(ws[i]);
     68    {
     69      // std::cout << "found no monomial in initial ideal!" << std::endl;
     70      p_Delete(&s,r);
     71      return R[i];
     72    }
     73    p_Delete(&s,r);
    6274  }
    63   return NULL;
     75  gfan::ZMatrix L = zc.generatorsOfLinealitySpace();
     76  for (int i=0; i<L.getHeight(); i++)
     77  {
     78    ideal inI = initial(I,r,L[i]);
     79    poly s = checkForMonomialViaSuddenSaturation(inI,r);
     80    id_Delete(&inI,r);
     81    if (s == NULL)
     82    {
     83      // std::cout << "found no monomial in initial ideal!" << std::endl;
     84      p_Delete(&s,r);
     85      return L[i];
     86    }
     87    p_Delete(&s,r);
     88  }
     89  return gfan::ZVector();
    6490}
    6591
    6692
    67 gfan::ZVector* tropicalStartingPoint(ideal &I, ring r)
     93gfan::ZVector tropicalStartingPoint(const ideal I, const ring r, const tropicalStrategy currentCase)
    6894{
    69   gfan::ZCone* zc = maximalGroebnerCone(currRing, I);
    70   gfan::ZVector* w = tropicalStartingPoint(zc,I,r);
    71   while (w==NULL)
     95  groebnerConeData sigma = maximalGroebnerConeData(id_Copy(I,r),rCopy(r));
     96  gfan::ZVector startingPoint = findTropicalPoint(sigma);
     97  while (startingPoint.size()==0)
    7298  {
    73     w = tropicalStartingPoint(zc,I,r);
     99    setOfGroebnerConeData neighbours = groebnerNeighbours(sigma,currentCase);
     100    setOfGroebnerConeData::iterator tau = neighbours.begin();
     101    for (; tau!=neighbours.end(); tau++)
     102    {
     103      startingPoint = findTropicalPoint(*tau);
     104      if (startingPoint.size() > 0) break;
     105    }
     106    tau = neighbours.begin();
     107    sigma = *tau;
    74108  }
    75   return w;
     109  return startingPoint;
    76110}
    77111
    78112
    79 gfan::ZCone* tropicalStartingCone(const ideal &I, ring r)
     113BOOLEAN tropicalStartingPoint0(leftv res, leftv args)
    80114{
    81   gfan::ZVector* w = tropicalStartingPoint(I,r);
    82   return groebnerCone(I,r,w);
     115  leftv u = args;
     116  ideal I = (ideal) u->CopyD();
     117  gfan::ZVector startingPoint = tropicalStartingPoint(I,currRing,nonValuedCase);
     118  id_Delete(&I, currRing);
     119  res->rtyp = BIGINTMAT_CMD;
     120  res->data = (char*) zVectorToBigintmat(startingPoint);
     121  return FALSE;
    83122}
     123
     124BOOLEAN tropicalStartingPoint1(leftv res, leftv args)
     125{
     126  leftv u = args;
     127  ideal I = (ideal) u->CopyD();
     128  gfan::ZVector startingPoint = tropicalStartingPoint(I,currRing,valuedCase);
     129  id_Delete(&I, currRing);
     130  res->rtyp = BIGINTMAT_CMD;
     131  res->data = (char*) zVectorToBigintmat(startingPoint);
     132  return FALSE;
     133}
     134
     135
     136// gfan::ZCone* tropicalStartingCone(const ideal &I, ring r)
     137// {
     138//   gfan::ZVector* w = tropicalStartingPoint(I,r);
     139//   return groebnerCone(I,r,w);
     140// }

  • Singular/dyn_modules/gfanlib/startingCone.h

    r11ce35 rc89014  
    22#define STARTING_CONE_H
    33
    4 namespace tropical
    5 {
     4#include <groebnerCone.h>
     5/* namespace tropical */
     6/* { */
    67
    7   class facet
    8   {
    9     gfan::ZVector interiorPoint;
    10     gfan::ZVector facetNormal;
     8/*   class facet */
     9/*   { */
     10/*     gfan::ZVector interiorPoint; */
     11/*     gfan::ZVector facetNormal; */
    1112
    12   public:
     13/*   public: */
    1314
    14     facet();
    15     facet(const facet &f);
    16     facet(const gfan::ZCone &c, const gfan::ZVector &v, const gfan::ZVector &w);
    17     ~facet();
     15/*     facet(); */
     16/*     facet(const facet &f); */
     17/*     facet(const gfan::ZCone &c, const gfan::ZVector &v, const gfan::ZVector &w); */
     18/*     ~facet(); */
    1819
    19     gfan::ZCone getEta() { return this->eta; };
    20     gfan::ZVector getInteriorPoint() { return this->interiorPoint; };
    21     gfan::ZVector getFacetNormal() { return this->facetNormal; };
     20/*     gfan::ZCone getEta() { return this->eta; }; */
     21/*     gfan::ZVector getInteriorPoint() { return this->interiorPoint; }; */
     22/*     gfan::ZVector getFacetNormal() { return this->facetNormal; }; */
    2223
    23     friend struct facet_compare;
    24   };
     24/*     friend struct facet_compare; */
     25/*   }; */
    2526
    26   struct facet_compare
    27   {
    28     bool operator()(const facet &f, const facet &g) const
    29     {
    30       const gfan::ZVector v1 = f.interiorPoint;
    31       const gfan::ZVector v2 = g.interiorPoint;
    32 #ifndef NDEBUG
    33       assume(v1.size() == v2.size());
    34 #endif
    35       return v1 < v2;
    36     }
    37   };
     27/*   struct facet_compare */
     28/*   { */
     29/*     bool operator()(const facet &f, const facet &g) const */
     30/*     { */
     31/*       const gfan::ZVector v1 = f.interiorPoint; */
     32/*       const gfan::ZVector v2 = g.interiorPoint; */
     33/* #ifndef NDEBUG */
     34/*       assume(v1.size() == v2.size()); */
     35/* #endif */
     36/*       return v1 < v2; */
     37/*     } */
     38/*   }; */
    3839
    39   typedef std::set<facet,facet_compare> facets;
     40/*   typedef std::set<facet,facet_compare> facets; */
    4041
    41   void mergeFacets(facets &F, const facets &newFacets);
     42/*   void mergeFacets(facets &F, const facets &newFacets); */
    4243
    43 }
     44/* } */
     45
     46gfan::ZVector containsTropicalPoint(const groebnerConeData sigma);
     47gfan::ZVector tropicalStartingPoint(ideal I, ring r);
     48
     49BOOLEAN tropicalStartingPoint0(leftv res, leftv args);
     50BOOLEAN tropicalStartingPoint1(leftv res, leftv args);
    4451
    4552#endif

  • Singular/dyn_modules/gfanlib/tropical.cc

    r11ce35 rc89014  
    22#include <libpolys/coeffs/coeffs.h>
    33
     4#include <callgfanlib_conversion.h>
    45#include <bbcone.h>
    56#include <ppinitialReduction.h>
    … …  
    1011#include <tropicalCurves.h>
    1112#include <neighbours.h>
     13#include <tropicalVarietyOfPolynomials.h>
    1214#include <tropicalStrategy.h>
     15#include <startingCone.h>
    1316
    1417BOOLEAN homogeneitySpace(leftv res, leftv args)
    … …  
    180183  p->iiAddCproc("","maximalGroebnerCone",FALSE,maximalGroebnerCone);
    181184  p->iiAddCproc("","initial",FALSE,initial);
    182   p->iiAddCproc("","tropicalNeighbours",FALSE,tropicalNeighbours);
     185  // p->iiAddCproc("","tropicalNeighbours",FALSE,tropicalNeighbours);
    183186#ifndef NDEBUG
    184187  p->iiAddCproc("","initial0",FALSE,initial0);
    … …  
    198201  p->iiAddCproc("","dwr0",FALSE,dwr0);
    199202  p->iiAddCproc("","witness0",FALSE,witness0);
     203  p->iiAddCproc("","tropicalVariety00",FALSE,tropicalVariety00);
     204  p->iiAddCproc("","tropicalVariety01",FALSE,tropicalVariety01);
    200205  p->iiAddCproc("","tropicalCurve0",FALSE,tropicalCurve0);
    201206  p->iiAddCproc("","tropicalCurve1",FALSE,tropicalCurve1);
    202   p->iiAddCproc("","tropicalCurve2",FALSE,tropicalCurve2);
     207  p->iiAddCproc("","tropicalStartingPoint0",FALSE,tropicalStartingPoint0);
     208  p->iiAddCproc("","tropicalStartingPoint1",FALSE,tropicalStartingPoint1);
    203209#endif //NDEBUG
    204210  p->iiAddCproc("","ppreduceInitially",FALSE,ppreduceInitially);

  • Singular/dyn_modules/gfanlib/tropicalCurves.cc

    r11ce35 rc89014  
    22#include <gfanlib/gfanlib_zcone.h>
    33#include <libpolys/polys/monomials/p_polys.h>
     4#include <callgfanlib_conversion.h>
    45#include <gfanlib_exceptions.h>
    5 #include <bbcone.h>
    6 #include <bbpolytope.h>
    7 #include <bbfan.h>
    86#include <containsMonomial.h>
    97#include <initial.h>
    108#include <witness.h>
     9#include <tropicalStrategy.h>
    1110#include <tropicalCurves.h>
    1211#include <set>
     12#ifndef NDEBUG
     13#include <bbfan.h>
     14#endif
    1315
    14 tropicalCurve::tropicalCurve():
    15   cones(),
    16   expectedDimension(0)
     16std::set<gfan::ZCone> intersect(const std::set<gfan::ZCone> setA, const std::set<gfan::ZCone> setB, int d)
    1717{
    18 }
    19 
    20 tropicalCurve::tropicalCurve(const int d):
    21   cones(),
    22   expectedDimension(d)
    23 {
    24 }
    25 
    26 /***
    27  * Returns the tropical curve of a polynomial g in ring r
    28  **/
    29 gfan::ZCones tropicalVariety(const poly &g, const ring &r)
    30 {
    31   if (!g || !g->next) return;
    32 
    33   int n = r->N;
    34   gfan::ZCones setOfCones;
    35   int* expv = (int*) omAlloc((n+1)*sizeof(int));
    36   gfan::ZMatrix exponents = gfan::ZMatrix(0,n);
    37   for (poly s=g; s; pIter(s))
    38   {
    39     p_GetExpV(s,expv,r);
    40     gfan::ZVector zv = intStar2ZVector(n,expv);
    41     exponents.appendRow(intStar2ZVector(n,expv));
    42   }
    43   omFreeSize(expv,(n+1)*sizeof(int));
    44 
    45   tropicalCurve C = tropicalCurve(n-1);
    46   int l = exponents.getHeight();
    47   for (int i=0; i<l; i++)
    48   {
    49     for (int j=i+1; j<l; j++)
    50     {
    51       gfan::ZMatrix equation = gfan::ZMatrix(0,n);
    52       equation.appendRow(exponents[i]-exponents[j]);
    53       gfan::ZMatrix inequalities = gfan::ZMatrix(0,n);
    54       for (int k=0; k<l; k++)
    55         if (k!=i && k!=j) inequalities.appendRow(exponents[i]-exponents[k]);
    56       gfan::ZCone zc = gfan::ZCone(inequalities,equation);
    57       if (dimension(zc)>=n-1)
    58         setOfCones.insert(zc);
    59     }
    60   }
    61 }
    62 
    63 gfan::ZCones intersect(const gfan::ZCones setA, const gfan::ZCones setB, int d)
    64 {
    65   gfan::ZCones setAB;
     18  std::set<gfan::ZCone> setAB;
    6619  for (std::set<gfan::ZCone>::iterator coneOfA=setA.begin(); coneOfA!=setA.end(); coneOfA++)
    6720  {
    68     for (std::set<gfan::ZCone>::iterator coneOfB=cones.begin(); coneOfB!=cones.end(); coneOfB++)
     21    for (std::set<gfan::ZCone>::iterator coneOfB=setB.begin(); coneOfB!=setB.end(); coneOfB++)
    6922    {
    7023      gfan::ZCone coneOfIntersection = gfan::intersection(*coneOfA,*coneOfB);
    71       if (dimension(coneOfIntersection)>=d)
     24      if (coneOfIntersection.dimension()>=d)
     25      {
     26        coneOfIntersection.canonicalize();
    7227        setAB.insert(coneOfIntersection);
     28      }
    7329    }
    7430  }
    7531  return setAB;
    7632}
    77 
    78 #ifndef NDEBUG
    79 // BOOLEAN tropicalCurve0(leftv res, leftv args)
    80 // {
    81 //   leftv u = args;
    82 //   poly g = (poly) u->CopyD();
    83 //   omUpdateInfo();
    84 //   Print("usedBytesBefore=%ld\n",om_Info.UsedBytes);
    85 //   gfan::ZFan* zf = new gfan::ZFan(tropicalCurve(g,currRing));
    86 //   p_Delete(&g,currRing);
    87 //   res->rtyp = fanID;
    88 //   res->data = (char*) zf;
    89 //   return FALSE;
    90 // }
    91 #endif
    92 
    9333
    9434/***
    … …  
    10343                                              const tropicalStrategy currentCase)
    10444{
     45  gfan::ZVector (*adjustWeight)(gfan::ZVector v, gfan::ZVector w);
     46  adjustWeight = currentCase.adjustWeightUnderHomogeneity;
     47
    10548  int n = r->N;
    10649  int h = E.getHeight();
    … …  
    12972    s->block0[j] = 1;
    13073    s->block1[j] = n;
    131     s->wvhdl[j] = ZVectorToIntStar(findPositiveWeight(E[j-1],w),overflow);
     74    s->wvhdl[j] = ZVectorToIntStar(adjustWeight(E[j-1],w),overflow);
    13275  }
    13376  s->order[h] = ringorder_wp;
    13477  s->block0[h] = 1;
    13578  s->block1[h] = n;
    136   s->wvhdl[h] = ZVectorToIntStar(findPositiveWeight(E[h-1],w),overflow);
     79  s->wvhdl[h] = ZVectorToIntStar(adjustWeight(E[h-1],w),overflow);
    13780  s->order[h+1] = ringorder_C;
    13881
    … …  
    14992 * which is weighted homogeneous with respect to weight w in ring r
    15093 **/
    151 gfan::ZCones tropicalCurve(const ideal I, const ring r, const gfan::ZVector w, const int d,
    152                            const tropicalStrategy currentCase)
     94std::set<gfan::ZCone> tropicalCurve(const ideal I, const ring r, const int d,
     95                         const tropicalStrategy currentCase)
    15396{
    15497  int k = idSize(I);
    155   int n = r->N;
     98  std::set<gfan::ZCone> (*tropicalVariety)(const poly &g, const ring &r);
     99  tropicalVariety = currentCase.tropicalVarietyOfPolynomial;
    156100  // Compute the common refinement of the tropical varieties
    157101  // of the generating set
    158   gfan::ZCones C = tropicalVariety(I->m[0],r);
     102  std::set<gfan::ZCone> C = tropicalVariety(I->m[0],r);
    159103  for (int i=1; i<k; i++)
    160     C = intersect(C,tropicalVariety(I->m[0],r),d);
     104    C = intersect(C,tropicalVariety(I->m[i],r),d);
    161105
    162106  // cycle through all maximal cones of the refinement
    … …  
    169113  do
    170114  {
    171     for (gfan::ZCones::iterator zc=C.begin(); zc!=C.end(); zc++)
     115    for (std::set<gfan::ZCone>::iterator zc=C.begin(); zc!=C.end(); zc++)
    172116    {
    173117      gfan::ZVector v = zc->getRelativeInteriorPoint();
    174118      gfan::ZMatrix E = zc->generatorsOfSpan();
    175119
    176       ideal inIr = initial(I,r,E[E.getHeight()-1]);
     120      // std::cout << "interiorPoint: " << v << std::endl;
     121      // std::cout << "generators of span: " << E << std::endl;
     122      // ideal inIr = initial(I,r,E[E.getHeight()-1]);
    177123      ring s = ringWithGenericlyWeightedOrdering(r,v,E,currentCase);
    178124      nMapFunc nMap = n_SetMap(r->cf,s->cf);
    179       ideal inIs = idInit(k);
     125      ideal Is = idInit(k);
    180126      for (int j=0; j<k; j++)
    181127      {
    182         inIs->m[j] = p_PermPoly(inI->m[j],NULL,r,s,nMap,NULL,0);
    183         p_Test(inIs->m[j],s);
     128        Is->m[j] = p_PermPoly(I->m[j],NULL,r,s,nMap,NULL,0);
     129        p_Test(Is->m[j],s);
    184130      }
     131      ideal inIs = initial(Is,s,E[E.getHeight()-1]);
     132      id_Delete(&Is,s);
     133      // id_Delete(&inIr,r);
    185134
    186       poly mon = checkForMonomialViaSuddenSaturation(inIs,s);
     135      mon = checkForMonomialViaSuddenSaturation(inIs,s);
    187136      if (mon)
    188137      {
    189         poly g = witness(mon,inIs,s);
    190         C.intersect(tropicalCurve(g,s));
     138        ideal Is = idInit(k);
     139        for (int j=0; j<k; j++)
     140        {
     141          Is->m[j] = p_PermPoly(I->m[j],NULL,r,s,nMap,NULL,0);
     142          p_Test(Is->m[j],s);
     143        }
     144        poly g = witness(mon,Is,inIs,s);
     145        C = intersect(C,tropicalVariety(g,s),d);
     146        p_Delete(&mon,s);
    191147        p_Delete(&g,s);
    192         zc=C.end();
     148        id_Delete(&inIs,s);
     149        id_Delete(&Is,s);
     150        rDelete(s);
     151        break;
    193152      }
    194153      id_Delete(&inIs,s);
    … …  
    202161 * which is weighted homogeneous with respect to weight w in ring r
    203162 **/
    204 // void dummyTropicalCurve(const ideal I, const gfan::ZVector w, const ring r)
    205 // {
    206 //   int k = idSize(I);
    207163
    208 //   // Compute the common refinement of the tropical varieties
    209 //   // of the generating set
    210 //   gfan::ZFan C = tropicalCurve(I->m[0],r);
    211 //   for (int i=1; i<k; i++)
    212 //     C = commonRefinement(C,tropicalCurve(I->m[i],r));
    213 
    214 //   poly mon = NULL;
    215 //   // do
    216 //   // {
    217 //   //   // cycle through all maximal cones of the refinement
    218 //   //   // pick a monomial ordering corresponding to a generic weight vector in it
    219 //   //   // check if the initial ideal is monomial free
    220 //   //   for (int d=C.getAmbientDimension(); d>0; d--)
    221 //   //   {
    222 //   //     for (int i=0; i<C.numberOfConesOfDimension(d,0,1); i++)
    223 //   //     {
    224 //   //       gfan::ZCone zc = C.getCone(d,i,0,1);
    225 //   //       // std::cout << "equation:" << zc.getFacets() << std::endl;
    226 //   //       // std::cout << "inequalities:" << zc.getImpliedEquations() << std::endl;
    227 
    228 //   //       gfan::ZVector v = zc.getRelativeInteriorPoint();
    229 //   //       gfan::ZMatrix E = zc.generatorsOfSpan();
    230 
    231 //   //       // std::cout << "generators of span: " << E << std::endl;
    232 //   //       ideal inI = initial(I,r,E[E.getHeight()-1]);
    233 //   //       ring s = ringWithGenericlyWeightedOrdering(r,v,E);
    234 //   //       nMapFunc nMap = n_SetMap(r->cf,s->cf);
    235 //   //       ideal J = idInit(k);
    236 //   //       for (int j=0; j<k; j++)
    237 //   //       {
    238 //   //         J->m[j] = p_PermPoly(inI->m[j],NULL,r,s,nMap,NULL,0);
    239 //   //         p_Test(J->m[j],s);
    240 //   //       }
    241 
    242 //   //       poly mon = checkForMonomialViaSuddenSaturation(J,s);
    243 //   //       if (mon)
    244 //   //       {
    245 //   //         poly g = witness(mon,J,s);
    246 //   //         gfan::ZFan zf = tropicalCurve(g,s);
    247 //   //         // std::cout << "before refinement" << std::endl << C.toStringJustRaysAndMaximalCones;
    248 //   //         // std::cout << "tropical curve" << std::endl << zf.toStringJustRaysAndMaximalCones;
    249 //   //         C = commonRefinement(C,zf);
    250 //   //         // std::cout << "after refinement" << std::endl << C.toStringJustRaysAndMaximalCones;
    251 //   //         p_Delete(&g,s);
    252 //   //         d = 0; break;
    253 //   //       }
    254 //   //       id_Delete(&J,s);
    255 //   //       rDelete(s);
    256 //   //     }
    257 //   //   }
    258 //   // } while (mon);
    259 //   // return C;
    260 // }
    261 
    262 // #ifndef NDEBUG
    263 // BOOLEAN tropicalCurve1(leftv res, leftv args)
    264 // {
    265 //   leftv u = args;
    266 //   ideal I = (ideal) u->CopyD();
    267 //   leftv v = u->next;
    268 //   bigintmat* w0 = (bigintmat*) v->Data();
    269 //   gfan::ZVector* w = bigintmatToZVector(w0);
    270 //   gfan::ZFan* zf = new gfan::ZFan(tropicalCurve(I,*w,currRing));
    271 //   id_Delete(&I,currRing);
    272 //   delete w;
    273 //   res->rtyp = fanID;
    274 //   res->data = (char*) zf;
    275 //   return FALSE;
    276 // }
    277 // BOOLEAN tropicalCurve2(leftv res, leftv args)
    278 // {
    279 //   leftv u = args;
    280 //   ideal I = (ideal) u->CopyD();
    281 //   leftv v = u->next;
    282 //   bigintmat* w0 = (bigintmat*) v->Data();
    283 //   gfan::ZVector* w = bigintmatToZVector(w0);
    284 //   omUpdateInfo();
    285 //   Print("usedBytesBefore=%ld\n",om_Info.UsedBytes);
    286 //   (void) dummyTropicalCurve(I,*w,currRing);
    287 //   id_Delete(&I,currRing);
    288 //   delete w;
    289 //   res->rtyp = NONE;
    290 //   res->data = NULL;
    291 //   return FALSE;
    292 // }
    293 // #endif
     164#ifndef NDEBUG
     165BOOLEAN tropicalCurve0(leftv res, leftv args)
     166{
     167  leftv u = args;
     168  ideal I = (ideal) u->CopyD();
     169  leftv v = u->next;
     170  int d = (long)(int) v->CopyD();
     171  tropicalStrategy currentCase = nonValuedCase;
     172  std::set<gfan::ZCone> C = tropicalCurve(I,currRing,d,currentCase);
     173  id_Delete(&I,currRing);
     174  omUpdateInfo();
     175  Print("usedBytesBefore=%ld\n",om_Info.UsedBytes);
     176  res->rtyp = fanID;
     177  res->data = (char*) toFanStar(C);
     178  return FALSE;
     179}
     180BOOLEAN tropicalCurve1(leftv res, leftv args)
     181{
     182  leftv u = args;
     183  ideal I = (ideal) u->CopyD();
     184  leftv v = u->next;
     185  int d = (long)(int) v->CopyD();
     186  tropicalStrategy currentCase = valuedCase;
     187  std::set<gfan::ZCone> C = tropicalCurve(I,currRing,d,currentCase);
     188  id_Delete(&I,currRing);
     189  omUpdateInfo();
     190  Print("usedBytesBefore=%ld\n",om_Info.UsedBytes);
     191  res->rtyp = fanID;
     192  res->data = (char*) toFanStar(C);
     193  return FALSE;
     194}
     195#endif

  • Singular/dyn_modules/gfanlib/tropicalCurves.h

    r11ce35 rc89014  
    55#include <gfanlib/gfanlib_zfan.h>
    66#include <libpolys/polys/monomials/p_polys.h>
     7#include <tropicalStrategy.h>
    78
    8 typedef std::set<gfan::ZCone> gfan::ZCones;
    9 
    10 class tropicalCurve
    11 {
    12 private:
    13   std::set<gfan::ZCone> cones;
    14   int expectedDimension;
    15 public:
    16   tropicalCurve();
    17   tropicalCurve(const int d);
    18   tropicalCurve(const tropicalCurve &C);
    19   tropicalCurve(const poly &g, const ring &r);
    20 
    21   std::set<gfan::ZCone>* getCones();
    22   void intersect(const tropicalCurve &C);
    23 };
    24 
    25 gfan::ZFan tropicalCurve(const ideal I, const gfan::ZVector w, const ring r);
     9std::set<gfan::ZCone> tropicalCurve(const ideal I, const ring r, const int d, const tropicalStrategy currentCase);
    2610
    2711#ifndef NDEBUG
    2812BOOLEAN tropicalCurve0(leftv res, leftv args);
    2913BOOLEAN tropicalCurve1(leftv res, leftv args);
    30 BOOLEAN tropicalCurve2(leftv res, leftv args);
    3114#endif
    3215

  • Singular/dyn_modules/gfanlib/tropicalStrategy.h

    r11ce35 rc89014  
    33
    44#include <gfanlib/gfanlib_vector.h>
     5#include <gfanlib/gfanlib_zcone.h>
    56#include <libpolys/polys/simpleideals.h>
     7#include <set>
    68
    79class tropicalStrategy
    810{
    911public:
     12  std::set<gfan::ZCone> (*tropicalVarietyOfPolynomial)(const poly &g, const ring &r);
    1013  gfan::ZVector (*adjustWeightForHomogeneity)(gfan::ZVector w);
    1114  gfan::ZVector (*adjustWeightUnderHomogeneity)(gfan::ZVector v, gfan::ZVector w);
     15  bool (*reduce)(ideal I, ring r);
    1216};
    1317

  • Singular/dyn_modules/gfanlib/witness.cc

    r11ce35 rc89014  
    22#include <Singular/lists.h>
    33#include <libpolys/polys/monomials/p_polys.h>
    4 #include <bbcone.h>
     4#include <callgfanlib_conversion.h>
    55#include <initial.h>
    66#include <utility>
    … …  
    1515static matrix divisionDiscardingRemainder(const poly f, const ideal G, const ring r)
    1616{
     17  ring origin = currRing;
    1718  if (currRing != r) rChangeCurrRing(r);
    1819  ideal F = idInit(1); F->m[0]=f;
    … …  
    2425  assume(Rest->m[0] == NULL);
    2526  id_Delete((ideal*) &Rest, r);
     27  if (currRing != origin) rChangeCurrRing(origin);
    2628  return Q;
    2729}
    … …  
    4951 * such that in_w(g)=m, where w is the uppermost weight vector of r.
    5052 **/
    51 poly witness(const poly m, const ideal I, const ring r)
     53poly witness(const poly m, const ideal I, const ideal inI, const ring r)
    5254{
    53   ideal inI = initial(I,r);
    5455  matrix Q = divisionDiscardingRemainder(m,inI,r);
    55   id_Delete(&inI,r);
    5656
    5757  int k = idSize(I);
    58   poly f = p_Mult_q(p_Copy(I->m[0],currRing),Q->m[0],r);
     58  poly f = p_Mult_q(p_Copy(I->m[0],r),Q->m[0],r);
    5959  Q->m[0] = NULL;
    6060  for (int i=1; i<k; i++)
    6161  {
    62     f = p_Add_q(f,p_Mult_q(p_Copy(I->m[i],currRing),Q->m[i],r),r);
     62    f = p_Add_q(f,p_Mult_q(p_Copy(I->m[i],r),Q->m[i],r),r);
    6363    Q->m[i] = NULL;
    6464  }
    … …  
    7373  leftv u = args;
    7474  leftv v = u->next;
     75  leftv w = v->next;
    7576  poly m = (poly) u->CopyD();
    7677  ideal G = (ideal) v->CopyD();
     78  ideal inG = (ideal) w->CopyD();
    7779  omUpdateInfo();
    7880  Print("usedBytesBefore=%ld\n",om_Info.UsedBytes);
    79   poly f = witness(m,G,currRing);
     81  poly f = witness(m,G,inG,currRing);
    8082  p_Delete(&m,currRing);
    8183  id_Delete(&G,currRing);
     84  id_Delete(&inG,currRing);
    8285  res->rtyp = POLY_CMD;
    8386  res->data = (char*) f;
    … …  
    103106  ideal J = idInit(k);
    104107  for (int i=0; i<k; i++)
    105     J->m[i] = witness(inI->m[i],Is,s);
     108    J->m[i] = witness(inI->m[i],Is,inI,s);
    106109  id_Delete(&Is,s);
    107110  return J;

  • Singular/dyn_modules/gfanlib/witness.h

    r11ce35 rc89014  
    77#include <gfanlib/gfanlib_vector.h>
    88
    9 poly witness(const poly m, const ideal I, const ring r);
     9poly witness(const poly m, const ideal I, const ideal inI, const ring r);
    1010std::pair<ideal,ring> flip(const ideal I, const ring r, const gfan::ZVector interiorPoint, const gfan::ZVector facetNormal);
    1111
Note: See TracChangeset for help on using the changeset viewer.