
[ NOTE: English translation follows the Spanish text. To get there fast,
search for: ENGLISH, else just scroll through this document ]


                              
                                    
                                     
                                 
                                       
                                     


                           Para   HP48 G & GX

                              Versin 1.0

        Autor:      Juan Jos Piero de Armas  (c) 1996.
            Facultad de Fsicas, Universidad de Valencia, Espaa.

        e-mail:     armas@alufis34.ffisic.uv.es




                 INDICE
            
       1.- Introduccin
        1.1-  Qu es un Pade ?
        1.2- Programa
       2.- Ejemplos
        2.1- Serie de Stieljes
        2.2- Serie oscilante
       3.- Notas



  1.- Introduccin

    1.1-  Que es un Pade ?

    Una funcin en general puede desarrollarse como cociente de
    polinomios, a esta fraccin se le llama  "Pade".
    Dada una funcin f(x) cuyo desarrollo en serie de Taylor sea
    a0 + a1 X + a2 X + ...  , el Pade de f(x) ser una fraccin de la

                           An X^n + ... + A2 X + A1 X + A0
    forma:   P(n,m,X) =   ----------------------------------
                           Bm X^n + ... + B2 X + B1 X + B0

    (sin perdida de generalidad podemos hacer B0 = 1)

    No siempre es posible hallar el Pade de una funcin. El Pade suele
    ofrecer buenos resultados numricos con pocos trminos y se muestra
    especialmente til cuando necesitamos sumar series asintticas.
    Muchas veces aunque el desarrollo de Taylor de una funcin no sea
    convergente en un punto si que lo es el Pade.


    1.2- Programa

    El programa consta de tres partes:

      ALG:
    Que calcula el Pade algebraico P(n,n,X) (que es el que suele ofrecer
    mejores resultados) de una funcin a partir de su desarrollo en serie
    de Taylor, aceptando como argumentos tanto una lista con los coefi-
    cientes de Taylor { a0 a1 a2 ... ap } (donde  p  es  mayor o igual que
    2n+1) como una funcin o programa que los genere. Dicha funcin o pro-
    grama deberan tener como variable  <-n  (donde <- es el carcter 142),
    adems deben tener valor finito para cualquier  <-n  desde  0  hasta 
    2n+1. El resultado ser dos listas, una con los coeficientes del nume-
    rador del Pade y otra con los del denominador.

                { An ... A2 A1 A0 }
                { Bn ... B2 B1  1 }

      Valor:
    Que evalua el Pade en un punto. Aceptando como argumentos las dos listas
    anteriormente calculadas y un nmero.

      Sust:
    Si cuesta mucho escribir las formulas en funcin de  <-n  se pueden es-
    cribir en funcin de  N  y utilizar esta pequea aplicacin para que
    sustituya las  N  por  <-n. Slo se puede utilizar sobre funciones alge-
    braicas y no sobre programas. Sust no es fundamental y se puede borrar.


  2.- Ejemplos:
                                                               n
    2.1- Para calcular el Pade 3,3 de la serie de Stieljes  (-x)*n!,
                                                           n=0
    serie que se obtiene por ejemplo al desarrollar la integral

               -t
            e
          ------- dt   pondremos:
        0   1 + t


               `(-1)^N*N!`
                         3
                     [ALG]

    y el resultado es:

             { 6 26 11 1 }
            { 24 36 12 1 }

    es decir, el Pade 3,3 de la serie de Stieljes es:

                           6 X^3 + 26 X + 11 X + 1
             P(3,3,X) =   ---------------------------
                           24 X^3 + 36 X + 12 X + 1 

    ahora queremos evaluar el Pade en el punto X=1:

                         1
                   [Valor]

    y obtenemos:

            0.602739726027

    Es posible realizar una grafica del Pade introduciendo como ecuacin

             << X Valor >>

    (En la pila debe estar el Pade calculado).


    2.2- Vamos a calcular la serie:
                n
           (-1) 
          -------
       n=0  n + 1

    Primero lo haremos de la forma tpica, es decir, sumando trmino a
    trmino todos los trminos de la serie hasta un  n  dado. 

             Valor mximo de n            Valor de la suma
           --------------------------------------------------
                              100    0.69 8073169403
                             1000    0.693 646431553
                            10000    0.6931 97173061
                           100000    0.6931 52180485
                          1000000    0.693147 680559
                         10000000    0.693147 230559
                        100000000    0.69314718 5560
                       1000000000    0.69314718 1060
                      10000000000    0.693147180 610
                     100000000000    0.6931471805 62
                                    0.693147180559944

   
    Vemos como se va obteniendo ms precisin a medida que se asciende
    en el nmero de terminos sumados, y que para obtener una precisin de
    6 decimales necesitamos calcular la suma hasta n  1000000, es decir
    habra que esperar unas seis horas para que la HP48 nos ofreciese
    semejante precisin, por supuesto que yo no he calculado el resultado
    de esa forma, sino que he utilizado un ordenador.

    Ahora lo haremos utilizando el programa para calcular el Pade.
    Introducimos:
                    `(-1)^<-n/(<-n+1)`
                                     4
                                 [ALG]

    Y obtenemos:

    { 1.5873013352E-3 .133597873438 .888888853963 1.72222219451 1 }
    { 3.96825361072E-2 .47619045088 1.66666661789 2.222222219451 1 }

    Ahora evaluamos esto en el punto X=1:

                                     1
                               [Valor]

    Y obtenemos:
                       .693147332353

    Es decir una precisin de 6 digitos, y esta vez el proceso completo
    ha durado  1.9 segundos, adems podriamos evaluar el Pade en otro punto
    en cuestin de dcimas.
    La precisin mxima la obtenemos al calcular el Pade 10,10 , en este
    caso se tarda  6.57 segundos en obtener:

                       .693147180559


  3.- Notas

    - El programa lo cre durante el curso de 1994-95, posteriormente he
    decidido retocarlo y ponerlo en la red para que quien quiera se sirva
    de l. Ha sido escrito en User-RPL sobre una HP48G por lo que debe
    funcionar en cualquier HP48G y HP48GX. Funcionara en una HP48SX si se
    crea un programa con el nombre REVLIST que invierta el orden de los
    elementos de una lista.
    - El tamao mximo del Pade calculado depende de la memoria libre,
    por ejemplo con 27 K de memoria libre podemos calcular un Pade 35,35
    mientras que con 7 K podemos calcular hasta el Pade 17,17.
    - La precisin de los coeficientes calculados puede dejar mucho que
    desear, sobre todo si el orden del Pade exigido es muy elevado, esto es
    debido entre otras cosas a que en uno de sus pasos el programa realiza
    una divisin entre un vector de n elementos y una matriz de n x n
    elementos. En ocasiones ser imposible alcanzar una precisin dada.
    - Recordar que si se tiene activado LASTARG, LASTSRACK y LASTCMD la
    calculadora ir ms lenta y se gastar mucha ms memoria.




******************************************************************************
                                <-- ENGLISH -->
******************************************************************************

        CONTENTS
            
       1.- Introduction.
        1.1- What's a Pade ?
        1.2- Program.
       2.- Examples.
        2.1- Stieljes' series.
        2.2- Oscillant series.
       3.- Observations.



  1.- Introduction

    1.1- What is a Pade ?

    Generally, any function can be expressed as a quotient of
    polynomials, this fraction is called "Pade".
    Given a function f(x) whose Taylor approximation is
    a0 + a1 X + a2 X + ...  , the Pade of f(x) will be a quotient having

                            An X^n + ... + A2 X + A1 X + A0
    the form: P(n,m,X) =   ----------------------------------
                            Bm X^n + ... + B2 X + B1 X + B0

    (we can do B0 = 1 without any generality loss)

    It's not always possible to obtain the Pade of a function. The Pade
    usually offers good numeric results with just a few terms and shows 
    itself as very useful when we need to sum asynthotic series.
    It can be the case that although Taylor's approximation of a function 
    doesn't converge in a point, the Pade does.
                                          

    1.2- Program

    The program has three parts:

      ALG:
    Calculates the algebraic Pade P(n,n,X) (this one often gives best 
    results) of a function given its Taylor approximation, accepting as 
    inputs both a list which contains the Taylor coefficients
    { a0 a1 a2 ... ap } (where  p  is  greater or equal to 2n+1) or a
    a function (or program) that generates them. That function or program
    must have as variable  <-n  (where <- is character 142), besides they
    must be finite for any  <-n from 0 to 2n+1. Output will be two lists,
    one with the Pade numerator coefficients and the other with the
    denominator ones.

                { An ... A2 A1 A0 }
                { Bn ... B2 B1  1 }

      Valor:
    Evaluates the Pade on a point. It gets as arguments the two lists
    previously calculated and a number.

      Sust:
    If it's hard for you to type the formulas as functions of <-n, then you
    can type N where you want a <-n and afterwards use this utility which 
    will replace the N's for <-n's. You can only use this on algebraic
    functions, not on programs. Sust isn't essential and it can be deleted.


  2.- Examples:
                                                               n
    2.1- To calculate the 3,3 Pade of Stieltjes' series:    (-x)*n!,
                                                           n=0
    series that you get when you simplify the integral

               -t
            e
          ------- dt   we will do:
        0   1 + t


               `(-1)^N*N!`
                         3
                     [ALG]

    and the result is:

             { 6 26 11 1 }
            { 24 36 12 1 }

    which means that the 3,3 Pade of Stieltjes' series is:

                           6 X^3 + 26 X + 11 X + 1
             P(3,3,X) =   ---------------------------
                           24 X^3 + 36 X + 12 X + 1 

    Now we want to evaluate the Pade on point X=1:

                         1
                   [Valor]

    and we get:

            0.602739726027

    It's possible to plot the Pade typing as equation

             << X Valor >>

    (The calculated Pade must be in the stack).


    2.2- We're going to calculate the series:
                n
           (-1) 
          -------
       n=0  n + 1

    First we'll do it in the usual way, I mean, adding all terms
    till a given n. 

             Maximum value of n           Value of the sum
           --------------------------------------------------
                              100    0.69 8073169403
                             1000    0.693 646431553
                            10000    0.6931 97173061
                           100000    0.6931 52180485
                          1000000    0.693147 680559
                         10000000    0.693147 230559
                        100000000    0.69314718 5560
                       1000000000    0.69314718 1060
                      10000000000    0.693147180 610
                     100000000000    0.6931471805 62
                                    0.693147180559944

   
    We can see that we get more accuraccy when we add more and more terms,
    as well as the fact of needing to add up to n=1000000 to have a 6
    decimal precision, that is to say, we should wait about six hours to
    obtain such preciseness from the HP48. It goes without saying that
    I haven't got the result that way but on a computer.

    Now we will do it using the program to calculate the Pade.
    We type:
                    `(-1)^<-n/(<-n+1)`
                                     4
                                 [ALG]

    And we get:

    { 1.5873013352E-3 .133597873438 .888888853963 1.72222219451 1 }
    { 3.96825361072E-2 .47619045088 1.66666661789 2.222222219451 1 }

    Now we evaluate this on X=1:

                                     1
                               [Valor]

    obtaining:
                       .693147332353

    A 6-digit accuraccy! And this time the whole proccess has taken 1.9 secs,
    besides we would be able to evaluate the Pade on other point in a flash.

    We get maximum precision when we calculate the 10,10 Pade, in this case
    it takes 6.57 seconds to obtain:

                       .693147180559


  3.- Notes

    - I created this program during the 1994-95 course. Afterwards, I've 
    decided to improve it and make it public so anybody could use it.
    It was written in User-RPL on a HP48G, therefore it should work on
    any HP48G or GX. It will work on a S/SX if you make a program named
    REVLIST that inverts the order of a list's elements.
    - The maximum size of a calculated Pade depends on free memory. For 
    example, with 27 K of free memory we can calculate a 35,35 Pade, while 
    as with 7 K we can calculate up to the 17,17 Pade.
    - Accuraccy of calculated coefficients can be bad if we ask for a Pade
    of very high order. This is due, among other things, to the fact that  
    the program in one of its steps makes a division for a n-element vector
    and a n x n matrix. Sometimes it will be impossible to reach a given
    accuraccy.
    - Remember that if you have LASTARG, LASTSRACK and LASTCMD activated,
    the calculator will work slower and will be using more memory.
