|Worry looks around, sorry looks back, faith looks up.|
Fractals, and The Mandelbrot Set
Fractal type were first considered by philsopher and matematician Gottfried Leibniz as he thought about the process of recursive self-similarity.
Fractals lend themselves to computer art, since they look infinitely complex, in a way that resembles many things in nature. The most notable objects that can reasonably be drawn algorithmically with fractals are: mist, smoke, clouds, terrain, plants and trees, lightning and snow flakes.
Some interesting recent movies have used fractals in their creation.
For more information, check out the work of Ronald Davis, George Grie, Matthias Groebel, Olga Kisseleva, John Lansdown, Manfred Mohr, Joseph Nechvatal, James Faure Walker and Perry Welman.
What Are Fractals Really
A fractal is an object that displays self-similarity at any level of detail or magnification. This is actually a somewhat obvious definition once you know how fractals are made. Essentially, fractals are made by contorting an object with a scaled down version of itself, and then repeating this process with every new contortion.
Fractals are known to have a similar level of detail regardless of the level of zoom, and strictly speaking, are too irregular to be described by simple geometric means.
In other words, fractals are simply a design made by repeatedly adding a scaled down copy of the base object to the object, and then repeating that process with that new piece.
This really is a case where an example should really help.
Fractals have several interesting properties. First each addition is similar to the base object. This is known as self-similarity in the fractal world.
Second, each addition is scaled by the same degree from it's parent. The degree of scaling is known as the fractal-dimension.
Third, fractals are made by repeating the process ad-infinitum.
Finally, fractals, essentially by definition since each addition is a scaled version of the base object, display self-similiarity at any level of magnification.
This process done by repeatedly taking a component of the fractal, adding a duplicated, usually smaller version of itself to the fractal, and repeating this process with the new element that was just created. The process is exemplified in nature by a tree splits whose trunk splits into smaller and smaller branches.
Benoît Mandelbrot (20 November 1924 – 14 October 2010) is arguably the kingpin of fractals, in part because he coined the term. Mandelbot was born in Poland, but moved to France in 1936 to avoid the war and eventually the United States in 1958 becoming an IBM fellow.
In the 1960's. Mandelbrot was working on a problem of measuring the coastline in Britain. If you have not thought of this problem before, you will realize it is a rather interesting problem since your result depends on the size of your measuring stick. If you use a mile long measuring stick, you will miss many in and out undulations that you would not miss with a foot long measuring stick, or a millimeter long stick. Mandelbrot simply classified all of situations where the length of the measuring stick would matter, or technically when the Hausdorff-Besicovitch dimension would be greater as a fractal. His fame was cemented when he shared images that displayed this property which caught peoples attention.
Two objects are said to be self-similiar in a fractal sense if they have the same shape. This is like kids who look like their parents who look like their grandparents, etc. Mathematicians actually break self-similarity into three different classifications.
How fractals are made in software
There are 4 main ways of generating fractals.
Four common techniques for generating fractals are:
Iterative, this is the main technique we discuss here. Orbit fractals in which a formula is applied at specific points repeatedly. Random fractals where a random process controls the process, and finally, Strange Attractors where complex differential equations exhibiting a chaotic nature are utilized.
The software that generates fractals is commonly recursive, meaning it will do the same thing over and over, with just slightly different parameters. For example, the software will, draw the trunk of a tree, then call itself again to draw the first big branch, then call itself to draw a small branch, etc until it has drawn the smallest element. After that, the software will first draw other twigs, then return to the smallest branch where it will again call and draw more twigs. This process of calling and returning will continue until it has finished drawing the last big branch, and is therefore done drawing the tree.
Link To Our Site
Send To A Friend
Go To The Site Map
Report A Broken Link Contact Us