Curva de Sierpinski

La versión actual de la página aún no ha sido revisada por colaboradores experimentados y puede diferir significativamente de la versión revisada el 23 de abril de 2020; las comprobaciones requieren 2 ediciones .

Las curvas de Sierpinski son una secuencia definida recursivamente de curvas fractales planas cerradas continuas descubiertas por Vaclav Sierpinski . La curva en el límite en llena completamente el cuadrado unitario, por lo que la curva límite, también llamada curva de Sierpinski , es un ejemplo de curvas que llenan espacios .

Dado que la curva de Sierpinski llena el espacio, su dimensión de Hausdorff (en el límite en ) es igual a . Longitud de la curva euclidiana

es igual a ,

es decir, crece exponencialmente en , y el límite para el área de la región encerrada por la curva es cuadrado (en la métrica euclidiana).

Uso de la curva

La curva de Sierpinski es útil para algunas aplicaciones prácticas porque es más simétrica que otras curvas de relleno de espacio comúnmente consideradas. Por ejemplo, se usó como base para construir rápidamente una solución aproximada al problema del viajante de comercio (que busca la ruta más corta alrededor de puntos dados) - la solución heurística es visitar los puntos en la secuencia en que ocurren en el Sierpinski curva [1] . La implementación requiere dos pasos. Primero, se calcula la posición inversa de cada punto, luego se ordenan los valores. Esta idea se utilizó para un sistema de rutas de vehículos comerciales basado únicamente en tarjetas Rolodex [2] .

Sobre la base de la curva de Sierpinski, se pueden implementar diseños de antenas impresas o vibradoras [3] .

Construcción de curvas

La curva que llena el espacio es un mapeo continuo del intervalo unitario al cuadrado unitario y un (pseudo) mapeo inverso del cuadrado unitario al intervalo unitario. Una forma de construir un mapeo pseudo-inverso es la siguiente. Deje que la esquina inferior izquierda (0, 0) del cuadrado unitario corresponda a 0.0 (y 1.0). Luego, la esquina superior izquierda de (0, 1) debe ser 0,25, la esquina superior derecha de (1, 1) debe ser 0,50 y la esquina inferior derecha de (1, 0) debe ser 0,75. La imagen inversa de los puntos interiores se calcula utilizando la estructura recursiva de la curva. A continuación se muestra una función de Java que calcula la posición relativa de cualquier punto en la curva de Sierpinski (es decir, la pseudo-inversa). La función toma las coordenadas del punto (x, y) y los ángulos del triángulo isósceles rectángulo que lo encierra (ax, ay), (bx, by) y (cx, cy) (Tenga en cuenta que el cuadrado unitario es la unión de dos de esos triángulos). Los parámetros restantes determinan el nivel de precisión de los cálculos.

static long sierp_pt2code ( doble hacha , doble ay , doble bx , doble por , doble cx , doble cy , int nivel actual , int nivel máximo , código largo , doble x , doble y ) { if ( nivel actual <= nivel máximo ) { nivel actual ++ ; if (( sqr ( x - ax ) + sqr ( y - ay )) < ( sqr ( x - cx ) + sqr ( y - cy ))) { código = sierp_pt2code ( ax , ay , ( ax + cx ) / 2.0 , ( ay + cy ) / 2.0 , bx , by , currentLevel , maxLevel , 2 * código + 0 , x , y ); } else { código = sierp_pt2code ( bx , by , ( ax + cx ) / 2.0 , ( ay + cy ) / 2.0 , cx , cy , currentLevel , maxLevel , 2 * code + 1 , x , y ); } } código de retorno ; }

El siguiente applet de Java dibuja la curva de Sierpinski utilizando cuatro métodos mutuamente recursivos (métodos que se llaman entre sí):

importar java.applet.Applet ; importar java.awt.Graphics ; importar java.awt.Imagen ; public class SierpinskyCurve extiende Applet { gráficos simples privados sg = null ; privado int dist0 = 128 , dist ; imagen privada offscrBuf ; gráficos privados offscrGfx ; public void init () { sg = new SimpleGraphics ( getGraphics ()); dist0 = 100 ; cambiar el tamaño ( 4 * dist0 , 4 * dist0 ); } actualización de vacío público ( Gráficos g ) { pintura ( g ); } pintura vacía pública ( Gráficos g ) { if ( g == null ) lanza una nueva NullPointerException (); if ( offscrBuf == null ) { offscrBuf = createImage ( this . getWidth () , this . getHeight ()); offscrGfx = offscrBuf . obtenerGráficos (); sg . setGraphics ( offscrGfx ); } nivel int = 3 ; dist = dist0 ; for ( int i = nivel ; i > 0 ; i -- ) dist /= 2 ; sg . goToXY ( 2 * dist , dist ); sierpA ( nivel ); // inicia la recursividad sg . lineRel ( 'X' , + dist , + dist ); sierpB ( nivel ); // inicia la recursividad sg . lineRel ( 'X' , - dist , + dist ); sierpC ( nivel ); // inicia la recursividad sg . lineRel ( 'X' , - dist , - dist ); sierpD ( nivel ); // inicia la recursividad sg . lineRel ( 'X' , + dist , - dist ); g . dibujarImagen ( offscrBuf , 0 , 0 , esto ); } privado void sierpA ( nivel int ) { if ( nivel > 0 ) { sierpA ( nivel - 1 ); sg . LineRel ( 'A' , + dist , + dist ); sierpB ( nivel - 1 ); sg . lineRel ( 'A' , + 2 * dist , 0 ); sierpD ( nivel - 1 ); sg . lineRel ( 'A' , + dist , - dist ); sierpA ( nivel - 1 ); } } privado void sierpB ( nivel int ) { if ( nivel > 0 ) { sierpB ( nivel - 1 ); sg . LineRel ( 'B' , - dist , + dist ); sierpc ( nivel - 1 ); sg . lineRel ( 'B' , 0 , + 2 * dist ); sierpA ( nivel - 1 ); sg . lineRel ( 'B' , + dist , + dist ); sierpB ( nivel - 1 ); } } privado void sierpC ( nivel int ) { if ( nivel > 0 ) { sierpC ( nivel - 1 ); sg . lineRel ( 'C ' , -dist , -dist ) ; sierpD ( nivel - 1 ); sg . lineRel ( 'C' , - 2 * dist , 0 ); sierpB ( nivel - 1 ); sg . lineRel ( 'C' , - dist , + dist ); sierpc ( nivel - 1 ); } } privado void sierpD ( nivel int ) { if ( nivel > 0 ) { sierpD ( nivel - 1 ); sg . lineRel ( 'D' , + dist , - dist ); sierpA ( nivel - 1 ); sg . lineRel ( 'D' , 0 , - 2 * dist ); sierpc ( nivel - 1 ); sg . lineRel ( 'D ' , -dist , -dist ) ; sierpD ( nivel - 1 ); } } } clase SimpleGraphics { gráficos privados g = null ; privado int x = 0 , y = 0 ; Public SimpleGraphics ( Gráficos g ) { setGraphics ( g ); } public void setGraphics ( Gráficos g ) { este . gramo = gramo ; } public void goToXY ( int x , int y ) { esto . x = x ; esto _ y = y _ } public void lineRel ( char s , int deltaX , int deltaY ) { g . dibujarLínea ( x , y , x + deltaX , y + deltaY ); x += deltaX ; y += delta Y ; } }

El siguiente programa de Logo dibuja una curva de Sierpinski usando recursividad .

to half.sierpinski :size :level if :level = 0 [forward :size stop] half.sierpinski :size :level - 1 left 45 forward :size * sqrt 2 left 45 half.sierpinski :size :level - 1 right 90 forward :size right 90 half.sierpinski :size :level - 1 left 45 forward :size * sqrt 2 left 45 half.sierpinski :size :level - 1 end to sierpinski :size :level half.sierpinski :size :level right 90 forward :size right 90 half.sierpinski :size :level right 90 forward :size right 90 end

Véase también

Notas

  1. ↑ Platzman, Bartholdi, 1989 .
  2. ↑ Bartholdi .
  3. ↑ Slyusar, V. Antenas fractales. Un tipo fundamentalmente nuevo de antenas "rotas". Parte 2. . Electrónica: ciencia, tecnología, negocios. - 2007. - Nº 6. S. 82-89. (2007). Consultado el 22 de abril de 2020. Archivado desde el original el 3 de abril de 2018.

Literatura