anchor.diff:  
   * "Handmade Hero Day 115 - SIMD Basics" https://www.youtube.com/watch?v=YnnTb0AQgYM
   
  -Two great SIMD mandelbrot examples that helped me designing the termination
  -condition of the mandelbrot calculation.
  +Two great SIMD Mandelbrot examples that helped me designing the termination
  +condition of the Mandelbrot calculation.
   
   * https://github.com/skeeto/mandel-simd by Chris Wellons
   
  
positive.code: Image Generator
  ===============
  
  This project at its core is a System Programming example, demonstrating the use
  of shared memory, semaphores, signal handling and pthreads in c.
  It consist of an "ImageWriter" program and a "PixelGenerator" program.
  The "PixelGenerator" continuously calculates images of the mandelbrot set and
  writes them into a shared memory segment. The "ImageWriter" program reads the
  image out of the shared memory segment and stores the image in a P6 ppm file.
  
  The shared memory segment can hold one image at a time. The "PixelGenerator" and
  "ImageWriter" are synchronized by semaphores to avoid simultaneous access of
  the shared memory segment.
  
  The "PixelGenerator" generates an image of the mandelbrot set an alters
  start parameters each time a new images is calculated to zoom into a section
  of the mandelbrot set.
  
  The computation of the mandelbrot set can be done by multiple threads.
  The number of threads to process the image, as well as the width and height
  of the image can be changed.
  Depending on the number of threads the computation of one image is split on
  several threads. For example: If the number of threads is set to 4, every thread
  generates a quarter of the image. If image width is set to 800- and image height
  to 600 pixels, thread number one will calculated image row 0 to 149,
  thread number two will process line 150 to 299, thread three 300 - 449 and
  thread four row 450 to 599.
  
  This project has been extended to use the OpenMP library or the OpenCL framework
  
negative.code: by the CPU or the GPU.
  
  The processing of the image with use of phtreads or the OpenMP library
  happens concurrently - without context switching - if the CPU has enough cores
  to execute all of the specified threads at the same time.
  
  At least for the version of the program using pthreads for parallelization
  each thread can only calculate one pixel at a time. Making use of
  SIMD "Single Instruction Multiple Data" Intrinsics however, each thread can
  process multiple pixels at the same time.
  The Mandelbrot set is obtained from quadratic recurrence equation
  z~n+1~ = z~n~^2^ + C .
  The calculation of the Mandelbrot set is done by applying mathematical
  operations on each pixel of the image over and over again.
  Interim results are thereby stored in 64-Bit double variables.
  Using SIMD Intrinsics for SSE it is possible to load 128-Bit wide
  registers with two 64-Bit double variables. This makes it possible to operate
  on two variables - two pixels - at once, by performing calculations on the
  128-Bit register, instead of having to apply the same operations successively
  