void writetens(tensor p)
{ char txt[STRSIZ];
int i,s;
int plus, first;
int isMono;
if(!p) {wrt_0("0"); return;}
if(p->next) plus=0; else plus=1;
for(; p; p=p->next)
{
strcpy(txt,"");
first = 1;
for (i = 1; i <= maxIndex; i++)
{
s = p->tens[i-1];
if(s < i && s)
{
if(first) first = 0; else strcat(txt,"*");
if(s > 0) sprintf(txt+strlen(txt),"m%d.m%d",i,s);
else sprintf(txt+strlen(txt),"p%d.m%d",-s,i);
}
}
isMono=0;
if(p->re && p->re->next==NULL && p->im==NULL) isMono=1;
if(p->im && p->im->next==NULL && p->re==NULL) isMono=1;
if(!isMono){if(plus) wrt_0("+("); else wrt_0("(");}
plus=1;
if(p->re) writepoly(p->re);
if(p->im)
{ if(p->im->next)
{ wrt_0("+i*(");
writepoly(p->im);
wrt_0(")");
} else {writepoly(p->im);wrt_0("*i");}
}
if(!isMono) wrt_0(")");
if(strlen(txt)) { wrt_0("*"); wrt_0(txt);}
}
}
void symb_print(char* txt, symb_data m)
{ char s[5];
int n;
tensor p;
wrt_0(txt);
switch(m.type)
{ case numbertp:
case polytp : writepoly(m.expr.p); break;
case tenstp : writetens(m.expr.t); break;
case spintp : writespinor(m.expr.s);break;
case etenstp: writeEtens(m.expr.et);break;
default:
if(m.type == vectortp)
{
p=m.expr.t;
if(p == NULL) wrt_0("0");
else
for(;p;p=p->next)
{ n=-p->tens[0];
sprintf(s,"p%d*(",n);
wrt_0(s);
if(p->re) writepoly(p->re);
if(p->im)
{ wrt_0("i*("); writepoly(p->re);wrt_0(")");}
wrt_0(")");
if(p->next) wrt_0("+");
}
}
else
{
n = m.expr.t->tens[0];
if(!n) n = 1;
sprintf(s,"l%d",n);
wrt_0(s);
writetens(m.expr.t);
}
}
writeF(";\n");
}
// Customized triangulation call.
void custom_triangulate(char *triswitches, struct triangulateio *in, struct triangulateio *out, struct triangulateio *vorout, const int *outside, const int *inside)
{
struct mesh m;
struct behavior b;
//REAL *holearray;
//REAL *regionarray;
triangleinit(& m);
parsecommandline(1, & triswitches, & b);
//b.verbose=2;
m.steinerleft = b.steiner;
transfernodes(& m, & b, in->pointlist, in->pointattributelist,
in->pointmarkerlist, in->numberofpoints,
in->numberofpointattributes);
if ( b.refine ) {
m.hullsize = reconstruct(& m, & b, in->trianglelist,
in->triangleattributelist, in->trianglearealist,
in->numberoftriangles, in->numberofcorners,
in->numberoftriangleattributes,
in->segmentlist, in->segmentmarkerlist,
in->numberofsegments);
} else {
m.hullsize = delaunay(& m, & b);
}
m.infvertex1 = ( vertex ) NULL;
m.infvertex2 = ( vertex ) NULL;
m.infvertex3 = ( vertex ) NULL;
if ( b.usesegments ) {
m.checksegments = 1;
if ( !b.refine ) {
formskeleton(& m, & b, in->segmentlist,
in->segmentmarkerlist, in->numberofsegments);
}
}
#if 0
struct osub subsegloop;
traversalinit(& m.subsegs);
subsegloop.ss = subsegtraverse(& m);
subsegloop.ssorient = 0;
while ( subsegloop.ss != ( subseg * ) NULL ) {
if ( subsegloop.ss != m.dummysub ) {
REAL *p1, *p2;
sorg(subsegloop, p1);
sdest(subsegloop, p2);
printf(" Connected (%f,%f) to (%f,%f)\n", p1 [ 0 ], p1 [ 1 ], p2 [ 0 ], p2 [ 1 ]);
subsegloop.ss = subsegtraverse(& m);
}
}
#endif
if ( b.poly && ( m.triangles.items > 0 ) ) {
//holearray = in->holelist;
m.holes = in->numberofholes;
//regionarray = in->regionlist;
m.regions = in->numberofregions;
if ( !b.refine ) {
/* Only increase quality if the regions are properly defined. */
int sane = custom_carveholes(& m, & b, outside, inside);
b.quality *= sane;
if ( sane == 0 ) {
printf("Probably bad PSLG\n");
exit(-1);
}
}
} else {
m.holes = 0;
m.regions = 0;
}
if ( b.quality && ( m.triangles.items > 0 ) ) {
enforcequality(& m, & b);
}
m.edges = ( 3l * m.triangles.items + m.hullsize ) / 2l;
if ( b.order > 1 ) {
highorder(& m, & b);
}
if ( !b.quiet ) {
printf("\n");
}
if ( b.jettison ) {
out->numberofpoints = m.vertices.items - m.undeads;
} else {
out->numberofpoints = m.vertices.items;
}
out->numberofpointattributes = m.nextras;
out->numberoftriangles = m.triangles.items;
out->numberofcorners = ( b.order + 1 ) * ( b.order + 2 ) / 2;
out->numberoftriangleattributes = m.eextras;
out->numberofedges = m.edges;
if ( b.usesegments ) {
out->numberofsegments = m.subsegs.items;
} else {
out->numberofsegments = m.hullsize;
}
if ( vorout != ( struct triangulateio * ) NULL ) {
vorout->numberofpoints = m.triangles.items;
vorout->numberofpointattributes = m.nextras;
vorout->numberofedges = m.edges;
}
if ( b.nonodewritten || ( b.noiterationnum && m.readnodefile ) ) {
if ( !b.quiet ) {
printf("NOT writing vertices.\n");
}
numbernodes(& m, & b);
} else {
writenodes(& m, & b, & out->pointlist, & out->pointattributelist,
& out->pointmarkerlist);
}
// Simp. always write the triangles.
writeelements(& m, & b, & out->trianglelist, & out->triangleattributelist);
if ( b.poly || b.convex ) {
writepoly(& m, & b, & out->segmentlist, & out->segmentmarkerlist);
out->numberofholes = m.holes;
out->numberofregions = m.regions;
if ( b.poly ) {
out->holelist = in->holelist;
out->regionlist = in->regionlist;
} else {
out->holelist = ( REAL * ) NULL;
out->regionlist = ( REAL * ) NULL;
}
}
if ( b.edgesout ) {
writeedges(& m, & b, & out->edgelist, & out->edgemarkerlist);
}
// Simp. no voronoi
if ( b.neighbors ) {
writeneighbors(& m, & b, & out->neighborlist);
}
// Simp. No statistics.
if ( b.docheck ) {
checkmesh(& m, & b);
checkdelaunay(& m, & b);
}
triangledeinit(& m, & b);
}
