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

std::vector< std::vector< int > > b_subsets

(

std::vector< int >

vec

)

Definition at line 607 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()

std::vector< std::vector< int > > boundary

(

poly

a

)

Definition at line 4080 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()

BOOLEAN bprime	(	leftv	res,
		leftv	args
	)

Definition at line 4987 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()

std::vector< std::vector< int > > bsubsets_1

(

poly

b

)

Definition at line 4129 of file cohomo.cc.

{
  std::vector<int>  bvs=support1(b), vs;
  std::vector<std::vector<int> > bset;
  for(int 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()

ideal c_New	(	ideal	Io,
		ideal	sig
	)

Definition at line 3849 of file cohomo.cc.

{
  poly p, q, g;
  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()

std::vector< std::vector< int > > canonicalbase

(

int

n

)

Definition at line 2176 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()

BOOLEAN cNew	(	leftv	res,
		leftv	args
	)

Definition at line 5041 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 5328 of file cohomo.cc.

{
  firstorderdef_setup(p);
  return MAX_TOK;
}

comedg()

BOOLEAN comedg	(	leftv	res,
		leftv	args
	)

Definition at line 4311 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()

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

Definition at line 3574 of file cohomo.cc.

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

complementsimplex()

ideal complementsimplex

(

ideal

h

)

Definition at line 1012 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()

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

Definition at line 2062 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()

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
	)

Definition at line 2077 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()

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

Definition at line 2873 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()

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

Definition at line 2095 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()

int dim_sim

(

ideal

h

)

Definition at line 1037 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()

BOOLEAN dimsim	(	leftv	res,
		leftv	args
	)

Definition at line 5237 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()

intvec * dmat	(	poly	a,
		poly	b
	)

Definition at line 4272 of file cohomo.cc.

{
  intvec *m;
  int i,j;
  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()

intvec * edgemat	(	poly	p,
		poly	q
	)

Definition at line 3587 of file cohomo.cc.

{
  intvec *m;
  int i,j;
  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()

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

Definition at line 1187 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()

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

Definition at line 1478 of file cohomo.cc.

{
  int i,j;
  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()

BOOLEAN eqsolve1	(	leftv	res,
		leftv	args
	)

Definition at line 4652 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()

void equmab

(

int

num

)

Definition at line 1894 of file cohomo.cc.

{
  int i,j;
  //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()

int existIn	(	poly	b,
		ideal	Xs
	)

Definition at line 3952 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(int i=0;i<bs.size();i++)
  {
    if(!vInvsl(bs[i], xvs))
    {
      return 1;
    }
  }
  return 0;
}

existsub()

BOOLEAN existsub	(	leftv	res,
		leftv	args
	)

Definition at line 4901 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()

BOOLEAN fa	(	leftv	res,
		leftv	args
	)

Definition at line 4390 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()

BOOLEAN fb	(	leftv	res,
		leftv	args
	)

Definition at line 4331 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()

BOOLEAN fgp	(	leftv	res,
		leftv	args
	)

Definition at line 4413 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()

BOOLEAN fgpl	(	leftv	res,
		leftv	args
	)

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() == 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()

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

Definition at line 1105 of file cohomo.cc.

{
  poly e=pOne();
  ideal h2=id_complement(h), aset=idInit(1,1);
  int i,j,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()

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

Definition at line 2274 of file cohomo.cc.

{
  std::vector<int> alset;
  for(int 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()

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

Definition at line 2891 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()

ideal findb

(

ideal

h

)

Definition at line 1076 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()

void firstorderdef_setup

(

SModulFunctions *

p

)

Definition at line 5272 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()

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

Definition at line 1279 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()

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

Definition at line 1303 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()

BOOLEAN gd	(	leftv	res,
		leftv	args
	)

Definition at line 4292 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()

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

Definition at line 4040 of file cohomo.cc.

{
  int i,j;
  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()

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

Definition at line 2705 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()

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

Definition at line 2986 of file cohomo.cc.

{
  int i,j;
  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(i=0;i<pvs.size();i++)
  {
    idInsertPoly(gens,pvs[i][0]);
    idInsertPoly(gens,pvs[i][1]);
  }
  idSkipZeroes(gens);
  return (gens);
}

genstt()

BOOLEAN genstt	(	leftv	res,
		leftv	args
	)

Definition at line 4465 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()

ideal getpresolve

(

ideal

h

)

Definition at line 2122 of file cohomo.cc.

{
  //ring r=currRing;
  int i;
  //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()

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

Definition at line 2200 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()

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

Definition at line 3202 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],av,bv))
        {
          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()

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

Definition at line 3349 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()

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

Definition at line 1986 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()

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

Definition at line 2764 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],av,bv))
        {
          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()

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

Definition at line 3267 of file cohomo.cc.

{
  t_start=clock();
  int i,j,co;
  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()

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

Definition at line 2371 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()

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

Definition at line 3011 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()

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

Definition at line 3422 of file cohomo.cc.

{
  int i,j,t;
  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()

ideal id_complement

(

ideal

h

)

Definition at line 832 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()

int id_maxdeg

(

ideal

h

)

Definition at line 890 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()

void id_print

(

ideal

h

)

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()

ideal id_sfmon

(

ideal

h

)

Definition at line 808 of file cohomo.cc.

{
  ideal asfmons,sfmons,mons,p;
  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;
}

id_subsets()

std::vector< std::vector< int > > id_subsets

(

std::vector< std::vector< int > >

vecs

)

Definition at line 1645 of file cohomo.cc.

{
  int i,j;
  std::vector<std::vector<int> > vvs, res;
  for(i=0;i<vecs.size();i++)
  {
    vvs=b_subsets(vecs[i]);
    //listsprint(vvs);
    for(j=0;j<vvs.size();j++)
    {
      if(!vInvsl(vvs[j],res))
        res.push_back(vvs[j]);
    }
  }
  //listsprint(res);
  return (res);
}

idadda()

ideal idadda	(	ideal	h1,
		ideal	h2
	)

Definition at line 965 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()

BOOLEAN idcomplement	(	leftv	res,
		leftv	args
	)

Definition at line 4220 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()

ideal idMake

(

std::vector< std::vector< int > >

vecs

)

Definition at line 455 of file cohomo.cc.

{
  int lv=vecs.size(), i, j;
  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()

ideal idMake3

(

std::vector< std::vector< int > >

vecs

)

Definition at line 1877 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()

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

Definition at line 1959 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()

ideal idMaken

(

std::vector< std::vector< int > >

vecs

)

Definition at line 587 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()

ideal idMinus	(	ideal	h1,
		ideal	h2
	)

Definition at line 736 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()

BOOLEAN idminus	(	leftv	res,
		leftv	args
	)

Definition at line 5118 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()

ideal idMinusp	(	ideal	I,
		poly	p
	)

Definition at line 4003 of file cohomo.cc.

{
  ideal h=idInit(1,1);
  int i,j,eq=0;
  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()

ideal idmodulo	(	ideal	h1,
		ideal	h2
	)

Definition at line 474 of file cohomo.cc.

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

idModulo()

BOOLEAN idModulo	(	leftv	res,
		leftv	args
	)

Definition at line 5100 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()

BOOLEAN idsr	(	leftv	res,
		leftv	args
	)

Definition at line 4250 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()

ideal idsrRing

(

ideal

h

)

Definition at line 910 of file cohomo.cc.

{
  int max,i,j,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()

int idvert

(

ideal

h

)

Definition at line 634 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()

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

Definition at line 3988 of file cohomo.cc.

{
  int i;
  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()

BOOLEAN ifIsomorphism	(	leftv	res,
		leftv	args
	)

Definition at line 5166 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()

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

Definition at line 143 of file cohomo.cc.

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

IsInX()

bool IsInX	(	poly	p,
		ideal	X
	)

Definition at line 856 of file cohomo.cc.

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

isoNum()

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

Definition at line 3968 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()

BOOLEAN isoNumber	(	leftv	res,
		leftv	args
	)

Definition at line 5137 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()

BOOLEAN isSim	(	leftv	res,
		leftv	args
	)

Definition at line 4552 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()

ideal IsSimplex

(

ideal

h

)

Definition at line 990 of file cohomo.cc.

{
  int i,j,ifbreak=0,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()

std::vector< int > keeporder

(

std::vector< int >

vec

)

Definition at line 1230 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()

BOOLEAN linkn	(	leftv	res,
		leftv	args
	)

Definition at line 4867 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()

BOOLEAN Links	(	leftv	res,
		leftv	args
	)

Definition at line 4534 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()

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

Definition at line 1527 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()

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

Definition at line 3924 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, vert);
    lkn=vsMinusvs(lko, lk1);
    lkn=vsUnion(lkn, lk2);
    return lkn;
  }
  if(ord==3)
  {
    lkn=phi2(a, Xo, Sigma, vert);
    return lkn;
  }
  WerrorS("Cannot find the links smartly!");
  return lko;
}

listprint()

void listprint

(

std::vector< int >

vec

)

Definition at line 49 of file cohomo.cc.

{
  int 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()

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

Definition at line 1828 of file cohomo.cc.

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

listsprint()

void listsprint

(

std::vector< std::vector< int > >

posMat

)

Definition at line 65 of file cohomo.cc.

{
  int i,j;
  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()

void lpprint

(

std::vector< poly >

pv

)

Definition at line 97 of file cohomo.cc.

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

lpsprint()

void lpsprint

(

std::vector< std::vector< poly > >

pvs

)

Definition at line 114 of file cohomo.cc.

{
  for(int 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()

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

Definition at line 1141 of file cohomo.cc.

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

mabtv()

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
	)

Definition at line 2345 of file cohomo.cc.

{
  std::vector<int> v1,var;
  std::vector<std::vector<int> > vars;
  for(int i=0;i<Mv.size();i++)
  {
    for(int 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()

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

Definition at line 1154 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(int i=0;i<h2v.size();i++)
  {
    pv=h2v[i];
    if(mabconditionv(hvs,pv,av,bv))
    {
      vecs.push_back(pv);
    }
  }
  return vecs;
}

mabvl()

BOOLEAN mabvl	(	leftv	res,
		leftv	args
	)

Definition at line 4808 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()

std::vector< int > make0

(

int

n

)

Definition at line 1390 of file cohomo.cc.

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

make1()

std::vector< int > make1

(

int

n

)

Definition at line 1404 of file cohomo.cc.

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

makeequation()

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

Definition at line 1841 of file cohomo.cc.

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

makemab()

ideal makemab	(	ideal	h,
		poly	a,
		poly	b
	)

Definition at line 4021 of file cohomo.cc.

{
  std::vector<std::vector<int> > mv=Mabv(h,a,b);
  ideal M=idMaken(mv);
  return M;
}

makeSimplex()

BOOLEAN makeSimplex	(	leftv	res,
		leftv	args
	)

Definition at line 4358 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()

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

Definition at line 2724 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()

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

Definition at line 2740 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()

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

Definition at line 2485 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()

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

Definition at line 2526 of file cohomo.cc.

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

nabtv()

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
	)

Definition at line 2539 of file cohomo.cc.

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

nabtvl()

BOOLEAN nabtvl	(	leftv	res,
		leftv	args
	)

Definition at line 4832 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(int 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()

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

Definition at line 2504 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()

BOOLEAN nabvl	(	leftv	res,
		leftv	args
	)

Definition at line 4730 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()

BOOLEAN newDegree	(	leftv	res,
		leftv	args
	)

Definition at line 5204 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 4565 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()

BOOLEAN nfaces2	(	leftv	res,
		leftv	args
	)

Definition at line 4588 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()

BOOLEAN nfaces3	(	leftv	res,
		leftv	args
	)

Definition at line 4616 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()

BOOLEAN nonf2f	(	leftv	res,
		leftv	args
	)

Definition at line 5223 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()

int num4dim	(	ideal	h,
		int	n
	)

Definition at line 1051 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()

BOOLEAN numdim	(	leftv	res,
		leftv	args
	)

Definition at line 5251 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()

std::vector< int > numfree

(

ideal

h

)

Definition at line 2153 of file cohomo.cc.

{
  int i,j,num=0;
  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()

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

Definition at line 1444 of file cohomo.cc.

{
  int i,j,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()

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

Definition at line 1420 of file cohomo.cc.

{
  int i,j,m;
  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()

ideal p_a

(

ideal

h

)

Definition at line 1572 of file cohomo.cc.

{
  poly e=pOne(), 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()

ideal p_b	(	ideal	h,
		poly	a
	)

Definition at line 1689 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, j, nu=res.size(), 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()

std::vector< std::vector< int > > p_change

(

ideal

Sigma

)

Definition at line 3806 of file cohomo.cc.

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

p_constant()

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

Definition at line 3797 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()

bool p_Ifsfree

(

poly

P

)

Definition at line 764 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()

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

Definition at line 3815 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()

BOOLEAN p_New	(	leftv	res,
		leftv	args
	)

Definition at line 4950 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()

BOOLEAN pa	(	leftv	res,
		leftv	args
	)

Definition at line 4344 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()

BOOLEAN pb	(	leftv	res,
		leftv	args
	)

Definition at line 4371 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()

BOOLEAN pChange	(	leftv	res,
		leftv	args
	)

Definition at line 4936 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()

int pcoef	(	poly	p,
		int	m
	)

Definition at line 486 of file cohomo.cc.

{
  int i,j,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()

BOOLEAN pConstant	(	leftv	res,
		leftv	args
	)

Definition at line 4919 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()

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

Definition at line 3649 of file cohomo.cc.

{
  int i, 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(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(i=0;i<evec.size();i++)
    {
      if(evec[i].size()==2)
      {
        fvs3=vsMinusv(fvs3, evec[i]);
      }
    }
    for(i=0;i<fvs3.size();i++)
    {
      vec=fvs3[i];
      vec.push_back(vert);
      fvs.push_back(vec);
    }
  }
  return (fvs);
}

phi1()

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

Definition at line 3888 of file cohomo.cc.

{
  std::vector<std::vector<int> > ss=supports(idCopy(Sigma)), fvs;
  std::vector<int> av=support1(a), intvec, vv;
  for(int 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()

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

Definition at line 3906 of file cohomo.cc.

{
 
  std::vector<std::vector<int> > ss=p_new(Sigma, Xo), fvs;
  std::vector<int> av=support1(a), intvec, vv;
  for(int 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()

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

Definition at line 2613 of file cohomo.cc.

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

phimagel()

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

Definition at line 3140 of file cohomo.cc.

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

pMake()

poly pMake

(

std::vector< int >

vbase

)

Definition at line 436 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()

poly pMake3

(

std::vector< int >

vbase

)

Definition at line 1858 of file cohomo.cc.

{
  int n=vbase.size(),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()

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

Definition at line 1943 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()

poly pMaken

(

std::vector< int >

vbase

)

Definition at line 573 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()

BOOLEAN psMinusp	(	leftv	res,
		leftv	args
	)

Definition at line 5001 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()

ideal psubset

(

poly

p

)

Definition at line 1804 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()

int pvert

(

poly

p

)

Definition at line 656 of file cohomo.cc.

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

qringadd()

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

Definition at line 877 of file cohomo.cc.

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

redefinedeg()

int redefinedeg	(	poly	p,
		int	num
	)

Definition at line 1551 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()

ideal sfreemon	(	ideal	h,
		int	deg
	)

Definition at line 781 of file cohomo.cc.

{
  int i,j,t;
  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()

BOOLEAN sgp	(	leftv	res,
		leftv	args
	)

Definition at line 4488 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()

BOOLEAN sgpl	(	leftv	res,
		leftv	args
	)

Definition at line 4511 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()

ideal SimFacset

(

poly

p

)

Definition at line 941 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()

std::vector< std::vector< int > > soleli1

(

std::vector< std::vector< int > >

eqs

)

Definition at line 1244 of file cohomo.cc.

{
  int i,j;
  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()

BOOLEAN SRideal	(	leftv	res,
		leftv	args
	)

Definition at line 4203 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()

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

Definition at line 4063 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()

BOOLEAN stars	(	leftv	res,
		leftv	args
	)

Definition at line 5061 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()

BOOLEAN stellarremain	(	leftv	res,
		leftv	args
	)

Definition at line 5020 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()

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

Definition at line 4095 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()

BOOLEAN stellarsubdivision	(	leftv	res,
		leftv	args
	)

Definition at line 5081 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()

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

Definition at line 1917 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()

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

Definition at line 2326 of file cohomo.cc.

{
  int i,j;
  std::vector<int> alset=findalpha(mv,bv), 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;
}

subspacet1()

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

Definition at line 2296 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()

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

Definition at line 2910 of file cohomo.cc.

{
  int i,j;
  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()

BOOLEAN support	(	leftv	res,
		leftv	args
	)

Definition at line 4970 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()

std::vector< int > support1

(

poly

p

)

Definition at line 355 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()

std::vector< int > support2

(

poly

p

)

Definition at line 396 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()

std::vector< std::vector< int > > supports

(

ideal

h

)

Definition at line 376 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()

std::vector< std::vector< int > > supports2

(

ideal

h

)

Definition at line 420 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()

void T1

(

ideal

h

)

Definition at line 2836 of file cohomo.cc.

{
  ideal bi=findb(h),ai;
  int mm=0,index=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()

BOOLEAN t1h	(	leftv	res,
		leftv	args
	)

Definition at line 4237 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()

void T2

(

ideal

h

)

Definition at line 3095 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);
        gp++;
      }
    }
    mm=mm+1;
  }
  if(mm==IDELEMS(bi))
      PrintS("Finished!\n");
  Print("There are %d graded pieces in total.\n",gp);
}

T_1h()

ideal T_1h

(

ideal

h

)

Definition at line 4148 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()

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

Definition at line 3606 of file cohomo.cc.

{
  int i;
  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(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 3191 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()

intvec * Tmat

(

std::vector< std::vector< int > >

vecs

)

Definition at line 2670 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()

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

Definition at line 2570 of file cohomo.cc.

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

tnab()

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

Definition at line 2591 of file cohomo.cc.

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

tnabvl()

BOOLEAN tnabvl	(	leftv	res,
		leftv	args
	)

Definition at line 4756 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(int i=0;i<tnv.size();i++)
         {
           tnbr.push_back(nvs[tnv[i]]);
         }
         res->data =idMaken(tnbr);
       }
     }
  }
  return false;
}

triangulations1()

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

Definition at line 3530 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()

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

Definition at line 3630 of file cohomo.cc.

{
  int i,j;
  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()

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

Definition at line 3695 of file cohomo.cc.

{
  int i,j;
  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(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()

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

Definition at line 3504 of file cohomo.cc.

{
  int i;
  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(i=0;i<fvs0.size();i++)
  {
    vec=fvs0[i];
    vec.push_back(vert);
    fvs.push_back(vec);
  }
  return (fvs);
}

trisets()

ideal trisets

(

ideal

h

)

Definition at line 3485 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()

BOOLEAN tsets	(	leftv	res,
		leftv	args
	)

Definition at line 4694 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()

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

Definition at line 4029 of file cohomo.cc.

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

vAbsorb()

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

Definition at line 1323 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()

int valency	(	ideal	h,
		poly	p
	)

Definition at line 3722 of file cohomo.cc.

{
  int i, 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(i=0;i<vecs.size();i++)
  {
    if(vecs[i].size()==2 && IsinL(ver, vecs[i]))
      val++;
  }
  return (val);
}

Valency()

BOOLEAN Valency	(	leftv	res,
		leftv	args
	)

Definition at line 4710 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()

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
	)

Definition at line 2624 of file cohomo.cc.

{
  int j;
  std::vector<int> pv, base;
  std::vector<std::vector<int> > bases;
  for(int t=0;t<vecs.size();t++)
  {
    for(int 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()

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
	)

Definition at line 3152 of file cohomo.cc.

{
  int j;
  std::vector<int> pv;
  std::vector<int> base;
  std::vector<std::vector<int> > bases;
  for(int t=0;t<vecs.size();t++)
  {
    for(int 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()

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
	)

Definition at line 2931 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(int t=0;t<vecs.size();t++)
  {
    for(int 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()

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
	)

Definition at line 3295 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(int t=0;t<vecs.size();t++)
  {
    for(int 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()

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

Definition at line 1372 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()

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

Definition at line 162 of file cohomo.cc.

{
  int 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()

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

Definition at line 281 of file cohomo.cc.

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

vecqring()

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

Definition at line 559 of file cohomo.cc.

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

vecUnion()

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

Definition at line 267 of file cohomo.cc.

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

vertset()

std::vector< int > vertset

(

std::vector< std::vector< int > >

vecs

)

Definition at line 1666 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);
}

vEv()

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

Definition at line 184 of file cohomo.cc.

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

vEvl()

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

Definition at line 220 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()

bool vInp	(	int	m,
		poly	p
	)

Definition at line 505 of file cohomo.cc.

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

vInvs()

int vInvs	(	std::vector< int >	vec,
		std::vector< std::vector< int > >	vecs
	)

Definition at line 251 of file cohomo.cc.

{
  int i;
  for(i=0;i<vecs.size();i++)
  {
    if(vEv(vec,vecs[i]))
    {
      return i+1;
    }
  }
  return -1;
}

vInvsl()

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

Definition at line 233 of file cohomo.cc.

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

vMake()

std::vector< int > vMake

(

poly

p

)

Definition at line 523 of file cohomo.cc.

{
  int i; poly q=pCopy(p);
  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()

std::vector< std::vector< int > > vs_subsets

(

std::vector< std::vector< int > >

vs

)

Definition at line 3784 of file cohomo.cc.

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

vsIntersec()

BOOLEAN vsIntersec	(	leftv	res,
		leftv	args
	)

Definition at line 4789 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()

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

Definition at line 333 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()

std::vector< std::vector< int > > vsMake

(

ideal

h

)

Definition at line 543 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()

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

Definition at line 299 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()

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

Definition at line 3772 of file cohomo.cc.

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

vsubset()

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

Definition at line 206 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()

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

Definition at line 314 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 3187 of file cohomo.cc.

t_construct

VAR clock_t t_construct =0

Definition at line 3187 of file cohomo.cc.

t_mark

VAR clock_t t_mark

Definition at line 3187 of file cohomo.cc.

t_solve

VAR clock_t t_solve =0

Definition at line 3187 of file cohomo.cc.

t_start

VAR clock_t t_start

Definition at line 3187 of file cohomo.cc.

t_total

VAR clock_t t_total =0

Definition at line 3187 of file cohomo.cc.

t_value

VAR clock_t t_value =0

Definition at line 3187 of file cohomo.cc.