cohomo.cc File Reference

#include "kernel/mod2.h"
#include "omalloc/omalloc.h"
#include "misc/mylimits.h"
#include "libpolys/misc/intvec.h"
#include <assert.h>
#include <unistd.h>
#include "kernel/combinatorics/hilb.h"
#include "kernel/combinatorics/stairc.h"
#include "kernel/combinatorics/hutil.h"
#include "cohomo.h"
#include "kernel/GBEngine/tgb.h"
#include "Singular/ipid.h"
#include "polys/monomials/ring.h"
#include "polys/monomials/p_polys.h"
#include "polys/simpleideals.h"
#include "Singular/lists.h"
#include "kernel/linear_algebra/linearAlgebra.h"
#include "kernel/GBEngine/kstd1.h"
#include <kernel/ideals.h>
#include <libpolys/polys/ext_fields/transext.h>
#include <libpolys/coeffs/coeffs.h>
#include <coeffs/numbers.h>
#include <vector>
#include <Singular/ipshell.h>
#include <Singular/libsingular.h>
#include <time.h>

Go to the source code of this file.

Functions
static void	listprint (std::vector< int > vec)
static void	listsprint (std::vector< std::vector< int > > posMat)
static void	id_print (ideal h)
static void	lpprint (std::vector< poly > pv)
static void	lpsprint (std::vector< std::vector< poly > > pvs)
static bool	IsinL (int a, std::vector< int > vec)
static std::vector< int >	vecIntersection (std::vector< int > p, std::vector< int > q)
static bool	vsubset (std::vector< int > vec1, std::vector< int > vec2)
static bool	vEvl (std::vector< int > vec1, std::vector< int > vec2)
static bool	vInvsl (std::vector< int > vec, std::vector< std::vector< int > > vecs)
static std::vector< int >	vecUnion (std::vector< int > vec1, std::vector< int > vec2)
static std::vector< int >	vecMinus (std::vector< int > vec1, std::vector< int > vec2)
static std::vector< std::vector< int > >	vsMinusv (std::vector< std::vector< int > > vecs, std::vector< int > vec)
static std::vector< std::vector< int > >	vsUnion (std::vector< std::vector< int > > vs1, std::vector< std::vector< int > > vs2)
static std::vector< std::vector< int > >	vsIntersection (std::vector< std::vector< int > > vs1, std::vector< std::vector< int > > vs2)
static std::vector< int >	support1 (poly p)
static std::vector< std::vector< int > >	supports (ideal h)
static std::vector< int >	support2 (poly p)
static std::vector< std::vector< int > >	supports2 (ideal h)
static poly	pMake (std::vector< int > vbase)
static ideal	idMake (std::vector< std::vector< int > > vecs)
static ideal	idmodulo (ideal h1, ideal h2)
static int	pcoef (poly p, int m)
static bool	vInp (int m, poly p)
static std::vector< int >	vMake (poly p)
static std::vector< std::vector< int > >	vsMake (ideal h)
static std::vector< std::vector< int > >	vecqring (std::vector< std::vector< int > > vec1, std::vector< std::vector< int > > vec2)
static poly	pMaken (std::vector< int > vbase)
static ideal	idMaken (std::vector< std::vector< int > > vecs)
static std::vector< std::vector< int > >	b_subsets (std::vector< int > vec)
static int	idvert (ideal h)
static int	pvert (poly p)
static ideal	idMinus (ideal h1, ideal h2)
static bool	p_Ifsfree (poly P)
static ideal	sfreemon (ideal h, int deg)
static ideal	id_sfmon (ideal h)
static ideal	id_complement (ideal h)
static bool	IsInX (poly p, ideal X)
static ideal	qringadd (ideal h1, ideal h2, int deg)
static int	id_maxdeg (ideal h)
static ideal	idsrRing (ideal h)
static ideal	SimFacset (poly p)
static ideal	idadda (ideal h1, ideal h2)
static ideal	IsSimplex (ideal h)
static ideal	complementsimplex (ideal h)
static int	dim_sim (ideal h)
static int	num4dim (ideal h, int n)
static ideal	findb (ideal h)
static ideal	finda (ideal h, poly S, int ddeg)
static bool	mabconditionv (std::vector< std::vector< int > > hvs, std::vector< int > pv, std::vector< int > av, std::vector< int > bv)
static std::vector< std::vector< int > >	Mabv (ideal h, poly a, poly b)
static std::vector< int >	eli1 (std::vector< int > eq1, std::vector< int > eq2)
static std::vector< int >	keeporder (std::vector< int > vec)
static std::vector< std::vector< int > >	soleli1 (std::vector< std::vector< int > > eqs)
static std::vector< int >	freevars (int n, std::vector< int > bset, std::vector< std::vector< int > > gset)
static std::vector< int >	fvarsvalue (int vnum, std::vector< int > fvars)
static std::vector< std::vector< int > >	vAbsorb (std::vector< int > bset, std::vector< std::vector< int > > gset)
static std::vector< int >	vecbase1 (int num, std::vector< int > oset)
static std::vector< int >	make0 (int n)
static std::vector< int >	make1 (int n)
static std::vector< int >	ofindbases1 (int num, int vnum, std::vector< int > bset, std::vector< std::vector< int > > gset)
static std::vector< std::vector< int > >	ofindbases (int num, std::vector< int > bset, std::vector< std::vector< int > > gset)
static std::vector< std::vector< int > >	eli2 (int num, std::vector< int > bset, std::vector< std::vector< int > > gset)
static std::vector< std::vector< int > >	links (poly a, ideal h)
static int	redefinedeg (poly p, int num)
static ideal	p_a (ideal h)
static std::vector< int >	vertset (std::vector< std::vector< int > > vecs)
static ideal	p_b (ideal h, poly a)
static ideal	psubset (poly p)
static std::vector< std::vector< int > >	listsinsertlist (std::vector< std::vector< int > > gset, int a, int b)
static std::vector< int >	makeequation (int i, int j, int t)
static poly	pMake3 (std::vector< int > vbase)
static ideal	idMake3 (std::vector< std::vector< int > > vecs)
static void	equmab (int num)
static std::vector< int >	subspace1 (std::vector< std::vector< int > > mv, std::vector< int > bv)
static std::vector< poly >	pMakei (std::vector< std::vector< int > > mv, std::vector< int > vbase)
static std::vector< std::vector< poly > >	idMakei (std::vector< std::vector< int > > mv, std::vector< std::vector< int > > vecs)
static void	gradedpiece1 (ideal h, poly a, poly b)
static bool	condition1for2 (std::vector< int > pv, std::vector< int > qv, std::vector< int > bv)
static bool	condition2for2 (std::vector< std::vector< int > > hvs, std::vector< int > pv, std::vector< int > qv, std::vector< int > sv, std::vector< int > av, std::vector< int > bv)
static bool	condition3for2 (std::vector< std::vector< int > > hvs, std::vector< int > pv, std::vector< int > qv, std::vector< int > av, std::vector< int > bv)
static ideal	getpresolve (ideal h)
static std::vector< int >	numfree (ideal h)
static std::vector< std::vector< int > >	canonicalbase (int n)
static std::vector< std::vector< int > >	getvector (ideal h, int n)
static std::vector< int >	findalpha (std::vector< std::vector< int > > mv, std::vector< int > bv)
static std::vector< int >	subspacet1 (int num, std::vector< std::vector< int > > ntvs)
static std::vector< std::vector< int > >	subspacet (std::vector< std::vector< int > > mv, std::vector< int > bv, std::vector< std::vector< int > > ntvs)
static std::vector< std::vector< int > >	mabtv (std::vector< std::vector< int > > hvs, std::vector< std::vector< int > > Mv, std::vector< int > av, std::vector< int > bv)
static void	gradedpiece2 (ideal h, poly a, poly b)
static bool	nabconditionv (std::vector< std::vector< int > > hvs, std::vector< int > pv, std::vector< int > av, std::vector< int > bv)
static std::vector< std::vector< int > >	Nabv (std::vector< std::vector< int > > hvs, std::vector< int > av, std::vector< int > bv)
static bool	nabtconditionv (std::vector< std::vector< int > > hvs, std::vector< int > pv, std::vector< int > qv)
static std::vector< std::vector< int > >	nabtv (std::vector< std::vector< int > > hvs, std::vector< std::vector< int > > Nv, std::vector< int > av, std::vector< int > bv)
static bool	tNab (std::vector< std::vector< int > > hvs, std::vector< int > pv, std::vector< std::vector< int > > bvs)
static std::vector< int >	tnab (std::vector< std::vector< int > > hvs, std::vector< std::vector< int > > nvs, std::vector< std::vector< int > > bvs)
static std::vector< int >	phimage (std::vector< int > pv, std::vector< int > av, std::vector< int > bv)
static std::vector< std::vector< int > >	value1 (std::vector< std::vector< int > > mvs, std::vector< std::vector< int > > nvs, std::vector< std::vector< int > > vecs, std::vector< int > av, std::vector< int > bv)
static intvec *	Tmat (std::vector< std::vector< int > > vecs)
static std::vector< int >	gensindex (ideal M, ideal ids)
static ideal	mingens (ideal h, poly a, poly b)
static std::vector< std::vector< int > >	minisolve (std::vector< std::vector< int > > solve, std::vector< int > index)
static intvec *	gradedpiece1n (ideal h, poly a, poly b)
static void	T1 (ideal h)
static bool	condition2for2nv (std::vector< std::vector< int > > hvs, std::vector< int > pv, std::vector< int > qv, std::vector< int > fv)
static std::vector< int >	findalphan (std::vector< std::vector< int > > N, std::vector< int > tN)
static std::vector< std::vector< int > >	subspacetn (std::vector< std::vector< int > > N, std::vector< int > tN, std::vector< std::vector< int > > ntvs)
static std::vector< std::vector< int > >	value2 (std::vector< std::vector< int > > mvs, std::vector< std::vector< int > > nvs, std::vector< std::vector< int > > mts, std::vector< std::vector< int > > nts, std::vector< std::vector< int > > vecs, std::vector< int > av, std::vector< int > bv)
static ideal	genst (ideal h, poly a, poly b)
static intvec *	gradedpiece2n (ideal h, poly a, poly b)
static void	T2 (ideal h)
static std::vector< int >	phimagel (std::vector< int > fv, std::vector< int > av, std::vector< int > bv)
static std::vector< std::vector< int > >	value1l (std::vector< std::vector< int > > mvs, std::vector< std::vector< int > > lks, std::vector< std::vector< int > > vecs, std::vector< int > av, std::vector< int > bv)
static void	TimeShow (clock_t t_construct, clock_t t_solve, clock_t t_value, clock_t t_total)
static std::vector< std::vector< int > >	gpl (ideal h, poly a, poly b)
static intvec *	gradedpiece1nl (ideal h, poly a, poly b, int set)
static std::vector< std::vector< int > >	value2l (std::vector< std::vector< int > > mvs, std::vector< std::vector< int > > lks, std::vector< std::vector< int > > mts, std::vector< std::vector< int > > lkts, std::vector< std::vector< int > > vecs, std::vector< int > av, std::vector< int > bv)
static std::vector< std::vector< int > >	gpl2 (ideal h, poly a, poly b)
static intvec *	gradedpiece2nl (ideal h, poly a, poly b)
static ideal	trisets (ideal h)
static std::vector< std::vector< int > >	triface (poly p, int vert)
static ideal	triangulations1 (ideal h, poly p, int vert)
static std::vector< int >	commonedge (poly p, poly q)
static intvec *	edgemat (poly p, poly q)
static std::vector< std::vector< int > >	tetraface (poly p, poly q, int vert)
static ideal	triangulations2 (ideal h, poly p, poly q, int vert)
static std::vector< std::vector< int > >	penface (poly p, poly q, poly g, int vert)
static ideal	triangulations3 (ideal h, poly p, poly q, poly g, int vert)
static int	valency (ideal h, poly p)
static std::vector< std::vector< int > >	vsMinusvs (std::vector< std::vector< int > > vs1, std::vector< std::vector< int > > vs2)
static std::vector< std::vector< int > >	vs_subsets (std::vector< std::vector< int > > vs)
static std::vector< std::vector< int > >	p_constant (ideal Xo, ideal Sigma)
static std::vector< std::vector< int > >	p_change (ideal Sigma)
static std::vector< std::vector< int > >	p_new (ideal Xo, ideal Sigma)
static ideal	c_New (ideal Io, ideal sig)
static std::vector< std::vector< int > >	phi1 (poly a, ideal Sigma)
static std::vector< std::vector< int > >	phi2 (poly a, ideal Xo, ideal Sigma)
static std::vector< std::vector< int > >	links_new (poly a, ideal Xo, ideal Sigma, int vert, int ord)
static int	existIn (poly b, ideal Xs)
static int	isoNum (poly p, ideal I, poly a, poly b)
static int	ifIso (poly p, poly q, poly f, poly g, poly a, poly b)
static ideal	idMinusp (ideal I, poly p)
static std::vector< int >	v_minus (std::vector< int > v1, std::vector< int > v2)
static std::vector< int >	gdegree (poly a, poly b)
static std::vector< std::vector< int > >	star (poly a, ideal h)
static std::vector< std::vector< int > >	boundary (poly a)
static std::vector< std::vector< int > >	stellarsub (poly a, ideal h)
static std::vector< std::vector< int > >	bsubsets_1 (poly b)
static ideal	T_1h (ideal h)
static BOOLEAN	SRideal (leftv res, leftv args)
static BOOLEAN	idcomplement (leftv res, leftv args)
static BOOLEAN	t1h (leftv res, leftv args)
static BOOLEAN	idsr (leftv res, leftv args)
static intvec *	dmat (poly a, poly b)
static BOOLEAN	gd (leftv res, leftv args)
static BOOLEAN	comedg (leftv res, leftv args)
static BOOLEAN	fb (leftv res, leftv args)
static BOOLEAN	pa (leftv res, leftv args)
static BOOLEAN	makeSimplex (leftv res, leftv args)
static BOOLEAN	pb (leftv res, leftv args)
static BOOLEAN	fa (leftv res, leftv args)
static BOOLEAN	fgp (leftv res, leftv args)
static BOOLEAN	fgpl (leftv res, leftv args)
static BOOLEAN	genstt (leftv res, leftv args)
static BOOLEAN	sgp (leftv res, leftv args)
static BOOLEAN	sgpl (leftv res, leftv args)
static BOOLEAN	Links (leftv res, leftv args)
static BOOLEAN	isSim (leftv res, leftv args)
BOOLEAN	nfaces1 (leftv res, leftv args)
static BOOLEAN	nfaces2 (leftv res, leftv args)
static BOOLEAN	nfaces3 (leftv res, leftv args)
static BOOLEAN	eqsolve1 (leftv res, leftv args)
static BOOLEAN	tsets (leftv res, leftv args)
static BOOLEAN	Valency (leftv res, leftv args)
static BOOLEAN	nabvl (leftv res, leftv args)
static BOOLEAN	tnabvl (leftv res, leftv args)
static BOOLEAN	vsIntersec (leftv res, leftv args)
static BOOLEAN	mabvl (leftv res, leftv args)
static BOOLEAN	nabtvl (leftv res, leftv args)
static BOOLEAN	linkn (leftv res, leftv args)
static BOOLEAN	existsub (leftv res, leftv args)
static BOOLEAN	pConstant (leftv res, leftv args)
static BOOLEAN	pChange (leftv res, leftv args)
static BOOLEAN	p_New (leftv res, leftv args)
static BOOLEAN	support (leftv res, leftv args)
static BOOLEAN	bprime (leftv res, leftv args)
static BOOLEAN	psMinusp (leftv res, leftv args)
static BOOLEAN	stellarremain (leftv res, leftv args)
static BOOLEAN	cNew (leftv res, leftv args)
static BOOLEAN	stars (leftv res, leftv args)
static BOOLEAN	stellarsubdivision (leftv res, leftv args)
static BOOLEAN	idModulo (leftv res, leftv args)
static BOOLEAN	idminus (leftv res, leftv args)
static BOOLEAN	isoNumber (leftv res, leftv args)
static BOOLEAN	ifIsomorphism (leftv res, leftv args)
static BOOLEAN	newDegree (leftv res, leftv args)
static BOOLEAN	nonf2f (leftv res, leftv args)
static BOOLEAN	dimsim (leftv res, leftv args)
static BOOLEAN	numdim (leftv res, leftv args)
static void	firstorderdef_setup (SModulFunctions *p)
int SI_MOD_INIT()	cohomo (SModulFunctions *p)

Variables
VAR clock_t	t_begin
VAR clock_t	t_mark
VAR clock_t	t_start
VAR clock_t	t_construct =0
VAR clock_t	t_solve =0
VAR clock_t	t_value =0
VAR clock_t	t_total =0

Function Documentation

b_subsets()

static std::vector< std::vector< int > > b_subsets ( std::vector< int >  vec )

static

Definition at line 496 of file cohomo.cc.

{
  int i,j;
  std::vector<int> bv;
  std::vector<std::vector<int> > vecs;
  for(i=0;i<vec.size();i++)
  {
    bv.push_back(vec[i]);
    vecs.push_back(bv);
    bv.clear();
  }
  //listsprint(vecs);
  for(i=0;i<vecs.size();i++)
  {
    for(j=i+1;j<vecs.size();j++)
    {
      bv=vecUnion(vecs[i], vecs[j]);
      if(!vInvsl(bv,vecs))
        vecs.push_back(bv);
    }
  }
  //listsprint(vecs);
  return(vecs);
}

boundary()

static std::vector< std::vector< int > > boundary ( poly  a )

static

Definition at line 3489 of file cohomo.cc.

{
  std::vector<int> av=support1(a), vec;
  std::vector<std::vector<int> > vecs;
  vecs=b_subsets(av);
  vecs.push_back(vec);
  vecs=vsMinusv(vecs, av);
  return vecs;
}

bprime()

static BOOLEAN bprime ( leftv  res, leftv  args  )

static

Definition at line 4319 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == POLY_CMD))
  {
     poly p= (poly)h->Data();
     res->rtyp =IDEAL_CMD;
     res->data =idMaken(bsubsets_1(p));
  }
  return false;
}

bsubsets_1()

static std::vector< std::vector< int > > bsubsets_1 ( poly  b )

static

Definition at line 3532 of file cohomo.cc.

{
  std::vector<int>  bvs=support1(b), vs;
  std::vector<std::vector<int> > bset;
  for(unsigned i=0;i<bvs.size();i++)
  {
    for(int j=0;j!=i; j++)
    {
      vs.push_back(bvs[j]);
    }
    bset.push_back(vs);
    vs.resize(0);
  }
  return bset;
}

c_New()

static ideal c_New ( ideal  Io, ideal  sig  )

static

Definition at line 3293 of file cohomo.cc.

{
  std::vector<std::vector<int> > vs1=p_constant(Io, sig), vs2=p_change(sig), vs3=p_new(Io, sig), vsig=supports(sig), vs;
  std::vector<int> ev;
  int ednum=vsig.size();
  if(ednum==2)
  {
    vsig.push_back(commonedge(sig->m[0], sig->m[1]));
  }
  else if(ednum==3)
  {
    for(int i=0;i<IDELEMS(sig);i++)
    {
      for(int j=i+1;j<IDELEMS(sig);j++)
      {
        ev=commonedge(sig->m[i], sig->m[j]);
        if(ev.size()==2)
        {
          vsig.push_back(ev);
        }
      }
    }
  }
//PrintS("the first part is:\n");id_print(idMaken(vs1));
//PrintS("the second part is:\n");id_print(idMaken(vsig));
//PrintS("the third part is:\n");id_print(idMaken(vs3));
  vs2=vsMinusvs(vs2, vsig);
//PrintS("the constant part2 is:\n");id_print(idMaken(vs2));
  vs=vsUnion(vs2, vs1);
//PrintS("the constant part is:\n");id_print(idMaken(vs));
  vs=vsUnion(vs, vs3);
//PrintS("the whole part is:\n");id_print(idMaken(vs));
  return(idMaken(vs));
}

canonicalbase()

static std::vector< std::vector< int > > canonicalbase ( int  n )

static

Definition at line 1843 of file cohomo.cc.

{
  std::vector<std::vector<int> > vecs;
  std::vector<int> vec;
  int i,j;
  for(i=0;i<n;i++)
  {
    for(j=0;j<n;j++)
    {
      if(i==j)
        vec.push_back(1);
      else
        vec.push_back(0);
    }
    vecs.push_back(vec);
    vec.clear();
  }
  return vecs;
}

cNew()

static BOOLEAN cNew ( leftv  res, leftv  args  )

static

Definition at line 4368 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
     ideal h1= (ideal)h->Data();
     h   = h->next;
     if((h != NULL)&&(h->Typ() == IDEAL_CMD))
     {
       ideal h2= (ideal)h->Data();
       res->rtyp =IDEAL_CMD;
       res->data =c_New(h1, h2);
     }
  }
  return false;
}

cohomo()

int SI_MOD_INIT() cohomo

(

SModulFunctions *

p

)

Definition at line 4630 of file cohomo.cc.

{
  firstorderdef_setup(p);
  return MAX_TOK;
}

comedg()

static BOOLEAN comedg ( leftv  res, leftv  args  )

static

Definition at line 3694 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == POLY_CMD))
  {
     poly p= (poly)h->Data();
     h   = h->next;
     if((h != NULL)&&(h->Typ() == POLY_CMD))
     {
       poly q= (poly)h->Data();
       res->rtyp =INTVEC_CMD;
       res->data =edgemat(p,q);
     }
  }
  return false;
}

commonedge()

static std::vector< int > commonedge ( poly  p, poly  q  )

static

Definition at line 3042 of file cohomo.cc.

{
  std::vector<int> ev, fv1= support1(p), fv2= support2(q);
  for(unsigned i=0;i<fv1.size();i++)
  {
    if(IsinL(fv1[i], fv2))
      ev.push_back(fv1[i]);
  }
  return ev;
}

complementsimplex()

static ideal complementsimplex ( ideal  h )

static

Definition at line 853 of file cohomo.cc.

{
  int i,j;poly p,e=pOne();
  ideal h1=idInit(1,1), pp, h3;
  for(i=1;i<=rVar(currRing);i++)
  {
    p = pOne(); pSetExp(p, i, 2); pSetm(p); pSetCoeff(p, nInit(1));
    idInsertPoly(h1, p);
  }
  idSkipZeroes(h1);
  ideal h2=idAdd(h,h1);
  pp=scKBase(1,h2);
  h3=idCopy(pp);
  for(j=2;j<=rVar(currRing);j++)
  {
    pp=scKBase(j,h2);
    h3=idAdd(h3,pp);
  }
  idInsertPoly(h3, e);
  idSkipZeroes(h3);
  return (h3);
}

condition1for2()

static bool condition1for2 ( std::vector< int >  pv, std::vector< int >  qv, std::vector< int >  bv  )

static

Definition at line 1751 of file cohomo.cc.

{
  std::vector<int > vec=vecUnion(pv,qv);
  if(vsubset(bv,vec))
  {
    //PrintS("condition1for2 yes\n");
    return true;
  }
  //PrintS("condition1for2 no\n");
  return false;
}

condition2for2()

static bool condition2for2 ( std::vector< std::vector< int > >  hvs, std::vector< int >  pv, std::vector< int >  qv, std::vector< int >  sv, std::vector< int >  av, std::vector< int >  bv  )

static

Definition at line 1764 of file cohomo.cc.

{
  std::vector<int> vec=vecUnion(pv,qv);
  vec=vecUnion(vec,sv);
  if(mabconditionv(hvs,vec,av,bv))
  {
    //PrintS("condition2for2 yes\n");
    return (true);
  }
  //PrintS("condition2for2 no\n");
  return (false);
}

condition2for2nv()

static bool condition2for2nv ( std::vector< std::vector< int > >  hvs, std::vector< int >  pv, std::vector< int >  qv, std::vector< int >  fv  )

static

Definition at line 2410 of file cohomo.cc.

{
  std::vector<int> vec=vecUnion(pv,qv);
  vec=vecUnion(vec,fv);
  if(vInvsl(vec,hvs))
  {
    //PrintS("condition2for2 yes\n");
    return (true);
  }
  //PrintS("condition2for2 no\n");
  return (false);
}

condition3for2()

static bool condition3for2 ( std::vector< std::vector< int > >  hvs, std::vector< int >  pv, std::vector< int >  qv, std::vector< int >  av, std::vector< int >  bv  )

static

Definition at line 1777 of file cohomo.cc.

{
  std::vector<int> v1,v2,v3;
  v1=vecIntersection(pv,qv);//intersection
  v2=vecUnion(pv,qv);
  v2=vecUnion(v2,av);
  v2=vecMinus(v2,bv);
  v3=vecUnion(v1,v2);
  if(vInvsl(v3,hvs))
  {
    //PrintS("condition3for2 yes\n");
    return(true);
  }
  //PrintS("condition3for2 no\n");
  return(false);
}

dim_sim()

static int dim_sim ( ideal  h )

static

Definition at line 876 of file cohomo.cc.

{
  int dim=pTotaldegree(h->m[0]), i;
  for(i=1; i<IDELEMS(h);i++)
  {
    if(dim<pTotaldegree(h->m[i]))
    {
      dim=pTotaldegree(h->m[i]);
    }
  }
  return dim;
}

dimsim()

static BOOLEAN dimsim ( leftv  res, leftv  args  )

static

Definition at line 4546 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
     ideal h1= (ideal)h->Data();
     res->rtyp =INT_CMD;
     res->data =(void *)(long)dim_sim(h1);
  }
  return false;
}

dmat()

static intvec * dmat ( poly  a, poly  b  )

static

Definition at line 3659 of file cohomo.cc.

{
  intvec *m;
  int i;
  std::vector<int> dg=gdegree(a,b);
  int lg=dg.size();
  m=new intvec(lg);
  if(lg!=0)
  {
    m=new intvec(lg);
    for(i=0;i<lg;i++)
    {
        (*m)[i]=dg[i];
    }
  }
  return (m);
}

edgemat()

static intvec * edgemat ( poly  p, poly  q  )

static

Definition at line 3053 of file cohomo.cc.

{
  intvec *m;
  int i;
  std::vector<int> dg=commonedge(p, q);
  int lg=dg.size();
  m=new intvec(lg);
  if(lg!=0)
  {
    m=new intvec(lg);
    for(i=0;i<lg;i++)
    {
        (*m)[i]=dg[i];
    }
  }
  return (m);
}

eli1()

static std::vector< int > eli1 ( std::vector< int >  eq1, std::vector< int >  eq2  )

static

Definition at line 996 of file cohomo.cc.

{
  int i,j;
  std::vector<int> eq;
  if(eq1[0]==eq2[0])
  {
    i=eq1[1];j=eq2[1];
    eq.push_back(i);
    eq.push_back(j);
  }
  else
  {
    eq=eq2;
  }
  return(eq);
}

eli2()

static std::vector< std::vector< int > > eli2 ( int  num, std::vector< int >  bset, std::vector< std::vector< int > >  gset  )

static

Definition at line 1254 of file cohomo.cc.

{
  std::vector<int> badset;
  std::vector<std::vector<int> > goodset, solve;
//PrintS("This is the input bset\n");listprint(bset);
//PrintS("This is the input gset\n");listsprint(gset);
  if(gset.size()!=0)//gset is not empty
  {
   //find all the variables which are zeroes
 
    if(bset.size()!=0)//bset is not empty
    {
      goodset=vAbsorb(bset, gset);//e.g. x_1=0, put x_i into the badset if x_i-x_1=0 or x_1-x_i=0
      int m=goodset.size();
      badset=goodset[m-1];
      goodset.erase(goodset.end());
    }
    else //bset is empty
    {
      goodset=gset;//badset is empty
    }//goodset is already the set which doesn't contain zero variables
//PrintS("This is the badset after absorb \n");listprint(badset);
//PrintS("This is the goodset after absorb \n");listsprint(goodset);
    goodset=soleli1(goodset);//get the triangular form of goodset
//PrintS("This is the goodset after triangulization \n");listsprint(goodset);
    solve=ofindbases(num,badset,goodset);
  }
  else
  {
    solve=ofindbases(num,bset,gset);
  }
//PrintS("This is the solution\n");listsprint(solve);
  return solve;
}

eqsolve1()

static BOOLEAN eqsolve1 ( leftv  res, leftv  args  )

static

Definition at line 4012 of file cohomo.cc.

{
  leftv h=args;int i;
  std::vector<int> bset,bs;
  std::vector<std::vector<int> > gset;
  if((h != NULL)&&(h->Typ() == INT_CMD))
  {
     int n= (int)(long)h->Data();
     h   = h->next;
     if((h != NULL)&&(h->Typ() == IDEAL_CMD))
     {
       ideal bi= (ideal)h->Data();
       h   = h->next;
       if((h != NULL)&&(h->Typ() == IDEAL_CMD))
       {
         ideal gi= (ideal)h->Data();
         for(i=0;i<IDELEMS(bi);i++)
         {
           bs=support1(bi->m[i]);
           if(bs.size()==1)
             bset.push_back(bs[0]);
           else if(bs.size()==0)
             ;
           else
           {
             WerrorS("Errors in T^1 Equations Solving!");
             usleep(1000000);
             assert(false);
           }
 
         }
         gset=supports2(gi);
         res->rtyp =INTVEC_CMD;
         std::vector<std::vector<int> > vecs=eli2(n,bset,gset);
         res->data =Tmat(vecs);
       }
     }
  }
  return false;
}

equmab()

static void equmab ( int  num )

static

Definition at line 1618 of file cohomo.cc.

{
  int i;
  //Print("There are %d new variables for equations solving.\n",num);
  ring r=currRing;
  char** tt;
  coeffs cf=nCopyCoeff(r->cf);
  tt=(char**)omAlloc(num*sizeof(char *));
  for(i=0; i <num; i++)
  {
    tt[i] = (char*)omalloc(10); //if required enlarge it later
    sprintf (tt[i], "t(%d)", i+1);
    tt[i]=omStrDup(tt[i]);
  }
  ring R=rDefault(cf,num,tt,ringorder_lp);
  idhdl h=enterid(omStrDup("Re"),0,RING_CMD,&IDROOT,FALSE);
  IDRING(h)=rCopy(R);
  rSetHdl(h);
}

existIn()

static int existIn ( poly  b, ideal  Xs  )

static

Definition at line 3386 of file cohomo.cc.

{
  std::vector<int> bv=support1(pCopy(b));
  std::vector<std::vector<int> > xvs=supports(idCopy(Xs)), bs=b_subsets(bv);
  bs=vsMinusv(bs, bv);
  for(unsigned i=0;i<bs.size();i++)
  {
    if(!vInvsl(bs[i], xvs))
    {
      return 1;
    }
  }
  return 0;
}

existsub()

static BOOLEAN existsub ( leftv  res, leftv  args  )

static

Definition at line 4244 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == POLY_CMD))
  {
     poly p= (poly)h->Data();
     h   = h->next;
     if((h != NULL)&&(h->Typ() == IDEAL_CMD))
     {
       ideal h1= (ideal)h->Data();
       res->rtyp =INT_CMD;
       res->data =(void *)(long)existIn(p, h1);
     }
   }
  return false;
}

fa()

static BOOLEAN fa ( leftv  res, leftv  args  )

static

Definition at line 3764 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
     ideal h1= (ideal)h->Data();
     h   = h->next;
     if((h != NULL)&&(h->Typ() == POLY_CMD))
     {
       poly q= (poly)h->Data();
       h   = h->next;
       if((h != NULL)&&(h->Typ() == INT_CMD))
       {
         int d= (int)(long)h->Data();
         res->rtyp =IDEAL_CMD;
         res->data =finda(h1,q,d);
       }
     }
  }
  return false;
}

fb()

static BOOLEAN fb ( leftv  res, leftv  args  )

static

Definition at line 3711 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
     ideal h1= (ideal)h->Data();
     res->rtyp =IDEAL_CMD;
     res->data =findb(h1);
  }
  return false;
}

fgp()

static BOOLEAN fgp ( leftv  res, leftv  args  )

static

Definition at line 3786 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
     ideal h1= (ideal)h->Data();
     h   = h->next;
     if((h != NULL)&&(h->Typ() == POLY_CMD))
     {
       poly p= (poly)h->Data();
       h   = h->next;
       if((h != NULL)&&(h->Typ() == POLY_CMD))
       {
         poly q= (poly)h->Data();
         res->rtyp =INTVEC_CMD;
         res->data =gradedpiece1n(h1,p,q);
       }
     }
  }
  return false;
}

fgpl()

static BOOLEAN fgpl ( leftv  res, leftv  args  )

static

Definition at line 3808 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
     ideal h1= (ideal)h->Data();
     h   = h->next;
     if((h != NULL)&&(h->Typ() == POLY_CMD))
     {
       poly p= (poly)h->Data();
       h   = h->next;
       if((h != NULL)&&(h->Typ() == POLY_CMD))
       {
         poly q= (poly)h->Data();
         h   = h->next;
         if((h != NULL)&&(h->Typ() == INT_CMD))
         {
           int d= (int)(long)h->Data();
           res->rtyp =INTVEC_CMD;
           res->data =gradedpiece1nl(h1,p,q,d);
         }
       }
     }
  }
  return false;
}

finda()

static ideal finda ( ideal  h, poly  S, int  ddeg  )

static

Definition at line 934 of file cohomo.cc.

{
  poly e=pOne();
  ideal h2=id_complement(h), aset=idInit(1,1);
  int i,deg1=pTotaldegree(S);
  int tdeg=deg1+ddeg;
  if(tdeg!=0)
  {
    std::vector<int> v,bv=support1(S),in;
    std::vector<std::vector<int> > hvs=supports(h);
    ideal ia=id_MaxIdeal(tdeg, currRing);
    for(i=0;i<IDELEMS(ia);i++)
    {
      v=support1(ia->m[i]);
      in=vecIntersection(v,bv);
      if(vInvsl(v,hvs)&&in.size()==0)
      {
        idInsertPoly(aset, ia->m[i]);
      }
    }
    idSkipZeroes(aset);
  }
  else idInsertPoly(aset,e);
  return(aset);
}

findalpha()

static std::vector< int > findalpha ( std::vector< std::vector< int > >  mv, std::vector< int >  bv  )

static

Definition at line 1927 of file cohomo.cc.

{
  std::vector<int> alset;
  for(unsigned i=0;i<mv.size();i++)
  {
    if(vsubset(bv,mv[i]))
    {
      alset.push_back(i);
    }
  }
  //Print("This is the alpha set, and the subspace is dim-%ld\n",alset.size());
  //listprint(alset);
  return alset;
}

findalphan()

static std::vector< int > findalphan ( std::vector< std::vector< int > >  N, std::vector< int >  tN  )

static

Definition at line 2424 of file cohomo.cc.

{
  int i;std::vector<int> alset,vec;
  for(i=0;i<N.size();i++)
  {
   // vec=N[i];
    if(!IsinL(i,tN))
    {
      alset.push_back(i);
    }
  }
  //listprint(alset);
  return alset;
}

findb()

static ideal findb ( ideal  h )

static

Definition at line 908 of file cohomo.cc.

{
  ideal ib=id_sfmon(h), nonf=id_complement(h), bset=idInit(1,1);
  poly e=pOne();
  int i,j;
  for(i=0;i<IDELEMS(ib);i++)
  {
    for(j=0;j<IDELEMS(nonf);j++)
    {
      if(p_DivisibleBy(ib->m[i],nonf->m[j],currRing))
      {
        idInsertPoly(bset, ib->m[i]);
        break;
      }
    }
  }
  idInsertPoly(bset,e);
  idSkipZeroes(bset);
  return bset;
}

firstorderdef_setup()

static void firstorderdef_setup ( SModulFunctions *  p )

static

Definition at line 4577 of file cohomo.cc.

{
  p->iiAddCproc("","mg",FALSE,idsr);
  p->iiAddCproc("","gd",FALSE,gd);
  p->iiAddCproc("","findbset",FALSE,fb);
  p->iiAddCproc("","findaset",FALSE,fa);
  p->iiAddCproc("","fgp",FALSE,fgp);
  p->iiAddCproc("","fgpl",FALSE,fgpl);
  p->iiAddCproc("","idcomplement",FALSE,idcomplement);
  p->iiAddCproc("","genst",FALSE,genstt);
  p->iiAddCproc("","sgp",FALSE,sgp);
  p->iiAddCproc("","sgpl",FALSE,sgpl);
  p->iiAddCproc("","Links",FALSE,Links);
  p->iiAddCproc("","eqsolve1",FALSE,eqsolve1);
  p->iiAddCproc("","pb",FALSE,pb);
  p->iiAddCproc("","pa",FALSE,pa);
  p->iiAddCproc("","makeSimplex",FALSE,makeSimplex);
  p->iiAddCproc("","isSim",FALSE,isSim);
  p->iiAddCproc("","nfaces1",FALSE,nfaces1);
  p->iiAddCproc("","nfaces2",FALSE,nfaces2);
  p->iiAddCproc("","nfaces3",FALSE,nfaces3);
  p->iiAddCproc("","comedg",FALSE,comedg);
  p->iiAddCproc("","tsets",FALSE,tsets);
  p->iiAddCproc("","valency",FALSE,Valency);
  p->iiAddCproc("","nab",FALSE,nabvl);
  p->iiAddCproc("","tnab",FALSE,tnabvl);
  p->iiAddCproc("","mab",FALSE,mabvl);
  p->iiAddCproc("","SRideal",FALSE,SRideal);
  p->iiAddCproc("","Linkn",FALSE,linkn);
  p->iiAddCproc("","Existb",FALSE,existsub);
  p->iiAddCproc("","pConstant",FALSE,pConstant);
  p->iiAddCproc("","pChange",FALSE,pChange);
  p->iiAddCproc("","pNew",FALSE,p_New);
  p->iiAddCproc("","pSupport",FALSE,support);
  p->iiAddCproc("","psMinusp",FALSE,psMinusp);
  p->iiAddCproc("","cNew",FALSE,cNew);
  p->iiAddCproc("","isoNumber",FALSE,isoNumber);
  p->iiAddCproc("","vsInsec",FALSE,vsIntersec);
  p->iiAddCproc("","getnabt",FALSE,nabtvl);
  p->iiAddCproc("","idmodulo",FALSE,idModulo);
  p->iiAddCproc("","ndegree",FALSE,newDegree);
  p->iiAddCproc("","nonf2f",FALSE,nonf2f);
  p->iiAddCproc("","ifIsom",FALSE,ifIsomorphism);
  p->iiAddCproc("","stellarsubdivision",FALSE,stellarsubdivision);
  p->iiAddCproc("","star",FALSE,stars);
  p->iiAddCproc("","numdim",FALSE,numdim);
  p->iiAddCproc("","dimsim",FALSE,dimsim);
  p->iiAddCproc("","bprime",FALSE,bprime);
  p->iiAddCproc("","remainpart",FALSE,stellarremain);
  p->iiAddCproc("","idminus",FALSE,idminus);
  p->iiAddCproc("","time1",FALSE,t1h);
}

freevars()

static std::vector< int > freevars ( int  n, std::vector< int >  bset, std::vector< std::vector< int > >  gset  )

static

Definition at line 1085 of file cohomo.cc.

{
  int ql=gset.size(), bl=bset.size(), i;
  std::vector<int> mvar, fvar;
  for(i=0;i<bl;i++)
  {
    mvar.push_back(bset[i]);
  }
  for(i=0;i<ql;i++)
  {
    mvar.push_back(gset[i][0]);
  }
  for(i=1;i<=n;i++)
  {
    if(!IsinL(i,mvar))
    {
      fvar.push_back(i);
    }
  }
  return fvar;
}

fvarsvalue()

static std::vector< int > fvarsvalue ( int  vnum, std::vector< int >  fvars  )

static

Definition at line 1108 of file cohomo.cc.

{
  int i;
  std::vector<int> fset=fvars;
  for(i=0;i<fset.size();i++)
  {
    if(fset[i]==vnum)
    {
      fset.erase(fset.begin()+i);
      break;
    }
  }
  return fset;
}

gd()

static BOOLEAN gd ( leftv  res, leftv  args  )

static

Definition at line 3677 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == POLY_CMD))
  {
     poly p= (poly)h->Data();
     h   = h->next;
     if((h != NULL)&&(h->Typ() == POLY_CMD))
     {
       poly q= (poly)h->Data();
       res->rtyp =INTVEC_CMD;
       res->data =dmat(p,q);
     }
  }
  return false;
}

gdegree()

static std::vector< int > gdegree ( poly  a, poly  b  )

static

Definition at line 3456 of file cohomo.cc.

{
  int i;
  std::vector<int> av,bv;
  for(i=1;i<=currRing->N;i++)
  {
    av.push_back(pGetExp(a,i));
    bv.push_back(pGetExp(b,i));
  }
  std::vector<int> vec=v_minus(av,bv);
  //PrintS("The degree is:\n");
  //listprint(vec);
  return vec;
}

gensindex()

static std::vector< int > gensindex ( ideal  M, ideal  ids  )

static

Definition at line 2260 of file cohomo.cc.

{
  int i;
  std::vector<int> vec,index;
  if(!idIs0(M))
  {
    std::vector<std::vector<int> > vecs=supports(ids);
    for(i=0;i<IDELEMS(M);i++)
    {
      vec=support1(M->m[i]);
      if(vInvsl(vec,vecs))
        index.push_back(i);
    }
  }
  return (index);
}

genst()

static ideal genst ( ideal  h, poly  a, poly  b  )

static

Definition at line 2511 of file cohomo.cc.

{
  std::vector<std::vector<int> > hvs=supports(h),mv,mts;
  std::vector<int> av=support1(a), bv=support1(b);
  mv=Mabv(h,a,b);
  mts=mabtv(hvs,mv,av,bv);
  std::vector<std::vector<poly> > pvs=idMakei(mv,mts);
  ideal gens=idInit(1,1);
  for(unsigned i=0;i<pvs.size();i++)
  {
    idInsertPoly(gens,pvs[i][0]);
    idInsertPoly(gens,pvs[i][1]);
  }
  idSkipZeroes(gens);
  return (gens);
}

genstt()

static BOOLEAN genstt ( leftv  res, leftv  args  )

static

Definition at line 3835 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
     ideal h1= (ideal)h->Data();
     h   = h->next;
     if((h != NULL)&&(h->Typ() == POLY_CMD))
     {
       poly p= (poly)h->Data();
       h   = h->next;
       if((h != NULL)&&(h->Typ() == POLY_CMD))
       {
         poly q= (poly)h->Data();
         res->rtyp =IDEAL_CMD;
         res->data =genst(h1,p,q);
       }
     }
  }
  return false;
}

getpresolve()

static ideal getpresolve ( ideal  h )

static

Definition at line 1796 of file cohomo.cc.

{
  //ring r=currRing;
  //assume (LIB "presolve.lib");
  sleftv a;a.Init();
  a.rtyp=IDEAL_CMD;a.data=(void*)h;
  idhdl solve=ggetid("elimlinearpart");
  if(solve==NULL)
  {
    WerrorS("presolve.lib are not loaded!");
    return NULL;
  }
  BOOLEAN sl=iiMake_proc(solve,NULL,&a);
  //PrintS("no errors here\n");
  if(sl)
  {
    WerrorS("error in solve!");
  }
  lists L=(lists) iiRETURNEXPR.Data();
  ideal re=(ideal)L->m[4].CopyD();
  //iiRETURNEXPR.CleanUp();
  iiRETURNEXPR.Init();
  //PrintS("no errors here\n");
  //idSkipZeroes(re);
  //id_print(re);
  return re;
}

getvector()

static std::vector< std::vector< int > > getvector ( ideal  h, int  n  )

static

Definition at line 1863 of file cohomo.cc.

{
  std::vector<int> vec;
  std::vector<std::vector<int> > vecs;
  ideal h2=idCopy(h);
  if(!idIs0(h))
  {
    ideal h1=getpresolve(h2);
    poly q,e=pOne();
    int lg=IDELEMS(h1),n,i,j,t;
    std::vector<int> fvar=numfree(h1);
    n=fvar.size();
    if(n==0)
    {
      vec=make0(IDELEMS(h1));vecs.push_back(vec);//listsprint(vecs);
    }
    else
    {
      for(t=0;t<n;t++)
      {
        vec.clear();
        for(i=0;i<lg;i++)
        {
          q=pCopy(h1->m[i]);
          //pWrite(q);
          if(q==0)
          {
            vec.push_back(0);
          }
          else
          {
            q=p_Subst(q, fvar[t], e,currRing);
            //Print("the %dth variable was substituted by 1:\n",fvar[t]);
            //pWrite(q);
            for(j=0;j<n;j++)
            {
              //Print("the %dth variable was substituted by 0:\n",fvar[j]);
              q=p_Subst(q, fvar[j],0,currRing);
              //pWrite(q);
            }
            if(q==0)
            {
              vec.push_back(0);
            }
            else
            {
              vec.push_back(n_Int(pGetCoeff(q),currRing->cf));
            }
          }
        }
        //listprint(vec);
        vecs.push_back(vec);
      }
    }
  }
  else
  {vecs=canonicalbase(n);}
  //listsprint(vecs);
  return vecs;
}

gpl()

static std::vector< std::vector< int > > gpl ( ideal  h, poly  a, poly  b  )

static

Definition at line 2704 of file cohomo.cc.

{
  int i,j,co;
  std::vector<std::vector<int> > hvs=supports(h),sbv,nv,mv,good,solve;
  std::vector<int> av=support1(a), bv=support1(b),index,bad,tnv;
  ideal sub=psubset(b);
  sbv=supports(sub);
  nv=Nabv(hvs,av,bv);
  mv=Mabv(h,a,b);
  ideal M=idMaken(mv);
  index = gensindex(M, idsrRing(h));
  int n=nv.size();
  ring r=currRing;
  t_begin=clock();
  if(n > 0)
  {
    tnv=tnab(hvs,nv,sbv);
    for(i=0;i<tnv.size();i++)
    {
      co=tnv[i];
      bad.push_back(co+1);
    }
    for(i=0;i<n;i++)
    {
      for(j=i+1;j<n;j++)
      {
        if(nabtconditionv(hvs,nv[i],nv[j]))
        {
          good=listsinsertlist(good,i+1,j+1);
        }
        else
        {
          ;
        }
      }
    }
    t_construct=t_construct+clock()-t_begin;
    t_begin=clock();
    solve=eli2(n,bad,good);
    t_solve=t_solve+clock()-t_begin;
    if(bv.size()!=1)
    {;
    }
    else
    {
      std::vector<int> su=make1(n);
      std::vector<std::vector<int> > suu;
      suu.push_back(su);
      equmab(n);
      solve=vecqring(solve,suu);
      rChangeCurrRing(r);
    }
  }
  else
  {
    solve.clear();
  }
  //listsprint(solve);
  //sl->show(0,0);
  return solve;
}

gpl2()

static std::vector< std::vector< int > > gpl2 ( ideal  h, poly  a, poly  b  )

static

Definition at line 2845 of file cohomo.cc.

{
  int i,j,t,n;
  std::vector<std::vector<int> > hvs=supports(h),sbv,nv,mv,mts,vecs,vars,ntvs,solve;
  std::vector<int> av=support1(a), bv=support1(b),vec,var,tnv;
  ideal sub=psubset(b);
  sbv=supports(sub);
  nv=Nabv(hvs,av,bv);
  n=nv.size();
  tnv=tnab(hvs,nv,sbv);
  ring r=currRing;
  mv=Mabv(h,a,b);
  mts=mabtv(hvs,mv,av,bv);
  if(n>0)
  {
    ntvs=nabtv( hvs, nv, av, bv);
    int l=ntvs.size();
    if(l>0)
    {
      for(int t0=0;t0<l;t0++)
      {
        i=ntvs[t0][0];
        j=ntvs[t0][1];
        if(tNab(hvs,nv[i],sbv)&&tNab(hvs,nv[j],sbv))//condition 1
        {
          vec=makeequation(t0+1,0,0);
          vecs.push_back(vec);
          vec.clear();
        }
        for(int t1=t0+1;t1<ntvs.size();t1++)
        {
          for(int t2=t1+1;t2<ntvs.size();t2++)
          {
            if(ntvs[t0][0]==ntvs[t1][0]&&ntvs[t1][1]==ntvs[t2][1]&&ntvs[t0][1]==ntvs[t2][0])
            {
              i=ntvs[t0][0];
              j=ntvs[t0][1];
              t=ntvs[t1][1];
              if(condition2for2nv(hvs,nv[i],nv[j],nv[t]))
              {
                vec=makeequation(t0+1,t1+1,t2+1);
                vecs.push_back(vec);
                vec.clear();
              }
            }
          }
        }
      }
      if(n==1) {l=1;}
      equmab(l);
      ideal id_re=idMake3(vecs);
      std::vector<std::vector<int> > re=getvector(id_re,l);
      rChangeCurrRing(r);
      std::vector<std::vector<int> > sub=subspacetn(nv, tnv,ntvs);
      equmab(l);
      solve=vecqring(re, sub);
      rChangeCurrRing(r);
    }
    else
    {
      solve.clear();
    }
  }
  else
    solve.clear();
  return solve;
}

gradedpiece1()

static void gradedpiece1 ( ideal  h, poly  a, poly  b  )

static

Definition at line 1691 of file cohomo.cc.

{
  int i,j,m;
  ideal sub=psubset(b);
  std::vector<int> av=support1(a), bv=support1(b), bad, vv;
  std::vector<std::vector<int> > hvs=supports(h), sbv=supports(sub), mv=Mabv(h,a,b),good;
  m=mv.size();
  ring r=currRing;
  if( m > 0 )
  {
    for(i=0;i<m;i++)
    {
      if(!vsubset(bv,mv[i]))
      {
        bad.push_back(i+1);
      }
    }
    for(i=0;i<m;i++)
    {
      for(j=i+1;j<m;j++)
      {
        vv=vecUnion(mv[i],mv[j]);
        if(mabconditionv(hvs,vv,av,bv))
        {
          good=listsinsertlist(good,i+1,j+1);
        }
        else
        {
          //PrintS("They are not in Mabt!\n");
          ;
        }
      }
    }
    std::vector<std::vector<int> > solve=eli2(m,bad,good);
    if(bv.size()!=1)
    {
      //PrintS("This is the solution of coefficients:\n");
      listsprint(solve);
    }
     else
    {
      std::vector<int> su=subspace1(mv,bv);
      //PrintS("This is the solution of subspace:\n");
      //listprint(su);
      std::vector<std::vector<int> > suu;
      suu.push_back(su);
      equmab(solve[0].size());
      std::vector<std::vector<int> > solves=vecqring(solve,suu);
      //PrintS("This is the solution of coefficients:\n");
      listsprint(solves);
      rChangeCurrRing(r);
    }
  }
  else
  {
    PrintS("No element considered!\n");
  }
}

gradedpiece1n()

static intvec * gradedpiece1n ( ideal  h, poly  a, poly  b  )

static

Definition at line 2313 of file cohomo.cc.

{
  int i,j,co,n;
  std::vector<std::vector<int> > hvs=supports(h),mv=Mabv(h,a,b),sbv,nv,good,solve;
  std::vector<int> av=support1(a), bv=support1(b), bad, tnv, index;
  ideal sub=psubset(b),M;
  sbv=supports(sub);
  nv=Nabv(hvs,av,bv);
  M=idMaken(mv);
  index = gensindex(M, idsrRing(h));
  n=nv.size();
  ring r=currRing;
  if(n > 0)
  {
    tnv=tnab(hvs,nv,sbv);
    for(i=0;i<tnv.size();i++)
    {
      co=tnv[i];
      bad.push_back(co+1);
    }
    for(i=0;i<n;i++)
    {
      for(j=i+1;j<n;j++)
      {
        if(nabtconditionv(hvs,nv[i],nv[j]))
        {
          good=listsinsertlist(good,i+1,j+1);
        }
        else
        {
          ;
        }
      }
    }
    solve=eli2(n,bad,good);
    if(bv.size()!=1)
    {;
      //PrintS("This is the solution of coefficients:\n");
      //listsprint(solve);
    }
    else
    {
      std::vector<int> su=make1(n);
      std::vector<std::vector<int> > suu;
      suu.push_back(su);
      equmab(n);
      solve=vecqring(solve,suu);
      //PrintS("This is the solution of coefficients:\n");
      //listsprint(solve);
      rChangeCurrRing(r);
    }
    solve=value1(mv,nv,solve,av,bv);
  }
  else
  {
    //PrintS("No element considered here!\n");
    solve.clear();
  }
  //PrintS("This is the solution of final coefficients:\n");
  //listsprint(solve);
  solve=minisolve(solve,index);
  intvec *sl=Tmat(solve);
  //sl->show(0,0);
  return sl;
}

gradedpiece1nl()

static intvec * gradedpiece1nl ( ideal  h, poly  a, poly  b, int  set  )

static

Definition at line 2768 of file cohomo.cc.

{
  t_start=clock();
  poly e=pOne();
  std::vector<int> av=support1(a),bv=support1(b),index, em;
  std::vector<std::vector<int> > solve, hvs=supports(h), lks=links(a,h),  mv=Mabv(h,a,b), nvl;
  ideal id_links=idMaken(lks);
  ideal M=idMaken(mv);
  index = gensindex(M, idsrRing(h));
  solve=gpl(id_links,e,b);
  t_mark=clock();
  nvl=Nabv(lks,em,bv);
  solve=value1l(mv, nvl , solve, av, bv);
  if(set==1)
  {
    solve=minisolve(solve,index);
  }
  intvec *sl=Tmat(solve);
  t_value=t_value+clock()-t_mark;
  t_total=t_total+clock()-t_start;
  return sl;
}

gradedpiece2()

static void gradedpiece2 ( ideal  h, poly  a, poly  b  )

static

Definition at line 2006 of file cohomo.cc.

{
  int t0,t1,t2,i,j,t,m;
  ideal sub=psubset(b);
  ring r=rCopy(currRing);
  std::vector<std::vector<int> > hvs=supports(h), mv=Mabv(h,a,b), mts, vecs,vars;
  std::vector<int> av=support1(a), bv=support1(b), vec,var;
  mts=mabtv(hvs,mv,av,bv);
  PrintS("The homomorphism should map onto:\n");
  lpsprint(idMakei(mv,mts));
  m=mv.size();
  if(m > 0)
  {
    vars=mabtv(hvs,mv,av,bv);
    int vn=vars.size();
    for(t0=0;t0<vars.size();t0++)
    {
      i=vars[t0][0];
      j=vars[t0][1];
      if(!condition1for2(mv[i],mv[j],bv))//condition 1
      {
        //PrintS("And they satisfy the condition 1.\n");
        vec=makeequation(t0+1,0,0);
        //PrintS("So the equation:\n");
        //pWrite(p);
        //PrintS("holds.\n");
        vecs.push_back(vec);
        vec.clear();
      }
      if(condition3for2(hvs,mv[i],mv[j],av,bv))//condition 3
      {
        //PrintS("And they satisfy the condition 3.\n");
        vec=makeequation(t0+1,0,0);
        //PrintS("So the equation: \n");
        //pWrite(p);
        //PrintS("holds.\n");
        vecs.push_back(vec);
        vec.clear();
      }
      for(t1=t0+1;t1<vars.size();t1++)
      {
        for(t2=t1+1;t2<vars.size();t2++)
        {
          if(vars[t0][0]==vars[t1][0]&&vars[t1][1]==vars[t2][1]&&vars[t0][1]==vars[t2][0])
          {
            i=vars[t0][0];
            j=vars[t0][1];
            t=vars[t1][1];
            if(condition2for2(hvs,mv[i],mv[j],mv[t],av,bv))//condition 2
            {
              vec=makeequation(t0+1,t1+1,t2+1);
              vecs.push_back(vec);
              vec.clear();
            }
          }
        }
      }
    }
    //PrintS("this is EQUATIONS:\n");
    //listsprint(vecs);
    equmab(vn);
    ideal id_re=idMake3(vecs);
    //id_print(id_re);
    std::vector<std::vector<int> > re=getvector(id_re,vn);
    PrintS("this is the solution for ideal :\n");
    listsprint(re);
    rChangeCurrRing(r);
    std::vector<std::vector<int> > sub=subspacet(mv, bv,vars);
    PrintS("this is the solution for subspace:\n");
    listsprint(sub);
    equmab(vn);
    std::vector<std::vector<int> > solve=vecqring(re, sub);
    PrintS("This is the solution of coefficients:\n");
    listsprint(solve);
    rChangeCurrRing(r);
  }
  else
  {
    PrintS("No element considered!");
  }
}

gradedpiece2n()

static intvec * gradedpiece2n ( ideal  h, poly  a, poly  b  )

static

Definition at line 2528 of file cohomo.cc.

{
  int i,j,t,n;
  std::vector<std::vector<int> > hvs=supports(h),nv,mv,mts,sbv,vecs,vars,ntvs,solve;
  std::vector<int> av=support1(a), bv=support1(b),tnv,vec,var;
  ideal sub=psubset(b);
  sbv=supports(sub);
  nv=Nabv(hvs,av,bv);
  n=nv.size();
  tnv=tnab(hvs,nv,sbv);
  ring r=currRing;
  mv=Mabv(h,a,b);
  mts=mabtv(hvs,mv,av,bv);
  //PrintS("The relations are:\n");
  //listsprint(mts);
  //PrintS("The homomorphism should map onto:\n");
  //lpsprint(idMakei(mv,mts));
  if(n>0)
  {
    ntvs=nabtv( hvs, nv, av, bv);
  //PrintS("The current homomorphism map onto###:\n");
  //lpsprint(idMakei(nv,ntvs));
    int l=ntvs.size();
    for(int t0=0;t0<l;t0++)
    {
      i=ntvs[t0][0];
      j=ntvs[t0][1];
      if(tNab(hvs,nv[i],sbv)&&tNab(hvs,nv[j],sbv))//condition 1
      {
        vec=makeequation(t0+1,0,0);
        vecs.push_back(vec);
        vec.clear();
      }
      for(int t1=t0+1;t1<ntvs.size();t1++)
      {
        for(int t2=t1+1;t2<ntvs.size();t2++)
        {
          if(ntvs[t0][0]==ntvs[t1][0]&&ntvs[t1][1]==ntvs[t2][1]&&ntvs[t0][1]==ntvs[t2][0])
          {
            i=ntvs[t0][0];
            j=ntvs[t0][1];
            t=ntvs[t1][1];
            if(condition2for2nv(hvs,nv[i],nv[j],nv[t]))
            {
              vec=makeequation(t0+1,t1+1,t2+1);
              vecs.push_back(vec);
              vec.clear();
            }
          }
        }
      }
    }
    //PrintS("this is EQUATIONS:\n");
    //listsprint(vecs);
    if(n==1) l=1;
    equmab(l);
    ideal id_re=idMake3(vecs);
    //id_print(id_re);
    std::vector<std::vector<int> > re=getvector(id_re,l);
    //PrintS("this is the solution for ideal :\n");
    //listsprint(re);
    rChangeCurrRing(r);
    std::vector<std::vector<int> > sub=subspacetn(nv, tnv,ntvs);
     //PrintS("this is the solution for subspace:\n");
    //listsprint(sub);
    equmab(l);
    solve=vecqring(re, sub);
    //PrintS("This is the solution of coefficients:\n");
    //listsprint(solve);
    rChangeCurrRing(r);
    solve=value2(mv,nv,mts,ntvs,solve,av,bv);
  }
  else
    solve.clear();
  intvec *sl=Tmat(solve);
  return sl;
}

gradedpiece2nl()

static intvec * gradedpiece2nl ( ideal  h, poly  a, poly  b  )

static

Definition at line 2913 of file cohomo.cc.

{
  poly e=pOne();
  std::vector<int> av=support1(a), bv=support1(b), em;
  std::vector<std::vector<int> > hvs=supports(h), mv=Mabv(h,a,b),mts,solve,lks,nvl,ntsl;
  mts=mabtv(hvs,mv,av,bv);
  lks=links(a,h);
  ideal id_links=idMaken(lks);
//PrintS("This is the links of a:\n"); id_print(id_links);
  nvl=Nabv(lks,em,bv);
//PrintS("This is the N set:\n"); id_print(idMaken(nvl));
  ntsl=nabtv(lks,nvl,em,bv);
//PrintS("This is N^2:\n"); listsprint(ntsl);
  solve=gpl2(id_links,e,b);
//PrintS("This is pre solution of N:\n"); listsprint(solve);
  if(solve.size() > 0)
  {
    solve=value2l(mv, nvl, mts, ntsl, solve, av, bv);
  }
//PrintS("This is solution of N:\n"); listsprint(solve);
  intvec *sl=Tmat(solve);
  return sl;
}

id_complement()

static ideal id_complement ( ideal  h )

static

Definition at line 698 of file cohomo.cc.

{
  int j, vert=idvert(h);
  ideal i1=id_sfmon(h);
  ideal i3=idInit(1,1);
  poly p;
  for(j=0;j<IDELEMS(i1);j++)
  {
    p=pCopy(i1->m[j]);
    if(pvert(p)<=vert)
    {
      idInsertPoly(i3, p);
    }
  }
  ideal i2=idMinus(i3,h);
  idSkipZeroes(i2);
  return (i2);
}

id_maxdeg()

static int id_maxdeg ( ideal  h )

static

Definition at line 744 of file cohomo.cc.

{
  int i,max;
  max=pTotaldegree(h->m[0]);
  for(i=1;i<IDELEMS(h);i++)
  {
    if(pTotaldegree(h->m[i]) > max)
      max=pTotaldegree(h->m[i]);
  }
  return (max);
}

id_print()

static void id_print ( ideal  h )

static

Definition at line 84 of file cohomo.cc.

{
  int i;
  for(i=0;i<IDELEMS(h);i++)
  {
    Print(" [%d]\n",i+1);
    pWrite(h->m[i]);
    PrintLn();
  }
}

id_sfmon()

static ideal id_sfmon ( ideal  h )

static

Definition at line 679 of file cohomo.cc.

{
  ideal asfmons,sfmons,mons;
  int j, vert=idvert(h);
  mons=id_MaxIdeal(1, currRing);
  asfmons=sfreemon(mons,1);
  for(j=2;j<=vert;j++)
  {
    mons=id_MaxIdeal(j, currRing);
    sfmons=sfreemon(mons,j);
    asfmons=id_Add(asfmons,sfmons,currRing);
  }
  return asfmons;
}

idadda()

static ideal idadda ( ideal  h1, ideal  h2  )

static

Definition at line 808 of file cohomo.cc.

{
  ideal h=idInit(1,1);
  for(int i=0;i<IDELEMS(h1);i++)
  {
    if(!IsInX(h1->m[i],h))
    {
      idInsertPoly(h, h1->m[i]);
    }
  }
  for(int i=0;i<IDELEMS(h2);i++)
  {
    if(!IsInX(h2->m[i],h))
    {
      idInsertPoly(h, h2->m[i]);
    }
  }
  idSkipZeroes(h);
  return h;
}

idcomplement()

static BOOLEAN idcomplement ( leftv  res, leftv  args  )

static

Definition at line 3612 of file cohomo.cc.

{
  leftv h=args;
   if((h != NULL)&&(h->Typ() == IDEAL_CMD))
   {
     ideal hh=(ideal)h->Data();
     ideal h2= id_complement(hh);
     res->rtyp =IDEAL_CMD;
     res->data =h2;
   }
  return false;
}

idMake()

static ideal idMake ( std::vector< std::vector< int > >  vecs )

static

Definition at line 358 of file cohomo.cc.

{
  int lv=vecs.size(), i;
  poly p;
  ideal id_re=idInit(1,1);
  for(i=0;i<lv;i++)
  {
    p=pMake(vecs[i]);
    idInsertPoly(id_re, p);
  }
  idSkipZeroes(id_re);
  return id_re;
}

idMake3()

static ideal idMake3 ( std::vector< std::vector< int > >  vecs )

static

Definition at line 1601 of file cohomo.cc.

{
  ideal id_re=idInit(1,1);
  poly p;
  int i,lv=vecs.size();
  for(i=0;i<lv;i++)
  {
    p=pMake3(vecs[i]);
    idInsertPoly(id_re, p);
  }
  idSkipZeroes(id_re);
  return id_re;
}

idMakei()

static std::vector< std::vector< poly > > idMakei ( std::vector< std::vector< int > >  mv, std::vector< std::vector< int > >  vecs  )

static

Definition at line 1671 of file cohomo.cc.

{
  int i,lv=vecs.size();
  std::vector<std::vector<poly> > re;
  std::vector<poly> h;
  for(i=0;i<lv;i++)
  {
    h=pMakei(mv,vecs[i]);
    re.push_back(h);
  }
  //PrintS("This is the metrix M:\n");
  //listsprint(vecs);
  //PrintS("the ideal according to metrix M is:\n");
  return re;
}

idMaken()

static ideal idMaken ( std::vector< std::vector< int > >  vecs )

static

Definition at line 479 of file cohomo.cc.

{
  ideal id_re=idInit(1,1);
  poly p;
  int i,lv=vecs.size();
  for(i=0;i<lv;i++)
  {
    p=pMaken(vecs[i]);
    idInsertPoly(id_re, p);
  }
  idSkipZeroes(id_re);
  //id_print(id_re);
  return id_re;
}

idMinus()

static ideal idMinus ( ideal  h1, ideal  h2  )

static

Definition at line 617 of file cohomo.cc.

{
  ideal h=idInit(1,1);
  int i,j,eq=0;
  for(i=0;i<IDELEMS(h1);i++)
  {
    eq=0;
    for(j=0;j<IDELEMS(h2);j++)
    {
      if(p_EqualPolys(pCopy(h1->m[i]),pCopy(h2->m[j]), currRing))
      {
        eq=1;
        break;
      }
    }
    if(eq==0)
    {
      idInsertPoly(h, pCopy(h1->m[i]));
    }
  }
  idSkipZeroes(h);
  return h;
}

idminus()

static BOOLEAN idminus ( leftv  res, leftv  args  )

static

Definition at line 4436 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
     ideal h1= (ideal)h->Data();
     h   = h->next;
     if((h != NULL)&&(h->Typ() == IDEAL_CMD))
     {
       ideal h2= (ideal)h->Data();
       res->rtyp =IDEAL_CMD;
       res->data =idMinus(h1, h2);
     }
  }
  return false;
}

idMinusp()

static ideal idMinusp ( ideal  I, poly  p  )

static

Definition at line 3429 of file cohomo.cc.

{
  ideal h=idInit(1,1);
  int i;
  for(i=0;i<IDELEMS(I);i++)
  {
    if(!p_EqualPolys(I->m[i], p, currRing))
    {
      idInsertPoly(h, pCopy(I->m[i]));
    }
  }
  idSkipZeroes(h);
  return h;
}

idmodulo()

static ideal idmodulo ( ideal  h1, ideal  h2  )

static

Definition at line 375 of file cohomo.cc.

{
  ideal gb=kStd(h2,NULL,testHomog,NULL,NULL,0,0,NULL);
  idSkipZeroes(gb);
  ideal idq=kNF(gb,NULL,h1);
  idSkipZeroes(idq);
  return idq;
}

idModulo()

static BOOLEAN idModulo ( leftv  res, leftv  args  )

static

Definition at line 4419 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
     ideal h1= (ideal)h->Data();
     h   = h->next;
     if((h != NULL)&&(h->Typ() == IDEAL_CMD))
     {
       ideal h2= (ideal)h->Data();
       res->rtyp =IDEAL_CMD;
       res->data =idmodulo(h1, h2);
     }
  }
  return false;
}

idsr()

static BOOLEAN idsr ( leftv  res, leftv  args  )

static

Definition at line 3637 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
     ideal h1= (ideal)h->Data();
     h   = h->next;
     if((h != NULL)&&(h->Typ() == POLY_CMD))
     {
       poly p= (poly)h->Data();
       h   = h->next;
       if((h != NULL)&&(h->Typ() == POLY_CMD))
       {
         poly q= (poly)h->Data();
         res->rtyp =IDEAL_CMD;
         res->data =mingens(h1,p,q);
       }
     }
  }
  return false;
}

idsrRing()

static ideal idsrRing ( ideal  h )

static

Definition at line 758 of file cohomo.cc.

{
  int i,n;
  ideal pp,qq,rsr,ppp,hc=idCopy(h);
  for(i=1;i<=rVar(currRing);i++)
  {
    pp=sfreemon(hc,i);
    pp=scKBase(i,pp);//quotient ring (R/I_i)_i
    if(!idIs0(pp))
    {
      pp=sfreemon(pp,i);
      rsr=pp;
      //Print("This is the first quotient generators %d:\n",i);
      //id_print(rsr);
      break;
    }
  }
  for(n=i+1;n<=rVar(currRing);n++)
  {
    qq=sfreemon(hc,n);
    pp=qringadd(qq,rsr,n);
    ppp=sfreemon(pp,n);
    rsr=idAdd(rsr,ppp);
  }
  idSkipZeroes(rsr);
  return rsr;
}

idvert()

static int idvert ( ideal  h )

static

Definition at line 522 of file cohomo.cc.

{
  int i, j, vert=0;
  if(idIs0(h))
    return vert;
  for(i=currRing->N;i>0;i--)
  {
    for(j=0;j<IDELEMS(h);j++)
    {
      if(pGetExp(h->m[j],i)>0)
      {
        vert=i;
        return vert;
      }
    }
  }
  return vert;
}

ifIso()

static int ifIso ( poly  p, poly  q, poly  f, poly  g, poly  a, poly  b  )

static

Definition at line 3418 of file cohomo.cc.

{
  std::vector<int> va=support1(a), vb=support1(b), vp=support1(p),  vq=support1(q), vf=support1(f), vg=support1(g);
  std::vector<int>   v1=phimagel(vp, va, vb), v2=phimagel(vq, va, vb), v3=phimagel(vf, va, vb), v4=phimagel(vg, va, vb);
  if((vEvl(v1, v3)&& vEvl(v2,v4))||(vEvl(v1, v4)&& vEvl(v2,v3)) )
  {
    return (1);
  }
  return (0);
}

ifIsomorphism()

static BOOLEAN ifIsomorphism ( leftv  res, leftv  args  )

static

Definition at line 4480 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == POLY_CMD))
  {
     poly p= (poly)h->Data();
     h   = h->next;
     if((h != NULL)&&(h->Typ() == POLY_CMD))
     {
       poly q= (poly)h->Data();
       h   = h->next;
       if((h != NULL)&&(h->Typ() == POLY_CMD))
       {
         poly f= (poly)h->Data();
         h   = h->next;
         if((h != NULL)&&(h->Typ() == POLY_CMD))
         {
           poly g= (poly)h->Data();
           h   = h->next;
           if((h != NULL)&&(h->Typ() == POLY_CMD))
           {
            poly a= (poly)h->Data();
             h   = h->next;
             if((h != NULL)&&(h->Typ() == POLY_CMD))
             {
               poly b= (poly)h->Data();
               res->rtyp =INT_CMD;
               res->data =(void *)(long)ifIso(p,q,f,g, a, b);
             }
           }
         }
       }
     }
  }
  return false;
}

IsinL()

static bool IsinL ( int  a, std::vector< int >  vec  )

static

Definition at line 132 of file cohomo.cc.

{
  unsigned i;
  for(i=0;i<vec.size();i++)
  {
    if(a==vec[i])
    {
      return true;
    }
  }
  return false;
}

IsInX()

static bool IsInX ( poly  p, ideal  X  )

static

Definition at line 719 of file cohomo.cc.

{
  int i;
  for(i=0;i<IDELEMS(X);i++)
  {
    if(pEqualPolys(p,X->m[i]))
    {
      //PrintS("yes\n");
      return(true);
    }
  }
  //PrintS("no\n");
  return(false);
}

isoNum()

static int isoNum ( poly  p, ideal  I, poly  a, poly  b  )

static

Definition at line 3401 of file cohomo.cc.

{
  int i;
  std::vector<std::vector<int> > vs=supports(idCopy(I));
  std::vector<int> v1=support1(a), v2=support1(b), v=support1(p);
  std::vector<int>  vp, iv=phimagel(v, v1, v2);
  for(i=0;i<IDELEMS(I);i++)
  {
    vp=support1(pCopy(I->m[i]));
    if(vEvl(iv, phimagel(vp, v1, v2)))
    {
      return (i+1);
    }
  }
  return (0);
}

isoNumber()

static BOOLEAN isoNumber ( leftv  res, leftv  args  )

static

Definition at line 4453 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == POLY_CMD))
  {
    poly p= (poly)h->Data();
    h   = h->next;
    if((h != NULL)&&(h->Typ() == IDEAL_CMD))
    {
      ideal h1= (ideal)h->Data();
      h   = h->next;
      if((h != NULL)&&(h->Typ() == POLY_CMD))
      {
        poly a= (poly)h->Data();
        h   = h->next;
        if((h != NULL)&&(h->Typ() == POLY_CMD))
        {
          poly b= (poly)h->Data();
          res->rtyp =INT_CMD;
          res->data =(void *)(long)isoNum(p, h1, a, b);
        }
      }
    }
  }
  return false;
}

isSim()

static BOOLEAN isSim ( leftv  res, leftv  args  )

static

Definition at line 3919 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
     ideal h1= (ideal)h->Data();
     res->rtyp =IDEAL_CMD;
     res->data =IsSimplex(h1);
  }
  return false;
}

IsSimplex()

static ideal IsSimplex ( ideal  h )

static

Definition at line 832 of file cohomo.cc.

{
  int i,max=id_maxdeg(h);
  poly e=pOne();
  ideal id_re, id_so=idCopy(h);
  for(i=0;i<IDELEMS(h);i++)
  {
    id_re=SimFacset(h->m[i]);
    if(!idIs0(id_re))
    {
      id_so=idadda(id_so, id_re);//idAdd(id_so,id_re);
    }
  }
  idInsertPoly(id_so,e);
  idSkipZeroes(id_so);
  return (idMinus(id_so,h));
}

keeporder()

static std::vector< int > keeporder ( std::vector< int >  vec )

static

Definition at line 1039 of file cohomo.cc.

{
  std::vector<int> yaya;
  int n;
  if(vec[0]>vec[1])
  {
    n=vec[0];
    vec[0]=vec[1];
    vec[1]=n;
  }
  return vec;
}

linkn()

static BOOLEAN linkn ( leftv  res, leftv  args  )

static

Definition at line 4212 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == POLY_CMD))
  {
    poly a= (poly)h->Data();
    h   = h->next;
    if((h != NULL)&&(h->Typ() == IDEAL_CMD))
    {
      ideal Xo= (ideal)h->Data();
      h   = h->next;
      if((h != NULL)&&(h->Typ() == IDEAL_CMD))
      {
        ideal Sigma= (ideal)h->Data();
        h   = h->next;
        if((h != NULL)&&(h->Typ() == INT_CMD))
        {
          int vert= (int)(long)h->Data();
          h   = h->next;
          if((h != NULL)&&(h->Typ() == INT_CMD))
          {
            int ord= (int)(long)h->Data();
            res->rtyp =IDEAL_CMD;
            res->data =idMaken(links_new(a,  Xo,  Sigma,  vert,  ord));
          }
        }
      }
    }
  }
  return false;
}

Links()

static BOOLEAN Links ( leftv  res, leftv  args  )

static

Definition at line 3901 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == POLY_CMD))
  {
     poly p= (poly)h->Data();
     h   = h->next;
     if((h != NULL)&&(h->Typ() == IDEAL_CMD))
     {
       ideal h1= (ideal)h->Data();
       res->rtyp =IDEAL_CMD;
       std::vector<std::vector<int> > vecs=links(p,h1);
       res->data =idMaken(vecs);
     }
  }
  return false;
}

links()

static std::vector< std::vector< int > > links ( poly  a, ideal  h  )

static

Definition at line 1293 of file cohomo.cc.

{
  int i;
  std::vector<std::vector<int> > lk,X=supports(h);
  std::vector<int> U,In,av=support1(a);
  for(i=0;i<X.size();i++)
  {
    U=vecUnion(av,X[i]);
    In=vecIntersection(av,X[i]);
    if( In.size()==0 && vInvsl(U,X))
    {
      //PrintS("The union of them is FACE and intersection is EMPTY!\n");
      lk.push_back(X[i]);
    }
    else
    {
      ;
    }
  }
  return lk;
}

links_new()

static std::vector< std::vector< int > > links_new ( poly  a, ideal  Xo, ideal  Sigma, int  vert, int  ord  )

static

Definition at line 3361 of file cohomo.cc.

{
  std::vector<int> av=support1(a);
  std::vector<std::vector<int> > lko, lkn, lk1, lk2;
  lko=links(a, Xo);
  if(ord==1)
    return lko;
  if(ord==2)
  {
    lk1=phi1(a, Sigma);
    lk2=phi2(a, Xo, Sigma);
    lkn=vsMinusvs(lko, lk1);
    lkn=vsUnion(lkn, lk2);
    return lkn;
  }
  if(ord==3)
  {
    lkn=phi2(a, Xo, Sigma);
    return lkn;
  }
  WerrorS("Cannot find the links smartly!");
  return lko;
}

listprint()

static void listprint ( std::vector< int >  vec )

static

Definition at line 49 of file cohomo.cc.

{
  unsigned i;
  for(i=0;i<vec.size();i++)
  {
    Print("   _[%d]=%d\n",i+1,vec[i]);
    PrintLn();
  }
  if(vec.size()==0)
  {
    PrintS("   _[1]= \n");
    PrintLn();
  }
}

listsinsertlist()

static std::vector< std::vector< int > > listsinsertlist ( std::vector< std::vector< int > >  gset, int  a, int  b  )

static

Definition at line 1561 of file cohomo.cc.

{
  std::vector<int> eq;
  eq.push_back(a);
  eq.push_back(b);
  gset.push_back(eq);
  return gset;
}

listsprint()

static void listsprint ( std::vector< std::vector< int > >  posMat )

static

Definition at line 65 of file cohomo.cc.

{
  unsigned i;
  for(i=0;i<posMat.size();i++)
  {
    Print("[%d]:\n",i+1);
    listprint(posMat[i]);
    Print("\n");
    PrintLn();
  }
  if(posMat.size()==0)
  {
    PrintS("[1]:\n");
    PrintLn();
  }
}

lpprint()

static void lpprint ( std::vector< poly >  pv )

static

Definition at line 97 of file cohomo.cc.

{
  for(unsigned i=0;i<pv.size();i++)
  {
    Print("   _[%d]=",i+1);
    pWrite(pv[i]);
  }
  if(pv.size()==0)
  {
    PrintS("   _[1]= \n");
    PrintLn();
  }
}

lpsprint()

static void lpsprint ( std::vector< std::vector< poly > >  pvs )

static

Definition at line 112 of file cohomo.cc.

{
  for(unsigned i=0;i<pvs.size();i++)
  {
    Print("[%d]:\n",i+1);
    lpprint(pvs[i]);
    Print("\n");
    PrintLn();
  }
  if(pvs.size()==0)
  {
    PrintS("[1]:\n");
    PrintLn();
  }
}

mabconditionv()

static bool mabconditionv ( std::vector< std::vector< int > >  hvs, std::vector< int >  pv, std::vector< int >  av, std::vector< int >  bv  )

static

Definition at line 963 of file cohomo.cc.

{
  std::vector<int> uv=vecUnion(pv,av);
  uv=vecMinus(uv,bv);
  if(vInvsl(uv,hvs))
  {
    return(true);
  }
  return(false);
}

mabtv()

static std::vector< std::vector< int > > mabtv ( std::vector< std::vector< int > >  hvs, std::vector< std::vector< int > >  Mv, std::vector< int >  av, std::vector< int >  bv  )

static

Definition at line 1983 of file cohomo.cc.

{
  std::vector<int> v1,var;
  std::vector<std::vector<int> > vars;
  for(unsigned i=0;i<Mv.size();i++)
  {
    for(unsigned j=i+1;j<Mv.size();j++)
    {
      var.clear();
      v1=vecUnion(Mv[i],Mv[j]);
      if(mabconditionv(hvs, v1, av, bv))
      {
        var.push_back(i);
        var.push_back(j);
        vars.push_back(var);
      }
    }
  }
  return vars;
}

Mabv()

static std::vector< std::vector< int > > Mabv ( ideal  h, poly  a, poly  b  )

static

Definition at line 975 of file cohomo.cc.

{
  std::vector<int> av=support1(a), bv=support1(b), pv, vec;
  ideal h2=id_complement(h);
  std::vector<std::vector<int> > hvs=supports(h), h2v=supports(h2), vecs;
  for(unsigned i=0;i<h2v.size();i++)
  {
    pv=h2v[i];
    if(mabconditionv(hvs,pv,av,bv))
    {
      vecs.push_back(pv);
    }
  }
  return vecs;
}

mabvl()

static BOOLEAN mabvl ( leftv  res, leftv  args  )

static

Definition at line 4156 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
     ideal h1= (ideal)h->Data();
     h   = h->next;
     if((h != NULL)&&(h->Typ() == POLY_CMD))
     {
       poly p= (poly)h->Data();
       h   = h->next;
       if((h != NULL)&&(h->Typ() == POLY_CMD))
       {
         poly q= (poly)h->Data();
         res->rtyp =IDEAL_CMD;
         res->data =idMaken(Mabv(h1,p,q));
       }
     }
  }
  return false;
}

make0()

static std::vector< int > make0 ( int  n )

static

Definition at line 1185 of file cohomo.cc.

{
  int i;
  std::vector<int> vec;
  for(i=0;i<n;i++)
  {
    vec.push_back(0);
  }
  return vec;
}

make1()

static std::vector< int > make1 ( int  n )

static

Definition at line 1198 of file cohomo.cc.

{
  int i;
  std::vector<int> vec;
  for(i=0;i<n;i++)
  {
    vec.push_back(1);
  }
  return vec;
}

makeequation()

static std::vector< int > makeequation ( int  i, int  j, int  t  )

static

Definition at line 1570 of file cohomo.cc.

{
  std::vector<int> equation;
  equation.push_back(i);
  equation.push_back(j);
  equation.push_back(t);
  //listprint(equation);
  return equation;
}

makeSimplex()

static BOOLEAN makeSimplex ( leftv  res, leftv  args  )

static

Definition at line 3735 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
     ideal h1= (ideal)h->Data();
     res->rtyp =IDEAL_CMD;
     res->data =complementsimplex(h1);
  }
  return false;
}

mingens()

static ideal mingens ( ideal  h, poly  a, poly  b  )

static

Definition at line 2277 of file cohomo.cc.

{
  int i;
  std::vector<std::vector<int> > mv=Mabv(h,a,b);
  ideal M=idMaken(mv), hi=idInit(1,1);
  std::vector<int> index = gensindex(M, idsrRing(h));
  for(i=0;i<index.size();i++)
  {
    idInsertPoly(hi,M->m[index[i]]);
  }
  idSkipZeroes(hi);
  return (hi);
}

minisolve()

static std::vector< std::vector< int > > minisolve ( std::vector< std::vector< int > >  solve, std::vector< int >  index  )

static

Definition at line 2291 of file cohomo.cc.

{
  int i,j;
  std::vector<int> vec,solm;
  std::vector<std::vector<int> > solsm;
  for(i=0;i<solve.size();i++)
  {
    vec=solve[i];
    for(j=0;j<vec.size();j++)
    {
      if(IsinL(j,index))
        solm.push_back(vec[j]);
    }
    solsm.push_back(solm);
    solm.clear();
  }
  return (solsm);
}

nabconditionv()

static bool nabconditionv ( std::vector< std::vector< int > >  hvs, std::vector< int >  pv, std::vector< int >  av, std::vector< int >  bv  )

static

Definition at line 2092 of file cohomo.cc.

{
  std::vector<int> vec1=vecIntersection(pv,bv), vec2=vecUnion(pv,bv);
  int s1=vec1.size();
  if(!vInvsl(vec2,hvs) && s1==0 && vsubset(av,pv))
  {
    //PrintS("nab condition satisfied\n");
    return(true);
  }
  //PrintS("nab condition not satisfied\n");
  return(false);
}

nabtconditionv()

static bool nabtconditionv ( std::vector< std::vector< int > >  hvs, std::vector< int >  pv, std::vector< int >  qv  )

static

Definition at line 2123 of file cohomo.cc.

{
  std::vector<int> v1;
  v1=vecUnion(pv,qv);
  if(vInvsl(v1,hvs))
  {
    return (true);
  }
  return (false);
}

nabtv()

static std::vector< std::vector< int > > nabtv ( std::vector< std::vector< int > >  hvs, std::vector< std::vector< int > >  Nv, std::vector< int >  av, std::vector< int >  bv  )

static

Definition at line 2135 of file cohomo.cc.

{
  std::vector<int> v1,var;
  std::vector<std::vector<int> > vars;
  for(unsigned i=0;i<Nv.size();i++)
  {
    for(unsigned j=i+1;j<Nv.size();j++)
    {
      var.clear();
      if(nabtconditionv(hvs, Nv[i], Nv[j]))
      {
        var.push_back(i);
        var.push_back(j);
        vars.push_back(var);
      }
    }
  }
  return vars;
}

nabtvl()

static BOOLEAN nabtvl ( leftv  res, leftv  args  )

static

Definition at line 4178 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
     ideal h1= (ideal)h->Data();
     h   = h->next;
     if((h != NULL)&&(h->Typ() == POLY_CMD))
     {
       poly p= (poly)h->Data();
       h   = h->next;
       if((h != NULL)&&(h->Typ() == POLY_CMD))
       {
         poly q= (poly)h->Data();
         std::vector<std::vector<int> > hvs=supports(h1), nv, ntvs;
         std::vector<int> av=support1(p), bv=support1(q);
         nv=Nabv(hvs,av,bv);
         ntvs=nabtv( hvs, nv, av, bv);
         std::vector<std::vector<poly> > pvs=idMakei(nv,ntvs);
         ideal gens=idInit(1,1);
         for(unsigned i=0;i<pvs.size();i++)
         {
           idInsertPoly(gens,pvs[i][0]);
           idInsertPoly(gens,pvs[i][1]);
         }
         idSkipZeroes(gens);
         res->rtyp =IDEAL_CMD;
         res->data =gens;
       }
     }
  }
  return false;
}

Nabv()

static std::vector< std::vector< int > > Nabv ( std::vector< std::vector< int > >  hvs, std::vector< int >  av, std::vector< int >  bv  )

static

Definition at line 2106 of file cohomo.cc.

{
  std::vector<std::vector<int> > vecs;
  int num=hvs.size();
  for(int i=0;i<num;i++)
  {
    if(nabconditionv(hvs,hvs[i],av,bv))
    {
      //PrintS("satisfy:\n");
      vecs.push_back(hvs[i]);
    }
  }
  return vecs;
}

nabvl()

static BOOLEAN nabvl ( leftv  res, leftv  args  )

static

Definition at line 4082 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
     ideal h1= (ideal)h->Data();
     h   = h->next;
     if((h != NULL)&&(h->Typ() == POLY_CMD))
     {
       poly p= (poly)h->Data();
       h   = h->next;
       if((h != NULL)&&(h->Typ() == POLY_CMD))
       {
         poly q= (poly)h->Data();
         res->rtyp =IDEAL_CMD;
         std::vector<std::vector<int> > vecs=supports(h1);
         std::vector<int> pv=support1(p), qv=support1(q);
         res->data =idMaken(Nabv(vecs,pv,qv));
       }
     }
  }
  return false;
}

newDegree()

static BOOLEAN newDegree ( leftv  res, leftv  args  )

static

Definition at line 4517 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == POLY_CMD))
  {
    poly p= (poly)h->Data();
    h   = h->next;
    if((h != NULL)&&(h->Typ() == INT_CMD))
    {
       int num= (int)(long)h->Data();
       res->rtyp =INT_CMD;
       res->data =(void *)(long)redefinedeg( p, num);
    }
  }
  return false;
}

nfaces1()

BOOLEAN nfaces1	(	leftv	res,
		leftv	args
	)

Definition at line 3931 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
     ideal h1= (ideal)h->Data();
     h   = h->next;
     if((h != NULL)&&(h->Typ() == POLY_CMD))
     {
       poly p= (poly)h->Data();
       h   = h->next;
       if((h != NULL)&&(h->Typ() == INT_CMD))
       {
         int d= (int)(long)h->Data();
         res->rtyp =IDEAL_CMD;
         res->data =triangulations1(h1, p, d);
       }
     }
  }
  return false;
}

nfaces2()

static BOOLEAN nfaces2 ( leftv  res, leftv  args  )

static

Definition at line 3953 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
     ideal h1= (ideal)h->Data();
     h   = h->next;
     if((h != NULL)&&(h->Typ() == POLY_CMD))
     {
       poly p= (poly)h->Data();
       h   = h->next;
       if((h != NULL)&&(h->Typ() == POLY_CMD))
       {
         poly q= (poly)h->Data();
         h   = h->next;
         if((h != NULL)&&(h->Typ() == INT_CMD))
         {
           int d= (int)(long)h->Data();
           res->rtyp =IDEAL_CMD;
           res->data =triangulations2(h1,p,q,d);
         }
       }
     }
  }
  return false;
}

nfaces3()

static BOOLEAN nfaces3 ( leftv  res, leftv  args  )

static

Definition at line 3980 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
     ideal h1= (ideal)h->Data();
     h   = h->next;
     if((h != NULL)&&(h->Typ() == POLY_CMD))
     {
       poly p= (poly)h->Data();
       h   = h->next;
       if((h != NULL)&&(h->Typ() == POLY_CMD))
       {
         poly q= (poly)h->Data();
         h   = h->next;
         if((h != NULL)&&(h->Typ() == POLY_CMD))
         {
           poly g= (poly)h->Data();
           h   = h->next;
           if((h != NULL)&&(h->Typ() == INT_CMD))
           {
             int d= (int)(long)h->Data();
             res->rtyp =IDEAL_CMD;
             res->data =triangulations3(h1,p,q,g,d);
           }
         }
       }
     }
  }
  return false;
}

nonf2f()

static BOOLEAN nonf2f ( leftv  res, leftv  args  )

static

Definition at line 4534 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
     ideal h1= (ideal)h->Data();
     res->rtyp =IDEAL_CMD;
     res->data =complementsimplex(h1);
  }
  return false;
}

num4dim()

static int num4dim ( ideal  h, int  n  )

static

Definition at line 889 of file cohomo.cc.

{
  int num=0;
  for(int i=0; i<IDELEMS(h); i++)
  {
    if(pTotaldegree(h->m[i])==n)
    {
      num++;
    }
  }
  return num;
}

numdim()

static BOOLEAN numdim ( leftv  res, leftv  args  )

static

Definition at line 4558 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
    ideal h1= (ideal)h->Data();
    h   = h->next;
    if((h != NULL)&&(h->Typ() == INT_CMD))
    {
       int num= (int)(long)h->Data();
       res->rtyp =INT_CMD;
       res->data =(void *)(long)num4dim( h1, num);
    }
  }
  return false;
}

numfree()

static std::vector< int > numfree ( ideal  h )

static

Definition at line 1824 of file cohomo.cc.

{
  int i,j;
  std::vector<int> fvar;
  for(j=1;j<=currRing->N;j++)
  {
    for(i=0;i<IDELEMS(h);i++)
    {
      if(vInp(j,h->m[i]))
      {
        fvar.push_back(j);
        break;
      }
    }
  }
  //Print("There are %d free variables in total\n",num);
  return fvar;
}

ofindbases()

static std::vector< std::vector< int > > ofindbases ( int  num, std::vector< int >  bset, std::vector< std::vector< int > >  gset  )

static

Definition at line 1227 of file cohomo.cc.

{
  int i,m;
  std::vector<std::vector<int> > bases;
  std::vector<int> fvars=freevars(num,   bset,  gset), base1;
  if (fvars.size()==0)
  {
    base1=make0(num);
    bases.push_back(base1);
  }
  else
  {
    for(i=0;i<fvars.size();i++)
    {
      m=fvars[i];
      base1=ofindbases1(num, m, bset, gset);
      bases.push_back(base1);
    }
  }
  //PrintS("They are the bases for the solution space:\n");
  //listsprint(bases);
  return bases;
}

ofindbases1()

static std::vector< int > ofindbases1 ( int  num, int  vnum, std::vector< int >  bset, std::vector< std::vector< int > >  gset  )

static

Definition at line 1211 of file cohomo.cc.

{
  std::vector<std::vector<int> > goodset;
  std::vector<int> fvars=freevars(num,   bset,  gset), oset, base;
  std::vector<int> zset=fvarsvalue(vnum, fvars);
  zset=vecUnion(zset,bset);
  oset.push_back(vnum);
  goodset=vAbsorb(oset, gset);
  oset=goodset[goodset.size()-1];
  goodset.erase(goodset.end());
  base= vecbase1(num,  oset);
  return base;
}

p_a()

static ideal p_a ( ideal  h )

static

Definition at line 1335 of file cohomo.cc.

{
  poly p;
  int i,j,deg=0,deg0;
  ideal aset=idCopy(h),ia,h1=idsrRing(h);
//PrintS("idsrRing is:\n");id_print(h1);
  std::vector<int> as;
  std::vector<std::vector<int> > hvs=supports(h);
  for(i=0;i<IDELEMS(h1);i++)
  {
    deg0=pTotaldegree(h1->m[i]);
    if(deg < deg0)
      deg=deg0;
  }
  for(i=2;i<=deg;i++)
  {
    ia=id_MaxIdeal(i, currRing);
    for(j=0;j<IDELEMS(ia);j++)
    {
      p=pCopy(ia->m[j]);
      if(!IsInX(p,h))
      {
        as=support1(p);
        if(vInvsl(as,hvs))
        {
          idInsertPoly(aset, p);
        }
      }
    }
  }
  idSkipZeroes(aset);
  return(aset);
}

p_b()

static ideal p_b ( ideal  h, poly  a  )

static

Definition at line 1427 of file cohomo.cc.

{
  std::vector<std::vector<int> > pbv,lk=links(a,h), res;
  std::vector<int> vert=vertset(lk), bv;
  res=b_subsets(vert);
  int i, adg=pTotaldegree(a);
  poly e=pOne();
  ideal idd=idInit(1,1);
  for(i=0;i<res.size();i++)
  {
    if(res[i].size()==adg)
      pbv.push_back(res[i]);
  }
  if(pEqualPolys(a,e))
  {
    idInsertPoly(idd, e);
    idSkipZeroes(idd);
    return (idd);
  }
  idd=idMaken(pbv);
  return(idd);
}

p_change()

static std::vector< std::vector< int > > p_change ( ideal  Sigma )

static

Definition at line 3255 of file cohomo.cc.

{
  std::vector<std::vector<int> > ss=supports(idCopy(Sigma)), fvs;
  fvs=vs_subsets(ss);
  return (fvs);
}

p_constant()

static std::vector< std::vector< int > > p_constant ( ideal  Xo, ideal  Sigma  )

static

Definition at line 3247 of file cohomo.cc.

{
  std::vector<std::vector<int> > xs=supports(idCopy(Xo)), ss=supports(idCopy(Sigma)), fvs1;
  fvs1=vs_subsets(ss);
  fvs1=vsMinusvs(xs, fvs1);
  return fvs1;
}

p_Ifsfree()

static bool p_Ifsfree ( poly  P )

static

Definition at line 643 of file cohomo.cc.

{
  int i,sf=1;
  for(i=1;i<=rVar(currRing);i++)
  {
    if (pGetExp(P,i)>1)
    {
      sf=0;
      break;
    }
  }
  return sf;
}

p_new()

static std::vector< std::vector< int > > p_new ( ideal  Xo, ideal  Sigma  )

static

Definition at line 3262 of file cohomo.cc.

{
  int vert=0;
  std::vector<std::vector<int> > ss=supports(idCopy(Sigma)), fvs;
  for(int i=1;i<=currRing->N;i++)
  {
    for(int j=0;j<IDELEMS(Xo);j++)
    {
      if(pGetExp(Xo->m[j],i)>0)
      {
        vert=i+1;
        break;
      }
    }
  }
  int typ=ss.size();
  if(typ==1)
  {
    fvs=triface(Sigma->m[0], vert);
  }
  else if(typ==2)
  {
     fvs=tetraface(Sigma->m[0], Sigma->m[1], vert);
  }
  else
  {
     fvs=penface(Sigma->m[0], Sigma->m[1], Sigma->m[2], vert);
  }
  return (fvs);
}

p_New()

static BOOLEAN p_New ( leftv  res, leftv  args  )

static

Definition at line 4290 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
     ideal h1= (ideal)h->Data();
     h   = h->next;
     if((h != NULL)&&(h->Typ() == IDEAL_CMD))
     {
       ideal h2= (ideal)h->Data();
       res->rtyp =IDEAL_CMD;
       res->data =idMaken(p_new(h1,h2));
     }
  }
  return false;
}

pa()

static BOOLEAN pa ( leftv  res, leftv  args  )

static

Definition at line 3723 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
     ideal h1= (ideal)h->Data();
     res->rtyp =IDEAL_CMD;
     res->data =p_a(h1);
  }
  return false;
}

pb()

static BOOLEAN pb ( leftv  res, leftv  args  )

static

Definition at line 3747 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
     ideal h1= (ideal)h->Data();
     h   = h->next;
     if((h != NULL)&&(h->Typ() == POLY_CMD))
     {
       poly p= (poly)h->Data();
       res->rtyp =IDEAL_CMD;
       res->data =p_b(h1,p);
     }
  }
  return false;
}

pChange()

static BOOLEAN pChange ( leftv  res, leftv  args  )

static

Definition at line 4278 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
     ideal h1= (ideal)h->Data();
     res->rtyp =IDEAL_CMD;
     res->data =idMaken(p_change(h1));
  }
  return false;
}

pcoef()

static int pcoef ( poly  p, int  m  )

static

Definition at line 386 of file cohomo.cc.

{
  int i,co; poly q=pCopy(p);
  for(i=1;i<=currRing->N;i++)
  {
    if(p_GetExp(q,m,currRing)!=0)
    {
      co=n_Int(pGetCoeff(q),currRing->cf);
      return co;
    }
    else
      q=pNext(q);
  }
  if(q!=NULL)
    co=0;
  return co;
}

pConstant()

static BOOLEAN pConstant ( leftv  res, leftv  args  )

static

Definition at line 4261 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
     ideal h1= (ideal)h->Data();
     h   = h->next;
     if((h != NULL)&&(h->Typ() == IDEAL_CMD))
     {
       ideal h2= (ideal)h->Data();
       res->rtyp =IDEAL_CMD;
       res->data =idMaken(p_constant(h1,h2));
     }
  }
  return false;
}

penface()

static std::vector< std::vector< int > > penface ( poly  p, poly  q, poly  g, int  vert  )

static

Definition at line 3109 of file cohomo.cc.

{
  int en=0;
  std::vector<int> ev1=commonedge(p, q), ev2=commonedge(p, g), ev3=commonedge(q, g), ind, vec, fv1=support1(p), fv2=support1(q), fv3=support1(g);
  std::vector<std::vector<int> > fvs1, fvs2, fvs3, fvs, evec;
  evec.push_back(ev1);
  evec.push_back(ev2);
  evec.push_back(ev3);
  for(unsigned i=0;i<evec.size();i++)
  {
    if(evec[i].size()==2)
    {
      en++;
    }
  }
  if(en==2)
  {
    vec.push_back(vert);
    fvs.push_back(vec);
    fvs1=b_subsets(fv1);
    fvs2=b_subsets(fv2);
    fvs3=b_subsets(fv3);
    fvs1=vsMinusv(fvs1, fv1);
    fvs2=vsMinusv(fvs2, fv2);
    fvs3=vsMinusv(fvs3, fv3);
    fvs3=vsUnion(fvs3, fvs2);
    fvs3=vsUnion(fvs3, fvs1);
    for(unsigned i=0;i<evec.size();i++)
    {
      if(evec[i].size()==2)
      {
        fvs3=vsMinusv(fvs3, evec[i]);
      }
    }
    for(unsigned i=0;i<fvs3.size();i++)
    {
      vec=fvs3[i];
      vec.push_back(vert);
      fvs.push_back(vec);
    }
  }
  return (fvs);
}

phi1()

static std::vector< std::vector< int > > phi1 ( poly  a, ideal  Sigma  )

static

Definition at line 3328 of file cohomo.cc.

{
  std::vector<std::vector<int> > ss=supports(idCopy(Sigma)), fvs;
  std::vector<int> av=support1(a), intvec, vv;
  for(unsigned i=0;i<ss.size();i++)
  {
    intvec=vecIntersection(ss[i], av);
    if(intvec.size()==av.size())
    {
      vv=vecMinus(ss[i], av);
      fvs.push_back(vv);
    }
  }
  return fvs;
}

phi2()

static std::vector< std::vector< int > > phi2 ( poly  a, ideal  Xo, ideal  Sigma  )

static

Definition at line 3344 of file cohomo.cc.

{
 
  std::vector<std::vector<int> > ss=p_new(Sigma, Xo), fvs;
  std::vector<int> av=support1(a), intvec, vv;
  for(unsigned i=0;i<ss.size();i++)
  {
    intvec=vecIntersection(ss[i], av);
    if(intvec.size()==av.size())
    {
      vv=vecMinus(ss[i], av);
      fvs.push_back(vv);
    }
  }
  return fvs;
}

phimage()

static std::vector< int > phimage ( std::vector< int >  pv, std::vector< int >  av, std::vector< int >  bv  )

static

Definition at line 2187 of file cohomo.cc.

{
  std::vector<int> qv=vecUnion(pv,av);
  qv=vecMinus(qv,bv);
  return qv;
}

phimagel()

static std::vector< int > phimagel ( std::vector< int >  fv, std::vector< int >  av, std::vector< int >  bv  )

static

Definition at line 2649 of file cohomo.cc.

{
  std::vector<int> nv;
  nv=vecMinus(fv,bv);
  nv=vecMinus(nv,av);
  return nv;
}

pMake()

static poly pMake ( std::vector< int >  vbase )

static

Definition at line 343 of file cohomo.cc.

{
  int n=vbase.size(); poly p,q=0;
  for(int i=0;i<n;i++)
  {
    if(vbase[i]!=0)
    {
      p = pOne();pSetExp(p, i+1, 1);pSetm(p);pSetCoeff(p, nInit(vbase[i]));
      q = pAdd(q, p);
    }
  }
  return q;
}

pMake3()

static poly pMake3 ( std::vector< int >  vbase )

static

Definition at line 1583 of file cohomo.cc.

{
  int co=1;
  poly p,q=0;
  for(int i=0;i<3;i++)
  {
    if(vbase[i]!=0)
    {
      if(i==1) co=-1;
      p = pOne();pSetExp(p, vbase[i], 1);pSetm(p);pSetCoeff(p, nInit(co));
    }
    else p=0;
      q = pAdd(q, p);
    co=1;
  }
  return q;
}

pMakei()

static std::vector< poly > pMakei ( std::vector< std::vector< int > >  mv, std::vector< int >  vbase  )

static

Definition at line 1657 of file cohomo.cc.

{
  poly p;
  std::vector<poly> h1;
  int n=vbase.size();
  for(int i=0;i<n;i++)
  {
    p=pMaken(mv[vbase[i]]);
    h1.push_back(p);
  }
  return h1;
}

pMaken()

static poly pMaken ( std::vector< int >  vbase )

static

Definition at line 465 of file cohomo.cc.

{
  int n=vbase.size();
  poly p,q=pOne();
  for(int i=0;i<n;i++)
  {
    p = pOne();pSetExp(p, vbase[i], 1);pSetm(p);pSetCoeff(p, nInit(1));
    //pWrite(p);
    q=pp_Mult_mm(q,p,currRing);
  }
  return q;
}

psMinusp()

static BOOLEAN psMinusp ( leftv  res, leftv  args  )

static

Definition at line 4331 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
     ideal h1= (ideal)h->Data();
     h   = h->next;
     if((h != NULL)&&(h->Typ() == POLY_CMD))
     {
       poly p= (poly)h->Data();
       res->rtyp =IDEAL_CMD;
       res->data =idMinusp(h1, p);
     }
  }
  return false;
}

psubset()

static ideal psubset ( poly  p )

static

Definition at line 1539 of file cohomo.cc.

{
  int i,j,max=pTotaldegree(p);
  ideal h1,mons, id_re=idInit(1,1);
  for(i=1;i<max;i++)
  {
    mons=id_MaxIdeal(i, currRing);
    h1=sfreemon(mons,i);
    for(j=0;j<IDELEMS(h1);j++)
    {
      if(p_DivisibleBy(h1->m[j],p,currRing))
        idInsertPoly(id_re, h1->m[j]);
    }
  }
  idSkipZeroes(id_re);
  //PrintS("This is the facset\n");
  //id_print(id_re);
  return id_re;
}

pvert()

static int pvert ( poly  p )

static

Definition at line 541 of file cohomo.cc.

{
  int i, vert=0;
  for(i=currRing->N;i>0;i--)
  {
      if(pGetExp(p,i)>0)
      {
        vert=i;
        return vert;
      }
  }
  return vert;
}

qringadd()

static ideal qringadd ( ideal  h1, ideal  h2, int  deg  )

static

Definition at line 735 of file cohomo.cc.

{
  ideal h,qrh;
  h=idAdd(h1,h2);
  qrh=scKBase(deg,h);
  return qrh;
}

redefinedeg()

static int redefinedeg ( poly  p, int  num  )

static

Definition at line 1315 of file cohomo.cc.

{
  int deg=0, deg0;
  for(int i=1;i<=currRing->N;i++)
  {
    deg0=pGetExp(p, i);
    if(i>num)
    {
      deg= deg+2*deg0;
    }
    else
    {
      deg=deg+deg0;
    }
  }
  //Print("the new degree is: %d\n", deg);
  return (deg);
}

sfreemon()

static ideal sfreemon ( ideal  h, int  deg  )

static

Definition at line 658 of file cohomo.cc.

{
  int j;
  ideal temp;
  temp=idInit(1,1);
  if(!idIs0(h))
  {
    for(j=0;j<IDELEMS(h);j++)
    {
      if((p_Ifsfree(h->m[j]))&&(pTotaldegree(h->m[j])==deg))
      {
        idInsertPoly(temp, h->m[j]);
      }
    }
    idSkipZeroes(temp);
  }
  return temp;
}

sgp()

static BOOLEAN sgp ( leftv  res, leftv  args  )

static

Definition at line 3857 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
     ideal h1= (ideal)h->Data();
     h   = h->next;
     if((h != NULL)&&(h->Typ() == POLY_CMD))
     {
       poly p= (poly)h->Data();
       h   = h->next;
       if((h != NULL)&&(h->Typ() == POLY_CMD))
       {
         poly q= (poly)h->Data();
         res->rtyp =INTVEC_CMD;
         res->data =gradedpiece2n(h1,p,q);
       }
     }
  }
  return false;
}

sgpl()

static BOOLEAN sgpl ( leftv  res, leftv  args  )

static

Definition at line 3879 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
     ideal h1= (ideal)h->Data();
     h   = h->next;
     if((h != NULL)&&(h->Typ() == POLY_CMD))
     {
       poly p= (poly)h->Data();
       h   = h->next;
       if((h != NULL)&&(h->Typ() == POLY_CMD))
       {
         poly q= (poly)h->Data();
         res->rtyp =INTVEC_CMD;
         res->data =gradedpiece2nl(h1,p,q);
       }
     }
  }
  return false;
}

SimFacset()

static ideal SimFacset ( poly  p )

static

Definition at line 787 of file cohomo.cc.

{
  int i,j,max=pTotaldegree(p);
  ideal h1,mons,id_re=idInit(1,1);
  for(i=1;i<max;i++)
  {
    mons=id_MaxIdeal(i, currRing);
    h1=sfreemon(mons,i);
 
    for(j=0;j<IDELEMS(h1);j++)
    {
      if(p_DivisibleBy(h1->m[j],p,currRing))
      {
        idInsertPoly(id_re, h1->m[j]);
      }
    }
  }
  idSkipZeroes(id_re);
  return id_re;
}

soleli1()

static std::vector< std::vector< int > > soleli1 ( std::vector< std::vector< int > >  eqs )

static

Definition at line 1052 of file cohomo.cc.

{
  int i;
  std::vector<int> yaya;
  std::vector<std::vector<int> >  pre=eqs, ppre, re;
  if(eqs.size()>0)
  {
    re.push_back(eqs[0]);
    pre.erase(pre.begin());
  }
  while(pre.size()>0)
  {
    yaya=keeporder(eli1(re[0],pre[0]));
    for(i=1;i<re.size();i++)
    {
      if(!vInvsl(yaya, re))
      {
        yaya=eli1(re[i],yaya);
        yaya=keeporder(yaya);
      }
    }
    if(!vInvsl(yaya, re))
    {
      re.push_back(yaya);
    }
    pre.erase(pre.begin());
  }
  return re;
}

SRideal()

static BOOLEAN SRideal ( leftv  res, leftv  args  )

static

Definition at line 3600 of file cohomo.cc.

{
  leftv h=args;
   if((h != NULL)&&(h->Typ() == IDEAL_CMD))
   {
     ideal hh=(ideal)h->Data();
     res->rtyp =IDEAL_CMD;
     res->data =idsrRing(hh);
   }
  return false;
}

star()

static std::vector< std::vector< int > > star ( poly  a, ideal  h  )

static

Definition at line 3473 of file cohomo.cc.

{
  int i;
  std::vector<std::vector<int> > st,X=supports(h);
  std::vector<int> U,av=support1(a);
  for(i=0;i<X.size();i++)
  {
    U=vecUnion(av,X[i]);
    if(vInvsl(U,X))
    {
      st.push_back(X[i]);
    }
  }
  return st;
}

stars()

static BOOLEAN stars ( leftv  res, leftv  args  )

static

Definition at line 4385 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == POLY_CMD))
  {
     poly p= (poly)h->Data();
     h   = h->next;
     if((h != NULL)&&(h->Typ() == IDEAL_CMD))
     {
       ideal h1= (ideal)h->Data();
       res->rtyp =IDEAL_CMD;
       res->data =idMaken(star(p, h1));
     }
   }
  return false;
}

stellarremain()

static BOOLEAN stellarremain ( leftv  res, leftv  args  )

static

Definition at line 4348 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
     ideal h1= (ideal)h->Data();
     h   = h->next;
     if((h != NULL)&&(h->Typ() == POLY_CMD))
     {
       poly p= (poly)h->Data();
       std::vector<std::vector<int> > st=star(p, h1);
       std::vector<std::vector<int> > hvs=supports(h1);
       std::vector<std::vector<int> > re= vsMinusvs(hvs, st);
       res->rtyp =IDEAL_CMD;
       res->data =idMaken(re);
     }
  }
  return false;
}

stellarsub()

static std::vector< std::vector< int > > stellarsub ( poly  a, ideal  h  )

static

Definition at line 3499 of file cohomo.cc.

{
  std::vector<std::vector<int> > vecs_minus, vecs_plus, lk=links(a,h), hvs=supports(h), sub, bys=boundary(a);
  std::vector<int> av=support1(a), vec, vec_n;
  int i,j,vert=0;
  for(i=1;i<=currRing->N;i++)
  {
    for(j=0;j<IDELEMS(h);j++)
    {
      if(pGetExp(h->m[j],i)>0)
      {
        vert=i+1;
        break;
      }
    }
  }
  vec_n.push_back(vert);
  for(i=0;i<lk.size();i++)
  {
    vec=vecUnion(av, lk[i]);
    vecs_minus.push_back(vec);
    for(j=0;j<bys.size();j++)
    {
      vec=vecUnion(lk[i], vec_n);
      vec=vecUnion(vec, bys[j]);
      vecs_plus.push_back(vec);
    }
  }
  sub=vsMinusvs(hvs, vecs_minus);
  sub=vsUnion(sub, vecs_plus);
  return(sub);
}

stellarsubdivision()

static BOOLEAN stellarsubdivision ( leftv  res, leftv  args  )

static

Definition at line 4402 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
     ideal h2= (ideal)h->Data();
     h   = h->next;
     if((h != NULL)&&(h->Typ() == POLY_CMD))
     {
       poly p= (poly)h->Data();
       res->rtyp =IDEAL_CMD;
       res->data =idMaken(stellarsub(p, h2));
     }
  }
  return false;
}

subspace1()

static std::vector< int > subspace1 ( std::vector< std::vector< int > >  mv, std::vector< int >  bv  )

static

Definition at line 1640 of file cohomo.cc.

{
  int i, num=mv.size();
  std::vector<int> base;
  for(i=0;i<num;i++)
  {
    if(IsinL(bv[0],mv[i]))
      base.push_back(1);
    else
      base.push_back(0);
  }
  return base;
}

subspacet()

static std::vector< std::vector< int > > subspacet ( std::vector< std::vector< int > >  mv, std::vector< int >  bv, std::vector< std::vector< int > >  ntvs  )

static

Definition at line 1969 of file cohomo.cc.

{
  std::vector<int> alset=findalpha(mv,bv), subase;
  std::vector<std::vector<int> > subases;
  for(unsigned i=0;i<alset.size();i++)
  {
    subase=subspacet1(alset[i],ntvs);
    subases.push_back(subase);
  }
  //PrintS("These are the bases for the subspace:\n");
  //listsprint(subases);
  return subases;
}

subspacet1()

static std::vector< int > subspacet1 ( int  num, std::vector< std::vector< int > >  ntvs  )

static

Definition at line 1942 of file cohomo.cc.

{
  int i, j, t, n=ntvs.size();
  std::vector<int> subase;
  for(t=0;t<n;t++)
  {
    i=ntvs[t][0];
    j=ntvs[t][1];
    if(i==(num))
    {
      subase.push_back(1);
    }
    else if(j==num)
    {
      subase.push_back(-1);
    }
    else
    {
      subase.push_back(0);
    }
  }
  //Print("This is the basis w.r.t. %dth polynomial in alpha set\n",num);
  //listprint(subase);
  return subase;
}

subspacetn()

static std::vector< std::vector< int > > subspacetn ( std::vector< std::vector< int > >  N, std::vector< int >  tN, std::vector< std::vector< int > >  ntvs  )

static

Definition at line 2440 of file cohomo.cc.

{
  int i;
  std::vector<int> alset=findalphan(N,tN), subase;
  std::vector<std::vector<int> > subases;
  for(i=0;i<alset.size();i++)
  {
    subase=subspacet1(alset[i],ntvs);
    subases.push_back(subase);
  }
  //PrintS("These are the bases for the subspace:\n");
  //listsprint(subases);
  return subases;
}

support()

static BOOLEAN support ( leftv  res, leftv  args  )

static

Definition at line 4307 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == POLY_CMD))
  {
     poly p= (poly)h->Data();
     res->rtyp =INT_CMD;
     res->data =(void *)(long)(support1(p).size());
  }
  return false;
}

support1()

static std::vector< int > support1 ( poly  p )

static

Definition at line 271 of file cohomo.cc.

{
  int j;
  std::vector<int> supset;
  if(p==0) return supset;
  for(j=1;j<=rVar(currRing);j++)
  {
    if(pGetExp(p,j)>0)
    {
      supset.push_back(j);
    }
  }
  return (supset);
}

support2()

static std::vector< int > support2 ( poly  p )

static

Definition at line 304 of file cohomo.cc.

{
  int j;
  poly q;
  std::vector<int> supset;
  for(j=1;j<=rVar(currRing);j++)
  {
    q=pCopy(p);
    while (q!=NULL)
    {
      if(p_GetExp(q,j,currRing)!=0)
      {
        supset.push_back(j);
        break;
      }
      q=pNext(q);
    }
  }
  return (supset);
}

supports()

static std::vector< std::vector< int > > supports ( ideal  h )

static

Definition at line 287 of file cohomo.cc.

{
  std::vector<std::vector<int> > vecs;
  std::vector<int> vec;
  if(!idIs0(h))
  {
    for(int s=0;s<IDELEMS(h);s++)
    {
      vec=support1(h->m[s]);
      vecs.push_back(vec);
    }
  }
  return vecs;
}

supports2()

static std::vector< std::vector< int > > supports2 ( ideal  h )

static

Definition at line 326 of file cohomo.cc.

{
  std::vector<std::vector<int> > vecs;
  std::vector<int> vec;
  if(!idIs0(h))
  {
    for(int s=0;s<IDELEMS(h);s++)
    {
      vec=support2(h->m[s]);
      vecs.push_back(vec);
    }
  }
  return vecs;
}

T1()

static void T1 ( ideal  h )

static

Definition at line 2380 of file cohomo.cc.

{
  ideal bi=findb(h),ai;
  int mm=0;
  id_print(bi);
  poly a,b;
  std::vector<std::vector<int> > solve;
  for(int i=0;i<IDELEMS(bi);i++)
  {
    //PrintS("This is aset according to:");
    b=pCopy(bi->m[i]);
    pWrite(b);
    ai=finda(h,b,0);
    if(!idIs0(ai))
    {
      id_print(ai);
      for(int j=0;j<IDELEMS(ai);j++)
      {
        //PrintS("This is a:");
        a=pCopy(ai->m[j]);
        //pWrite(a);
        intvec * solve=gradedpiece1n(h, a, b);
        if (IMATELEM(*solve,1,1)!=10)
           mm++;
      }
    }
  }
  Print("Finished %d!\n",mm);
}

t1h()

static BOOLEAN t1h ( leftv  res, leftv  args  )

static

Definition at line 3625 of file cohomo.cc.

{
  leftv h=args;
   if((h != NULL)&&(h->Typ() == IDEAL_CMD))
   {
     ideal hh=(ideal)h->Data();
     res->rtyp =IDEAL_CMD;
     res->data =T_1h(hh);
   }
  return false;
}

T2()

static void T2 ( ideal  h )

static

Definition at line 2607 of file cohomo.cc.

{
  ideal bi=findb(h),ai;
  id_print(bi);
  poly a,b;
  int mm=0,gp=0;
  std::vector<int> bv,av;
  std::vector<std::vector<int> > solve;
  for(int i=0;i<IDELEMS(bi);i++)
  {
    b=pCopy(bi->m[i]);
    //bv=support1(b);
    //PrintS("This is aset according to:");
    pWrite(b);
//if(bv.size()==2)
  //{
    ai=finda(h,b,0);
    if(!idIs0(ai))
    {
      PrintS("This is a set according to current b:\n");
      id_print(ai);
      for(int j=0;j<IDELEMS(ai);j++)
      {
        PrintS("This is a:");
        a=pCopy(ai->m[j]);
        pWrite(a);
        PrintS("This is b:");
        pWrite(b);
        intvec *solve=gradedpiece2n(h, a, b);
        delete solve;
        gp++;
      }
    }
    mm=mm+1;
  }
  if(mm==IDELEMS(bi))
      PrintS("Finished!\n");
  Print("There are %d graded pieces in total.\n",gp);
}

T_1h()

static ideal T_1h ( ideal  h )

static

Definition at line 3549 of file cohomo.cc.

{
  int i, j;
  //std::vector < intvec > T1;
  ideal ai=p_a(h), bi;
  //intvec *L;
  for(i=0;i<IDELEMS(ai);i++)
  {
    bi=p_b(h,ai->m[i]);
    if(!idIs0(bi))
    {
      for(j=0;j<IDELEMS(bi);j++)
      {
        //PrintS("This is for:\n");pWrite(ai->m[i]); pWrite(bi->m[j]);
        gradedpiece1nl(h,ai->m[i],bi->m[j], 0);
        //PrintS("Succeed!\n");
        //T1.push_back(L);
      }
    }
  }
  TimeShow(t_construct, t_solve, t_value, t_total);
  return h;
}

tetraface()

static std::vector< std::vector< int > > tetraface ( poly  p, poly  q, int  vert  )

static

Definition at line 3072 of file cohomo.cc.

{
  std::vector<int> ev=commonedge(p, q), vec, fv1=support1(p), fv2=support1(q);
  std::vector<std::vector<int> > fvs1, fvs2, fvs;
  vec.push_back(vert);
  fvs.push_back(vec);
  fvs1=b_subsets(fv1);
  fvs2=b_subsets(fv2);
  fvs1=vsMinusv(fvs1, fv1);
  fvs2=vsMinusv(fvs2, fv2);
  fvs2=vsUnion(fvs1, fvs2);
  fvs2=vsMinusv(fvs2, ev);
  for(unsigned i=0;i<fvs2.size();i++)
  {
    vec=fvs2[i];
    vec.push_back(vert);
    fvs.push_back(vec);
  }
  return (fvs);
}

TimeShow()

static void TimeShow ( clock_t  t_construct, clock_t  t_solve, clock_t  t_value, clock_t  t_total  )

static

Definition at line 2695 of file cohomo.cc.

{
  Print("The time of value matching for first order deformation:   %.2f sec ;\n", ((double) t_value)/CLOCKS_PER_SEC);
  Print("The total time of fpiece:  %.2f sec ;\n", ((double) t_total)/CLOCKS_PER_SEC);
  Print("The time of equations construction for fpiece:   %.2f sec ;\n", ((double) t_construct)/CLOCKS_PER_SEC);
  Print("The total time of equations solving for fpiece:  %.2f sec ;\n", ((double) t_solve)/CLOCKS_PER_SEC);
  PrintS("__________________________________________________________\n");
}

Tmat()

static intvec * Tmat ( std::vector< std::vector< int > >  vecs )

static

Definition at line 2233 of file cohomo.cc.

{
    //std::vector<std::vector<int> > solve=gradedpiece1n(h,a,b);
   //Print("the size of solve is: %ld\n",solve.size());
 //vtm(solve);
  intvec *m;
  int i,j, a=vecs.size();
  if(a==0)
  {
    m=new intvec(1,1,10);
  }
  else
  {
    int b=vecs[0].size();
    m=new intvec(a,b,0);
    for(i=1;i<=a;i++)
    {
      for(j=1;j<=b;j++)
      {
        IMATELEM(*m,i,j)=vecs[i-1][j-1];
      }
    }
  }
  return (m);
}

tNab()

static bool tNab ( std::vector< std::vector< int > >  hvs, std::vector< int >  pv, std::vector< std::vector< int > >  bvs  )

static

Definition at line 2157 of file cohomo.cc.

{
  std::vector<int> sv;
  if(bvs.size()<=1) return false;
  for(unsigned i=0;i<bvs.size();i++)
  {
    sv=vecUnion(pv,bvs[i]);
    if(!vInvsl(sv,hvs))
    {
      return true;
    }
  }
  return false;
}

tnab()

static std::vector< int > tnab ( std::vector< std::vector< int > >  hvs, std::vector< std::vector< int > >  nvs, std::vector< std::vector< int > >  bvs  )

static

Definition at line 2172 of file cohomo.cc.

{
  std::vector<int> pv, vec;
  for(unsigned j=0;j<nvs.size();j++)
  {
    pv=nvs[j];
    if(tNab(hvs, pv, bvs))
    {
      vec.push_back(j);
    }
  }
  return vec;
}

tnabvl()

static BOOLEAN tnabvl ( leftv  res, leftv  args  )

static

Definition at line 4106 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
     ideal h1= (ideal)h->Data();
     h   = h->next;
     if((h != NULL)&&(h->Typ() == POLY_CMD))
     {
       poly p= (poly)h->Data();
       h   = h->next;
       if((h != NULL)&&(h->Typ() == POLY_CMD))
       {
         poly q= (poly)h->Data();
         res->rtyp =IDEAL_CMD;
         std::vector<std::vector<int> > vecs=supports(h1), sbv,tnbr;
         std::vector<int> pv=support1(p), qv=support1(q);
         std::vector<std::vector<int> > nvs=Nabv(vecs, pv, qv);
         ideal sub=psubset(q);
         sbv=supports(sub);
         std::vector<int> tnv =tnab(vecs,nvs,sbv);
         for(unsigned i=0;i<tnv.size();i++)
         {
           tnbr.push_back(nvs[tnv[i]]);
         }
         res->data =idMaken(tnbr);
       }
     }
  }
  return false;
}

triangulations1()

static ideal triangulations1 ( ideal  h, poly  p, int  vert  )

static

Definition at line 3004 of file cohomo.cc.

{
  std::vector<int> vec, pv=support1(p);
  std::vector<std::vector<int> > vecs=supports(h),vs,vs0;
  vs0=triface(p,vert);
  vecs=vsMinusv(vecs, pv);
  vecs=vsUnion(vecs,vs0);
  //PrintS("This is the new simplicial complex according to the face \n"); pWrite(p);
  //PrintS("is:\n");
  //listsprint(vecs);
  ideal re=idMaken(vecs);
  return re;
}

triangulations2()

static ideal triangulations2 ( ideal  h, poly  p, poly  q, int  vert  )

static

Definition at line 3094 of file cohomo.cc.

{
  std::vector<int> ev, fv1=support1(p), fv2=support1(q);
  std::vector<std::vector<int> > vecs=supports(h), vs1;
  ev=commonedge(p, q);
  vecs=vsMinusv(vecs, ev);
  vecs=vsMinusv(vecs,fv1);
  vecs=vsMinusv(vecs,fv2);
  vs1=tetraface(p, q, vert);
  vecs=vsUnion(vecs,vs1);
  ideal hh=idMaken(vecs);
  return hh;
}

triangulations3()

static ideal triangulations3 ( ideal  h, poly  p, poly  q, poly  g, int  vert  )

static

Definition at line 3153 of file cohomo.cc.

{
  std::vector<int> ev1=commonedge(p, q), ev2=commonedge(p, g), ev3=commonedge(q, g), fv1=support1(p), fv2=support1(q), fv3=support1(g);
  std::vector<std::vector<int> > vecs=supports(h), vs1, evec;
  evec.push_back(ev1);
  evec.push_back(ev2);
  evec.push_back(ev3);
  for(unsigned i=0;i<evec.size();i++)
  {
    if(evec[i].size()==2)
    {
      vecs=vsMinusv(vecs, evec[i]);
    }
  }
  vecs=vsMinusv(vecs,fv1);
  vecs=vsMinusv(vecs,fv2);
  vecs=vsMinusv(vecs,fv3);
  vs1=penface(p, q, g, vert);
  vecs=vsUnion(vecs,vs1);
  ideal hh=idMaken(vecs);
  return hh;
}

triface()

static std::vector< std::vector< int > > triface ( poly  p, int  vert  )

static

Definition at line 2985 of file cohomo.cc.

{
  std::vector<int> vec, fv=support1(p);
  std::vector<std::vector<int> > fvs0, fvs;
  vec.push_back(vert);
  fvs.push_back(vec);
  fvs0=b_subsets(fv);
  fvs0=vsMinusv(fvs0,fv);
  for(unsigned i=0;i<fvs0.size();i++)
  {
    vec=fvs0[i];
    vec.push_back(vert);
    fvs.push_back(vec);
  }
  return (fvs);
}

trisets()

static ideal trisets ( ideal  h )

static

Definition at line 2969 of file cohomo.cc.

{
  int i;
  ideal ids=idInit(1,1);
  std::vector<int> pv;
  for(i=0;i<IDELEMS(h);i++)
  {
    pv= support1(h->m[i]);
    if(pv.size()==3)
      idInsertPoly(ids, pCopy(h->m[i]));
  }
  idSkipZeroes(ids);
  return ids;
}

tsets()

static BOOLEAN tsets ( leftv  res, leftv  args  )

static

Definition at line 4053 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
     ideal h1= (ideal)h->Data();
     res->rtyp =IDEAL_CMD;
     res->data =trisets(h1);
  }
  return false;
}

v_minus()

static std::vector< int > v_minus ( std::vector< int >  v1, std::vector< int >  v2  )

static

Definition at line 3446 of file cohomo.cc.

{
  std::vector<int> vec;
  for(unsigned i=0;i<v1.size();i++)
  {
    vec.push_back(v1[i]-v2[i]);
  }
  return vec;
}

vAbsorb()

static std::vector< std::vector< int > > vAbsorb ( std::vector< int >  bset, std::vector< std::vector< int > >  gset  )

static

Definition at line 1125 of file cohomo.cc.

{
  std::vector<int> badset=bset;
  int i,j,m, bl=bset.size(), gl=gset.size();
  for(i=0;i<bl;i++)
  {
    m=badset[i];
    for(j=0;j<gl;j++)
    {
      if(gset[j][0]==m && !IsinL(gset[j][1],badset))
      {
        badset.push_back(gset[j][1]);
        gset.erase(gset.begin()+j);
        j--;
        gl--;
        bl++;
      }
      else if(!IsinL(gset[j][0],badset) && gset[j][1]==m)
      {
        badset.push_back(gset[j][0]);
        gset.erase(gset.begin()+j);
        j--;
        gl--;
        bl++;
      }
      else if(IsinL(gset[j][0],badset) && IsinL(gset[j][1],badset))
      {
        gset.erase(gset.begin()+j);
        j--;
        gl--;
      }
      else
      {
        ;
      }
    }
  }
  if(badset.size()==0) badset.push_back(0);
  gset.push_back(badset);
  return gset;
}

valency()

static int valency ( ideal  h, poly  p  )

static

Definition at line 3178 of file cohomo.cc.

{
  int val=0;
  std::vector<int> ev=support1(pCopy(p));
  int ver=ev[0];
//PrintS("the vertex is :\n"); listprint(p);
  std::vector<std::vector<int> > vecs=supports(idCopy(h));
  for(unsigned i=0;i<vecs.size();i++)
  {
    if(vecs[i].size()==2 && IsinL(ver, vecs[i]))
      val++;
  }
  return (val);
}

Valency()

static BOOLEAN Valency ( leftv  res, leftv  args  )

static

Definition at line 4065 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
     ideal h1= (ideal)h->Data();
     h   = h->next;
     if((h != NULL)&&(h->Typ() == POLY_CMD))
     {
       poly p= (poly)h->Data();
       res->rtyp =INT_CMD;
       res->data =(void *)(long)valency(h1,p);
     }
  }
  return false;
}

value1()

static std::vector< std::vector< int > > value1 ( std::vector< std::vector< int > >  mvs, std::vector< std::vector< int > >  nvs, std::vector< std::vector< int > >  vecs, std::vector< int >  av, std::vector< int >  bv  )

static

Definition at line 2196 of file cohomo.cc.

{
  int j;
  std::vector<int> pv, base;
  std::vector<std::vector<int> > bases;
  for(unsigned t=0;t<vecs.size();t++)
  {
    for(unsigned i=0;i<mvs.size();i++)
    {
      pv=phimage(mvs[i],av,bv);
      for( j=0;j<nvs.size();j++)
      {
        if(vEvl(pv,nvs[j]))
        {
          base.push_back(vecs[t][j]);
          break;
        }
      }
      if(j==nvs.size())
      {
        base.push_back(0);
      }
    }
    if(base.size()!=mvs.size())
    {
      //WerrorS("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1");
      WerrorS("Errors in Equations solving (Values Finding)!");
      usleep(1000000);
      assert(false);
 
    }
    bases.push_back(base);
    base.clear();
  }
  return bases;
}

value1l()

static std::vector< std::vector< int > > value1l ( std::vector< std::vector< int > >  mvs, std::vector< std::vector< int > >  lks, std::vector< std::vector< int > >  vecs, std::vector< int >  av, std::vector< int >  bv  )

static

Definition at line 2659 of file cohomo.cc.

{
  int j;
  std::vector<int> pv;
  std::vector<int> base;
  std::vector<std::vector<int> > bases;
  for(unsigned t=0;t<vecs.size();t++)
  {
    for(unsigned i=0;i<mvs.size();i++)
    {
      pv=phimagel(mvs[i], av, bv);
      for(j=0;j<lks.size();j++)
      {
        if(vEvl(pv,lks[j]))
        {
          base.push_back(vecs[t][j]);break;
        }
      }
      //if(j==lks.size()) {base.push_back(0);}
    }
    if(base.size()!=mvs.size())
    {
      WerrorS("Errors in Values Finding(value1l)!");
      usleep(1000000);
      assert(false);
    }
    bases.push_back(base);
    base.clear();
  }
  return bases;
}

value2()

static std::vector< std::vector< int > > value2 ( std::vector< std::vector< int > >  mvs, std::vector< std::vector< int > >  nvs, std::vector< std::vector< int > >  mts, std::vector< std::vector< int > >  nts, std::vector< std::vector< int > >  vecs, std::vector< int >  av, std::vector< int >  bv  )

static

Definition at line 2459 of file cohomo.cc.

{
  int row,col,j;
  std::vector<int> pv,qv, base;
  std::vector<std::vector<int> > bases;
  //PrintS("This is the nabt:\n");
  //listsprint(nts);
  //PrintS("nabt ends:\n");
  //PrintS("This is the mabt:\n");
  //listsprint(mts);
  //PrintS("mabt ends:\n");
  for(unsigned t=0;t<vecs.size();t++)
  {
    for(unsigned i=0;i<mts.size();i++)
    {
      row=mts[i][0];
      col=mts[i][1];
      pv=phimage(mvs[row],av,bv);
      qv=phimage(mvs[col],av,bv);
      if(vEvl(pv,qv))
        base.push_back(0);
      else
      {
        for(j=0;j<nts.size();j++)
        {
          row=nts[j][0];
          col=nts[j][1];
          if(vEvl(pv,nvs[row])&&vEvl(qv,nvs[col]))
          {
            base.push_back(vecs[t][j]);break;
          }
          else if(vEvl(pv,nvs[col])&&vEvl(qv,nvs[row]))
          {
            base.push_back(-vecs[t][j]);break;
          }
        }
        if(j==nts.size()) {base.push_back(0);}
      }
    }
    if(base.size()!=mts.size())
    {
      WerrorS("Errors in Values Finding(value2)!");
       //WerrorS("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1");
      usleep(1000000);
      assert(false);
    }
    bases.push_back(base);
    base.clear();
  }
  return bases;
}

value2l()

static std::vector< std::vector< int > > value2l ( std::vector< std::vector< int > >  mvs, std::vector< std::vector< int > >  lks, std::vector< std::vector< int > >  mts, std::vector< std::vector< int > >  lkts, std::vector< std::vector< int > >  vecs, std::vector< int >  av, std::vector< int >  bv  )

static

Definition at line 2792 of file cohomo.cc.

{
  std::vector<int> pv,qv,base;
  int row,col,j;
  std::vector<std::vector<int> > bases;
  if(vecs.size()==0)
  {
 
  }
  for(unsigned t=0;t<vecs.size();t++)
  {
    for(unsigned i=0;i<mts.size();i++)
    {
      row=mts[i][0];
      col=mts[i][1];
      pv=phimagel(mvs[row],av,bv);
      qv=phimagel(mvs[col],av,bv);
      if(vEvl(pv,qv))
        base.push_back(0);
      else
      {
        for(j=0;j<lkts.size();j++)
        {
          row=lkts[j][0];
          col=lkts[j][1];
          if(vEvl(pv,lks[row])&&vEvl(qv,lks[col]))
          {
            base.push_back(vecs[t][j]);break;
          }
          else if(vEvl(qv,lks[row])&&vEvl(pv,lks[col]))
          {
            base.push_back(-vecs[t][j]);break;
          }
        }
        //if(j==lkts.size())
        //{
          //base.push_back(0);
        //}
      }
    }
    if(base.size()!=mts.size())
    {
       WerrorS("Errors in Values Finding!");
        //WerrorS("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1");
      usleep(1000000);
      assert(false);
    }
    bases.push_back(base);
    base.clear();
  }
  return bases;
}

vecbase1()

static std::vector< int > vecbase1 ( int  num, std::vector< int >  oset  )

static

Definition at line 1169 of file cohomo.cc.

{
  int i;
  std::vector<int> base;
  for(i=0;i<num;i++)
  {
    if(IsinL(i+1,oset))
      base.push_back(1);
    else
      base.push_back(0);
  }
  return base;
}

vecIntersection()

static std::vector< int > vecIntersection ( std::vector< int >  p, std::vector< int >  q  )

static

Definition at line 147 of file cohomo.cc.

{
  unsigned i;
  std::vector<int> inte;
  for(i=0;i<p.size();i++)
  {
    if(IsinL(p[i],q))
      inte.push_back(p[i]);
  }
  return inte;
}

vecMinus()

static std::vector< int > vecMinus ( std::vector< int >  vec1, std::vector< int >  vec2  )

static

Definition at line 212 of file cohomo.cc.

{
  std::vector<int> vec;
  for(unsigned i=0;i<vec1.size();i++)
  {
    if(!IsinL(vec1[i],vec2))
    {
      vec.push_back(vec1[i]);
    }
  }
  return vec;
}

vecqring()

static std::vector< std::vector< int > > vecqring ( std::vector< std::vector< int > >  vec1, std::vector< std::vector< int > >  vec2  )

static

Definition at line 454 of file cohomo.cc.

{
  ideal h1=idMake(vec1), h2=idMake(vec2);
  ideal h=idmodulo(h1,h2);
  std::vector<std::vector<int> > vecs= vsMake(h);
  return vecs;
}

vecUnion()

static std::vector< int > vecUnion ( std::vector< int >  vec1, std::vector< int >  vec2  )

static

Definition at line 200 of file cohomo.cc.

{
  std::vector<int> vec=vec1;
  unsigned i;
  for(i=0;i<vec2.size();i++)
  {
    if(!IsinL(vec2[i],vec))
      vec.push_back(vec2[i]);
  }
  return vec;
}

vertset()

static std::vector< int > vertset ( std::vector< std::vector< int > >  vecs )

static

Definition at line 1404 of file cohomo.cc.

{
  int i,j;
  std::vector<int> vert;
  std::vector<std::vector<int> > vvs;
  for(i=1;i<=currRing->N;i++)
  {
    for(j=0;j<vecs.size();j++)
    {
      if(IsinL(i, vecs[j]))
      {
        if(!IsinL(i , vert))
        {
          vert.push_back(i);
        }
        break;
      }
    }
  }
  return (vert);
}

vEvl()

static bool vEvl ( std::vector< int >  vec1, std::vector< int >  vec2  )

static

Definition at line 174 of file cohomo.cc.

{
  if(vec1.size()==0 && vec2.size()==0)
    return true;
  if(vsubset(vec1,vec2)&&vsubset(vec2,vec1))
    return true;
  return false;
}

vInp()

static bool vInp ( int  m, poly  p  )

static

Definition at line 405 of file cohomo.cc.

{
  poly q=pCopy(p);
  while (q!=NULL)
  {
    if(p_GetExp(q,m,currRing)!=0)
    {
      return true;
    }
    q=pNext(q);
  }
  return false;
}

vInvsl()

static bool vInvsl ( std::vector< int >  vec, std::vector< std::vector< int > >  vecs  )

static

Definition at line 186 of file cohomo.cc.

{
  int i;
  for(i=0;i<vecs.size();i++)
  {
    if(vEvl(vec,vecs[i]))
    {
      return true;
    }
  }
  return false;
}

vMake()

static std::vector< int > vMake ( poly  p )

static

Definition at line 420 of file cohomo.cc.

{
  int i;
  std::vector<int> vbase;
  for(i=1;i<=currRing->N;i++)
  {
    if(vInp(i,p))
    {
      vbase.push_back(pcoef(p,i));
    }
    else
    {
      vbase.push_back(0);
    }
  }
  return (vbase);
}

vs_subsets()

static std::vector< std::vector< int > > vs_subsets ( std::vector< std::vector< int > >  vs )

static

Definition at line 3236 of file cohomo.cc.

{
  std::vector<std::vector<int> >  sset, bv;
  for(unsigned i=0;i<vs.size();i++)
  {
    bv=b_subsets(vs[i]);
    sset=vsUnion(sset, bv);
  }
  return sset;
}

vsIntersec()

static BOOLEAN vsIntersec ( leftv  res, leftv  args  )

static

Definition at line 4138 of file cohomo.cc.

{
  leftv h=args;
  if((h != NULL)&&(h->Typ() == IDEAL_CMD))
  {
     ideal h1= (ideal)h->Data();
     h   = h->next;
     if((h != NULL)&&(h->Typ() == IDEAL_CMD))
     {
       ideal h2= (ideal)h->Data();
       res->rtyp =INT_CMD;
       std::vector<std::vector<int> > vs1=supports(h1), vs2=supports(h2);
       res->data =(void *)(long)(vsIntersection(vs1, vs2).size());
     }
  }
  return false;
}

vsIntersection()

static std::vector< std::vector< int > > vsIntersection ( std::vector< std::vector< int > >  vs1, std::vector< std::vector< int > >  vs2  )

static

Definition at line 253 of file cohomo.cc.

{
  int i;
  std::vector<std::vector<int> > vs;
  for(i=0;i<vs2.size();i++)
  {
    if(vInvsl(vs2[i],vs1))
    {
      vs.push_back(vs2[i]);
    }
  }
  return vs;
}

vsMake()

static std::vector< std::vector< int > > vsMake ( ideal  h )

static

Definition at line 439 of file cohomo.cc.

{
  std::vector<int> vec;
  std::vector<std::vector<int> > vecs;
  int i;
  for(i=0;i<IDELEMS(h);i++)
  {
    vec=vMake(h->m[i]);
    vecs.push_back(vec);
  }
  return vecs;
}

vsMinusv()

static std::vector< std::vector< int > > vsMinusv ( std::vector< std::vector< int > >  vecs, std::vector< int >  vec  )

static

Definition at line 225 of file cohomo.cc.

{
  int i;
  std::vector<std::vector<int> > rem;
  for(i=0;i<vecs.size();i++)
  {
    if(!vEvl(vecs[i],vec))
    {
      rem.push_back(vecs[i]);
    }
  }
  return (rem);
}

vsMinusvs()

static std::vector< std::vector< int > > vsMinusvs ( std::vector< std::vector< int > >  vs1, std::vector< std::vector< int > >  vs2  )

static

Definition at line 3226 of file cohomo.cc.

{
  std::vector<std::vector<int> > vs=vs1;
  for(unsigned i=0;i<vs2.size();i++)
  {
    vs=vsMinusv(vs, vs2[i]);
  }
  return vs;
}

vsubset()

static bool vsubset ( std::vector< int >  vec1, std::vector< int >  vec2  )

static

Definition at line 160 of file cohomo.cc.

{
  int i;
  if(vec1.size()>vec2.size())
    return false;
  for(i=0;i<vec1.size();i++)
  {
    if(!IsinL(vec1[i],vec2))
      return false;
  }
  return true;
}

vsUnion()

static std::vector< std::vector< int > > vsUnion ( std::vector< std::vector< int > >  vs1, std::vector< std::vector< int > >  vs2  )

static

Definition at line 239 of file cohomo.cc.

{
  int i;
  std::vector<std::vector<int> > vs=vs1;
  for(i=0;i<vs2.size();i++)
  {
    if(!vInvsl(vs2[i],vs))
    {
      vs.push_back(vs2[i]);
    }
  }
  return vs;
}

Variable Documentation

t_begin

VAR clock_t t_begin

Definition at line 2692 of file cohomo.cc.

t_construct

VAR clock_t t_construct =0

Definition at line 2692 of file cohomo.cc.

t_mark

VAR clock_t t_mark

Definition at line 2692 of file cohomo.cc.

t_solve

VAR clock_t t_solve =0

Definition at line 2692 of file cohomo.cc.

t_start

VAR clock_t t_start

Definition at line 2692 of file cohomo.cc.

t_total

VAR clock_t t_total =0

Definition at line 2692 of file cohomo.cc.

t_value

VAR clock_t t_value =0

Definition at line 2692 of file cohomo.cc.