Sunteți pe pagina 1din 16

Fundamentos de procesos

aleatorios

PROYECTO 2 : FRACTALES

Integrantes del equipo:


Sanchez Quezada Jose Yaomautzin
Objetivo: Aplicar Sistemas de Funciones Iteradas (IFS) para la generación de fractales.
Conocer Matlab para la generación de variables aleatorias de distribución uniforme. Aplicar
instrucciones "histogram", "rand (o unifrnd)" y "scatter".
PROCEDIMIENTO
Se toma un punto escogido aleatoriamente en el plano y se le aplica una de las funciones
definidas mediante transformaciones afines lineales. Cada función se selecciona
aleatoriamente, dibujando el punto correspondiente. Los elementos estructurales son básicos y
se repiten en diferentes escalas de resolución espacial. La densidad de las estructuras depende
del número de iteraciones que se especifican.
1. Genera un arreglo de un millón de números aleatorios con distribución U [0,1]. Grafícalos
empleando la instrucción "histogram" y verifica la correcta generación de datos.
Código:
clc;
clear all;
close all;

x = rand (1000000,1);
h = histogram (x);

Fig. 1 Histograma de un millón de números aleatorios de distribución U {0,1]

Aplica el siguiente procedimiento para generar al fractal "Helecho".


2. Inicialización: Sea (Xo, Yo) = (0,0) un punto en el plano.
3. Genera una variable aleatoria U, uniformemente distribuida U (O, 1), la cual se interpreta
como la probabilidad para escoger aleatoriamente a una trasformación Ti.
4. Aplica la transformación Ti al punto (Xo, Yo) para obtener el nuevo punto (X1, Y1) y
grafícalo. El índice i de la transformación se determina según el intervalo donde se
encuentra la variable U.
5. Repite la operación a fin de obtener la secuencia de puntos. El proceso es iterativo y el
punto anterior sirve para generar al nuevo punto:

6. Repite hasta graficar diez mil puntos

Código:
clear all;
x=0;
y=0;
P = [0;0];
T1 = [0 0;0 0.16];
T2 = [0.85 0.04;-0.04 0.85];
T3 = [0.2 -0.26; 0.23 0.22];
T4 = [-0.15 0.28;0.26 0.24];
S1=[0;1.6];
S2=[0;0.44];

tiempo_inicio = cputime;

for i = 1:10000
U = rand;
if U < 0.01;
P = T1 * P;
elseif U >= 0.01 & U < 0.86
P = T2 * P + S1;
elseif U >= 0.86 & U < 0.93
P = T3 * P + S1;
else
P = T4 * P + S2;
end
x = P(1);
y = P(2);
hold on;
p = plot(x,y);
p.Marker = '.';
end

tiempo_fin = cputime - tiempo_inicio

Fig. 2 Frcatal Helecho con 10000 puntos

Tiempo de procesamiento: 18.5625 s


7. Reinicia el procedimiento y genera cien mil puntos
Fig. 3 Fractal helecho con 100000 puntos

Tiempo de procesamiento: 159.0469 s


8. Genera el fractal "Estrella", empleando las transformaciones Tl y T2.
Algoritmo:
a. Fija un número razonablemente grande de iteraciones
b. Inicialización: Fija las coordenadas de un punto inicial
c. Ciclo de iteraciones
 Escoge aleatoriamente una transformación, según las probabilidades PI y P2.
 Determina el punto siguiente transformando al punto actual, según la
transformada escogida.

Código:
clear all;
x=0;
y=0;
P = [10;10];
T1 = [0.745455 -0.459091;0.406061 0.887121];
T2 = [-0.424242 -0.065152;-0.175758 -0.218182];
S1=[1.460279;0.691072];
S2=[3.809567;6.741476];

tiempo_inicio = cputime;

for i = 1:10000
U = rand;
if U <= 0.912675;
P = T1 * P + S1;
else
P = T2 * P + S2;
end
x=P(1);
y=P(2);
hold on;
p = plot(x,y);
p.Marker = '.';
end

tiempo_fin = cputime - tiempo_inicio

Fig. 4 Fractal Estrella con 100000 puntos

Tiempo de procesamiento: 205.3750 s

9. Repite para generar el fractal “Dragón”


Código:
clear all;
x=0;
y=0;
P = [10;10];
T1 = [0.8240740 0.281482;-0.2123460 0.864198];
T2 = [0.288272 0.720988;-0.463889 -0.377778];
S1=[-1.88229;-0.110607];
S2=[0.720988;8.095759];

tiempo_inicio = cputime;
for i = 1:10000
U = rand;
if U <= 0.787473
P = T1 * P + S1;
else
P = T2 * P + S2;
end
x=P(1);
y=P(2);
hold on;
p = plot(x,y);
p.Marker = '.';
end

tiempo_fin = cputime - tiempo_inicio


Fig. 5 Fractal Dragón con 100000 puntos

Tiempo de procesamiento: 184.2031 s

10. Repite para generar el fractal “Hoja de maple”


Fig. 6 Fractal Hoja de maple con 100000 puntos

Tiempo de procesamiento: 183.2500 s

Codigo:
clc;
clear all:
close all;

hold on;

N = 10000000;
x = zeros(1,N);
x = y ;

tiempo_inicio = cputime;

for i = 2 : N
U = randi([0 2]);

switch U
case 0
x(i) = 0.5*x(i-1) + 1;
y(i) = 0.5*y(i-1) + 1;
case 1
x(i) = 0.5*x(i-1) + 1;
y(i) = 0.5*y(i-1) + 50;
case 2
x(i) = 0.5*x(i-1) + 50;
y(i) = 0.5*y(i-1) + 50;
end
end

p = plot(x,y,'.');

tiempo_fin = cputime - tiempo_inicio

Fig. 7 Fractal Triangulo de Sierpinsky con 1000000 puntos

Tiempo de procesamiento: 8.7344 s


Código:
clear all;
x=0;
y=0;
P = [0;0];
T1 = [0.5 0;0 0.75];
T2 = [0.25 -0.2;-0.1 0.3];
T3 = [0.25 0.2; -0.1 0.3];
T4 = [0.2 0;0 0.3];
S1=[0.25;0];
S2=[0.25;0.5];
S3=[0.5;0.4];
S4=[0.4;0.55];

tiempo_inicio = cputime;

for i = 1:100000
U = rand;
if U < 0.25;
P = T1 * P + S1;
elseif U >= 0.25 & U < 0.5
P = T2 * P + S2;
elseif U >= 0.5 & U <0.75
P = T3 * P + S3;
else
P = T4 * P + S4;
end
x=P(1);
y=P(2);
hold on;
p = plot(x,y);
p.Marker = '.';
end

tiempo_fin = cputime - tiempo_inicio

Fig. 8 Fractal Rama con 100000 puntos

Código:
clear all;
x=0;
y=0;
P = [0;0];
T1 = [0 -0.5;0.5 0];
T2 = [0 0.5;-0.5 0];
T3 = [0.5 0;0 0.5];
S1=[0.5;0];
S2=[0.5;0.5];
S3=[0.25;0.5];

tiempo_inicio = cputime;

for i = 1:10000
U = rand;
if U < 0.333333;
P = T1 * P + S1;
elseif U >= 0.333333 & U < 0.6666666
P = T2 * P + S2;
else
P = T3 * P + S3;
end
x=P(1);
y=P(2);
hold on;
p = plot(x,y);
p.Marker = '.';
end

tiempo_fin = cputime - tiempo_inicio

Fig. 9 Fractal Diamante con 100000 puntos


Fundamentos de IFS

En 1985, M. F. Barnsley, justamente el creador del juego del caos, generalizó más el método
desarrollando lo que hoy conocemos como IFS (Iterated Function Systems). Vamos paso a
paso para entender esta nueva forma de obtener fractales.

Observa el monigote inicial de la tabla inferior. Llamémoslo semilla inicial. Sobre él vamos a
ejercer una serie de transformaciones. Creamos tres copias reducidas a 1/3 y las situamos
como se observa en la segunda celda. Repetimos el procedimiento con cada nuevo monigote
y ...

A las transformaciones aplicadas a cada iteración podemos llamarlas dinámicas. Y al


resultado final atractor.

Las transformaciones lineales a las que hacemos referencia se denominan técnicamente


transformaciones afines. Una transformación afín de un punto (x,y) del plano a un punto (x',y')
tiene la forma:
x' = ax + by + e
y' = cx + dy + f
donde a, b, e, c, d y f son constantes. Veamos como funcionan estas transformaciones
geométricamente. Tomemos como ejemplo el siguiente triángulo ABC:
Consideremos en concreto la transformación:
x' = (1/2)x + 0y + 0
y' = 0x + (1/2)y + 0
Aplicada a los puntos del triángulo nos devuelve el triángulo A'B'C'. Por sustitución es fácil ver
que los vértices se transforman de la siguiente manera:
A(0,0) --> A'(0,0)
B(1,0) --> B'(1/2,0)
C(1,1) --> C'(1/2,1/2)
El resultado es una contracción del triángulo inicial que mantiene inalterados los ángulos. El
triángulo se reescala en un factor 1/2. Compliquemos ligeramente el ejemplo cambiando la
transformación anterior a:
x' = (1/2)x + 0y + 1/2
y' = 0x + (1/2)y + 1/2
Ahora la transformación mueve los vértices a:
A(0,0) --> A'(1/2,1/2)
B(1,0) --> B'(1,1/2)
C(1,1) --> C'(1,1)

S-ar putea să vă placă și