Fractales en C/C++

Un fractal es un patrón interminable. Los fractales son patrones infinitamente complejos que son autosimilares en diferentes escalas. Se crean repitiendo un proceso simple una y otra vez en un ciclo de retroalimentación continuo. Matemáticamente, los fractales se pueden explicar de la siguiente manera.

• La ubicación de un punto en una pantalla se introduce en una ecuación como su solución inicial y la ecuación se repite una gran cantidad de veces.
• Si esa ecuación tiende a cero (es decir, el valor al final de las iteraciones es menor que el valor inicial), el punto se colorea de negro.
• Si la ecuación tiende a infinito (es decir, el valor final es mayor que el valor inicial), dependiendo de la tasa de aumento (es decir, la tasa a la que el valor tiende a infinito), el píxel se pinta con un color apropiado.

Conjunto de Mandelbrot:
El conjunto de Mandelbrot es el conjunto de números complejos c para los cuales la función f _c (z) = z ² + c no diverge cuando se itera desde z = 0, es decir, para los cuales la secuencia fc(0), fc( fc(0)), etc., permanece acotado en valor absoluto.

El conjunto de Mandelbrot es el conjunto de valores de c en el plano complejo para el cual la órbita de 0 bajo la iteración del mapa cuadrático Z _n+1 = Z _n ² + c permanece acotada. Es decir, un número complejo c es parte del conjunto de Mandelbrot si, al comenzar con Z ₀ = 0 y aplicar la iteración repetidamente, el valor absoluto de Z _n permanece acotado por grande que sea n. A continuación se muestra la imagen inicial de una secuencia de zoom establecida por Mandelbrot. Los puntos negros corresponden a números que están fuera del conjunto.

Properties of Mandelbrot Set :

• El conjunto de Mandelbrot es un conjunto conexo ya que siempre tiene un camino de un punto del conjunto a otro punto del conjunto de modo que todos los puntos del camino también están en el conjunto.
• El conjunto de Mandelbrot tiene un área finita pero una longitud de borde infinita.
• El conjunto de Mandelbrot es simétrico con respecto al eje real. Esto significa que si un número complejo pertenece al conjunto, su conjugado también pertenecerá a ese conjunto.
• El conjunto de Mandelbrot está acotado.
• El conjunto de Mandelbrot es en sí mismo similar en un sentido no exacto.
• El borde del conjunto de Mandelbrot es una estructura fractal con una dimensión fractal aún no conocida.

Implementación: dado que el concepto de fractales involucra las propiedades matemáticas de las ecuaciones, el algoritmo y los programas que crean fractales son difíciles de escribir y optimizar. Uno puede encontrar muchos programas comerciales que crean fractales. Estos programas representan algunos de los algoritmos e implementaciones fractales más optimizados y probablemente los mejores que se han creado. A continuación se muestra el enfoque:

• Para dibujar el conjunto de Mandelbrot, establezca el píxel que es un número complejo.
• Colorea el píxel si pertenece al conjunto.
• Iterar a través de cada píxel y calcular los números complejos correspondientes cuyo resultado se guarda en c_real para la parte real y c_imaginario para la parte imaginaria.
• Calcule la función de Mandelbrot que se define como z = z*z + c donde z es un número complejo.
• Dado que la multiplicación compleja es difícil, rompa la ecuación y calcule las subpartes, es decir, la parte real y la parte imaginaria por separado.
• Como cuadrado de un número complejo (a + ib) ² = a ² – b ² + 2abi, donde a ² -b ² es la parte real y 2abi es la parte imaginaria .
• Al calcular z, calcúlelos por separado, es decir,
  

  Z_real = z_real*z_real – z_imaginario*z_imaginario + c_real
  Z_imaginario = 2*z_real*z_imaginario + c_imaginario

• Continuar calculando estos valores para cada píxel hasta que lleguemos al máximo de iteraciones y el valor absoluto de z no sea menor a 2. Finalmente, coloreamos el píxel.

// C++ implementation for mandelbrot set fractals
#include <graphics.h>
#include <stdio.h>
#define MAXCOUNT 30
  
// Function to draw mandelbrot set
void fractal(float left, float top, float xside, float yside)
{
    float xscale, yscale, zx, zy, cx, tempx, cy;
    int x, y, i, j;
    int maxx, maxy, count;
  
    // getting maximum value of x-axis of screen
    maxx = getmaxx();
  
    // getting maximum value of y-axis of screen
    maxy = getmaxy();
  
    // setting up the xscale and yscale
    xscale = xside / maxx;
    yscale = yside / maxy;
  
    // calling rectangle function
    // where required image will be seen
    rectangle(0, 0, maxx, maxy);
  
    // scanning every point in that rectangular area.
    // Each point represents a Complex number (x + yi).
    // Iterate that complex number
    for (y = 1; y <= maxy - 1; y++) {
        for (x = 1; x <= maxx - 1; x++)
        {
            // c_real
            cx = x * xscale + left;
  
            // c_imaginary
            cy = y * yscale + top;
  
            // z_real
            zx = 0;
  
            // z_imaginary
            zy = 0;
            count = 0;
  
            // Calculate whether c(c_real + c_imaginary) belongs
            // to the Mandelbrot set or not and draw a pixel
            // at coordinates (x, y) accordingly
            // If you reach the Maximum number of iterations
            // and If the distance from the origin is
            // greater than 2 exit the loop
            while ((zx * zx + zy * zy < 4) && (count < MAXCOUNT))
            {
                // Calculate Mandelbrot function
                // z = z*z + c where z is a complex number
  
                // tempx = z_real*_real - z_imaginary*z_imaginary + c_real
                tempx = zx * zx - zy * zy + cx;
  
                // 2*z_real*z_imaginary + c_imaginary
                zy = 2 * zx * zy + cy;
  
                // Updating z_real = tempx
                zx = tempx;
  
                // Increment count
                count = count + 1;
            }
  
            // To display the created fractal
            putpixel(x, y, count);
        }
    }
}
  
// Driver code
int main()
{
    // gm is Graphics mode which is
    // a computer display mode that
    // generates image using pixels.
    // DETECT is a macro defined in
    // "graphics.h" header file
    int gd = DETECT, gm, errorcode;
  
    float left, top, xside, yside;
  
    // setting the left, top, xside and yside
    // for the screen and image to be displayed
    left = -1.75;
    top = -0.25;
    xside = 0.25;
    yside = 0.45;
    char driver[] = "";
  
    // initgraph initializes the
    // graphics system by loading a
    // graphics driver from disk
    initgraph(&gd, &gm, driver);
  
    // Function calling
    fractal(left, top, xside, yside);
  
    getch();
  
    // closegraph function closes the
    // graphics mode and deallocates
    // all memory allocated by
    // graphics system
    closegraph();
  
    return 0;
}

Producción :

Aplicaciones de los Fractales: La idea básica de los Fractales es encontrar regularidades en las irregularidades existentes. A continuación se dan algunas aplicaciones de los fractales:

• La compresión de imágenes fractales se usa en informática, basada en los hechos de la geometría fractal. Al usar esta técnica, la imagen se comprime mucho más en comparación con JPEG, GIF, etc. Además, no hay pixelización cuando se amplía la imagen.
• Para facilitar el estudio de los flujos turbulentos se utiliza la representación fractal. Además, los fractales se utilizan para representar medios porosos que se utilizan en la ciencia del petróleo.
• Recientemente se han utilizado antenas con forma de fractal que ayudan a reducir el tamaño y el peso de las antenas y proporcionan un alto rendimiento.