==== Example code for mandelbrot ====

C/C++ skeleton code for Mandelbrot computation. 

<code>
#include <iostream>
#include <string>
#include <algorithm>
#include "tbb/parallel_for.h"
#include "tbb/blocked_range.h"
// or use blocked_range2d if appropriate

using namespace tbb;
using namespace std;

// default constants

// square area, lower left angle and size
#define DEFAULT_X -2.0
#define DEFAULT_Y -2.0
#define DEFAULT_SIZE 4.0
#define DEFAULT_PIXELS 10
#define DEFAULT_ITERATIONS 1000

// we assume a point diverges if its squared modulus exceeds this value
#define MAX_SMODULUS = 4

// a variable holding the number of iterations limit
static int maxIter = DEFAULT_ITERATIONS;


//function computing the mandelbrot in asingle point
//returns the number of iteration until divergence
int mand_compute( double cx, double cy)
{
 int i=0;
    double x = cx; double y = cy;
    double nx, ny;
    for (i=0; i<maxIter; i++)
    {
       // (x,y)^2 + c
       nx = x*x - y*y + cx;
       ny = 2*x*y + cy;
       if ( nx*nx + ny*ny > MAX_SMODULUS ) break;
       x=nx; y=ny;
    }
    return i;
}

// define class to hold the computation


//main 
int main () {

// initialization

// inizialize data if needed

// parallel for
// with blocked_range


}
</code>

==== Example code for saving an array as PPM graphics ====

Compile and link this file together with you code. 
Remember to insert the function prototye in the main source file

<code>
#include <stdlib.h>
#include <stdio.h>

/** C routine to save a 2d int array as an image to a simple graphic format **/ 
/** edited form of code from the rosetta code project **/
/** https://rosettacode.org/wiki/Bitmap/Write_a_PPM_file **/


int saveimg(int dimx, int dimy, const char * filename, int * matrix, int max_value)
{
  // filename must end with  .ppm 
  // no parameter checking!!! you are on your own
  
  // const int dimx = 800, dimy = 800;
  int i, j;
  FILE *fp = fopen(filename, "wb"); /* b - binary mode */
  (void) fprintf(fp, "P6\n%d %d\n255\n", dimx, dimy);
  for (j = 0; j < dimy; ++j)
  {
    for (i = 0; i < dimx; ++i)
    {
      // here you may use any scaling function you prefer
      int val = matrix[i +j*dimy];
      if (max_value!=255)
	{ val = (val *255) / max_value; // scale to 0 - 255
	}
      //
      // rgb values are still rounded in case of mistakes
      static unsigned char color[3];
      color[0] = val % 256;  /* red */
      color[1] = val % 256;  /* green */
      color[2] = val % 256;  /* blue */
      (void) fwrite(color, 1, 3, fp);
    }
  }
  (void) fclose(fp);
  return 0;
}

</code>