UNIVERSIDAD NACIONAL DE

SAN AGUSTIN
FACULTAD DE INGENIERÍA
DE PRODUCCIÓN Y
SERVICIOS
ESCUELA PROFESIONAL DE
INGENIERA INDUSTRIAL

CURSO:

PROGRAMACIÓN Y MÉTODOS
NUMÉRICOS
TEMA:
FRACTALES EN VISUAL BASIC

REALIZADO POR:

 HURTADO CHUCTAYA, DAYANA

 SAAVEDRA YANQUI,FIORELLA
 CARRASCO MENDOZA, MILAGROS
 QUISPE FLORES, MILAGROS
 TORRES HILAZACA, MAURICIO
 VIZCARRA MENDOZA, FABRIZIO
 MAMANI TUNCO, JONATAN

DOCENTE:
Ing. Ismael Véliz Vilca
GRUPO:
«C»

Arequipa, Perú

| 2018 - A
 INTRODUCCIÓN

En la naturaleza hay abundantes ejemplos de formas pertenecientes a la geometría

euclidiana (hexágonos, cubos, tetraedros, cuadrados, triángulos, etc.) pero su vasta

diversidad también produce objetos que eluden la descripción euclidiana. En esos casos

los fractales nos proporcionan un mejor medio de explicación.

Los fractales permiten modelizar, por ejemplo, objetos tales como una hoja de helecho o

un copo de nieve.

Pero ¿qué es un fractal? Es muy complicado dar una definición general, muchas de estas

definiciones no se pueden aplicar a todas las familias de fractales existentes. Sin

embargo, todos los fractales tienen algo en común, ya que todos ellos son el producto de

la iteración, repetición, de un proceso geométrico elemental que da lugar a una

estructura final de una complicación aparente extraordinaria.

Cuando vemos una ilustración o una fotografía de un fractal, lo estamos viendo en un

momento de tiempo....está congelado en una etapa determinada de su crecimiento.

Pueden crearse fractales para simular cualquier forma que uno pueda imaginar. Los

fractales no están necesariamente limitados a una sola regla, sino que pueden estar

formados por varias reglas o estipulaciones.

ÍNDICE
OBJETIVOS......................................................................................................................1

OBJETIVO GENERAL.................................................................................................1

OBJETIVOS ESPECÍFICOS.......................................................................................1

MARCO TEÓRICO..........................................................................................................2

TIPOS DE FRACTALES..............................................................................................4

TRIANGULO DE SIERPINSKY..................................................................................6

DESCRIPCIÓN DEL TRABAJO.....................................................................................7

PROGRAMA FUENTE Y EJECUTABLE......................................................................8

TRIÁNGULO DE SIERPINSKI...................................................................................8

CÍRCULOS RECURSIVOS........................................................................................10

BOSQUE RECURSIVO..............................................................................................11

BIBLIOGRAFÍA.............................................................................................................14

0
OBJETIVOS

OBJETIVO GENERAL

 El objetivo planteado es familiarizar los conjuntos fractales con el lenguaje de

programación en Visual Basic y explicar los algoritmos utilizados en su

elaboración.

OBJETIVOS ESPECÍFICOS

 Aplicar los conocimientos adquiridos en el desarrollo del curso de Programacion

y Metodos numericos para diseñar fractales usando en Windows forms con el

lenguaje de programación de Visual Basic.

 Incentivar la programación como herramienta para aplicarla en situaciones y

problemas planteados.

1
MARCO TEÓRICO

Antes de que Newton, Leibniz y colaboradores crearan en el siglo XVII lo que hoy

conocemos como Calculus y estudiamos en la facultad como Cálculo, Análisis

Matemático o Cálculo Infinitesimal, se conocían funciones con enormes irregularidades

y discontinuidades, pero los científicos de aquella época supusieron que esas mismas

funciones discontinuas eran muy escasas y que raramente surgirían en sistemas

naturales, por lo que las consideraban excepciones a la matemática tradicional y

simplemente las dejaban de lado, o si no las ignoraban, realizaban aproximaciones a

través de redondeos, lo cual aún hoy en día se continua haciendo con éxito en diferentes

sistemas, pero dichos redondeos se vuelven peligrosos en sistemas con una dinámica

caótica.

Un grupo de matemáticos comenzó a darse cuenta que en la naturaleza se daban muy

frecuentemente este tipo de irregularidades y que no eran excepciones como se suponía.

Los primeros que comenzaron a demostrar teóricamente esta problemática fueron

Cantor (con su famoso conjunto de Cantor) y Peano. Los fractales fueron concebidos

aproximadamente en 1890 por el francés Henrí Poincaré. Sus ideas fueron extendidas

más tarde por dos matemáticos también franceses, Gastón Juliá y Pierre Fatuo, hacia

1918. Los trabajos realizados en este campo quedaron detenidos en los años 20. El

estudio de los fractales fue renovado a partir de 1974 en IBM y fue fuertemente

impulsado por el desarrollo de la computadora digital. El doctor Mandelbrot de la

Universidad de Yale, que es considerado el padre de la Geometría Fractal, realizó

incontables experimentos con computadoras. En su honor uno de los conjuntos que él

investigó lleva su nombre. En 1980, la publicación de su libro La Geometría Fractal de

la Naturaleza popularizó la geometría fractal a nivel mundial.

2
Los algoritmos Fractales se utilizan para describir formas complejas con una reducida

cantidad de información mediante sencillos procesos iterativos.

El libro “The Fractal Geometry of Nature” describe numerosas aplicaciones de este tipo

de estructuras para la investigación en ciencias aplicadas, siendo una herramienta

fundamental en la modelización de un gran número de fenómenos naturales. El término

fractal, procedente del latín “fractus” (fragmentado, irregular), fue introducido por

Mandelbrot.

Con la introducción de los fractales como objeto de estudio, se puede trabajar de

acuerdo con numerosos objetivos de la competencia matemática. Se manejan conceptos

habituales de los currículos matemáticos como la iteración, las transformaciones

geométricas lineales y las no-lineales, la semejanza y la homotecia, la convergencia y el

límite, o el determinismo y el azar, permitiendo mostrar interesantes interconexiones

entre diferentes ideas matemáticas.

En el intento de una definición, hay que considerar dos propiedades que los objetos

presentan: la autosimilitud y la “dimensión extraña”.

El término autosimilitud (que puede ser entendido también como autosemejanza) está

relacionado a la propiedad de un objeto de presentar en sus partes la misma forma o

estructura que el todo, aunque pueden encontrarse a diferentes escalas y ligeramente

deformadas en algunos casos. Se mencionarán tres tipos diferentes de autosimilitud:

•Autosimilitud exacta: es el tipo más restrictivo y exige que el fractal parezca idéntico

a diferentes escalas (sistemas de funciones iteradas). Ejemplo: conjunto de Cantor,

triángulo de Sierpinski, copo de nieve de Von Koch y otros.

3
•Cuasiautosimilitud: exige que el fractal parezca aproximadamente idéntico a

diferentes escalas (fractales definidos por relaciones de recurrencia). Ejemplo: conjunto

de Julia, conjunto de Mandelbrot y otros.

•Autosimilitud estadística: es el tipo más débil y exige que el fractal tenga medidas

numéricas o estadísticas que se preserven con el cambio de escala (fractales aleatorios).

Ejemplo: el vuelo de Levy, paisajes fractales, árboles brownianos y otros.

Todos los fractales tienen algo en común, ya que todos son el producto de la iteración,

repetición, de un proceso geométrico elemental que da lugar a una estructura final de

una complicación aparente extraordinaria.

TIPOS DE FRACTALES

a) Fractales lineales

Son aquellos que se construyen con un simple cambio en la variación de sus

escalas. Esto implica algo muy importante, los fractales lineales son exactamente

idénticos en todas sus escalas hasta el infinito. El triángulo y la alfombra de

Sierpinski y la curva de Koch son ejemplos de fractales lineales.

4
 b) Fractales no lineales

Son aquellos que se generan a partir de distorsiones complejas o justamente

como lo dice su nombre, y usando un término proveniente de la matemática

Caótica, distorsiones no lineales. La mayoría de los objetos fractales puramente

matemáticos y naturales son no lineales. Ejemplos de ellos son: el súper

conocido Conjunto de Mandelbrot o el Conjunto de Julia.

El triángulo de Sierpinski (1915) es el ejemplo más sencillo que se puede utilizar para

describir cómo se obtiene la imagen fractal.

5
TRIANGULO DE SIERPINSKY

El triángulo de Sierpinski fue ideado porWaclaw Sierpinski en 1915. El triángulo de

Sierpinski se obtiene después de infinitas repeticiones de un algoritmo geométrico

sencillo: dividir un triángulo equilátero en cuatro triángulos iguales y eliminar el

triángulo equilátero central, es decir quedarnos con los tres triángulos de los vértices.

Para construir un triángulo de Sierpinski se comienza con un único triángulo grande. Se

divide este gran triángulo en cuatro nuevos triángulos conectando el punto medio de

cada lado. Ignorando el triángulo medio que se acaba de crear, se aplica el mismo

procedimiento a cada uno de los tres triángulos de las esquinas. Cada vez que cree un

nuevo conjunto de triángulos, aplique recursivamente este procedimiento a los tres

triángulos más pequeños de las esquinas

PROCESO DE GENERACIÓN DEL TRIANGULO DE SIERPINSKI

6
DESCRIPCIÓN DEL TRABAJO

En el presente trabajo usaremos los conocimientos adquiridos en el tema de

recursividad, siendo un claro ejemplo el árbol, el bosque donde pusimos dichos

conocimientos en práctica, prosiguiendo a desarrollar nuevos ejemplares:

Triángulos y círculos recursivos: Usando Windows Form, partiendo de un primer

triangulo se genera nuevos triángulos a partir de los puntos medios del primer triangulo

si cada uno de estos triangulo se dividen a su vez en tres, tendremos una nueva figura

recursiva, la función calcula los vértices del triángulo, dibuja la figura y la llama tres

veces una por cada sub triangulo en cada llamada a la función se reduce el valor de

recursividad así cuando es cero termina el llamado de la función.

En el caso de los círculos recursivos, a partir de un primer círculo se forman cuatro

nuevos en la intersección de ejes trazados desde el punto medio del primer círculo con

este mismo.

Bosque recursivo.- A partir de gráficos de líneas se genera ramas de un árbol

modificando su densidad para darle una forma semejante, para el tallo igualmente se usa

la línea de mayor tamaño además también se pueden modificar características como la

inclinación de las ramas, la posición del árbol, su tamaño general.

Se puede formar un bosque generando de estos árboles de diferentes tamaños, colores

generados al azar por el programa.

7
PROGRAMA FUENTE Y EJECUTABLE

TRIÁNGULO DE SIERPINSKI

Public Class Form1

Dim Gráfico As Graphics
Dim Tinta As Pen = New Pen(Brushes.Red, 3)
Dim Generaciones As Integer
Dim RadioA100 As Single

Dim Seno As Single = Math.Sin(Math.PI / 6)

Dim Coseno As Single = Math.Cos(Math.PI / 6)
Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
RadioA100 = pbGráfico.Width / 2
Gráfico = pbGráfico.CreateGraphics
8
 End Sub

Private Sub hsbGen_Scroll(sender As Object, e As ScrollEventArgs) Handles

hsbGen.Scroll
lblGen.Text = "Generaciones: " & hsbGen.Value
End Sub

Private Sub hsbEsc_Scroll(sender As Object, e As ScrollEventArgs) Handles

hsbEsc.Scroll
lblEsc.Text = "Escala: " & hsbEsc.Value
End Sub

Private Sub btnDibujar_Click(sender As Object, e As EventArgs) Handles

btnDibujar.Click
Generaciones = hsbGen.Value - 1
Dim Escala As Integer = hsbEsc.Value

Dim RadioEscalado As Single = RadioA100 * Escala / 100

Dim Punto1 As Point = New Point(RadioEscalado * Coseno + RadioA100,

RadioEscalado * Seno + RadioA100)
Dim Punto2 As Point = New Point(RadioA100, -RadioEscalado + RadioA100)
Dim Punto3 As Point = New Point(-RadioEscalado * Coseno + RadioA100,
RadioEscalado * Seno + RadioA100)

Gráfico.Clear(Color.White)
Gráfico.DrawPolygon(Tinta, {Punto1, Punto2, Punto3})
CrearTriángulo(New Point(RadioA100, RadioA100), RadioEscalado, 0)
End Sub

Sub CrearTriángulo(ByVal PuntoBase As Point, ByVal Radio As Single, ByVal

Generación As Integer)
If Generación < Generaciones Then
Dim RadioReal As Single = Radio / 2

Dim Punto1 As Point = New Point(RadioReal * Coseno + PuntoBase.X,

-RadioReal * Seno + PuntoBase.Y)
Dim Punto2 As Point = New Point(PuntoBase.X, RadioReal + PuntoBase.Y)
Dim Punto3 As Point = New Point(-RadioReal * Coseno + PuntoBase.X,
-RadioReal * Seno + PuntoBase.Y)

Gráfico.DrawPolygon(Tinta, {Punto1, Punto2, Punto3})

CrearTriángulo(New Point(PuntoBase.X, PuntoBase.Y - Radio / 2), Radio / 2,

Generación + 1)
CrearTriángulo(New Point(-Radio / 2 * Coseno + PuntoBase.X, Radio / 2 *
Seno + PuntoBase.Y), Radio / 2, Generación + 1)
CrearTriángulo(New Point(Radio / 2 * Coseno + PuntoBase.X, Radio / 2 * Seno
+ PuntoBase.+
), Radio / 2, Generación + 1)
End If

9
 End Sub

End Class

CÍRCULOS RECURSIVOS

Public Class Form1

Dim Recursividad, EscalaTotal, EscalaRecursividad As Integer
Dim Lapicero As Pen = New Pen(Brushes.Black, 3)
Dim Gráficos As Graphics
Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
Gráficos = pbImagen.CreateGraphics
End Sub
Private Sub btnGraficar_Click(sender As Object, e As EventArgs) Handles
btnGraficar.Click
Recursividad = txtRecursividad.Text
EscalaTotal = txtEscalaTotal.Text
EscalaRecursividad = txtEscalaRecursividad.Text

Gráficos.Clear(Color.White)
DibujarCírculo(New Point(pbImagen.Width / 2, pbImagen.Height / 2), 150 *
EscalaTotal / 100, 0)
End Sub
10
 Sub DibujarCírculo(ByVal Centro As Point, ByVal Radio As Single, ByVal Iteración
As Integer)
If Iteración < Recursividad Then
Gráficos.DrawEllipse (Lapicero, New Rectangle(Centro.X - Radio, Centro.Y -
Radio, Radio * 2, Radio * 2))
DibujarCírculo (New Point(Centro.X, Centro.Y - Radio), Radio *
EscalaRecursividad / 100, Iteración + 1)
DibujarCírculo(New Point(Centro.X, Centro.Y + Radio), Radio *
EscalaRecursividad / 100, Iteración + 1)
DibujarCírculo(New Point(Centro.X - Radio, Centro.Y), Radio *
EscalaRecursividad / 100, Iteración + 1)
DibujarCírculo(New Point(Centro.X + Radio, Centro.Y), Radio *
EscalaRecursividad / 100, Iteración + 1)
End If
End Sub
End Class
BOSQUE RECURSIVO

Public Class Form1

Dim GRAFICO As Graphics
Dim pluma As Pen
Dim brocha As SolidBrush
Dim x, y, alto, teta, w, paro, rama, grosor As Single
Sub Arbol(ByVal x As Single, ByVal y As Single, ByVal alto As Single, _
ByVal teta As Single, ByVal w As Single, paro As Single, rama As
Single)
Dim x1 As Single, y1 As Single, t1 As Single
If (alto > paro) Then '//condición de paro
x1 = x + alto * Math.Cos(teta)
y1 = y + alto * Math.Sin(teta)
GRAFICO.DrawLine(pluma, x, y, x1, y1)
't1 = alto / 1.8 '1.7
t1 = alto / rama
Arbol(x1, y1, t1, teta - w, w, paro, rama)

11
 Arbol(x1, y1, t1, teta, w, paro, rama)
Arbol(x1, y1, t1, teta + w, w, paro, rama)
End If
End Sub

Private Sub BTNaRBOL_Click(sender As Object, e As EventArgs) Handles

BTNaRBOL.Click
Arbol(x, y, alto, 3 * Math.PI / 2.0, 0.6, 20, 1.4)
End Sub
Private Sub btnBosque_Click(sender As Object, e As EventArgs) Handles
btnBosque.Click
Randomize()
Dim fila, narboles, rojo, verde, azul, grosor As Integer
GRAFICO.Clear(brocha.Color)
narboles = 50 + Int(Rnd() * 200)
For fila = 1 To narboles
grosor = 1 + Int(Rnd() * 10)
pluma.Width = grosor
rojo = 4 + Int(Rnd() * 250)
verde = 4 + Int(Rnd() * 250)
azul = 4 + Int(Rnd() * 250)
pluma.Color = Color.FromArgb(rojo, verde, azul)
x = 50 + Int(Rnd() * 500)
y = 50 + Int(Rnd() * 500)
alto = 20 + Int(Rnd() * 200)
teta = 3 * Math.PI / 2.0
w = (Rnd() * 1000) / 1000
paro = 10 + Int(Rnd() * 100)
rama = 1.3 + (Rnd() * 30) / 100
Arbol(x, y, alto, teta, w, paro, rama)
Next
End Sub

Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load

GRAFICO = PictureBox1.CreateGraphics
pluma = New Pen(Brushes.Green, 4)
pluma.Color = Color.Green
brocha = New SolidBrush(Color.Aqua)
brocha.Color = Color.FromArgb(255, 255, 123, 112)
grosor = 4
HSParo.Minimum = 10 : HSParo.Maximum = 80 : HSParo.Value = 20 :
txtparo.Text = HSParo.Value
HSRama.Minimum = 0
HSRama.Maximum = 200
pluma.Width = grosor : x = 200 : y = 300 : alto = 100
teta = 3 * Math.PI / 2.0 : w = 0.6 : paro = 20 : rama = 1.4
Arbol(x, y, alto, teta, w, paro, rama)
End Sub

Private Sub HSX_Scroll(sender As Object, e As ScrollEventArgs) Handles

HSX.Scroll
GRAFICO.Clear(brocha.Color)
x = HSX.Value
txtX.Text = x
Arbol(x, y, alto, teta, w, paro, rama)
End Sub

Private Sub HSy_Scroll(sender As Object, e As ScrollEventArgs) Handles

HSy.Scroll
GRAFICO.Clear(brocha.Color)
y = HSy.Value
TXTy.Text = y
Arbol(x, y, alto, teta, w, paro, rama)
End Sub
12
 Private Sub HSalto_Scroll(sender As Object, e As ScrollEventArgs) Handles
HSalto.Scroll
GRAFICO.Clear(brocha.Color)
alto = HSalto.Value
txtalto.Text = alto
Arbol(x, y, alto, teta, w, paro, rama)
End Sub

Private Sub HSIncli_Scroll(sender As Object, e As ScrollEventArgs) Handles

HSIncli.Scroll
GRAFICO.Clear(brocha.Color)
teta = HSIncli.Value / 100
txtincli.Text = alto
Arbol(x, y, alto, teta, w, paro, rama)
End Sub

Private Sub HSAbertura_Scroll(sender As Object, e As ScrollEventArgs) Handles

HSAbertura.Scroll
GRAFICO.Clear(brocha.Color)
w = HSAbertura.Value / 100
txtAbertura.Text = alto
Arbol(x, y, alto, teta, w, paro, rama)
End Sub

Private Sub btnfondo_Click(sender As Object, e As EventArgs) Handles

btnfondo.Click
ColorDialog1.ShowDialog()
brocha.Color = ColorDialog1.Color
End Sub
Private Sub HSgrosor_Scroll(sender As Object, e As ScrollEventArgs) Handles
HSgrosor.Scroll
GRAFICO.Clear(brocha.Color)
grosor = HSgrosor.Value / 10
txtgrosor.Text = grosor
pluma.Width = grosor
Arbol(x, y, alto, teta, w, paro, rama)
End Sub

Private Sub HSValor_Scroll(sender As Object, e As ScrollEventArgs) Handles

HSParo.Scroll
GRAFICO.Clear(brocha.Color)
paro = HSParo.Value
txtparo.Text = paro
Arbol(x, y, alto, teta, w, paro, rama)
End Sub
Private Sub HSdx_Scroll(sender As Object, e As ScrollEventArgs) Handles
HSRama.Scroll
GRAFICO.Clear(brocha.Color)
rama = 1.2 + HSRama.Value / 1000
txtRama.Text = rama
Arbol(x, y, alto, teta, w, paro, rama)
End Sub

Private Sub Button1_Click(sender As Object, e As EventArgs) Handles

BtnColorArbol.Click
ColorDialog1.ShowDialog()
pluma.Color = ColorDialog1.Color
End Sub
Private Sub Button1_Click_1(sender As Object, e As EventArgs) Handles
btnAnimar.Click
Timer1.Interval = 100
Timer1.Start()
End Sub
13
 Private Sub Button2_Click(sender As Object, e As EventArgs) Handles
btnParar.Click
Timer1.Stop()
End Sub
Private Sub Timer1_Tick(sender As Object, e As EventArgs) Handles Timer1.Tick
GRAFICO.Clear(brocha.Color)
If alto < 100 Then
alto = alto + 1
Else
alto = 20
End If
txtalto.Text = alto
HSalto.Value = alto
Arbol(x, y, alto, teta, w, paro, rama)
End Sub
Private Sub Button1_Click_2(sender As Object, e As EventArgs) Handles
Button1.Click
End
End Sub
End Class
BIBLIOGRAFÍA

Escribano, C.; Giraldo, A.; Sastre, M. (). Prácticas con algoritmos fractales.

Recuperado de:

http://bioinfo.uib.es/~joemiro/aenui/procJenui/ProcWeb/actas2001/gipra

359.pdf

Iturriaga, R. & Jovanovich, C. (2012). Los fractales y el diseño en las construcciones.

Recuperado de:

http://www5.uva.es/trim/TRIM/TRIM5_files/FRACTALES.pdf

Majdalawi, A. (2005). Matemáticas en la vida cotidiana. FRACTALES. Recuperado de:

https://www.lpi.tel.uva.es/~nacho/docencia/ing_ond_1/trabajos_05_06/io

2/public_html/images/curiosidades/Trabajo%20Fractales%20(Amir

%202006).pdf

Moreno, J. (noviembre del 2002). El juego del caos en la calculadora gráfica:

construcción de fractales. SUMA. Revista sobre la enseñanza y

aprendizaje de las matemáticas, (42), pp. 69-79. Recuperado de:

https://www.researchgate.net/profile/Marcela_Falsetti/publication/39220

14
 768_Interacciones_y_aprendizaje_en_Matematicas_analisis_de_una_exp

eriencia_didactica/links/56afce6d08ae9f0ff7b292c4.pdf#page=71

Sardella, O.; Zapico, I.; Berio, A. (2006). Fractales: una nueva mirada en la enseñanza

de la geometría. Números. Revista de Didáctica de las Matemáticas, 65,

pp. 14-20. Recuperado de:

http://funes.uniandes.edu.co/3462/1/Sardella2006FractalesNumeros65.pd

15