int main(int argc, char** argv)
{
int grid_size_x;
int grid_size_y;
int max_iter;
float xmin;
float xmax;
float ymin;
float ymax;
int **image;
int rank;
//initialise a fn pointer
in_set_fn_t fp;
MPI_Comm comm;
comm = MPI_COMM_WORLD;
MPI_Init(&argc, & argv);
MPI_Comm_rank(comm, &rank);
read_options(argc, argv, &grid_size_x, &grid_size_y, &max_iter,
&xmin, &xmax, &ymin, &ymax);
if(0 == rank)
{
initialise_image(&image, grid_size_x, grid_size_y);
}
//set it to either julia or mandelbrot calculation
fp = &point_in_julia;
compute_set(fp, image, xmin, xmax, ymin, ymax, grid_size_x, grid_size_y, max_iter, comm);
if(0 == rank)
{
write_ppm("output.ppm", image, grid_size_x, grid_size_y, max_iter);
free(image);
}
MPI_Finalize();
return 0;
}
int main(int argc, char** argv)
{
int grid_size_x;
int grid_size_y;
int max_iter;
float xmin;
float xmax;
float ymin;
float ymax;
int **image;
int rank;
MPI_Comm comm;
comm = MPI_COMM_WORLD;
MPI_Init(&argc, & argv);
MPI_Comm_rank(comm, &rank);
read_options(argc, argv, &grid_size_x, &grid_size_y, &max_iter,
&xmin, &xmax, &ymin, &ymax);
if(0 == rank)
{
initialise_image(&image, grid_size_x, grid_size_y);
}
compute_mandelbrot_set(image, xmin, xmax, ymin, ymax,
grid_size_x, grid_size_y, max_iter, comm);
if(0 == rank)
{
write_ppm("output.ppm", image, grid_size_x, grid_size_y, max_iter);
free(image);
}
MPI_Finalize();
return 0;
}
int main(int argc, char** argv)
{
int grid_size_x;
int grid_size_y;
int max_iter;
float xmin;
float xmax;
float ymin;
float ymax;
int **image;
read_options(argc, argv, &grid_size_x, &grid_size_y, &max_iter,
&xmin, &xmax, &ymin, &ymax);
initialise_image(&image, grid_size_x, grid_size_y);
compute_mandelbrot_set(image, xmin, xmax, ymin, ymax,
grid_size_x, grid_size_y, max_iter);
write_ppm("output.ppm", image, grid_size_x, grid_size_y, max_iter);
free(image);
return 0;
}
/*-
* init_swirl
*
* Initialise things for swirling
*
* - win is the window to draw in
*/
void
init_swirl(ModeInfo * mi)
{
Display *display = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
swirlstruct *sp;
/* does the swirls array exist? */
if (swirls == NULL) {
int i;
/* allocate an array, one entry for each screen */
if ((swirls = (swirlstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (swirlstruct))) == NULL)
return;
/* initialise them all */
for (i = 0; i < MI_NUM_SCREENS(mi); i++)
initialise_swirl(&swirls[i]);
}
/* get a pointer to this swirl */
sp = &(swirls[MI_SCREEN(mi)]);
sp->mi = mi;
/* get window parameters */
sp->width = MI_WIDTH(mi);
sp->height = MI_HEIGHT(mi);
sp->depth = MI_DEPTH(mi);
sp->rdepth = sp->depth;
sp->visual = MI_VISUAL(mi);
if (sp->depth > 16)
sp->depth = 16;
/* initialise image for speeding up drawing */
if (!initialise_image(display, sp)) {
free_swirl(display, sp);
return;
}
MI_CLEARWINDOW(mi);
if (!sp->gc) {
if (MI_IS_INSTALL(mi) && MI_NPIXELS(mi) > 2) {
XColor color;
#ifndef STANDALONE
sp->fg = MI_FG_PIXEL(mi);
sp->bg = MI_BG_PIXEL(mi);
#endif
sp->blackpixel = MI_BLACK_PIXEL(mi);
sp->whitepixel = MI_WHITE_PIXEL(mi);
if ((sp->cmap = XCreateColormap(display, window,
MI_VISUAL(mi), AllocNone)) == None) {
free_swirl(display, sp);
return;
}
XSetWindowColormap(display, window, sp->cmap);
(void) XParseColor(display, sp->cmap, "black", &color);
(void) XAllocColor(display, sp->cmap, &color);
MI_BLACK_PIXEL(mi) = color.pixel;
(void) XParseColor(display, sp->cmap, "white", &color);
(void) XAllocColor(display, sp->cmap, &color);
MI_WHITE_PIXEL(mi) = color.pixel;
#ifndef STANDALONE
(void) XParseColor(display, sp->cmap, background, &color);
(void) XAllocColor(display, sp->cmap, &color);
MI_BG_PIXEL(mi) = color.pixel;
(void) XParseColor(display, sp->cmap, foreground, &color);
(void) XAllocColor(display, sp->cmap, &color);
MI_FG_PIXEL(mi) = color.pixel;
#endif
sp->colors = (XColor *) NULL;
sp->ncolors = 0;
}
if ((sp->gc = XCreateGC(display, MI_WINDOW(mi),
(unsigned long) 0, (XGCValues *) NULL)) == None) {
free_swirl(display, sp);
return;
}
}
MI_CLEARWINDOW(mi);
/* Set up colour map */
sp->direction = (LRAND() & 1) ? 1 : -1;
if (MI_IS_INSTALL(mi) && MI_NPIXELS(mi) > 2) {
if (sp->colors != NULL) {
if (sp->ncolors && !sp->no_colors)
free_colors(display, sp->cmap, sp->colors, sp->ncolors);
free(sp->colors);
sp->colors = (XColor *) NULL;
}
sp->ncolors = MI_NCOLORS(mi);
if (sp->ncolors < 2)
sp->ncolors = 2;
if (sp->ncolors <= 2)
sp->mono_p = True;
else
sp->mono_p = False;
if (sp->mono_p)
sp->colors = (XColor *) NULL;
else
if ((sp->colors = (XColor *) malloc(sizeof (*sp->colors) *
(sp->ncolors + 1))) == NULL) {
free_swirl(display, sp);
return;
}
sp->cycle_p = has_writable_cells(mi);
if (sp->cycle_p) {
if (MI_IS_FULLRANDOM(mi)) {
if (!NRAND(8))
sp->cycle_p = False;
else
sp->cycle_p = True;
} else {
sp->cycle_p = cycle_p;
}
}
if (!sp->mono_p) {
if (!(LRAND() % 10))
make_random_colormap(
#if STANDALONE
display, MI_WINDOW(mi),
#else
mi,
#endif
sp->cmap, sp->colors, &sp->ncolors,
True, True, &sp->cycle_p);
else if (!(LRAND() % 2))
make_uniform_colormap(
#if STANDALONE
display, MI_WINDOW(mi),
#else
mi,
#endif
sp->cmap, sp->colors, &sp->ncolors,
True, &sp->cycle_p);
else
make_smooth_colormap(
#if STANDALONE
display, MI_WINDOW(mi),
#else
mi,
#endif
sp->cmap, sp->colors, &sp->ncolors,
True, &sp->cycle_p);
}
XInstallColormap(display, sp->cmap);
if (sp->ncolors < 2) {
sp->ncolors = 2;
sp->no_colors = True;
} else
sp->no_colors = False;
if (sp->ncolors <= 2)
sp->mono_p = True;
if (sp->mono_p)
sp->cycle_p = False;
}
if (MI_IS_INSTALL(mi) && MI_NPIXELS(mi) > 2) {
if (sp->mono_p) {
sp->cur_color = MI_BLACK_PIXEL(mi);
}
}
/* resolution starts off chunky */
sp->resolution = MIN_RES + 1;
/* calculate the pixel step for this resulution */
sp->r = (1 << (sp->resolution - 1));
/* how many knots? */
sp->n_knots = random_no((unsigned int) MI_COUNT(mi) / 2) +
MI_COUNT(mi) + 1;
/* what type of knots? */
sp->knot_type = ALL; /* for now */
/* use two_plane mode occaisionally */
if (random_no(100) <= TWO_PLANE_PCNT) {
sp->two_plane = sp->first_plane = True;
sp->max_resolution = 2;
} else
sp->two_plane = False;
/* fix the knot values */
if (!create_knots(sp)) {
free_swirl(display, sp);
return;
}
/* we are off */
sp->started = True;
sp->drawing = False;
}
int main(int argc, char** argv)
{
int grid_size_x;
int grid_size_y;
int max_iter;
float xmin;
float xmax;
float ymin;
float ymax;
int **image;
int i, j, n;
mycomplex c, z, ztmp;
double xscale, yscale;
read_options(argc, argv, &grid_size_x, &grid_size_y, &max_iter,
&xmin, &xmax, &ymin, &ymax);
initialise_image(&image, grid_size_x, grid_size_y);
/* Compute the mandelbrot set here and write results into image
* array. Note that the image writing code assumes the following
* mapping from array entries to pixel positions in the image:
*
* A == image[0][0]
* B == image[grid_size_y-1][0]
* C == image[grid_size_y-1][grid_size_x-1]
* D == image[0][grid_size_x-1]
*
* B-----------------C
* | |
* | |
* A-----------------D
*/
xscale = (xmax - xmin)/grid_size_x;
yscale = (ymax - ymin)/grid_size_y;
for(i=0; i<grid_size_y; ++i)
{
for(j=0; j<grid_size_x; ++j)
{
c.x = xmin + j*xscale;
c.y = ymin + i*yscale;
z.x = c.x;
z.y = c.y;
n = 0;
while(complexabs(z)<=2)
{
ztmp = complexsquared(z);
z.x = ztmp.x + c.x;
z.y = ztmp.y + c.y;
n++;
if(n == max_iter)
{
break;
}
}
image[i][j] = n;
}
}
write_ppm("output.ppm", image, grid_size_x, grid_size_y, max_iter);
free(image);
return 0;
}
