pm_genproc_cleanedup.c

mpi程序

void Q_Enqueue(q, r)
rect_queue *q;
rect *r;
{

  Q_Checksize(q);
  q->r[q->tail] = *r;

  if (++q->tail == q->size)
    q->tail = 0;


}


void Q_Dequeue(q, r)
rect_queue *q;
rect *r;
{

  *r = q->r[q->head];

  if (++q->head == q->size)
    q->head = 0;
  if (q->randomize && ((q->head == q->randomPt) ||
		       (q->head == q->randomPt + 1))) {
    int i, j, numItems;
    rect temp;
    numItems = (q->tail < q->head)
       ? q->size - q->head + q->tail
       : q->tail - q->head;
    for (i = q->head; i != q->tail; i++) {
      j = (int) (drand48() * numItems) + q->head;
      if (j >= q->size)
	j -= q->size;
      temp = q->r[j];
      q->r[j] = q->r[i];
      q->r[i] = temp;
      if (i == q->size - 1) {
	i = -1;
      }
    }
    q->randomPt = q->tail;
  }
}




int RectBorderLen(r)
rect *r;
{
  return (r->r - r->l) ?
     (r->b - r->t) ?
     (2 * (r->r - r->l + r->b - r->t))
     :
     (r->r - r->l + 1)
     :
     (r->b - r->t) ?
     (r->b - r->t + 1)
     :
     1;
}


PrintHelp(progName)
char *progName;
{
  printf("Options recognized by %s:\n", progName);
  printf("(defaults are in parentheses () )\n");



  printf("   -i <filename>              (none) input file\n");

  printf("   -l <filename>              (\"%s\") name of log file\n", 0);

  printf("   -xpos <xpos>               (%d) window horizontal coordinate\n",
	 -1);
  printf("   -ypos <xpos>               (%d) window vertical coordinate\n",
	 -1);
  printf("   -width <width>             (%d) width of computed area in points\n", 500);
  printf("   -height <height>           (%d) height of computed area in points\n", 500);
  printf("   -boundary <boundary>       (%.1lf) boundary value for M-set computation\n", 2.0);
  printf("   -maxiter <max. iter>       (%d) maximum # of iterations for M-set\n", 1000);
  printf("                              compuptation algorithm\n");
  printf("   -rmin <real min.>          (%.2lf) minimum real coordinate of computed area\n", -2.0);
  printf("   -rmax <real max.>          (%.2lf) maximum real coordinate of computed area\n", 2.0);
  printf("   -imin <imag. min.>         (%.2lf) minimum imaginary coordinate of computed\n", -2.0);
  printf("                              area\n");
  printf("   -imax <imag. max.>         (%.2lf) maximum imaginary coordinate of computed\n", 2.0);
  printf("                              area\n");
  printf("\n");
  printf("      alternate form: (if specified, overrides <r|i><min|max>)\n");
  printf("   -rcenter <real center>     (%.2lf) center real coordinate of computed area\n", (-2.0 + 2.0) / 2);
  printf("   -icenter <imag. center>    (%.2lf) center imaginary coordinate of computed\n", (-2.0 + 2.0) / 2);
  printf("                              area\n");
  printf("   -radius <area radius>      (%.2lf) radius of the computed area\n", (2.0 - -2.0));
  printf("\n");
  printf("   -breakout <breakout size>  (%d) maximum length or width rectangle to\n", 12);
  printf("                              subdivide\n");
  printf("   -colors <# of colors>      (%d) number of colors to request\n", 16);
  printf("   -colreduce <reduce factor> (%d) factor by which to scale down iteration\n", 4);
  printf("                              values to reduce color changes\n");
  printf("   <+,->zoom                  (%s) turn on (off) drag&zoom\n",
	 1 ? "on" : "off");
  printf("   <+,->randomize             (%sset) (on,off) compute regions in as random of\n",
	 1 ? "" : "not ");
  printf("                              order as possible\n");




  printf("   -bw                        (%sset) draw in black and white instead of\n", 0 ? "" : "not ");
  printf("                              color\n");
  exit(0);
}


MPE_Color Iter2Color(flags, iter)
Flags *flags;
int iter;
{
  if (flags->winspecs->bw) {
    return ((iter == flags->maxiter) ? MPE_BLACK :
	    ((iter / flags->colReduceFactor) % 2) ? MPE_WHITE : MPE_BLACK);
  } else {
    if (iter == flags->maxiter) {
      return MPE_BLACK;
    } else {
      return flags->winspecs->colorArray[(iter / flags->colReduceFactor) %
					 flags->winspecs->numColors];
    }
  }
}


ChunkIter2Color(flags, iterData, colorData, size)
Flags *flags;
int *iterData, size;
int *colorData;
{
  int i;

  for (i = 0; i < size; i++) {
    *colorData = Iter2Color(flags, *iterData);

    colorData++;
    iterData++;
  }
}




ComputeChunk(flags, r, pointData, iterData, maxnpoints, npoints)
Flags *flags;
rect *r;
int *iterData, maxnpoints, *npoints;
MPE_Point *pointData;
{
  int i, x, y;

  CalcField(flags->fractal, iterData, r->l, r->r, r->t, r->b);


  *npoints = (r->r - r->l + 1) * (r->b - r->t + 1);
  x = r->l;
  y = r->t;
  for (i = 0; i < *npoints; i++) {
    pointData[i].x = x++;
    pointData[i].y = y;
    pointData[i].c = Iter2Color(flags, iterData[i]);

    if (x > r->r) {
      x = r->l;
      y++;
    }
  }
  return 0;
}



DrawChunk(graph, colorData, r)
MPE_XGraph graph;
int *colorData;
rect r;
{
  int a, b;

  for (b = r.t; b <= r.b; b++) {
    for (a = r.l; a <= r.r; a++) {
      MPE_Draw_point(graph, a, b, *colorData);

      colorData++;
    }
  }
  MPE_Update(graph);
  return 0;
}








































int ComputeBorder(winspecs, flags, rectPtr, pointData, maxnpoints,
		   npoints, isContinuous)
Winspecs *winspecs;
Flags *flags;
rect *rectPtr;
MPE_Point *pointData;
int maxnpoints, *npoints, *isContinuous;
{
  register double re, im, rstep, istep;
  register int x, y;
  register MPE_Point *pointPtr;
  register MPE_Color firstColor;
  rect r;

  r = *rectPtr;



  {
    (re) = (((((((double) ((r.l) - (0)))) * ((((((flags->rmax)) - ((flags->rmin)))) / (((double) ((
		      winspecs->width - 1) - (0)))))))) + ((flags->rmin))));
  };
  {
    (im) = (((((((double) ((r.t) - (0)))) * ((((((flags->imin)) - ((flags->imax)))) / (((double) ((
		     winspecs->height - 1) - (0)))))))) + ((flags->imax))));
  };
  {
    (rstep) = (((((flags->rmax) - (flags->rmin))) / (
					((double) (winspecs->width - 1)))));
  };
  {
    (istep) = (((((flags->imin) - (flags->imax))) / (
				       ((double) (winspecs->height - 1)))));
  };

  pointPtr = pointData + 1;
  pointData->x = r.l;
  pointData->y = r.t;
  pointData->c = firstColor = Iter2Color(flags,
			 (flags->fractal == MBROT) ? MbrotCalcIter(re, im) :
			 (flags->fractal == JULIA) ? JuliaCalcIter(re, im) :
					 MbrotCalcIter(re, im));


  *npoints = r.length;



  switch (flags->fractal) {
  case MBROT:
    if (r.b - r.t > 1 && r.r - r.l > 1) {
      (y = r.t, x = r.l + 1);
      while (x <= r.r) {
	n {
	  (re) = (((re) + (rstep)));
	};
	pointPtr->x = x;
	pointPtr->y = y;
	pointPtr->c = Iter2Color(flags, MbrotCalcIter(re, im));
	if (pointPtr->c != firstColor)
	  goto m1;
	(pointPtr++, x++);
      };;;
      (x = r.r, y = r.t + 1);
      while (y <= r.b) {{
	  (im) = (((im) + (istep)));
      };
      pointPtr->x = x;
      pointPtr->y = y;
      pointPtr->c = Iter2Color(flags, MbrotCalcIter(re, im));
      if (pointPtr->c != firstColor)
	goto m2;
	(pointPtr++, y++);
      };;;
      (y = r.b, x = r.r - 1);
      while (x >= r.l) {{
	  (re) = (((re) - (rstep)));
      };
      pointPtr->x = x;
      pointPtr->y = y;
      pointPtr->c = Iter2Color(flags, MbrotCalcIter(re, im));
      if (pointPtr->c != firstColor)
	goto m3;
	(pointPtr++, x--);
      };;;
      (x = r.l, y = r.b - 1);
      while (y > r.t) {{
	  (im) = (((im) - (istep)));
      };
      pointPtr->x = x;
      pointPtr->y = y;
      pointPtr->c = Iter2Color(flags, MbrotCalcIter(re, im));
      if (pointPtr->c != firstColor)
	goto m4;
	(pointPtr++, y--);
      };;;
      *isContinuous = 1;
      return 1;
      (y = r.t, x = r.l + 1);
      while (x <= r.r) {{
	  (re) = (((re) + (rstep)));
      };
      pointPtr->x = x;
      pointPtr->y = y;
      pointPtr->c = Iter2Color(flags, MbrotCalcIter(re, im));;
  m1:(pointPtr++, x++);
      };;;
      (x = r.r, y = r.t + 1);
      while (y <= r.b) {{
	  (im) = (((im) + (istep)));
      };
      pointPtr->x = x;
      pointPtr->y = y;
      pointPtr->c = Iter2Color(flags, MbrotCalcIter(re, im));;
  m2:(pointPtr++, y++);
      };;;
      (y = r.b, x = r.r - 1);
      while (x >= r.l) {{
	  (re) = (((re) - (rstep)));
      };
      pointPtr->x = x;
      pointPtr->y = y;
      pointPtr->c = Iter2Color(flags, MbrotCalcIter(re, im));;
  m3:(pointPtr++, x--);
      };;;
      (x = r.l, y = r.b - 1);
      while (y > r.t) {{
	  (im) = (((im) - (istep)));
      };
      pointPtr->x = x;
      pointPtr->y = y;
      pointPtr->c = Iter2Color(flags, MbrotCalcIter(re, im));;
  m4:(pointPtr++, y--);
      };;;
      *isContinuous = 0;
      return 0;
    } else {
      (y = r.t, x = r.l + 1);
      while (x <= r.r) {{
	  (re) = (((re) + (rstep)));
      };
      pointPtr->x = x;
      pointPtr->y = y;
      pointPtr->c = Iter2Color(flags, MbrotCalcIter(re, im));;
      (pointPtr++, x++);
      };;
      (x = r.r, y = r.t + 1);
      while (y <= r.b) {{
	  (im) = (((im) + (istep)));
      };
      pointPtr->x = x;
      pointPtr->y = y;
      pointPtr->c = Iter2Color(flags, MbrotCalcIter(re, im));;
      (pointPtr++, y++);
      };;
      if (r.r - r.l && r.b - r.t) {
	(y = r.b, x = r.r - 1);
	while (x >= r.l) {{
	    (re) = (((re) - (rstep)));
	};
	pointPtr->x = x;
	pointPtr->y = y;
	pointPtr->c = Iter2Color(flags, MbrotCalcIter(re, im));;
	(pointPtr++, x--);
	};;
	(x = r.l, y = r.b - 1);
	while (y > r.t) {{
	    (im) = (((im) - (istep)));
	};
	pointPtr->x = x;
	pointPtr->y = y;
	pointPtr->c = Iter2Color(flags, MbrotCalcIter(re, im));;
	(pointPtr++, y--);
	};;
      } *isContinuous = 0;
      return 0;
    };
  case JULIA:
    if (r.b - r.t > 1 && r.r - r.l > 1) {
      (y = r.t, x = r.l + 1);
      while (x <= r.r) {
	n {
	  (re) = (((re) + (rstep)));
	};
	pointPtr->x = x;
	pointPtr->y = y;
	pointPtr->c = Iter2Color(flags, JuliaCalcIter(re, im));
	if (pointPtr->c != firstColor)
	  goto j1;
	(pointPtr++, x++);
      };;;
      (x = r.r, y = r.t + 1);
      while (y <= r.b) {{
	  (im) = (((im) + (istep)));
      };
      pointPtr->x = x;
      pointPtr->y = y;
      pointPtr->c = Iter2Color(flags, JuliaCalcIter(re, im));
      if (pointPtr->c != firstColor)
	goto j2;
	(pointPtr++, y++);
      };;;
      (y = r.b, x = r.r - 1);
      while (x >= r.l) {{
	  (re) = (((re) - (rstep)));
      };
      pointPtr->x = x;
      pointPtr->y = y;
      pointPtr->c = Iter2Color(flags, JuliaCalcIter(re, im));
      if (pointPtr->c != firstColor)
	goto j3;
	(pointPtr++, x--);
      };;;
      (x = r.l, y = r.b - 1);
      while (y > r.t) {{
	  (im) = (((im) - (istep)));
      };
      pointPtr->x = x;
      pointPtr->y = y;
      pointPtr->c = Iter2Color(flags, JuliaCalcIter(re, im));
      if (pointPtr->c != firstColor)
	goto j4;
	(pointPtr++, y--);
      };;;
      *isContinuous = 1;
      return 1;
      (y = r.t, x = r.l + 1);
      while (x <= r.r) {{
	  (re) = (((re) + (rstep)));
      };
      pointPtr->x = x;
      pointPtr->y = y;
      pointPtr->c = Iter2Color(flags, JuliaCalcIter(re, im));;
  j1:(pointPtr++, x++);
      };;;
      (x = r.r, y = r.t + 1);
      while (y <= r.b) {{
	  (im) = (((im) + (istep)));
      };
      pointPtr->x = x;
      pointPtr->y = y;
      pointPtr->c = Iter2Color(flags, JuliaCalcIter(re, im));;
  j2:(pointPtr++, y++);
      };;;
      (y = r.b, x = r.r - 1);
      while (x >= r.l) {{
	  (re) = (((re) - (rstep)));
      };
      pointPtr->x = x;
      pointPtr->y = y;
      pointPtr->c = Iter2Color(flags, JuliaCalcIter(re, im));;
  j3:(pointPtr++, x--);
      };;;
      (x = r.l, y = r.b - 1);
      while (y > r.t) {{
	  (im) = (((im) - (istep)));
      };
      pointPtr->x = x;
      pointPtr->y = y;
      pointPtr->c = Iter2Color(flags, JuliaCalcIter(re, im));;
  j4:(pointPtr++, y--);
      };;;
      *isContinuous = 0;
      return 0;
    } else {
      (y = r.t, x = r.l + 1);
      while (x <= r.r) {{
	  (re) = (((re) + (rstep)));
      };
      pointPtr->x = x;
      pointPtr->y = y;
      pointPtr->c = Iter2Color(flags, JuliaCalcIter(re, im));;
      (pointPtr++, x++);
      };;
      (x = r.r, y = r.t + 1);
      while (y <= r.b) {{
	  (im) = (((im) + (istep)));
      };
      pointPtr->x = x;
      pointPtr->y = y;
      pointPtr->c = Iter2Color(flags, JuliaCalcIter(re, im));;
      (pointPtr++, y++);
      };;
      if (r.r - r.l && r.b - r.t) {
	(y = r.b, x = r.r - 1);
	while (x >= r.l) {{
	    (re) = (((re) - (rstep)));
	};
	pointPtr->x = x;
	pointPtr->y = y;
	pointPtr->c = Iter2Color(flags, JuliaCalcIter(re, im));;
	(pointPtr++, x--);
	};;
	(x = r.l, y = r.b - 1);
	while (y > r.t) {{
	    (im) = (((im) - (istep)));
	};
	pointPtr->x = x;
	pointPtr->y = y;
	pointPtr->c = Iter2Color(flags, JuliaCalcIter(re, im));;
	(pointPtr++, y--);
	};;
      } *isContinuous = 0;
      return 0;
    };
  case NEWTON:
    if (r.b - r.t > 1 && r.r - r.l > 1) {
      (y = r.t, x = r.l + 1);
      while (x <= r.r) {
	n {
	  (re) = (((re) + (rstep)));
	};
	pointPtr->x = x;
	pointPtr->y = y;
	pointPtr->c = Iter2Color(flags, MbrotCalcIter(re, im));
	if (pointPtr->c != firstColor)
	  goto n1;
	(pointPtr++, x++);
      };;;
      (x = r.r, y = r.t + 1);
      while (y <= r.b) {{
	  (im) = (((im) + (istep)));
      };
      pointPtr->x = x;
      pointPtr->y = y;
      pointPtr->c = Iter2Color(flags, MbrotCalcIter(re, im));
      if (pointPtr->c != firstColor)
	goto n2;
	(pointPtr++, y++);
      };;;
      (y = r.b, x = r.r - 1);
      while (x >= r.l) {{
	  (re) = (((re) - (rstep)));
      };
      pointPtr->x = x;
      pointPtr->y = y;
      pointPtr->c = Iter2Color(flags, MbrotCalcIter(re, im));
      if (pointPtr->c != firstColor)
	goto n3;
	(pointPtr++, x--);
      };;;
      (x = r.l, y = r.b - 1);
      while (y > r.t) {{
	  (im) = (((im) - (istep)));
      };
      pointPtr->x = x;
      pointPtr->y = y;
      pointPtr->c = Iter2Color(flags, MbrotCalcIter(re, im));
      if (pointPtr->c != firstColor)
	goto n4;
	(pointPtr++, y--);
      };;;
      *isContinuous = 1;
      return 1;
      (y = r.t, x = r.l + 1);
      while (x <= r.r) {{
	  (re) = (((re) + (rstep)));
      };
      pointPtr->x = x;
      pointPtr->y = y;
      pointPtr->c = Iter2Color(flags, MbrotCalcIter(re, im));;
  n1:(pointPtr++, x++);
      };;;
      (x = r.r, y = r.t + 1);
      while (y <= r.b) {{
	  (im) = (((im) + (istep)));
      };
      pointPtr->x = x;
      pointPtr->y = y;
      pointPtr->c = Iter2Color(flags, MbrotCalcIter(re, im));;
  n2:(pointPtr++, y++);
      };;;
      (y = r.b, x = r.r - 1);
      while (x >= r.l) {{
	  (re) = (((re) - (rstep)));
      };
      pointPtr->x = x;
      pointPtr->y = y;
      pointPtr->c = Iter2Color(flags, MbrotCalcIter(re, im));;
  n3:(pointPtr++, x--);
      };;;
      (x = r.l, y = r.b - 1);
      while (y > r.t) {{
	  (im) = (((im) - (istep)));
      };
      pointPtr->x = x;
      pointPtr->y = y;
      pointPtr->c = Iter2Color(flags, MbrotCalcIter(re, im));;
  n4:(pointPtr++, y--);
      };;;
      *isContinuous = 0;
      return 0;
    } else {
      (y = r.t, x = r.l + 1);
      while (x <= r.r) {{
	  (re) = (((re) + (rstep)));
      };
      pointPtr->x = x;
      pointPtr->y = y;
      pointPtr->c = Iter2Color(flags, MbrotCalcIter(re, im));;
      (pointPtr++, x++);
      };;
      (x = r.r, y = r.t + 1);
      while (y <= r.b) {{
	  (im) = (((im) + (istep)));
      };
      pointPtr->x = x;
      pointPtr->y = y;
      pointPtr->c = Iter2Color(flags, MbrotCalcIter(re, im));;
      (pointPtr++, y++);
      };;
      if (r.r - r.l && r.b - r.t) {
	(y = r.b, x = r.r - 1);
	while (x >= r.l) {{
	    (re) = (((re) - (rstep)));
	};
	pointPtr->x = x;
	pointPtr->y = y;
	pointPtr->c = Iter2Color(flags, MbrotCalcIter(re, im));;
	(pointPtr++, x--);
	};;
	(x = r.l, y = r.b - 1);
	while (y > r.t) {{
	    (im) = (((im) - (istep)));
	};
	pointPtr->x = x;
	pointPtr->y = y;
	pointPtr->c = Iter2Color(flags, MbrotCalcIter(re, im));;
	(pointPtr++, y--);
	};;
      } *isContinuous = 0;
      return 0;
    };
  }
}


DrawBorder(graph, colorData, r)
MPE_XGraph graph;
int *colorData;
rect r;
{
  int x, y;

  for (y = r.t, x = r.l; x <= r.r; x++) {

    MPE_Draw_point(graph, x, y, *colorData);
    colorData++;
  }
  for (x = r.r, y = r.t + 1; y <= r.b; y++) {

    MPE_Draw_point(graph, x, y, *colorData);
    colorData++;
  }
  if (r.r - r.l && r.b - r.t) {
    for (y = r.b, x = r.r - 1; x >= r.l; x--) {

      MPE_Draw_point(graph, x, y, *colorData);
      colorData++;
    }
    for (x = r.l, y = r.b - 1; y > r.t; y--) {

      MPE_Draw_point(graph, x, y, *colorData);
      colorData++;
    }
  }
  MPE_Update(graph);
}


DrawBlock(graph, pointData, r)
MPE_XGraph graph;
MPE_Point *pointData;
rect *r;
{


  MPE_Fill_rectangle(graph, r->l, r->t, r->r - r->l + 1, r->b - r->t + 1,
		     pointData->c);

  MPE_Update(graph);
}