int main(){
push(1);
push(2);
print();
printf("now pop:%d \n",pop());
print();
printf("now top:%d \n",findtop()->val);
printf("now pop:%d \n",pop());
printf(empty() ? "true" : "false");
printf(" \n");
printf("now pop:%d \n",pop());
return 0;
}
/*------------------------------------------------------------------------------
Spherical harmonics of sum of weighted polygons.
Input: poly = array of pointers to npoly polygons.
npoly = number of polygons in poly array.
mtol = initial angular tolerance in radians within which to merge multiple intersections.
lmax = maximum harmonic number.
Output: w = harmonics;
NW = ((lmax + 1)(lmax + 2))/ 2 is defined in harmonics.h.
Return value: number of polygons for which spherical harmonics were computed,
or -1 if error occurred.
*/
int harmonize_polys(int npoly, polygon *poly[/*npoly*/], double mtol, int lmax, harmonic w[/*NW*/])
{
int accelerate, i, ier, ip, ipoly, iq, ir, isrect, iw, naccelerate, ndone, ner, nrect;
double azmin, azmax, elmin, elmax, azmn, azmx, elmn, elmx, tol;
/* work array contains harmonics of single polygon */
harmonic *dw;
/* work arrays to deal with possible acceleration */
int *iord, *ir_to_ip;
double *elord;
/* work arrays */
dw = (harmonic *) malloc(sizeof(harmonic) * NW);
if (!dw) {
fprintf(stderr, "harmonize_polys: failed to allocate memory for %d harmonics\n", NW);
return(-1);
}
iord = (int *) malloc(sizeof(int) * npoly);
if (!iord) {
fprintf(stderr, "harmonize_polys: failed to allocate memory for %d ints\n", npoly);
return(-1);
}
ir_to_ip = (int *) malloc(sizeof(int) * npoly);
if (!ir_to_ip) {
fprintf(stderr, "harmonize_polys: failed to allocate memory for %d ints\n", npoly);
return(-1);
}
elord = (double *) malloc(sizeof(double) * npoly);
if (!elord) {
fprintf(stderr, "harmonize_polys: failed to allocate memory for %d doubles\n", npoly);
return(-1);
}
/* zero harmonics of mask */
for (iw = 0; iw < NW; iw++) {
for (i = 0; i < IM; i++) {
w[iw][i] = 0.;
}
}
/* determine which polygons are rectangles, for which acceleration may be possible */
nrect = 0;
ir = npoly;
for (ipoly = 0; ipoly < npoly; ipoly++) {
isrect = poly_to_rect(poly[ipoly], &azmin, &azmax, &elmin, &elmax);
if (isrect && poly[ipoly]->weight != 0.) {
ir_to_ip[nrect] = ipoly;
elord[nrect] = elmin * 1.e8 + elmax;
nrect++;
} else {
ir--;
ir_to_ip[ir] = ipoly;
}
}
msg("harmonize_polys: %d polygons are rectangles, for which acceleration may be possible\n",
nrect);
/* order rectangles by elmin, elmax */
findtop(elord, nrect, iord, nrect);
/* do each polygon */
ndone = 0;
naccelerate = 0;
ner = 0;
if (lmax >= LMAX_ADVICE) msg("doing polygon number (of %d):\n", npoly);
for (ip = 0; ip < npoly; ip++) {
if (lmax >= LMAX_ADVICE) msg(" %d", ip);
accelerate = 0;
/* rectangle */
if (ip < nrect) {
ir = iord[ip];
ipoly = ir_to_ip[ir];
poly_to_rect(poly[ipoly], &azmin, &azmax, &elmin, &elmax);
/* does previous rectangle have same elevation limits? */
if (ip > 0) {
iq = iord[ip - 1];
iq = ir_to_ip[iq];
poly_to_rect(poly[iq], &azmn, &azmx, &elmn, &elmx);
/* if so, use acceleration */
if (elmn == elmin && elmx == elmax) accelerate = 1;
}
/* if not, does next rectangle have same elevation limits? */
if (!accelerate && ip + 1 < nrect) {
iq = iord[ip + 1];
iq = ir_to_ip[iq];
poly_to_rect(poly[iq], &azmn, &azmx, &elmn, &elmx);
/* if so, worth accelerating */
if (elmn == elmin && elmx == elmax) accelerate = 1;
}
/* accelerated computation */
if (accelerate) {
ier = gsphra(azmin, azmax, elmin, elmax, lmax, dw);
if (ier == -1) return(-1);
/* standard computation */
} else {
tol = mtol;
ier = gsphr(poly[ipoly], lmax, &tol, dw);
if (ier == -1) return(-1);
}
/* non-rectangle */
} else {
ipoly = ir_to_ip[ip];
/* zero weight polygon requires no computation */
if (poly[ipoly]->weight == 0.) {
ndone++;
continue;
} else {
tol = mtol;
ier = gsphr(poly[ipoly], lmax, &tol, dw);
if (ier == -1) return(-1);
}
}
/* computation failed */
if (ier) {
ner++;
if (lmax >= LMAX_ADVICE) msg("\n");
fprintf(stderr, "harmonize_polys: computation failed for polygon %d; discard it\n", ipoly);
/* success */
} else {
naccelerate += accelerate;
ndone++;
/* increment harmonics of region */
for (iw = 0; iw < NW; iw++) {
for (i = 0; i < IM; i++) {
w[iw][i] += dw[iw][i] * poly[ipoly]->weight;
}
}
}
}
if (lmax >= LMAX_ADVICE) msg("\n");
/* number of computations that were accelerated */
msg("computation was accelerated for %d rectangles\n", naccelerate);
/* advise */
if (ner > 0) {
fprintf(stderr, "harmonize_polys: discarded %d polygons for which computations failed\n", ner);
}
msg("spherical harmonics of %d weighted polygons accumulated\n", ndone);
/* free work arrays */
free(dw);
free(iord);
free(ir_to_ip);
free(elord);
return(ndone);
}
