Fractali

Funcția primește n, numărul de repetări rămase, și coordonatele x și y ale vârfurilor A, B și C. Rândurile evidențiate sunt cele care se execută la nivelul ales.

void fractal(int n,
             double xA, double yA,
             double xB, double yB,
             double xC, double yC) {
    // La nivelul 0, desenam si ne oprim.
    if (n == 0) {
        deseneazaTriunghi(xA, yA, xB, yB, xC, yC);
        return;
    }

    // Calculam mijloacele celor trei laturi.
    double xAB = (xA + xB) / 2;
    double yAB = (yA + yB) / 2;
    double xBC = (xB + xC) / 2;
    double yBC = (yB + yC) / 2;
    double xCA = (xC + xA) / 2;
    double yCA = (yC + yA) / 2;

    // Continuam cu triunghiul din coltul A.
    fractal(n - 1, xA, yA, xAB, yAB, xCA, yCA);

    // Continuam cu triunghiul din coltul B.
    fractal(n - 1, xAB, yAB, xB, yB, xBC, yBC);

    // Continuam cu triunghiul din coltul C.
    fractal(n - 1, xCA, yCA, xBC, yBC, xC, yC);
}

// Triunghiul lui Sierpinski, varianta recursiva.
// Programul scrie desenul in fisierul sierpinski.svg.
#include <fstream>
using namespace std;

ofstream fout("sierpinski.svg");

void deseneazaTriunghi(double xA, double yA, double xB, double yB, double xC, double yC) {
    fout << "<polygon fill='#d34c2a' points='"
         << xA << "," << yA << " " << xB << "," << yB << " " << xC << "," << yC << "'/>\n";
}

void fractal(int n,
             double xA, double yA,
             double xB, double yB,
             double xC, double yC) {
    // La nivelul 0, desenam si ne oprim.
    if (n == 0) {
        deseneazaTriunghi(xA, yA, xB, yB, xC, yC);
        return;
    }

    // Calculam mijloacele celor trei laturi.
    double xAB = (xA + xB) / 2, yAB = (yA + yB) / 2;
    double xBC = (xB + xC) / 2, yBC = (yB + yC) / 2;
    double xCA = (xC + xA) / 2, yCA = (yC + yA) / 2;

    // Continuam cu cele trei triunghiuri din colturi.
    fractal(n - 1, xA, yA, xAB, yAB, xCA, yCA);
    fractal(n - 1, xAB, yAB, xB, yB, xBC, yBC);
    fractal(n - 1, xCA, yCA, xBC, yBC, xC, yC);
}

int main() {
    int n = 5;
    fout << "<svg xmlns='http://www.w3.org/2000/svg' width='600' height='530'>\n";
    fout << "<rect width='600' height='530' fill='white'/>\n";
    fractal(n, 300, 10, 10, 512, 590, 512);
    fout << "</svg>\n";
    return 0;
}

// Curba Koch, varianta recursiva.
// Programul scrie desenul in fisierul koch.svg.
#include <fstream>
#include <cmath>
using namespace std;

ofstream fout("koch.svg");

void segment(double x1, double y1, double x2, double y2) {
    fout << "<line x1='" << x1 << "' y1='" << y1
         << "' x2='" << x2 << "' y2='" << y2 << "' stroke='#3e5b9c'/>\n";
}

void koch(int n, double x1, double y1, double x2, double y2) {
    // La nivelul 0, desenam segmentul si ne oprim.
    if (n == 0) {
        segment(x1, y1, x2, y2);
        return;
    }
    double dx = (x2 - x1) / 3, dy = (y2 - y1) / 3;

    // P si Q impart segmentul in trei parti egale.
    double xP = x1 + dx, yP = y1 + dy;
    double xQ = x1 + 2 * dx, yQ = y1 + 2 * dy;

    // V este varful: rotim segmentul PQ cu 60 de grade in jurul lui P.
    double xV = xP + dx * 0.5 + dy * sqrt(3.0) / 2;
    double yV = yP + dy * 0.5 - dx * sqrt(3.0) / 2;

    koch(n - 1, x1, y1, xP, yP);
    koch(n - 1, xP, yP, xV, yV);
    koch(n - 1, xV, yV, xQ, yQ);
    koch(n - 1, xQ, yQ, x2, y2);
}

int main() {
    int n = 4;
    fout << "<svg xmlns='http://www.w3.org/2000/svg' width='600' height='220'>\n";
    fout << "<rect width='600' height='220' fill='white'/>\n";
    koch(n, 10, 200, 590, 200);
    fout << "</svg>\n";
    return 0;
}

// Multimea Mandelbrot desenata cu caractere, in consola.
#include <iostream>
using namespace std;

int main() {
    int latime = 78, inaltime = 32, maxPasi = 100;
    char simboluri[] = " .:-=+*#%&";   // de la "evadeaza repede" la "evadeaza greu"

    for (int linie = 0; linie < inaltime; linie++) {
        for (int col = 0; col < latime; col++) {
            // Punctul c = a + bi corespunzator caracterului de pe ecran.
            double a = -2.2 + col * 3.0 / latime;
            double b = 1.2 - linie * 2.4 / inaltime;

            // Pornim de la z = 0 si repetam z = z*z + c.
            double x = 0, y = 0;
            int pas = 0;
            while (x * x + y * y <= 4 && pas < maxPasi) {
                double xNou = x * x - y * y + a;
                y = 2 * x * y + b;
                x = xNou;
                pas++;
            }

            if (pas == maxPasi) cout << '@';    // nu a evadat: punct din multime
            else {
                int k = pas;                    // a evadat dupa "pas" pasi
                if (k > 9) k = 9;
                cout << simboluri[k];
            }
        }
        cout << '\n';
    }
    return 0;
}