Actualizaciones de agosto, 2012 Mostrar/Ocultar Comentarios | Atajos de teclado

  • hernandezgomez 11:43 pm el August 15, 2012 Permalink | Responder
    Etiquetas: números primos   

    La Distribución de los Números Primos 

    LOS NÚMEROS PRIMOS COMO UNA ESCALERA INFINITA:
    Los números primos son los átomos de los números: las partículas elementales de las matemáticas. Cualquier número entero positivo puede obtenerse como la multiplicación de primos. Por definición son aquellos naturales (excluyendo el 1) que sólo son divisibles entre 1 y ellos mismos. No es difícil listar los primeros:

    2, 3, 5, 7, 11, 13, 17, 19, .... 

    Los usamos todo el tiempo en la vida diaria para sumar quebrados, encontrar mínimo común múltiplo, máximo común divisor, factorizar, etc. Los matemáticos siempre han estado interesados en ellos; hoy hay científicos de la computación y hasta físicos interesados en su estudio.
    Algunas propiedades de éste conjunto son bien conocidas. El 2 es el único que es par, cualquier otro par es divisible entre el 1, el 2 y él mismo, con lo cual se sale de la definición. Otra propiedad del conjunto es que es infinito. La primera demostración de ésto se debe al matemático griego Euclides y tiene unos 2300 años. Analizando listas grandes de primos, es posible ver que, a medida que el tamaño de los números se incrementan, los primos disminuyen. Ésto es intuitivamente claro si pensamos que entre más predecesores tenga un entero, más posibles divisores tiene.
    La siguiente gráfica muestra el comportamiento de los número primos acumulados desde el 1 hasta el 100.

    La gráfica de los primos acumulados hasta el número 100. 25 son primos


    Aquí se observa que siguen una distribución más o menos suave o predecible. No hay saltos o escalones muy pronunciados. La gráfica comienza con el natural 1. En 1 no tenemos ningún primo; sigue en 2, y en ese momento hay uno (el 2); 3, y ese es el segundo; 4, y seguimos teniendo 2 primos, porque 4 es un número compuesto (2 x 2 = 4); 5, el tercero; 6, también compuesto (3 x 2 = 6) y por lo tanto seguimos en 3; 7, el cuarto primo, etc. En el eje horizontal de la gráfica, se muestran todos los enteros desde 1 hasta 100; y en el eje vertical los primos acumulados. Pero analizar el comportamiento de los primeros 100 números naturales (los números 1, 2, 3, 4, 5, 6, 7, …..), que incluyen 25 números primos, no es para nada representativo del comportamiento de todo el conjunto. Para ir un poco más lejos, podemos hacer uso de un programa de computadora como el siguiente, en lenguaje Java:

    Este archivo debe llamarse UsaEratostenes.java

    import java.util.Scanner;
    
    public class UsaEratostenes
     {  // Abre clase UsaEratostenes
     public static void main(String args[])
     {  // Abre main
    
     // Se crea un Objeto de tipo Eratostenes
     Eratostenes miObjeto = new Eratostenes();
     
     // Se llama al metodo Principal
      miObjeto.Principal(); 
     }  // Cierra main
     
     }  // Cierra clase UsaEratostenes
    

    El siguiente archivo debe llamarse Eratostenes.java

     /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
       +                          CRIBA DE ERATOSTENES                            +
       + Este programa muestra numeros primos obtenidos mediante el algoritmo de  +
       + Eratostenes.                                                             + 
       + ENTRADA: No requiere entrada                                             + 
       + SALIDA: Numeros primos                                                   + 
       +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
    
      /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
       *                                ALGORITMO:                                *
       * Los numeros de 2 a N se consideran todos primos en un principio          *
       *                                                                          * 
       * Desde j = 2 hasta N - 1                                                  *
       *   Desde k = j hasta N/j                                                  *
       *     El Numero k*j se considera no primo.                                 *  
       *                                                                          *
       * Recorre de nuevo todo el arreglo desde 2 a N y cuenta los primos         *
       *                                                                          *
       * Imprime los numeros primos acumulados hasta el elemento actual del       *
       * arreglo                                                                  *
       +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ 
      
     public class Eratostenes
     {   // Abre clase Eratostenes
     private int Tamano_Arreglo = 1000000;
     //Basta cambiar este numero para obtener
     // los primos hasta ese limite
    
     /////////////////////////////////////////////
     // METODO PRINCIPAL
     /////////////////////////////////////////////
    
     public void Principal()
    
     { //ABRE PRINCIPAL 
     boolean Arreglo[];
     Arreglo = new boolean[Tamano_Arreglo + 1];
     for ( int i = 1; i < Tamano_Arreglo; i++ )
     Arreglo[i] = true; //EN PRINCIPIO TODOS LOS NUMEROS SE CONSIDERAN PRIMOS
    
     for ( int j = 2; j <= Tamano_Arreglo; j++ )
     if ( true == Arreglo[j] ) // Para numeros grandes este if hace una 
                               // diferencia de tiempo importante
     for ( int k = 2; k <= (Tamano_Arreglo)/j; k++ )
     Arreglo[k*j] = false;
    
     // Se llama al metodo Imprime
     Imprime( Arreglo, Tamano_Arreglo );
    
     } //CIERRA PRINCIPAL 
    
     //////////////////////////////////////////////
     // IMPRIME
     //////////////////////////////////////////////
    
     public void Imprime( boolean A[], int Tamano )
    
     { //ABRE IMPRIME
    
     int acumulado = 0; 
    
     for ( int n = 2; n <= Tamano; n++ )
     { //ABRE FOR
      
     if ( true == A[n] )
     {
     acumulado++;
     }
     System.out.printf("%d\n", acumulado);
     } //CIERRA FOR
     
     System.out.printf("\n");
     } //CIERRA IMPRIME  
    
     }   // Cierra clase Eratostenes
    

    El código consta de dos archivos, uno con la clase principal, llamado UsaEratostenes.java y otro llamado Eratostenes.Java. Ambos deben guardarse con esos nombres. Si no sabe programar, o no conoce Java, no importa. Es solo un trabajo de calculadora. Lo que estamos haciendo es encontrar los números primos hasta cierto natural, identificado con el nombre Tamano_Arreglo, con el viejo algoritmo de la criba de Eratóstenes. A partir de ahí empezamos a contar desde el número 2 cuántos primos hay acumulados, exactamente lo que hicimos arriba, y luego graficamos. La siguiente figura muestra un análisis del primer millón de naturales, que contienen 78498 primos

    El comportamiento de los primos acumulados hasta el primer millón de naturales. 78498 son primos.


    Y de nuevo parece que los primos están distribuidos de manera que no hay acumulaciones de muchos de ellos en un intervalo corto de enteros, lo cual se vería reflejado en cambios abruptos de tipo escalón. Éste tipo de análisis los empezó a hacer el matemático alemán Karl Friedrich Gauss, con el pequeño inconveniente de que no tenía a su disposición una computadora. Así que los estudios de Gauss eran más bien tardados. Sin embargo, a cambio de una computadora, tenía uno de los cerebros más aptos para las matemáticas que ha dado la humanidad. Fue capaz de darse cuenta de lo siguiente:
    1) Entre los números 1 y 10 hay 4 primos, lo cual equivale, más o menos, a la mitad de todos los enteros contenidos en ese intervalo.
    2) Entre 1 y 100 hay 25 primos, lo cual equivale a 1/4 de los enteros en el conjunto.
    3) Entre 1 y 1000 hay 169 primos, lo cual equivale a 1/6 de los enteros
    4) Entre 1 y 10000 hay 1229, que equivalen, aproximadamente a 1/8 del total de enteros.
    5) Entre 1 y 100000 hay 9592 primos, que son aproximadamente 1/10
    6) Entre 1 y 1000000 hay 78498 primos, o 1/12.
    El problema con éste análisis, es que, incluso para 1 millón, no podemos decir que sea el comportamiento típico. Los números primos son infinitos.

     
    • Carlos S. C. 1:34 am el junio 15, 2016 Permalink | Responder

      Necesito unas clases para comprender y entender el como hacer demostraciones formales en matematicas para aplicarlas en fisica. Alguna recomendacion. Saludos, gracias por los aportes.

  • hernandezgomez 9:10 pm el August 5, 2012 Permalink | Responder  

    Unas Teclas Especiales en la Calculadora 

    Las teclas de las calculadoras sirven para introducir números, realizar operaciones aritméticas, calcular funciones importantes, etc. La mayoría de las calculadoras contienen teclas con unas funciones básicas: x^{2}, sin(x), 1/x, etc. y la mayoría de esas funciones son aburridas. En un día de esos en los que no se tiene nada mejor qué hacer, podemos analizar el comportamiento “a largo plazo” de algunas de ellas, y ver si les sacamos algo de provecho:
    La Tecla x^{2}
    Vamos a suponer que tenemos la tecla x^{2} Se puede hacer el siguiente ejercicio. Iniciando con un valor arbitrario (digamos 0.5427) en el intervalo (0,1) vamos a iterar unas cuantas veces los resultados sucesivos. Esto es, se escribe en la calculadora el número 0.5427, y a continuación x^{2} varias veces. En caso de que la calculadora no tenga la tecla x^{2}, se puede obtener un resultado equivalente con X y luego =.
    El resultado de hacer esto, es que muy rápidamente veremos que las iteraciones se acercan y finalmente convergen al punto estable 0. De hecho, bastan unas 5 iteraciones.
    La tecla cos(x)
    Vamos a elegir ahora la tecla cos(x). Con esta tecla calculamos el coseno de un ángulo. Es importante que antes hayamos puesto nuestra calculadora en el modo Radianes. Elegimos un número arbitrario entre 0 y 1 y aplicamos la tecla sucesivamente a los valores que vayan apareciendo. Si lo hacemos unas cuantas veces, unas 30, observamos que este mapeo converge a un valor estable igual a 0.739085, como puede verse en la siguiente gráfica.

    La iteración de la función coseno converge rápidamente a el valor 0.739085. ¿Por qué?


    La Tecla tan(x)
    Tomemos ahora otra función trigonométrica, la tangente. Y vamos a hacer la misma rutina. Comenzamos con el número 0.5427 y presionamos la tecla tan(x). La pantalla presentará un valor y nosotros presionamos de nuevo tan(x), y lo hacemos así unas cuantas decenas de veces. ¿A qué valor convergen las iteraciones de la tangente? Supongamos que presionamos 40 veces la tecla de la tangente. Si graficamos los números obtenidos, veremos una figura parecida a la siguiente:

    Hasta las primeras 40 iteraciones, la función tangente parece converger a un número estacionario.


    Hay que admitir, de entrada, que esta serie tiene un comportamiento extraño. hasta la cuarta iteración, los números suben, pero en la quinta bajan, y a partir de la sexta, parecen establecerse alrededor de 0. Pero, ¿de verdad están acercándose a un número? Para responder a esta pregunta, podemos hacer un acercamiento a la figura anterior acotando un poco el eje de las Y.

    Un acercamiento a la gráfica anterior, muestra que la serie en realidad no está convergiendo.


    De hecho, la serie no está convergiendo. Esto se puede ver fácilmente si iteramos más veces, digamos, unas 4 mil. Sí, es mucho para hacerlo en una calculadora manual, pero se supone que tenemos mucho tiempo libre. Si almacenamos esos datos y los graficamos, vamos a obtener la siguiente figura:

    4000 iteraciones muestran que la función tangente no converge (al menos en esas primeras 4 mil), aunque presenta períodos de relativa estabilidad.


    No tenemos que hacerlo más veces. Es un hecho que ese mapeo no converge, aunque hay veces que parece realmente hacerlo, y se queda “estancado” cerca de un punto. Éste caso, nos deja la importante lección de que no todas las teclas de la calculadora caen a un sólo número. En tanto que x^{2} y cos(x) sí se acercan a un número, tan(x) no.
    La Tecla x^{2} - 1
    Bueno, nunca me he encontrado con una calculadora que tenga esta tecla, pero podemos crearla. Vamos ahora a construir la tecla x^{2} -1. Las calculadoras no incluyen esa función, por lo cual nosotros la construimos por medio de teclear X y =. Y vamos también a crear un ciclo de iteración empezando por un número contenido entr 0 y 1, de nuevo 0.5427. Es importante decir que ese es un número que a mi se me ha ocurrido y no tiene nada de especial; a alguien más se le puede ocurrir otro. Tampoco es que tenga mucha importancia el número de decimales, pero para poder ver cómo evoluciona la función, he tomado hasta los primeros 4 dígitos después del punto. Lo importante realmente es que sea un número comprendido entre 1 y 0, pero sin incluir a éstos. Este ciclo de iteración se puede hacer con la calculadora, siempre que se quiera dedicar unos minutos a la tarea de estar oprimiendo teclas.
    1) Escribimos 0.5427
    2) Tecleamos X e =
    3) tecleamos -1 e =
    4) Repetimos los pasos 2) y 3) muchas veces.
    Esa es la receta, pero ya que somos programadores, bien podemos escribir unas cuantas líneas de código para que el trabajo sea mínimo. El siguiente es un programa en el lenguaje C, pero el algoritmo se puede escribir fácilmente en cualquier otro.

    /*+++++++++++++++++++++++++++++++++++++++++++++++++++++
      *                                                    *
      * Este programa itera una <<tecla especial>> de la   *
      * calculadora.                                       *
      *                                                    *
      * +++++++++++++++++++++++++++++++++++++++++++++++++++*/
    
     /*+++++++++++++++++++++++++++++++++++++++++++++++++++++
      *                                                    *
      *                 ALGORITMO:                         *
      *  Mientras la variable n sea menor a N              *
      *  x(n+1) = k(x*x) - 1                               *
      *  incrementa n en uno                               *
      *++++++++++++++++++++++++++++++++++++++++++++++++++++*/
     
      #include <stdio.h>
      #define N 100
     
      int main()
      {     /*Abre main*/
      int k = 1; /*Esta variable se puede cambiar*/
      int n;  /* Variable contador */
      double x = 0.5427;
      
      for ( n = 1; n <= N; n++ )
      {  /* Abre for */
      x = k*x*x - 1;
      printf("%f\n", x);
      }  /* Cierra for */
    
      return 0; 
      }     /*Cierra main*/   
    

    Los resultados que arroja ese programa son los siguientes:

    -0.705477  -0.502303  -0.747692  -0.440957  -0.805557  -0.351077
    -0.876745  -0.231319  -0.946492  -0.104154  -0.989152  -0.021578
    -0.999534  -0.000931  -0.999999  -0.000002  -1.000000  -0.000000
    -1.000000   0.000000  -1.000000   0.000000   ...
    

    Tal vez no sea evidente a partir de la lista, pero los números presentan un comportamiento errático al principio, empiezan a oscilar y finalmente se establecen en 0 y -1. La siguiente gráfica muestra la evolución

    Para la aplicación x = x*x – 1, Iniciando con un número en (0,1), después de unas cuantas iteraciones, se llega a un par de puntos fijos: 0 y 1.


    La Tecla 2x^{2} -1
    Vamos construir una tecla más. Una muy parecida a la anterior. De hecho, lo único que cambia es el 2 que multiplica a x^{2}. Es de esperarse, por lo tanto, que su comportamiento a largo plazo sea parecido a x^{2} -1. Para esto, podemos usar el mismo programa que se presentó arriba. Basta con cambiar el valor de la variable k de 1 a 2. Después de 50 iteraciones, el resultado es el siguiente:

    A diferencia de x^{2} - 1, el mapeo 2x^{2} -1 no muestra ninguna regularidad.


    Esta iteración no converge a un punto, ni a dos. Tampoco muestra periodos de relativa regularidad, como tan(x). Podrían hacerse miles de iteraciones, y el resultado sería el mismo.

    Sensibilidad fuerte a las condiciones iniciales en el mapeo 2x^{2} - 1. Un par de puntos con una diferencia de 0.0001, divergen después de algunas iteraciones.


    Las dos últimas teclas muestran el comportamiento del mapeo kx^{2} - 1. La variación del parámetro k es lo que lo determina. Para x = 1, el resultado es el que hemos visto, se alcanza un par de ciclos límite. En cambio, para k = 2 el comportamiento es totalmente impredecible. Para k = 1.4, aparecen 16 ciclos, y para k = 1.5 no hay ninguno. Sin embargo, en k = 1.75 se obtienen 3 ciclos.
    Un profesor de mecánica, solía decir que los físicos con una teoría, son como niños con un objeto interesante. Cuando un niño se encuentra un objeto que le atrae, lo mira de frente, lo mira de lado, lo gira, etc. El objeto sigue siendo el mismo, pero su comprensión se facilita con todas esas perspectivas. Lo mismo hacen los físicos con las teorías. Para finales del siglo XVIII, la mecánica newtoniana había sido reformulada y reconstruida de distintas maneras. Ninguna nueva ley había sido descubierta, pero el conocimiento se había incrementado. Tan grande era la confianza y tan grande era su rango de aplicaciones, que el matemático francés, Pierre Simon, marqués de Laplace llegó a escribir una frase que desde entonces se hizo célebre:
    “Un ser inteligente, que en un instante dado conociera todas las fuerzas que animan la naturaleza y las posiciones de los seres que la forman, y que fuera lo suficientemente inmenso como para poder analizar dichos datos, podría condensar en una única fórmula el movimiento de los objetos más grandes del universo y el de los átomos más ligeros: nada sería incierto para dicho ser, tanto el futuro como el pasado estarían presentes ante sus ojos”
    Ésta declaración tiene incluso implicaciones filosóficas, aunque esa es otra discusión. En realidad lo importante, es que el mundo mecánico del siglo XVIII era visto como un sistema de relojería. Todo el universo era un engranaje enorme, del cual podía saberse el pasado y el futuro, con tal de saber las condiciones iniciales y la ecuación que lo gobierna. Tuvo que llegar la mecánica cuántica más de un siglo después para acabar con éste optimismo. Si no somos capaces de dar certeza sobre un electrón, menos lo somos para hablar del universo. Y sin embargo, no es necesaria la mecánica cuántica para derribar esta visión de relojería.
    El estudio del comportamiento a largo plazo de las teclas de calculadora que hemos visto, y que en realidad son mapeos simples, dejan una lección muy importante: muestra que una ecuación sencilla, no necesariamente conduce a una dinámica sencilla. De hecho, el caso de las teclas tan(x) y kx^{2} - 1 son un par de ejemplos de sistemas caóticos, o más bien, de sistemas que presentan caos determinista, que es como los expertos prefieren denominarlo, para dejar claro, que, a pesar del nombre, algo de orden puede encontrarse en él. La función tan(x) llega al caos por una vía llamada intermitencia, en tanto que kx^{2} - 1 llega por una vía llamada duplicación de períodos, y el ejemplo más estudiado de él es el Mapeo Logístico. Sólo hace falta una ruta llamada crisis, de las cuales no se presenta un ejemplo.
    Tal vez la característica más conocida de un comportamiento caótico, sea la sensibilidad fuerte a las condiciones iniciales. Iniciar en un par de puntos muy cercanos, no garantiza que terminemos en puntos cercanos. La segunda figura de la Tecla 2x^{2} - 1 es una muestra de ésto. Aunque tal vez, la sensibilidad fuerte a condiciones iniciales sea mejor conocida como “efecto mariposa”: el aleteo de una mariposa en Brasil puede provocar un huracán en Florida. Y la imagen más conocida es la del atractor de Lorenz, el cual, como coincidencia, parecen las alas de una mariposa:

    El atractor de Lorenz


    Si usted tenía la idea de que las ecuaciones que predicen el comportamiento de los sistemas dinámicos eran, más o menos como una bola de cristal para ver el futuro, es bueno reconsiderar esa postura. El caos está saltando desde las teclas de su calculadora de bolsillo. Los modelos de población, los modelos económicos, los movimientos de la bolsa de valores, entre muchos otros fenómenos, presentan caos. El ecólogo Robert May dijo en un famoso artículo en 1976:
    “No sólo en investigación, sino en el mundo ordinario de la política y la economía, estaríamos mucho mejor si hubiese más gente que comprendiera que los sistemas simples no poseen necesariamente propiedades dinámicas simples”.

     
  • hernandezgomez 8:08 pm el March 16, 2012 Permalink | Responder  

    Caos Cuántico 

    Un problema subyacente en el nacimiento de la mecánica cuántica es el cómo se relaciona ésta con la mecánica clásica. En una pregunta ¿Es la mecánica clásica un caso especial (límite macroscópico para los humanos) de la mecánica cuántica? Supongo, y esta es una manera de meterme en problemas, que la mayoría de los físicos dirá que sí, o que al menos  “así debería ser”. Suponiendo que esto fuera cierto, ¿Cuál es la receta para obtener este límite? Hacer que n tienda a infinito, o hacer que  h sea cero, son dos respuestas comunes. Pero, ¿son equivalentes estos dos límites? Desconozco las respuestas a estas preguntas y sólo las presento como un problema inicial con el que uno se encuentra cuando trata de estudiar el caos cuántico. El caos cuántico estudia los problemas que en su versión clásica son caóticos. Hay varias aproximaciones al tema. En particular aquí se discutirán dos, el método de aproximación estadística mediante la teoría de matrices aleatorias (RMT) y el método de las trayectorias clásicas de Gutzwiller.

     
    • jarmvel 12:58 pm el marzo 17, 2012 Permalink | Responder

      Siempre que veo tus entradas de este tipo, me dan ganas de aprender más y más. 🙂

    • Bad88 8:10 pm el marzo 25, 2012 Permalink | Responder

      interesante señor

    • Anónimo 10:43 pm el julio 28, 2012 Permalink | Responder

      me recordaste a alguien

  • hernandezgomez 4:45 pm el October 6, 2011 Permalink | Responder  

    Los exponentes de Liapunov 

    Consideremos para empezar la aplicación logística definida por la relación recursiva
    x_{n+1} = r(1 - x_{n}) , x \in (0,1), en donde r es un parámetro (fertilidad) que determina el comportamiento del mapeo.
    Lo que es importante mencionar aquí es el comportamiento del mapeo para dos puntos iniciales, x y x + \epsilon , que empiezan relativamente cerca el uno del otro, i.e. \epsilon/x \ll 1. Después de N iteraciones, la distancia entre los puntos es una cantidad que viene dada por la función
    |f^{N}(x + \epsilon ) - f^{N}(x)| = g(x, \epsilon, N), en donde
    f(x)=rx(1 - x).
    La relación exacta que da la distancia entre los puntos es

    g(x, \epsilon, N) = \epsilon e^{N\lambda (x)}
    donde \lambda (x) es llamado el exponente de Liapunov de x, y es una medida de la contracción o alejamiento de los puntos en el espacio fase. Si se despeja, el exponente de Liapunov es el siguiente:
    \lambda(x) = \frac{1}{N} \ln \frac{f^{N}(x + \epsilon) - f^{N}(x) }{\epsilon }\

    Llevado al límite en el cual N\to\infty y \epsilon\to 0
    el exponente de Liapunov se transforma en:

    \lambda (x) = \lim_{N \longrightarrow \infty} \frac{1}{N} \ln|\frac{df^{N}(x_{0})}{dx_{0}}|

    Este resultado se puede escribir de una manera diferente si se usa la regla de la cadena para derivar f^{2}(x)
    \frac{d}{dx}f^{2}(x)|_{x_{0}} = f^{'}[f(x_{1})]f^{'}(x_{0})
    con lo cual el exponente de Liapunov puede expresarse como:

    \label{liapunov} \lambda(x_{0}) = \lim_{\longrightarrow \infty } \frac{1}{N} \sum_{i = 0} \ln|f^{'}(x_{i})|

    Lo que se puede ver de la Ecuación es que cuando el valor absoluto de la derivada es mayor que 1, entonces el logaritmo es positivo; si los sucesivos puntos divergen, entonces el promedio de los logaritmos del valor absoluto de la derivada es
    positivo. Esto permite dar una definición de comportamiento caótico:

    Un mapeo unidimensional tiene trayectorias caóticas para un valor particular del parámetro si el exponente de Liapunov es positivo para ese valor del parámetro.

    Con este resultado es posible calcular el exponente de Liapunov como función de r para la aplicación logística.

    Exponente de Liapunov para la Aplicación Logística

    La Figura fue hecha a partir del siguiente código en C++. Las zonas en las que el exponente de Liapunov es mayor que cero son zonas caóticas, coincidiendo con lo dicho arriba.

    #include <iostream>
    using namespace::std;
    
    #include <cmath>
    
    enum { CONTADOR = 10000 };
    
    int main()
    
     { // Abre main
    
    long double EquisN = 0.1;
    long double Suma = 0;
    long double EquisNmasUno;
    long double k;
    
    for( k = 3.3; k <= 4; k += 0.0001 )
     { // Abre for
    
     Suma = 0;
    
    for ( int n = 1; n <= CONTADOR; n++ )
    
     { // Abre for anidado controlado por CONTADOR
    
     EquisNmasUno = k*EquisN*(1 - EquisN);
     Suma += log(fabs(k - 2*k*EquisNmasUno));
     EquisN = EquisNmasUno; 
    
     } // Cierra for anidado controlado por contador 
    
     cout << k << " " << Suma/CONTADOR << endl; 
    
     } // Cierra for que controla el valor de k 
    
    return 0;
     } // Cierra main

    Es bueno comparar la Gráfica con la gráfica (XXX) en la cual se muestra cómo la aplicación logística va pasando por regímenes de periodicidad hasta llegar a zonas en las que su comportamiento se vuelve caótico, dentro de las cuales de nuevo existen zonas de periodicidad, etcétera. Si se hiciera un acercamiento a la Gráfica ( ) en esas zonas, modificando el programa de arriba para hacer que r varíe más lentamente, podrían verse pequeñas secciones en las que los exponentes de Liapunov están por debajo de 0.

     
  • hernandezgomez 2:39 am el August 31, 2011 Permalink | Responder  

    La Medida de la Información Según Shannon 

    En la búsqueda binaria los datos están ordenados, digamos de manera ascendente en un arreglo de N enteros con N par, y gracias a este orden en la información es posible realizar una búsqueda en un tiempo relativamente breve. Esta rapidez en la búsqueda tiene un costo, desde luego, ya que antes fue necesario ordenar las entradas, pero este no es el asunto aquí. Supongamos que queremos verificar si el numero x se encuentra o no dentro del arreglo. El algoritmo en seudocódigo sería más o menos el que sigue:

    • Obtén el valor del arreglo en la entrada N/2
    • Si el valor del arreglo en la entrada N/2 es igual a x, entonces:
    1. Detén la búsqueda e informa que x está en el arreglo.
    • De lo contrario:
    1. Si x es mayor que el valor del arreglo en N/2
    • Obtén el valor del arreglo en (N/2)/2
    • Si en valor del arreglo en (N/2)/2 es igual a x, entonces:
    1. Detén la búsqueda e informa que x está en el arreglo.
    • De lo contrario:

    Este algoritmo realiza, en el peor de los casos, ldN pasos (donde ldN es el logaritmo en base 2 de N) para encontrar x o informar al usuario que x no está contenido en el arreglo. Este número es el número de bits de información que puede almacenar el arreglo. En términos sencillos un bit es la mínima cantidad de información que se puede tener. Supongamos, por ejemplo, que se lanza una moneda y obtenemos cara, la información de este acontecimiento puede almacenarse en un arreglo de dos entradas en el que previamente se ha establecido que la entrada de la izquierda es cruz y la de la derecha es cara. Entonces, y con esta convención, si hemos de almacenar el resultado basta con dejar en blanco la primera entrada del arrreglo y colocar un punto * en la segunda. Cuando alguien más vea este arreglo, y conozca la convención que hemos hecho, será capaz de decir que ha ocurrido una cara. En este ejemplo podríamos pensar que basta con un arreglo de una sola entrada, en la que ponemos 0 si ocurre cara o 1 si ocurre cruz, con lo cual almacenamos igual cantidad de información en menos espacio. Lo que ocurre es que en este caso es que hemos invertido los papeles y el arreglo de dos entradas son el 0 y el 1 y el punto es el arreglo de una entrada, también podríamos almacenar información acerca de lo que obtuvimos en un lanzamiento de dados, pero esto implica el uso de un sistema numérico de base 6. Necesitamos de una marca y de un sistema con dos posibles estados. Otra forma de ver esto es el caso presentado arriba, de la búsqueda binaria. Cuantas preguntas necesitemos para localizar el punto, x en el ejemplo, es el número de bits que puede almacenar nuestro sistema. ¿Cuánta información obtenemos cuando sabemos el resultado de un volado? 1 bit, ya lo sabemos, pero ¿Cómo está esto relacionado con la probabilidad de obtener una cara? El número de bits puede expresarse asì:

    1 = (-1/2)ln(1/2) – (1/2)ln(1/2)

    o

    1 = Σplnp

    Una relación válida también para los casos que en los que la moneda no es legal y las probabilidades no son iguales en los eventos mutuamente excluyentes.

     
  • hernandezgomez 12:41 am el March 8, 2011 Permalink | Responder  

    El Mapeo Logístico 

    La serie de fibonacci es un intento bastante elemental de modelar el crecimiento de una población. Sin embargo, tiene el gran problema de que está diseñada pensando que existen una cantidad inagotable de recursos que permiten el crecimiento: alimento, espacio, etcétera. Desde luego, esto no es así en el mundo real; las poblaciones nunca crecen de manera infinita, y es previsible un freno cuando los recursos escasean o cuando ataca una epidémia. Un intento más refinado de modelar una población es el Mapeo Logístico.

    Xn+1 = k*Xn( 1 – Xn )

    Esta aplicación es, al menos algorítmicamente, bastante simple. Si quisiéramos hacer las cosas fáciles y trabajar con un modelo de caricatura, este resultaría perfecto. Su gráfica es la de una parábola que se abre hacia abajo. En el inicio esta gráfica se parece a la gráfica de la serie de fibonacci, tanto como puede parecerse una recta a una parábola, localmente todo es plano. Ahora, mientras que la población de conejos crece indiscriminadamente en el modelo de fibonacci, la aplicación logística llega a un máximo y de ahí empieza a descender, algo que está más cercano a la realidad en cuanto a modelar poblaciones se refiere. Cuando se acaban los recursos y el espacio se limita, el ritmo de crecimiento disminuye e incluso la población se reduce. Es difícil imaginar un modelo más simple. Sin embargo, con toda su sencillez, el mapeo logístico contiene una característica esencial que la hace muy diferente de la serie de fibonacci: no es lineal.

    Es necesario hacer algunas acotaciones en este punto. La ecuación de arriba contiene un parámetro k, que llamaremos de crecimiento o de fertilidad; la rapidez con la que se reproduzcan los conejos dependerá de esa constante. Pero también dependerá del número de individuos que haya originalmente. Así que para hacer las cosas divertidas se restringirá los valores que puede tomar Xo al intervalo (0, 1) y los de k al intervalo (1, 4). ¿Por qué restringir a esos valores el rango de validez de la aplicación? Para contestar esta pregunta es necesario ver geométricamente qué es lo que hace la aplicación logística. El primer factor del lado derecho (k*Xn) “estira” o comprime, dependiendo del parámetro de fertilidad, el valor inicial; esto sería un aburrido crecimiento lineal si no fuera por el segundo factor, que puede disminuir o hacer más grande, o incluso negativo, el valor final. Si Xn es mayor que 1, entonces, la siguiente población de conejos tendrá un número negativo de miembros, lo cual implica su extinción, este caso no nos interesa; obviamente tampoco supondremos que se inicia con una población negativa. Así pues, es conveniente tomar a Xn con un valor inicial entre 0 y 1. Esto a su vez impone que el valor de k no pueda ser mayor que 4. ¿Por qué? Porque el punto máximo de la población se alcanza en 0.5, y el valor de este máximo es k/4. Para valores mayores que 4, la aplicación rapidamente tiende a infinito, en tanto que para los valores entre 0 y 4 el valor de la población regresa nuevamente al segmento 0-1. La mitad del segmento unitario es estirado o comprimido y la segunda mitad se mapea en el orden inverso. Cabe aclarar también, que, aunque Robert May propuso esta aplicación como un modelo poblacional, su aplicación va más allá y en principio no necesitamos hacer referencia a conejos ni tenemos que justificar que los intervalos de Xo y k sean los elegidos. Se toman esos porque ahí ocurren cosas extraordinarias.

    ¿Hacia donde evoluciona la aplicación logística? Si el sistema se deja “correr” sin límites, ¿se estabiliza después de varias (muchas) generaciones ? Para averiguar esto podemos iniciar con un par de valores para nuestros parámetros, digamos Xo =0.2 y k =1.5.

    La serie de valores que encontramos son los siguientes :

    1. 0.32
    2. 0.4352
    3. 0.491602
    4. 0.499859
    5. 0.5
    6. 0.5
    7. 0.5

    Con 0.5 repitiéndose por siempre.

    Resultó fácil. Esto se puede intentar con una calculadora de bolsillo e incluslo con papel y lápiz y un poco de paciencia. Con el valor fijo de k se puede probar con otros valores para Xo, El comportamiento es el mismo. Después de algunos ciclos, que no deberán ser muchos, se llega a un punto muerto, 0.5. Si ahora ponemos k = 2.5 entonces todos los valores de Xo acaban en 0.6. De hecho, todos los valores de k comprendidos entre 0 y 3 tienen un comportamiento “aburrido”, por usar un adjetivo. A esta zona se le llama el régimen de estado estacionario. Otra forma de ver esto es mediante la figura que se muestra a continución. Cualquier punto en el diagrama converge hacia un único valor.

    Mapeo Logístico en estado estacionario.

    Mapeo Logístico en estado estacionario.

    La gráfica anterior muestra los puntos de la tabla de arriba. Finalmente se alcanza el estado estacionario después de pocas iteraciones. Sin embargo, no todos puntos en el estado estacionario convergen rápidamente. En el límite cuando k se acerca a 3, la convergencia se hace cada vez más y más lenta. Para ahorrar el trabajo de teclear una y otra entrada miles de veces en una calculadora electrónica, se puede usar un programa como el mostrado aquí en C++.

    # include<iostream>
    using namespace::std;
    
    enum {contador = 2};
    
    int main()
    
    { 
    long double EquisNmasUno, EquisN = 0.3, k = 2;
    int n;
    
    for ( n = 1; n <= contador; n++ )
     {
     EquisNmasUno = k*EquisN*( 1 - EquisN );
     cout << EquisNmasUno <<endl;
     EquisN = EquisNmasUno;
     }
    
    return 0;
    } 
    

    Utilizando este código pruebo con el valor de k = 2.99, y Xo = .7 para obtener el valor 0.665552 después de miles de iteraciones. Ignoro, por la precisión de mi computadora, si es ese el valor exacto o si aún está variando el valor hacia un punto fijo. Sin embargo, lo que es seguro es que no habrá un comportamiento distinto. El sistema tiende a quedarse quieto.

    Para valores de k mayores a 3, y menores a 3.58, más o menos, el sistema ya no tiende a estar en un sólo punto, se mueve de manera cíclica entre dos o mas valores de manera infinita. Con el programa anterior pruebo el valor k = 3.2 y Xo = 0.4, después de 100 iteraciones obtengo los valores:

    1. 0.513045
    2. 0.799455
    3. 0.513045
    4. 0.799455

    repitiéndose de manera infinita. ¿Qué está pasando? Para hacer las cosas más claras, es conveniente mostrar en una gráfica la manera en que los puntos se mueven en la aplicación.

    Mapeo Logístico en el régimen periódico.

    Después de algunas iteraciones la aplicación se estabiliza en los dos ciclos que se obtuvieron con el programa. Pero en la zona de periodicidad no sólo aparece un par de de ciclos. Sea por caso el valor de k = 3.53 y Xo = 0.03. Usando de nueva cuenta el programa anterior, después de unos cien ciclos se obtiene

    Gráfica 3

    Cuatro periódos en la aplicación logística para k = 3.53

    Si ahora se toma un valor de k = 3.59, lo que se obtiene es lo que se muestra en la figura siguiente.

    Figura.

    Esto es, los ciclos se han duplicado tanto que en realidad están apareciendo una gran cantidad de ellos sin control. De pronto se ha perdido el orden y la periodicidad de las etapas anteriores y en realidad no puede decirse que el sistema regrese a un valor anterior, sino que todos los valores de Xn+1 son nuevos. A partir del valor de k = 3.58, aproximadamente hasta k = 4, la aplicación logística está en la llamada zona caótica. Todos los puntos han sido alcanzados o, cuando menos, se pasará tan cerca de ellos como se quiera, siempre que se deje tiempo evolucionar al sistema un tiempo suficiente. Abajo se muestra la gráfica del valor final al que converge la aplicación logística contra el valor k del parámetro de fertilidad. Para hacer esta gráfica, en lugar de cncontrar los resultados con una calculadora, se usa un programa cuyo código aparece aquí escrito en C++. Este programa itera n veces la aplicación y desecha esos números, que representan fluctuaciones alrededor de los puntos a los que finalmente converge. Finalmente se toman los últimos 20, que se presumen bastante cercanos o exactamente los puntos finales. La calidad de la gráfica depende también de las variaciones en el parámetro k. Estos incrementos se han hecho bastante chicos.

     # include<iostream>
     using namespace::std;
    
     #include<iomanip>
     using std::setprecision; 
    
     enum {contador = 10000};
    
     int main()
    
     {
       long double  EquisNmasUno, EquisN = 0.51, k = 3.81;
       int n;
    
       for (double k = 3.8282; k <= 3.8285; k += 0.0000001 )
       {       // Abre primer for
       EquisN = 0.51;
    
       for ( n = 1; n <= contador; n++ )
       {
          EquisNmasUno = k*EquisN*( 1 - EquisN );
          EquisN = EquisNmasUno;
       }
    
       for ( int m = 1; m <= 200; m++ )
       {    // Abre for 
    
          EquisNmasUno = k*EquisN*( 1 - EquisN );
          EquisN = EquisNmasUno;
          cout <<  setprecision(10) << k << " " << EquisNmasUno <<endl;
       }    // Abre for
    
       } // Cierra for anidado
    
     return 0;
    
     }

    Gráfica Nítida

    La higuera de Feigenbaum con una alta resolución.

    La figura fue hecha a partir de varios miles de puntos, se puede variar los incrementos en k en el programa o incrementar el contador n en el primer ciclo for anidado para obtener una resolución un poco más baja. Se ha hecho con gran fidelidad para poner en evidencia que a pesar de haber entrado en zonas donde se alcanzan todos los valores del rango (0, 1), existen zonas de periodicidad (zonas blancas dentro de zonas rojas). En particular hay una zona periódica cerca de 3.8. Para analizarla mejor en la gráfica de abajo se hace un zoom a la zona (3.815, 3.86). Este acercamiento se logra haciendo más pequeña la variación de k en el ciclo inicial del programa de arriba.

    Primer acercamiento a la higuera de Feingenbaum.

    El acercamiento hace evidente que en 0.5 y a partir de k= 3.84 hay una figura bastante parecida a la original presentada arriba. Para salir de dudas, de nuevo es posible hacer un acercamiento a la figura. Abajo se presenta la zona ampliada. Se trata de una imagen especular de la original. Y si se observa bien, cerca de 3.854, aparece otra zona de estabilidad en la cual se observa una bifurcación parecida a la que hemos encontrado. La memoria de mi máquina no permite hacer otro acercamiento, porque GNUPLOT, que es el programa que uso para graficar, no puede manejar tantos puntos que se producen, sin embargo, es seguro que la figura se va repitiendo una y otra vez al infinito.

    Zoom a la Higuera de Feigenbaum

    Grafiga

    Acercamiento a la higuera

    Acercamiento

    Segundo Zoom

    Segundo acercamiento a la higuera de Feigenbaum

    Hasta aquí un bosquejo breve de todo lo que surge a partir de la aplicación logística. Sin embargo, ha sido muy general. Lo principal es entender que se trata de algo más complejo de lo que se piensa a primera vista. En su viaje a través de todos los valores de k, el mapeo sufre una gran cantidad de transformaciones. Saliendo de una estabilidad esperada, pasa por sucesivas duplicaciones, no tan esperadas, hasta llegar a zonas de aparente desorden dentro de las cuales hay ventanas con un poco de orden… y así de manera infinita. El destino final de ese viaje es el caos determinista. ¿Qué es el caos? Baste por ahora decir que es simplimente ese destino en donde aparecen todos los ciclos. Uno de los caminos para llegar a ese destino se llama duplicación de periódos. Por este camino transitan muchos fenómenos, algunos más complejos que otros. Para entender al caos determinista, vale mucho la pena revisar la forma en que se llega a él a través de ésta ruta.

    Volvamos a la Figura 1. En ella se muestra la gráfica de la primera iteración contra Xo, como función de k.

    # include<iostream>
    usingnamespace::std;
    
    int main()
    
     {
    
    longdouble EquisNmasUno, EquisN = 0.5, k = 3.5;
    longdouble X;
    int n;
    int contador = 4;
    
    for ( X = 0; X <= 1; X += 0.001 )
     { // Abre primer for
    
     EquisN = X; 
    // No se puede usar EquisN como controlador del
    // ciclo for porque esta variable es modificada
    // en el cuerpo del ciclo.
    
    for ( n = 1; n <= contador; n++ )
     { // Abre for anidado
     EquisNmasUno = k*EquisN*( 1 - EquisN );
     EquisN = EquisNmasUno;
     } // Cierra for anidado
    
    // Esta es la salida al archivo de datos
     cout << X << " " << EquisNmasUno << endl;
    
     } 
    //Cierra primer for
    return0;
    
     } 

    Las siguientes figuras muestran algunos puntos de bifurcación de la aplicación logística.

    Cuatro Iteraciones de la aplicación logística.

    Esta es la gráfica de la segunda iteración de la aplicación logística.

    Segunda Iteración de la Aplicación Logística

    Esta gráfica es un acercamiento de la anterior

    Espacio

    r1″ src=”https://masejerciciosresueltos.files.wordpress.com/2011/03/graficarr1.jpg&#8221; alt=”Gráfica que muestra la primera bifurcación.de la aplicación logística. ” width=”640″ height=”448″ />

    Primera bifurcación.de la aplicación logística, r < r1

    l

     
  • hernandezgomez 8:48 pm el March 7, 2011 Permalink | Responder
    Etiquetas: Complejidad y Caos   

    La Serie de Fibonacci 

    EL HIJO DE BONACCI:

    Leonardo Fibonacci

    El matemático italiano Leonardo de Pisa (1170(?)-1250) ha pasado a la historia con el apodo de Fibonacci, contracción de filius Bonacci o hijo de Bonacci. Bonacci era el sobrenombre de su padre, Guglielmo. Debido a que Guglielmo era un agente diplomático, su hijo Leonardo pudo viajar por el cercano oriente, tomando contacto con la matemática árabe. Probablemente la mayor contribución de Fibonacci, sea la introducción del sistema de numeración árabe a Europa. El sistema posicional de los árabes, con 10 símbolos, incluyendo un 0, es muy superior a el sistema romano. Si alguien ha intentado alguna vez realizar operaciones simples de aritmética con números romanos, se habrá dado cuenta de esta importancia. Un sistema posicional simplificado (de hecho el más simple) que incluye al 0, ha permitido el diseño de las computadoras electrónicas en el siglo XX. No fue difícil que los comerciantes de la época se dieran cuenta de la importancia del sistema árabe y lo adoptaran.
    EL PROBLEMA DE LOS CONEJOS:
    Sin embargo, Fibonacci es más conocido por la llamada serie o sucesión de Fibonacci. La serie surge en diversas fenómenos de la naturaleza. Uno de esos problemas es el estudio de poblaciones de conejos. Es bien sabida la gran fertilidad de estos animales. La formulación del problema de la población es el siguiente:

    Una pareja madura de conejos procrea una nueva pareja cada mes, en tanto que una pareja de conejos recién nacidos tarda dos meses en procrear a su vez otra pareja. Si se tiene una pareja de conejos tiernos en un sistema aislado. ¿Cuántas parejas de conejos habrá al cabo de un año?

    Al inicio, la población es de 1 pareja.
    Al primer mes la pareja tierna habrá madurado, pero no tendrá hijos todavía, por lo tanto de nuevo habrá 1 pareja.
    Al segundo mes, tendremos la pareja original madura y una pareja tierna, por lo tanto habrá 2 parejas.
    Al tercer mes, la pareja madura habrá procreado nuevamente, en tanto que la otra pareja está alcanzando la madurez. Se tienen 3 parejas.
    Para el cuarto mes, se tiene la pareja original, la cual ha tenido de nuevo hijos, sus primeros hijos, ya maduros, que también acaban de tener hijos, y los segundos hijos de los primeros conejos que acaban de alcanzar la madurez. Por lo tanto hay 5 parejas.

    Ésto empieza a ser más o menos un lío. Para dejarlo más claro es útil consultar la siguiente figura, que muestra el número de conejos por mes:

    El número de parejas de conejos por mes.

    ¿Cómo podemos saber cuántas parejas habrá en el mes siguiente? Eso depende de cuántas hay en el presente mes y de cuántas hubo en el pasado. Para empezar, el próximo mes van a estar todas las que están ahora, pero también habrá nuevas parejas. ¿Cuántas nuevas parejas habrá? No todas las parejas del presente mes van a procrear para el siguiente, algunas sí, pero las que acaban de nacer necesitan dos meses. ¿Cuáles sí van a procrear? todas las que estaban el mes pasado. Esas ya tienen un mes como mínimo y para el próximo darán origen a una nueva pareja. Es decir, para saber el número del siguiente mes, hay que sumar el número actual más el número del mes pasado. Fíjese que esto se cumple en los primeros meses:

    Penúltimo Mes         Último Mes        Mes Actual
          0                   0                  1
          0                   1                  1
          1         +         1        =         2
          1         +         2        =         3
          2         +         3        =         5
          

    De hecho una forma de definir la serie es la siguiente:
    LA DEFINICIÓN RECURSIVA
    Los números de Fibonacci están definidos como:

    f_{0} = 0, f_{1} = 1,
    f_{n} = f_{n-1} + f_{n-2}
    para n = 2, 3, 4, 5,....

    Ésta definición es recursiva: para conocer el número de fibonacci actual necesitamos conocer los dos números de fibonacci anteriores. Con ésta fórmula es posible encontrar los primeros 20 números de la sucesión

    Fibonacci de: 0 es 0
    Fibonacci de: 1 es 1
    Fibonacci de 2 es 1
    Fibonacci de 3 es 2
    Fibonacci de 4 es 3
    Fibonacci de 5 es 5
    Fibonacci de 6 es 8
    Fibonacci de 7 es 13
    Fibonacci de 8 es 21
    Fibonacci de 9 es 34
    Fibonacci de 10 es 55
    Fibonacci de 11 es 89
    Fibonacci de 12 es 144
    Fibonacci de 13 es 233
    Fibonacci de 14 es 377
    Fibonacci de 15 es 610
    Fibonacci de 16 es 987
    Fibonacci de 17 es 1597
    Fibonacci de 18 es 2584
    Fibonacci de 19 es 4181
    Fibonacci de 20 es 6765

    Observe que este número está creciendo muy rápidamente. Al cabo de un año, hay 144 parejas, a los 20 meses tenemos 6765 parejas de conejos, y en el mes 30 esa cifra llega hasta 832040. Es prácticamente imposible que alguien pueda realmente tener esa cantidad de parejas de conejo. Como modelo poblacional, la sucesión de Fibonacci es mala porque no toma en cuenta varios factores adversos. Por ejemplo, no consideramos el hecho de que la muerte de conejos debe producirse en algún momento. Tampoco se toma en cuenta la limitación de recursos (espacio, agua, alimento) que desde luego limitan el tamaño de la población.
    LA SERIE DE FIBONACCI EN LA COMPUTACIÓN
    La sucesión de fibonacci es un problema clásico para estudiantes de computación. En particular es un ejemplo de problema recursivo. En oposición a la iteración (un método directo para solucinar un problema), la recursión es una manera simple de resolver problemas computacionales. Solucionar un problema de forma recursiva es reducir ese problema a casos más simples de sí mismo. Por ejemplo, ¿cuál es el número de fibonacci 5? La respuesta recursiva es que es el número de fibonacci 4 + el número de fibonacci 3, pero ¿cuáles son los números de fibonacci 4 y 3? respectivamente son número de fibonacci 3 + número de fibonacci2 y número de fibonacci2 + número de fibonacci1, etc. hasta llegar a los casos bases fibonacci 0 y fibonacci 1. Teóricamente, cualquier problema recursivo puede resolverse de manera iterativa, aunque nadie nos dice de qué manera. Ya que en computación, como en la vida misma, hay una gran distancia entre la teoría y la práctica, muchas veces, la recursión es la única forma que tenemos para resolver un problema, si bien se necesitan más recursos (memoria, procesador).
    El problema de la serie de Fibonacci también es un ejemplo típico de cómo el tamaño de los tipos de datos es superado muy pronto. Casi todos los lenguajes de programación clasifican las variables en tipos distintos: enteros, flotantes, etc. Cada uno de éstos tipos tiene asignado un tamaño específico en bits que determinan la cifra máxima que se puede almacenar en dicho espacio de memoria. En el lenguaje Java, por ejemplo, los tipos int tienen un tamaño de 32 bits, (4 byts) en los cuales se puede almacenar números enteros desde -2147483648 hasta 2147483647 (el bit 32 se reserva para el signo). Como hemos visto, los números en la serie de Fibonacci crecen muy rápidamente con cada ciclo, ésto hace que pronto los tipos de datos sean superados pronto.
    El siguiente programa en C++ calcula los números de Fibonacci:

     //Calcula la serie de Fibonacci
    
    #include <iostream>
    using namespace std;
       
    /*Prototipo de la funcion fibonacci*/
    int fibonacci (int);
       
    ///////////////////////////////////////////////////////////////////
    // MAIN
    ///////////////////////////////////////////////////////////////////
       
    int main()
    {
    int number, respuesta;
    cout <<endl<<endl<< "Este programa calcula el numero de Fibonacci."<<endl;
    cout <<"Introduzca un numero: " <<endl;
    cin >> number;
    
    if (0 == number || 1 == number )
    cout <<"Fibonacci de: " << number<<" es " << number << endl;
    else
    {
    respuesta = fibonacci (number);
    cout<<"Fibonacci de " << number << " es " << respuesta << endl;
    
    }
    return 0;
    
    }
    
    /////////////////////////////////////////////////////////////////////
    // FUNCION FIBONACCI
    /////////////////////////////////////////////////////////////////////
      
    int fibonacci (int number)
    {
    int fib1 = 0, fib2 = 1, fibn = 0, temp;
    
    for ( int n = 2; n <= number; ++n )
       {
       fibn = fib2 + fib1;
       temp = fib2;
       fib2 = temp + fib1;
       fib1 = temp;
       }
    
    return fibn;
    }
    
     
c
Crea una nueva entrada
j
Siguiente entrada / Siguiente comentario
k
anterior entrada/anterior comentario
r
Responder
e
Editar
o
mostrar/ocultar comentarios
t
ir al encabezado
l
ir a iniciar sesión
h
mostrar/ocultar ayuda
shift + esc
Cancelar