El movimiento browniano es el movimiento aleatorio que se observa en las partículas que se hallan en un medio fluido (líquido o gas), como resultado de choques contra las moléculas de dicho fluido.
Este fenómeno de transporte recibe su nombre en honor al escocés Robert Brown, biólogo y botánico. En 1827, mientras miraba a través de un microscopio a las partículas atrapadas en las cavidades dentro de un grano de polen en el agua, señaló que las partículas se movían a través del líquido; pero no fue capaz de determinar los mecanismos que provocaron este movimiento. Los átomos y las moléculas habían sido teorizadas como componentes de la materia, y Albert Einstein publicó un artículo en 1905, considerado por él como el Annus Mirabilis ("año maravilloso", en latín) donde explicó con todo detalle cómo el movimiento que Brown había observado era el resultado del polen siendo movido por moléculas de agua individuales. Esta explicación sirvió como prueba convincente de que existen los átomos y moléculas, y fue verificado experimentalmente por Jean Perrin en 1908. Perrin fue galardonado con el Premio Nobel de Física en 1926 por su trabajo sobre la estructura discontinua de la materia (Einstein había recibido el premio cinco años antes por sus servicios a la física teórica con especial mención al efecto fotoeléctrico). La dirección de la fuerza de bombardeo atómico está cambiando constantemente, y en diferentes momentos, la partícula es golpeada más en un lado que en otro, lo que lleva a la naturaleza aleatoria del movimiento.
El movimiento browniano se encuentra entre los procesos estocásticos más simples, y es afín a otros dos procesos estocásticos más simples y complejos: el camino aleatorio y el teorema de Donsker. Esta universalidad está estrechamente relacionada con la universalidad de la distribución normal. En ambos casos, a menudo es la conveniencia matemática, más que exactitud de los modelos, lo que lleva al uso de la distribución normal.
Tanto la difusión como la ósmosis se basan en el movimiento browniano.
El poema científico Sobre la Naturaleza de las cosas, del romano Lucrecio (60 a. C.), incluye la notable descripción de un movimiento browniano de partículas de polvo desde los versos 113 hasta el 140. El autor presentó este hecho como prueba de la existencia de los átomos:
Observa lo que acontece cuando rayos de sol son admitidos dentro de un edificio y cómo arroja la luz sobre los lugares oscuros. Puedes ver la multitud de pequeñas partículas moviéndose en un sinnúmero de caminos... su baile es un indicio de movimientos subyacentes de materia escondidos de nuestra vista... eso origina el movimiento de los átomos en sí mismos (p.e., espontáneamente). Entonces los pequeños organismos que son eliminados del impulso de los átomos son puestos en marcha por golpes invisibles y a su vez en contra de unos diminutos cañones. Así, el movimiento de los átomos emerge gradualmente de un nivel del sentido, que estos cuerpos están en movimiento como vemos en el rayo de sol, movidos por soplos que parecen invisibles.
Sobre la naturaleza de las cosas, Lucrecio
Aunque el movimiento de mezcla de partículas de polvo es causado principalmente por las corrientes de aire, el brillo y el ajetreo de las partículas es, ciertamente, producto de la dinámica browniana
Jan Ingenhousz describió el movimiento irregular de partículas de carbón pulverizadas en la superficie del alcohol en 1785. No obstante, el descubrimiento del movimiento browniano se atribuye tradicionalmente al botánico Robert Brown en 1827. Se cree que Brown estuvo estudiando al microscopio partículas de polen de la planta Clarkia pulchella flotando en el agua. Dentro de las vacuolas de los granos de polen observó diminutas partículas con movimientos nerviosos. Al repetir el experimento con partículas de polvo, concluyó que el movimiento no se debía a que las partículas de polen estuvieran "vivas", aunque no explicó el origen del movimiento.
El primero en describir matemáticamente el movimiento browniano fue Thorvald N. Thiele en 1880, en un documento sobre el método de los mínimos cuadrados. Fue seguido independientemente por Louis Bachelier en 1900, en su tesis doctoral La teoría de la especulación, en la que se presenta un análisis estocástico de acción y opción de mercados. El modelo del movimiento browniano de las acciones de mercado es citado frecuentemente, pero Benoit Mandelbrot rechazó su aplicación al movimiento de los precios de las acciones, en parte porque son discontinuos.
Sin embargo, fue el estudio independiente de Albert Einstein en su artículo de 1905 (Über die von der molekularischen Theorie der Wärme geforderte Bewegung von in ruhenden Flüssigkeiten suspendierten Teilchen / Sobre el movimiento postulado por la teoría cinética molecular del calor de pequeñas partículas suspendidas en un líquido estacionario) en el que mostró la solución a los físicos, como una forma indirecta de confirmar la existencia de átomos y moléculas.
En esa época la naturaleza atómica de la materia aún era una idea controvertida. Einstein y Marian Smoluchowski dedujeron que, si la teoría cinética de los fluidos era correcta, entonces las moléculas de agua tendrían movimientos aleatorios. Por lo tanto, las partículas pequeñas podrían recibir un número aleatorio de impactos, de fuerza aleatoria y de direcciones aleatorias, en cortos períodos de tiempo. Este bombardeo aleatorio por las moléculas del fluido podría ser suficiente para que las partículas pequeñas se moviesen de la manera exacta que Brown había descrito. Theodor Svedberg hizo importantes demostraciones del movimiento browniano en coloides, así como Felix Ehrenhaft lo hizo con partículas de plata en la atmósfera terrestre. Jean Perrin también realizó experimentos para verificar los modelos matemáticos, y al publicar sus resultados finales se puso fin a dos mil años de disputa sobre la realidad de las moléculas y los átomos.
El programa instruye a una sucesión de partículas para que vagabundeen sin objeto por la pantalla hasta que acaben por encontrarse con una colección de parientes. Tan pronto acontece el encuentro, la partícula queda "congelada", y se detiene. Al irse acumulando una a una varios centenares de partículas, la colección va lentamente desarrollando las ramificaciones irregulares y los zarcillos que caracterizan a las configuraciones fractales.
A este proceso lo llamaremos Agregación Difusa Limitada, que abreviaremos por ADL. El proceso ADL podría perfectamente representar la difusión de iones de cinc a través de una disolución electrolítica bidimensional.
Cuando los iones entran en contacto con una agregación de cinc metálico en uno de los electrodos, se ligan inmediatamente a los compañeros atómicos que componen el agregado. Las partículas de hollín que son arrastradas por el aire de acá para allá, antes de tropezar con otras partículas adheridas a cierto sustrato, parecen ajustarse al mismo proceso, si bien en este caso la fuerza que mantiene las partículas en cohesión es, según parece de naturaleza electrostática.
El más pintoresco (aunque también el menos realista) de los modelos de proceso ADL supone que una sucesión de beodos van dando tumbos en la oscuridad hasta topar con una multitud de otros insensatos camaradas; arrullados por el rumor de los pacíficos ronquidos, se tumban y duermen al instante. Una vista aérea de la muchedumbre durmiente podría perfectamente revelar el mismo perfil fractal que vemos en el cúmulo de cinc o en un pegote de hollín.
La clave para construir la parte de difusión del proceso de agregación con difusión limitada es un "paseo aleatorio". Cada uno de los pasos de una caminata aleatoria en dos dimensiones se da en una de cuatro direcciones: norte, sur, este y oeste; en cuál de las cuatro, lo va decidiendo el azar. (En ocasiones, los paseos aleatorios admiten también direcciones intermedias, como el sureste, pero aquí nos atendremos a la versión mas restrictiva). La partícula parece seguir un curso tortuoso y sin objeto. Al observar sobre la pantalla el desplazamiento de tal partícula, uno podría estar disculpado si tuviera serias dudas de que llegase jamás a un destino determinado. Pero la partícula sí tiene una meta (por ser un poco teológico): alcanzar la multitud de partículas congéneres que se acumulan en el centro de la pantalla.
Todo comienza cuando el programa sitúa una partícula individual en el centro de la pantalla del ordenador.
Seguidamente, se libera una partícula, que emprende un paseo aleatorio desde un punto seleccionado al azar en un gran círculo centrado en la partícula inicial. Tras larga y ardua jornada, la partícula, móvil se tropieza con la estacionaria y se detiene. En cuanto así ocurre, el programa despacha desde un punto igualmente elegido al azar una nueva partícula, que realizará un viaje similar. Las partículas van reuniéndose una tras otra en torno al punto que ocupaba la primera, y dentro del círculo hace aparición un extraño perfil, una excrecencia arbórea con ramas y varas cuidadosamente retorcidas. Tal figura es consecuencia de la tendencia de la partícula que camina al azar a tropezarse con la parte exterior de la muchedumbre bastante antes de que con la cohorte situada mucho más adentro en la multitud; por así decirlo, más probable es que les crezcan ramas a los vástagos que al tronco.
Los algoritmos que describimos a continuación dan una versión algo más rápida del programa, aunque, como es obvio, la duración de una pasada dependerá del número de partículas que se deseen acumular.
El algoritmo de difusión (LENTO) es un.poco más fácil de preparar que el algoritmo de agregación (CRECE). Por simplicidad, limitaremos la acción al interior de un circulo de 200 pixeles de diámetro. Para elegir el punto desde el cual emprende su caminata aleatoria una partícula dada, LENTO determina en una instrucción un ángulo al azar, y en las dos instrucciones siguientes calcula las coordenadas del punto de la circunferencia de tal ángulo:
ángulo <------------ azar X 360
X <--------------- 100 X coseno(ángulo) + 100
Y <--------------- 100 X seno(ángulo) + 100
El propio ordenador ha de elegir aleatoriamente un número, al que hemos llamado azar. Dado que las instrucciones de obtención de azar proporcionan un número comprendido entre 0 y 1, es preciso multiplicarlo por 360 para disponer de un ángulo comprendido entre 0 y 360 grados. (En los sistemas que en lugar de grados utilicen radianes, es preciso multiplicar azar por 2it, o sea, por 6,283 aproximadamente.) El paso siguiente calcula la abscisa X de un punto de la circunferencia situado en dicho ángulo, multiplicando por 100 (el radio del círculo) el coseno del ángulo. El tercer paso calcula la ordenada y el punto con ayuda de la función seno. Dado que los sistemas de programación más populares sitúan el origen (el punto de coordenadas (0,0)) en un ángulo de la pantalla, hemos sumado incrementos de 100 a las dos coordenadas, para dejar centrado el círculo en la pantalla. Como es obvio, ello sólo sucederá en aquellas pantallas que tengan 200 por 200 pixeles. Lo que hay que averiguar por cuenta de cada uno cuales son los incrementos más idóneos para las pantallas de que dispongan.
Una vez determinado el punto de partida de la partícula, LENTO tiene ahora que ponerla en movimiento, lo que se hace con el siguiente algoritmo (que esta incluido en un bucle):
opción <--------------- azar
si opción <= 0,25
entonces X <---------- X + 1
si opción > 0,25 y <= 0,5
entonces X <---------- X - 1
si opción > 0,5 Y <= 0,75
entonces Y <---------- Y + 1
si opción > 0,75
entonces Y <---------- Y - 1
La reglas de funcionamiento están explícitamente formuladas en función de una variable aleatoria, llamada "opción". Dependiendo de dónde caiga "opción" (dentro de uno de los cuatro intervalos equiprobables de su gama de valores), una de las coordenadas de la partícula será aumentada o disminuida en una unidad. De ese modo, la partícula se mueve al azar un pixel hacia arriba, hacia abajo, hacia la derecha o hacia la izquierda.
En cambio, lo que no se ha enunciado explícitamente son las condiciones en las que ha de detenerse el movimiento de una partícula, a saber: cuando la partícula, en su aleatoria caminata, se haya salido del circulo en el cual se originó o cuando haya llegado a un pixel adyacente a la masa en acreción de pixeles que constituyen la muchedumbre fractal. En el primer caso, el programa se limita a extinguir la partícula; de no hacerlo, sería muy probable que la partícula se alejara en su vagabundeo y se internase en una noche electrónica sin fin. En el segundo, el programa fija la partícula al punto donde encuentra al cúmulo en crecimiento, dejándolo como paralizado por la visión de una Medusa Fractal.
Tales instrucciones están incorporadas en un enunciado condicional del tipo "mientras" al comienzo del bucle del paseo aleatorio que da animación a las partículas. Las excursiones que se salen del círculo quedan desechadas sin más que llevar el control de la distancia de la partícula al centro de la circunferencia.
La distancia es computada cada vez que se dispone de nuevos valores de X e Y. (En realidad, el programa calcula el cuadrado de la distancia. Se ahorra así un poco de tiempo, porque se elimina el cálculo de una raíz cuadrada.)
distX <---------------------- X - 100
distY <---------------------- Y - 100
distancia <----------------- dist X^2 + dist Y^2
La condición "mientras" va comprobando cuánto ha viajado la partícula desde el centro del circulo, para lo cual compara "distancia" con el cuadrado de 100 (más 1). Si se infringe la condición, el programa saldrá del bucle y volverá a empezar con otra partícula.
¿Como se determina la otra condición, a saber, si la partícula ha ido a engrosar la multitud?. Para responder a esta pregunta, el programa mantiene dos listas, una para las abscisas y otra para las ordenadas de cada partícula de la muchedumbre. Tales listas matrices unidimensionales llamadas "multx" y "multy". La partícula "semilla" inicialmente situada en el centro de la pantalla tiene, pues, coordenadas multx(1) =100 y multy(1)=100. Cuando en su peripatética carrera una partícula entra en contacto con la muchedumbre, el programa ejecuta las instrucciones:
multx(contador) <------------------- X
multy(contador) <------------------- Y
Como su nombre indica, "contador" lleva la cuenta del número de partículas de que consta el agregado. Al principio de el programa, "contador" tiene el valor 1; cada vez que se suma una nueva partícula al agregado, el "contador"" ha de ser incrementado en una unidad.
Mas, ¿cómo puede saber CRECE que una partícula ha acabado por engrosar la agrupación de sus congéneres? El algoritmo de contacto más sencillo consiste en comparar las coordenadas de los cuatro pixeles que rodean a la partícula en su posición actual que están registrados en las listas "multx" y multy".
para n <---------------------- 1 hasta "contador"
XI <--------------- X + 1
si XI = "multx"(n) e Y = "multy"(n)
entonces "contacto" <--------------- verdadero
XI <--------------- X - 1
si XI = "multx"(n) e Y = "multy"(n)
entonces "contacto" <--------------- verdadero
Y1 <-------------- Y + 1
si X = "multx"(n) e Y1 = "multy"(n)
entonces "contacto" <-------------- verdadero
Y1 <-------------- Y - 1
si X = "multx"(n) e Y1 = "multy"(n)
entonces "contacto" <--------------- veradero
Hemos utilizado también una variable de las llamadas "booleanas", a la que hemos llamado "contacto". Tal variable toma los valores verdadero o falto (o lo que es equivalente,1 y 0). Justo antes de iniciarse el bucle "mientras”, se le da a "contacto" el valor inicial de falso.
Hemos descrito ya todas las características esenciales del programa, si se exceptúa un bucle externo del tipo "mientras", que mantiene a el programa en funcionamiento hasta que "contador" alcanza un número predeterminado de partículas, por ejemplo, 500. El algoritmo completo del programa puede verse a continuación:
dibujar el punto(100,100)
contador <------- 1
multx(1) <------- 100
multy(1) <------- 100
mientras contador <= 500
ELECCION DE PUNTO EN EL CIRCULO
distancia <------- 0
contacto <--------falso
mientras distancia < 10001 y no contacto borrar el punto (x,y)
ALGORITMO DE MOVIMIENTO
dibujar el punto (x,y)
COMPUTAR DISTANCIA
ALGORITMO DE CONTACTO
si contacto = verdadero
entonces contador < contador + 1
multx(contador) <--------------- X
multy(contador) <--------------- Y
Las porciones ya descritas están representadas mediante bloques debidamente rotulados. Las partes que no han sido explícitamente descritas contienen instrucciones de inicialización de las variables y que borran y dibujan partículas. (Es preciso advertir a los programadores novatos para que no se tomen literalmente lo de borrar y dibujar; en los sistemas de programación reales estas órdenes no son viables. En lugar de eso, ambas operaciones se efectúan mediante otras órdenes que colorean píxeles.)
Las multitudes fractales, como las producidas por el programa, pueden ser clasificadas en categorías mediante una dimensión que caracteriza su tasa de crecimiento. Consideremos, en particular, el número de partículas que yacen en el interior de un círculo de radio R. Si un acumulo fractal llegase -poco más o menos- a llenar el área general donde tiene lugar su crecimiento, seria de esperar que la duplicación del radio produjese una cuadruplicación del número de partículas contenidas en el interior del círculo: el crecimiento de la multitud será cuadrático. Dicho de otro modo, será de esperar que el número de partículas fuese sensiblemente proporcional a R^2. Por otra parte, si una multitud de partículas adoptase forma lineal, con pequeña o nula ramificación, la duplicación de R no haría más que duplicar el número de partículas comprendidas en el círculo.
El crecimiento de la multitud sería lineal, es decir, proporcional a R. Resulta que el crecimiento fractal tiende a ser mas rápido que el lineal, pera más lento que el cuadrático: el número de partículas fractales de un círculo de radio R es proporcional a R^d, siendo d un número comprendido entre 1 y 2.
Por tal motivo, la representación gráfica que muestre el número N de partículas de una multitud del programa en un eje y el radio R (medido en píxeles) en otro produce una línea que se encuentra a medio camino entre la linea recta (el resultado del crecimiento lineal) y una parábola (resultado del crecimiento cuadrático). Resulta delicado determinar el exponente fraccionario que determina el crecimiento de la multitud de partículas a partir del mero examen de esa curva.
La tarea se simplifica un poco efectuando la representación gráfica sobre papel logarítmico.
El papel logarítmico tiene señaladas coordenadas horizontales y verticales que se duplican, triplican o aumentan en un determinado factor dependiente de la unidad elegida. Al representar N en función de R en papel logarítmico, a las curvas cuadráticas les ocurre algo curioso: ¡se convierten en lineas rectas! ¿Por qué? Recordemos que en el crecimiento cuadrático, cada vez que se duplica el radio, el número de partículas se cuadruplica. En papel logarítmico tal hecho supone en ordenadas un aumento regular de cuatro unidades por cada dos unidades que se avanza en abscisas, situación que corresponde a una línea recta de pendiente 2. De hecho, las tasas de crecimiento proporcionales a R^3 aparecen por igual razón convertidas en líneas rectas de pendiente 3 al representarlas en papel logarítmico.
Esta última observación nos dice qué hemos de hacer una vez representados en papel logarítmico los puntos correspondientes a todas las parejas de valores de R y N. Si la figura es fractal, todos estos puntos se hallarán sensiblemente en torno a una línea recta (salvo cerca del origen de la línea, donde la multitud propende a disminuir paulatinamente). La pendiente de esta recta es aproximación de la dimensionalidad fractal de la multitud.
Tanto este articulo como el siguiente programa corresponde a la especie de revista que publicamos entre mi hermano y yo en los años 80/90 que se llamaba Discovery the Chaos. Estaba hecha a base de fotocopias encuadernadas.1 ' Difusion de Agregacion Limitada
2 '
3 ' Fuente: Scientific American Febrero 1987
4 '
10 ' Pantalla de introduccion
11 '
12 SCREEN 2: SCREEN 0
13 LOCATE 5, 1
14 PRINT "Modelo de Difusion de Agregacion Limitada"
15 PRINT: PRINT: PRINT
16 PRINT "Basado en Fractal Growth"
17 PRINT "de Leonard M. Sander .Scientific American January.1987"
19 LOCATE 12, 1
20 PRINT "Scott Camazine "
23 PRINT "Ithaca, Nev; York"
24 PRINT "Discovery The Chaos. Enrique Murciano - Espana"
25 LOCATE 20, 1
30 PRINT "Pulse ESC para detener el proceso de Agregacion."
31 PRINT
33 PRINT "Pulse una tecla para continuar."
40 A$ = INKEY$: IF A$ = "" THEN GOTO 40
50 '
51 '
54 LOCATE 20, 1
60 COUNT = 1
90 CLS: KEY OFF
100 A = 0: B = 0
110 SCREEN 1: REM con screen 1 sale en color y con 2 b/n
120 COLOR 0, 0
126 XO = 160: YO = 100 REM en modo grafico la posicion del cursor se inicializa colocandose en el centro de la pantalla 160,100 o 320,10
130 PSET (XO, YO), 1
150 RANDOMIZE VAL(RIGHT$(TIME$, 2))
200 ' Bucle de control principal
210 '
215 A$ = XNKEY$: IF A$ = CHR$(27) THEN GOTO 20000
220 GOSUB 4000
225 AGGREGATE = 0
235 GOSUB 7000
236 GOSUB 5000
240 GOSUB 8000
242 GOSUB 11000
245 PSET (XCOORD + XO, YCOORD + YO), VALUE
248 GOSUB 9000
249 IF AGGREGATE = 0 THEN GOTO 235
300 COUNT = COUNT + 1: LOCATE 1, 30: PRINT COUNT
325 GOTO 200
350 '
4000 '
4300 '
4302 '
4310 XCOORD = INT(RND * 120)
4320 YCOORD = INT(RND * 120)
4325 IF SQR(XCOORD ^ 2 + YCOORD ^ 2) < 100 THEN GOTO 4310
4340 R = RND
4345 IF R > .5 THEN SGNX = 1 ELSE SGNX = -1
4347 R = RND
4355 IF R > .5 THEN SGNY = 1 ELSE SGNY = -1
4360 XCOORD = XCOORD * SGNX
4370 YCOORD = YCOORD * SGNY
4390 RETURN
5000 '
5601 '
5605 '
5620 RX = INT(RND * 6)
5625 R = RND
5630 IF R > .5 THEN SGNX = 1 ELSE SGNX = -1
5640 XSTEP = RX * SGNX
5655 '
5670 RY = INT(RND * 6)
5675 R = RND
5680 IF R > .5 THEN SGNY = 1 ELSE SGNY = -1
5685 YSTEP = RY * SGNY
5689 XCOORD = XCOORD + XSTEP
5690 YCOORD = YCOORD + YSTEP
5691 '
5692 '
5693 IF SQR(XCOORD ^ 2 + YCOORD ^ 2) > (SQR(OLDX ^ 2 + OLDY ^ 2) + 5) THEN XCOORD = OLDX: YCOORD = OLDY: GOTO 5000
5694 '
5695 '
5696 IF POINT(XCOORD + XO, YCOORD + YO) > 0 THEN XCOORD = OLDX: YCOORD = OLDY: GOTO 5000
5698 '
5699 RETURN
7000 '
7001 '
7010 OLDX = XCOORD
7020 OLDY = YCOORD
7025 RETURN
7040 '
8000 '
8001 '
8010 PSET (OLDX + XO, OLDY + YO), 0
8015 RETURN
8020 '
9000 '
9401 '
9410 IF POINT(XCOORD - 1 + XO, YCOORD + 1 + YO) > 0 THEN AGGREGATE = 1
9420 IF POINT(XCOORD + XO, YCOORD + 1 + YO) > 0 THEN AGGREGATE = 1
9430 IF POINT(XCOORD + 1 + XO, YCOORD + 1 + YO) > 0 THEN AGGREGATE = 1
9440 IF POINT(XCOORD - 1 + XO, YCOORD + YO) > 0 THEN AGGREGATE = 1
9450 IF POINT(XCOORD + 1 + XO, YCOORD + YO) > 0 THEN AGGREGATE = 1
9460 IF POINT(XCOORD - 1 + XO, YCOORD - 1 + YO) > 0 THEN AGGREGATE = 1
9470 IF POINT(XCOORD + XO, YCOORD - 1 + YO) > 0 THEN AGGREGATE = 1
9480 IF POINT(XCOORD + 1 + XO, YCOORD - 1 + YO) > 0 THEN AGGREGATE = 1
9490 RETURN
9491 '
11000 '
11001 '
11010 IF COUNT <= 3000 THEN VALUE = 3
11015 IF COUNT > 3000 AND COUNT <= 6000 THEN VALUE = 1
11020 IF COUNT > 6000 AND COUNT <= 9000 THEN VALUE = 2
11025 IF COUNT > 9000 AND COUNT <= 12000! THEN VALUE = 3
11030 IF COUNT > 12000! AND COUNT <= 15000! THEN VALUE = 1
11035 IF COUNT > 15000! THEN VALUE = 2
11040 RETURN
20000 '
20001 '
20002 LOCATE 1, 1: PRINT STRING$(39, 32)
20004 GOSUB 30000
20005 LOCATE 1, 1
20007 PRINT " + y = cambios de color, c continuar"
20010 A$ = INKEY$: IF A$ = "" THEN GOTO 20010
20012 IF A$ = "+" THEN A = A + 1: COLOR A, B
20014 IF A$ = "=" THEN B = B + 1: COLOR A, B
20016 IF A$ = "c" OR A$ = "C" THEN GOTO 20020 ELSE GOTO 20010
20020 LOCATE 1, 1: PRINT STRING$(39, 32): LOCATE 1, 1
20030 PRINT "Guardo la figura ? (S/N)"
20040 A$ = INKEY$: IF A$ = "" THEN GOTO 20040
20050 IF A$ = "S" OR A$ = "s" THEN GOTO 20060
20055 IF A$ = "n" OR A$ = "N" THEN GOTO 20110
20057 GOTO 20040
20060 LOCATE 1, 1: PRINT STRING$(15, 32);
20070 LOCATE 1, 1: INPUT "Nombre de fichero < 8 letras", FILENAME$
20075 LOCATE 1, 1: PRINT STRING$(38, 32);
20080 FILENAME$ = FILENAME$ + ".PIC"
20090 DEF SEG = &HB800
20100 BSAVE FILENAME$, 0, &H4000
20110 CLS
20115 PRINT "Particulas en radio = 5 "; R5
20120 PRINT "Particulas en radio = 10 "; R1O
20130 PRINT "Particulas en radio = 50 "; R50
20140 PRINT "Particulas en radio = 100 "; R100
20150 PRINT
20160 PRINT "Calcula la dimension de N = C * R ^ D"
20170 PRINT
20180 PRINT " N = numero de particulas agregadas"
20185 PRINT " C = constante "
20187 PRINT " R = radio "
20189 PRINT " D = DIMENSION "
20190 PRINT: PRINT: PRINT "Pulse una tecla para finalizar"
20200 A$ = INKEY$: IF A$ = "" THEN GOTO 20200 ELSE END
30000 '
30001 '
30003 R5 = 0
30005 R1O = 0
30006 R50 = 0
30007 R100 = 0
3000 FOR X = 60 TO 260
30020 FOR Y = 0 TO 199
30030 IF POINT(X, Y) = 0 THEN GOTO 30040
30031 IF SQR((X - XO) ^ 2 + (Y - YO) ^ 2) <= 5 THEN R5 = R5 + 1
30032 IF SQR((X - XO) ^ 2 + (Y - YO) ^ 2) <= 10 THEN R10 = R10 + 1
30034 IF SQR((X - XO) ^ 2 + (Y - YO) ^ 2) <= 50 THEN R50 = R50 + 1
30036 IF SQR((X - XO) ^ 2 + (Y - YO) ^ 2) <= 100 THEN R100 = R100 + 1
30040 NEXT Y
30050 NEXT X
30060 '
32000 '
32002 LOCATE 1, 1
32005 PRINT "Pulse un tecla"
32006 ' No se desespere espere a que el programa le conteste
32007 A$ = INKEY$: IF A$ = "" THEN GOTO 32007
32010 LOCATE 1, 1: PRINT STRING$(39, 32)
32100 RETURN
No hay comentarios:
Publicar un comentario
Nota: solo los miembros de este blog pueden publicar comentarios.