mandelbrot

At Wikipedia's Mandelbrot set page there are really beautiful generated images of the Mandelbrot set. I also just implemented my own Mandelbrot algorithm. Given n is the number of iterations used to calculate each pixel, I color them pretty simple from black to green to white like that (with C++ and Qt 5.0): QColor mapping(Qt::white); if (n <= MAX_ITERATIONS){ double quotient = (double) n / (double) MAX_ITERATIONS; double color = _clamp(0.f, 1.f, quotient); if (quotient > 0.5) { // Close to the mandelbrot set the color changes from green to white mapping.setRgbF(color, 1.f, color); } else { //

Recently I started making Mandelbrot set, but I wasn't able to find a good color spectrum. Here's my result But I want to create something like this: Any Suggestions? Thanks! In the deeper zoom, not only are the contours much closer together than in the base image (the "landscape" rises more steeply), but the palette used has smaller transitions. The palette used in the base image has a large step in colour values between adjacent contours, taking only 9 steps to go from deep blue to yellow. If you use a single value step in just one of the three primaries from one contour to the next, you can

I've been given an assignment for my class to make a program that draws Mandelbrot figures. We have to basically get the program to draw a bitmap of the result. Thing is, my CalcMBF function only outputs 2 as the Mandelbrot number. I have absolutely no idea why that is. Can anyone help me out? Here is my code: using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Windows.Forms; namespace Mandelbrot_Figure { class PreMainClass { static void main

When I first got a Haswell processor I tried implementing FMA to determine the Mandelbrot set. The main algorithm is this: intn = 0; for(int32_t i=0; i<maxiter; i++) { floatn x2 = square(x), y2 = square(y); //square(x) = x*x floatn r2 = x2 + y2; booln mask = r2<cut; //booln is in the float domain non integer domain if(!horizontal_or(mask)) break; //_mm256_testz_pd(mask) n -= mask floatn t = x*y; mul2(t); //mul2(t): t*=2 x = x2 - y2 + cx; y = t + cy; } This determines if n pixels are in the Mandelbrot set. So for double floating point it runs over 4 pixels ( floatn = __m256d , intn = __m256i ).

I've been successful in coloring the Mandelbrot-set although I can't zoom in very far until it becomes "blurry" and the pattern stops. I fix this by increasing the max_iteration, this works but I get very few colors at *1 magnification and lot's of colors only appear when I zoom in. I understand why this happens since in a "true" Mandelbrot-set there are no colors and increasing the max_iterations just brings it closer to that. But my question is, is how do zooms such as on youtube have beautiful colors throughout the whole zooming process while still being able to zoom on for what feels like

As an OpenMP & Rcpp performance test I wanted to check how fast I could calculate the Mandelbrot set in R using the most straightforward and simple Rcpp + OpenMP implementation. Currently what I did was: #include <Rcpp.h> #include <omp.h> // [[Rcpp::plugins(openmp)]] using namespace Rcpp; // [[Rcpp::export]] Rcpp::NumericMatrix mandelRcpp(const double x_min, const double x_max, const double y_min, const double y_max, const int res_x, const int res_y, const int nb_iter) { Rcpp::NumericMatrix ret(res_x, res_y); double x_step = (x_max - x_min) / res_x; double y_step = (y_max - y_min) / res_y; int