Sin embargo poca gente sabría definir lo que es un Fractal. En realidad se trata de un objeto matemático generado por la repetición infinita de un proceso geométrico dado.

Y es ahí precisamente donde radica su complejidad, porque los fractales con los que trabajan los ordenadores no son sino aproximaciones a los verdaderos, fruto de la repetición finita del proceso geométrico de generación del fractal.

DEL CONJUNTO DE CANTOR AL CONJUNTO DE MANDELBROT

Imaginemos el segmento de la recta real comprendido entre el 0 y el 1. Dividimos dicho segmento en tres partes iguales y eliminamos la parte central. Ahora tenemos dos segmentos diferentes, con los que repetimos el proceso... y así indefinidamente.

El conjunto así obtenido es un fractal, denominado "Conjunto de Cantor", en honor al matemático que lo construyó y estudió.

Este es un sencillo ejemplo de fractal, que contrasta con el más complejo y, paradójicamente, más conocido fractal: el "Conjunto de Mandelbrot".

No me voy a extender en los fundamentos matemáticos del conjunto de Mandelbrot, simplemente diré que mide la conexidad de otro fractal también muy conocido: el "Conjunto de Julia".

CURVAS, ITERACIONES Y SISTEMAS L

Los sistemas L nos permiten obtener sucesivas aproximaciones a fractales, partiendo de códigos que contienen la información sobre el fractal.

Dichos códigos se van reproduciendo a sí mismos, creciendo hasta el infinito, momento en el cual definen por completo el fractal.

Con lo dicho hasta ahora parece que un sistema L es muy complejo y laborioso de construir, pero en realidad es muy simple, ya que sólo necesitamos definir unas cuantas cosas:

- Un Alfabeto: compuesto por una serie finita de símbolos que nos ayudan a definir la estructura del fractal.

- Unas reglas de transición: quizá la parte más importante del sistema. Estas reglas definen la forma en la que el código se reproduce. Si nos equivocamos en estas reglas lo más probable es que el dibujo que nos salga no sea el que en realidad queríamos, aunque los más grandes descubrimientos vienen precedidos de los más grandes errores.

- Un código inicial: digamos que es como la semilla del fractal. Aplicando sucesivas veces las reglas de transición a este código inicial, iremos obteniendo aproximaciones cada vez más precisas de nuestro fractal.

- Un código de representación: cuando hayamos realizado el número de iteraciones deseado, tendremos un código compuesto por una sucesión de símbolos del alfabeto. Pero ese código a nosotros no nos dice nada en absoluto. Por ello necesitaremos traducirlo a una representación gráfica.

Veamos ahora de forma práctica la construcción del fractal denominado "Curva de Koch" mediante un sistema L. La construcción geométrica de la curva de Koch es la siguiente:

Partimos de un segmento al que dividimos en tres partes iguales y eliminamos la parte central (¿De qué me suena a mi esto?) sustituyéndola por los dos segmentos que junto con esta parte eliminada formarían un triángulo equilátero (Ver Figura 1).

Con cada uno de estos cuatro segmentos repetimos el mismo proceso y así sucesivamente hasta alcanzar en el infinito la Curva de Koch.

Definamos el sistema L asociado a la curva Koch:

- Alfabeto: {U,+,-}

- Reglas de transición:
U -> U+U-U+U
+ -> +
- -> -

- Código de representación:
U -> Segmento unitario
+ -> Giro de 60 grados
- -> Giro de -60 grados

- Código inicial: U

Entonces al aplicar sucesivas veces las reglas de transición iremos obteniendo cadenas de código que se aproximan cada vez más al fractal:

Iteración 1: "U"
Iteración 2: "U+U-U+U"
Iteración 3: "U+U-U+U+U+U-U+U-U+U-U+U+U+U-U+U"

Y así sucesivamente, hasta alcanzar el número de iteraciones deseado.

El programa AMOS que representa la curva de Koch mediante este sistema L es el listado 1.

Una vez se ejecute el programa, este preguntará el número de iteraciones a realizar y la longitud en puntos del segmento unidad. No aconsejo que sean más de cinco iteraciones, pues la cadena del código crece de forma espectacular, y con ella el tiempo de espera. Para que os hagais una idea aquí van unas cifras, tomadas en un A500 normal:

4 Iteraciones: 2 segundos y 596 caracteres.
5 Iteraciones: 11 segundos y 2388 caracteres.
6 Iteraciones: 81 segundos y 9556 caracteres.

Si en la variable CI$, que es la que contiene el código inicial, introducimos "U" obtenemos la curva de Koch. Pero si introducimos el código "U-U-U" (que es un triángulo equilátero) obtenemos la llamada "Isla de Koch". En la figura 2 se pueden observar varias iteraciones de la isla de Koch.

Como ejercicio de programación propongo la realización de un programa que negere un sistema L más complejo. Que admita giros variables y segmentos de diversa longitud, para así poder representar muchos más fractales. Aquí dejo un par de indicaciones para el programa:

Axx -> representa un avance de longitud xx
Gxxx -> representa un giro xxx grados (xxx de 0 a 360)

Basándose en el programa AmosKoch resultará un buen ejercicio de programación sobre el manejo de cadenas de caracteres.

Set Buffer 100
Input "Número de iteraciones: ";NUMDEIT
A:
Input "Longitud (1-100): ";LONG
If LONG<1 or LONG>100 Then Goto A
Default Palette 0,4095
Screen Open 0,640,512,2,Hires+Laced
Curs Off : Flash Off : Cls 0
CI$="U" : Rem **** Código inicial ****
D=0 : Rem **** Dirección inicial ****
X#=10 : Y#=400 : Rem **** Coordenadas iniciales del gráfico ****
Global X#,Y#
Dim ALFATRA$(3,2)
For A=1 To 3
   Read ALFATRA$(A,1)
   Read ALFATRA$(A,2)
Next
Data "U","U+U--U+U"
Data "+","+"
Data "-","-"
Shared ALFATRA$()
Timer=0
If NUMDEIT=0 Then S$=CI$ : Goto TRAZADO
Proc ITERACION[NUMDEIT,CI$,3]
S$=Param$
Rem **** Rutina de trazado ****
TRAZADO:
Plot X#,Y#
For L=1 To Len(S$)
   D$=Mid$(S$,L,1)
   IF D$="+" Then D=(D+60)
   IF D$="-" Then D=(D-60)
   If D$="U" Then Proc TRAZA[D,LONG]
Next
T=Timer
T#=T/50
Wait Key
Screen Open 0,320,256,2,Lowres
Cls 0 : Curs Off : Flash Off
Print "Numero de iteraciones:";NUMDEIT
Print "Tiempo empleado:";T#;" segundos."
Print "Longitud de la cadena:";Len(S$);" caracteres."
End
Procedure ITERACION[NUMDEIT,CI$,NUDIM]
   S$=CI$
   For I=1 To NUMDEIT
      R$=""
      For L=1 To Len(S$)
         D$=Mid$(S$,L,1)
         For N=1 To NUDIM
            If D$=ALFATRA$(M,1) Then R$=R$+AL-FATRA$(M,2)
         Next
      Next
      S$=R$
   Next
End Proc[S$]
Procedure TRAZA[D,L]
   X#=X#+L*Cos(D*Pi#/180)
   Y#=Y#+L*Sin(D*Pi#/180)
End Proc