Hoe programmeer je een fractal?

Ik heb geen ervaring met het programmeren van fractals. Natuurlijk heb ik de beroemde Mandelbrot-afbeeldingen en dergelijke gezien.

Kun je me eenvoudige algoritmen voor fractals geven.

Programmeertaal maakt eigenlijk niet uit, maar ik ben het meest bekend met actionscript, C#, Java.

Ik weet dat als ik fractals google, ik veel (ingewikkelde) informatie krijg, maar ik wil graag beginnen met een eenvoudig algoritme en ermee spelen.

Suggesties om het basisalgoritme te verbeteren zijn ook welkom, zoals hoe je ze in die mooie kleuren kunt maken en dergelijke.

Antwoord 1, autoriteit 100%

De Mandelbrot programmeren is eenvoudig.
Mijn quick-n-dirty-code staat hieronder (niet gegarandeerd bug-vrij, maar een goed overzicht).

Hier is het overzicht:
De Mandelbrot-verzameling ligt in het Complex-raster volledig binnen een cirkel met straal 2.

Dus begin met het scannen van elk punt in dat rechthoekige gebied.
Elk punt vertegenwoordigt een complex getal (x + yi).
Herhaal dat complexe getal:

[new value] = [old-value]^2 + [original-value]terwijl je twee dingen bijhoudt:

1.) het aantal iteraties

2.) de afstand van [nieuwe-waarde] vanaf de oorsprong.

Als u het maximale aantal iteraties bereikt, bent u klaar.
Als de afstand vanaf de oorsprong groter is dan 2, ben je klaar.

Als je klaar bent, kleur je de originele pixel, afhankelijk van het aantal herhalingen dat je hebt gedaan.
Ga dan verder met de volgende pixel.

public void MBrot()
{
    float epsilon = 0.0001; // The step size across the X and Y axis
    float x;
    float y;
    int maxIterations = 10; // increasing this will give you a more detailed fractal
    int maxColors = 256; // Change as appropriate for your display.
    Complex Z;
    Complex C;
    int iterations;
    for(x=-2; x<=2; x+= epsilon)
    {
        for(y=-2; y<=2; y+= epsilon)
        {
            iterations = 0;
            C = new Complex(x, y);
            Z = new Complex(0,0);
            while(Complex.Abs(Z) < 2 && iterations < maxIterations)
            {
                Z = Z*Z + C;
                iterations++;
            }
            Screen.Plot(x,y, iterations % maxColors); //depending on the number of iterations, color a pixel.
        }
    }
}

Enkele details die zijn weggelaten zijn:

1.) Leer precies wat het kwadraat van een complex getal is en hoe je het kunt berekenen.

2.) Zoek uit hoe u het (-2,2) rechthoekige gebied vertaalt naar schermcoördinaten.

Antwoord 2, autoriteit 47%

Je moet inderdaad beginnen met de Mandelbrot-seten begrijpen wat het werkelijk is.

Het idee erachter is relatief eenvoudig. Je begint met een functie van complexe variabele

f(z) = z²+ C

waarbij z een complexe variabeleis en C een complexe constanteis. Nu herhaal je het vanaf z = 0, dwz je berekent z₁= f(0), z₂= f(z₁) , z₃= f(z₂) enzovoort. De verzameling van die constanten C waarvoor de rij z₁, z₂, z₃, … is begrensd, dwz het gaat niet naar oneindig, is de Mandelbrot-verzameling (de zwarte verzameling in de afbeelding op de Wikipedia-pagina).

In de praktijk moet je om de Mandelbrot-set te tekenen:

• Kies een rechthoek in het complexe vlak (bijvoorbeeld van punt -2-2i naar punt 2+2i).
• Bedek de rechthoek met een geschikt rechthoekig raster van punten (bijvoorbeeld 400×400 punten), die worden toegewezen aan pixels op uw monitor.
• Laat voor elk punt/pixel C dat punt zijn, bereken bijvoorbeeld 20 termen van de corresponderende herhaalde reeks z₁, z₂, z₃, … en controleer of het “naar oneindig gaat”. In de praktijk kun je tijdens het itereren controleren of de absolute waarde van een van de 20 termen groter is dan 2 (als een van de termen dat doet, zijn de volgende termen gegarandeerd onbegrensd). Als sommige z_k dat doen, gaat de reeks “naar oneindig”; anders kun je het als begrensd beschouwen.
• Als de reeks die overeenkomt met een bepaald punt C begrensd is, teken dan de corresponderende pixel op de afbeelding in het zwart (want deze behoort tot de Mandelbrot-verzameling). Teken het anders in een andere kleur. Als je plezier wilt hebben en mooie plots wilt maken, teken het dan in verschillende kleuren, afhankelijk van de grootte van de buikspieren (20e termijn).

Het verbazingwekkende feit over fractals is hoe we een enorm complexe verzameling (in het bijzonder de grensvan de Mandelbrot-verzameling) kunnen verkrijgen met gemakkelijke en schijnbaar onschuldige vereisten.

Veel plezier!

Antwoord 3, autoriteit 16%

Als je hoofdpijn krijgt van complexe getallen, is er een breed scala aan fractals die kunnen worden geformuleerd met behulp van een L-systeem. Dit vereist een aantal lagen die op elkaar inwerken, maar elk is op zichzelf interessant.

Eerst heb je een schildpad nodig. Vooruit, Achteruit, Links, Rechts, Pen omhoog, Pen omlaag. Er zijn veel leuke vormen te maken met schildpadafbeeldingen met behulp van schildpadgeometrie, zelfs zonder dat een L-systeem het aanstuurt. Zoek naar “LOGO-afbeeldingen” of “Turtle-afbeeldingen”. Een volledig LOGO-systeem is in feite een Lispprogrammeeromgeving met behulp van een niet-haakjes geplaatste Cambridge Poolssyntaxis. Maar je hoeft niet zo ver te gaan om mooie foto’s te maken met het schildpadconcept.

Dan heb je een laag nodig om een ​​L-systeem uit te voeren. L-systemen zijn gerelateerd aan Post-systemenen Semi-Thue-systemen, en net als virii, overschrijden ze de grens van Turing Volledigheid. Het concept is string-herschrijven. Het kan worden geïmplementeerd als een macro-uitbreiding of een procedureset met extra bedieningselementen om de recursie te binden. Als je macro-uitbreiding gebruikt (zoals in het onderstaande voorbeeld), heb je nog steeds een procedure nodig om symbolen toe te wijzen aan turtle-commando’s en een procedure om de string of array te doorlopen om het gecodeerde turtle-programma uit te voeren. Voor een procedureset met begrensde recursie (bijv.), sluit je de turtle-commando’s in de procedures in en voeg controles op recursieniveau toe aan elke procedure of ontbind deze aan een handlerfunctie.

Hier is een voorbeeld van een Pythagoras-boom in postscript met macro-uitbreiding en een zeer verkorte set van turtle-commando’s. Voor enkele voorbeelden in python en mathematica, zie mijn code golf uitdaging.

Antwoord 4, autoriteit 13%

Er is een geweldig boek genaamd Chaos and Fractalsmet eenvoudige voorbeeldcode aan het einde van elk hoofdstuk dat een of ander fractal-voorbeeld implementeert. Een lange tijd geleden, toen ik dat boek las, heb ik elk voorbeeldprogramma (in een of ander basisdialect) omgezet in een Java-applet die op een webpagina draait. De applets zijn hier: http://hewgill.com/chaos-and-fractals/

Een van de voorbeelden is een eenvoudige Mandelbrot-implementatie.

Antwoord 5, autoriteit 10%

Een andere uitstekende fractal om te leren is de Sierpinski Triangle Fractal.

Kortom, teken drie hoeken van een driehoek (een gelijkzijdige heeft de voorkeur, maar elke driehoek zal werken), en begin dan een punt P op een van die hoeken. Verplaats P willekeurig halverwege naar een van de 3 hoeken en teken daar een punt. Verplaats P opnieuw halverwege naar een willekeurige hoek, trek en herhaal.

Je zou denken dat de willekeurige beweging een willekeurig resultaat zou opleveren, maar dat is niet het geval.

Referentie: http://en.wikipedia.org/wiki/Sierpinski_triangle

Antwoord 6, autoriteit 10%

De Sierpinski-driehoek en de Koch-curve zijn speciale soorten vlamfractalen. Vlamfractals zijn een zeer algemeen type herhaald functiesysteem, omdat het niet-lineaire functies gebruikt.

Een algoritme voor IFS:es is als volgt:

Start with a random point.

Herhaal het volgende vele malen (minstens een miljoen, afhankelijk van de uiteindelijke afbeeldingsgrootte):


Apply one of N predefined transformations (matrix transformations or similar) to the point. An example would be that multiply each coordinate with 0.5.
Plot the new point on the screen.


Als het punt buiten het scherm is, kies dan willekeurig een nieuw punt binnen het scherm.

Als je mooie kleuren wilt, laat de kleur dan afhangen van de laatst gebruikte transformatie.

Antwoord 7, autoriteit 8%

Ik zou beginnen met iets eenvoudigs, zoals een Koch Snowflake. Het is een eenvoudig proces om een ​​regel te nemen en deze te transformeren, en vervolgens het proces recursief te herhalen totdat het er netjes uitziet.

Iets supereenvoudigs, zoals 2 punten nemen (een lijn) en een 3e punt toevoegen (een hoek maken), en dan herhalen op elke nieuwe sectie die wordt gemaakt.

fractal(p0, p1){
    Pmid = midpoint(p0,p1) + moved some distance perpendicular to p0 or p1;
    fractal(p0,Pmid);
    fractal(Pmid, p1);
}

Antwoord 8, autoriteit 8%

Ik denk dat je fractals misschien niet ziet als een algoritme of iets om te programmeren. Fractals is een concept! Het is een wiskundig concept van gedetailleerd patroon dat zichzelf herhaalt.

Daarom kun je op veel manieren een fractal maken, met verschillende benaderingen, zoals weergegeven in de onderstaande afbeelding.

Kies een aanpak en onderzoek vervolgens hoe u deze kunt implementeren. Deze vier voorbeelden zijn geïmplementeerd met behulp van Marvin Framework. De broncodes zijn beschikbaar hier

Antwoord 9, autoriteit 5%

De mandelbrot-set wordt gegenereerd door herhaaldelijk een functie te evalueren totdat deze overloopt (een bepaalde gedefinieerde limiet), en vervolgens te controleren hoe lang het duurde voordat u overstroomde.

Pseudocode:

MAX_COUNT = 64 // if we haven't escaped to infinity after 64 iterations, 
               // then we're inside the mandelbrot set!!!
foreach (x-pixel)
  foreach (y-pixel)
    calculate x,y as mathematical coordinates from your pixel coordinates
    value = (x, y)
    count = 0
    while value.absolutevalue < 1 billion and count < MAX_COUNT
        value = value * value + (x, y)
        count = count + 1
    // the following should really be one statement, but I split it for clarity
    if count == MAX_COUNT 
        pixel_at (x-pixel, y-pixel) = BLACK
    else 
        pixel_at (x-pixel, y-pixel) = colors[count] // some color map. 

Opmerkingen:

waarde is een complex getal. een complex getal (a+bi) wordt gekwadrateerd om (aa-b*b+2*abi) te geven. U moet een complex type gebruiken of die berekening in uw lus opnemen.

Antwoord 10, autoriteit 5%

Hier is een codepen die ik heb geschrevenvoor de Mandelbrot-fractal met gebruik van gewoon javascript en HTML.

Hopelijk is het gemakkelijk om de code te begrijpen.

Het meest gecompliceerde deel is het schalen en vertalen van de coördinatenstelsels. Ook ingewikkeld is het maken van het regenboogpalet.

function mandel(x,y) {
  var a=0; var b=0;
  for (i = 0; i<250; ++i) {
    // Complex z = z^2 + c
    var t = a*a - b*b;
    b = 2*a*b;
    a = t;
    a = a + x;
    b = b + y;
    var m = a*a + b*b;
    if (m > 10)  return i;
  }
  return 250;
}

Antwoord 11, autoriteit 3%

Soms programmeer ik fractals voor de lol en als uitdaging. Je kunt ze hiervinden. De code is geschreven in Javascript met behulp van de P5.js-bibliotheek en kan rechtstreeks uit de HTML-broncode worden gelezen.

Voor degenen die ik heb gezien, zijn de algoritmen vrij eenvoudig, zoek gewoon het kernelement en herhaal het keer op keer. Ik doe het met recursieve functies, maar het kan ook anders.

Antwoord 12, autoriteit 2%

Mensen hierboven gebruiken het vinden van middelpunten voor sierpinski en Koch, ik zou veel meer aanraden om vormen te kopiëren, ze te schalen en ze vervolgens te vertalen om het ‘fractal’-effect te bereiken.
Pseudo-code in Java voor sierpinski zou er ongeveer zo uitzien:

public ShapeObject transform(ShapeObject originalCurve)
    {
        Make a copy of the original curve
        Scale x and y to half of the original
        make a copy of the copied shape, and translate it to the right so it touches the first copied shape
        make a third shape that is a copy of the first copy, and translate it halfway between the first and second shape,and translate it up
        Group the 3 new shapes into one
        return the new shape
    }