Curso de Programacin User RPL

Por: Roger Broncano Reyes rgbinnet@hotmail.com http://hpuser.8m.com

Curso de Programacin de User RPL

Tabla de Contenidos

Tabla de Contenidos. Tabla de Contenidos.........................................................................................................................3 1. Introduccin .................................................................................................................................4 2. Los Objetos HP. ...........................................................................................................................5 2.1. Nmeros Reales y Complejos: ..............................................................................................5 2.2. Secuencia de Caracteres: .......................................................................................................5 2.3. Sistema Real y Complejo: .....................................................................................................5 2.4. Listas: ....................................................................................................................................6 2.4. Nombre Global y Local:........................................................................................................6 2.5. Programa: ..............................................................................................................................6 2.6. Objeto Algebraico: ................................................................................................................6 2.7. Entero Binario: ......................................................................................................................6 2.8. Objeto de Grficos: ...............................................................................................................7 2.9. Objeto Etiquetado:.................................................................................................................7 3. Variables Locales y Globales. ......................................................................................................9 3.1. Variables Globales: ...............................................................................................................9 3.2. Variables Locales: .................................................................................................................9 4. Estructuras de Control Condicionales ........................................................................................11 4.1. IF ... THEN ... END ............................................................................................................11 4.2. IF ... THEN ... ELSE ... END..............................................................................................11 4.3. CASE ... END .....................................................................................................................12 4.4. Ejemplos de Condiciones:...................................................................................................12 4.5. IFERR ... THEN ... END, IFERR ... THEN ... ELSE ... END............................................13 5. Estructuras de Control de Bucle.................................................................................................14 5.1. START ... NEXT, START ... STEP....................................................................................14 5.2. FOR ... NEXT, FOR ... STEP .............................................................................................15 5.3. DO ... UNTIL ... END.........................................................................................................16 5.4. WHILE ... REPEAT ... END...............................................................................................17 6. Trabajando con Ecuaciones........................................................................................................19 7. Trabajando con Matrices. ...........................................................................................................21 8. Trabajando con Listas. ...............................................................................................................23 9. Trabajando con Cadenas ............................................................................................................24 10. Trabajando con Grficos. .........................................................................................................25 11. Depuracin de Programas. .......................................................................................................26

Curso de Programacin de User RPL

Introduccin

1. Introduccin El curso de programacin en las calculadora HP est orientado sobre todo a aquellos que programan en User RPL, est basado en la experiencia que tengo programando en esta calculadora. La explicaciones que presento en cada captulo son complementadas con ejemplos prcticos para su mejor entendimiento. An me faltan concluir algunos captulos, pero muy pronto los tendr listos. Si deseas una versin del curso en formato ZIP, escrbeme rgbinnet@hotmail.com y te lo enviar para que puedas leerlo sin estar conectado a Internet.

Curso de Programacin de User RPL

Los Objetos HP

2. Los Objetos HP. La calculadora HP es una herramienta de trabajo muy poderosa y de uso variado y flexible que la convierte en un instrumento fundamental a la hora de realizar grandes tareas. La programacin constituye una pieza fundamental para lograr sacarle el mximo provecho a la calculadora. Pues ste es el objetivo de este curso de programacin, que puedas aprender a utilizar tu HP y facilitar tu trabajo. Un programa es en general una secuencia de comandos, es decir todo el proceso para resolver determinado problema paso a paso lgicamente. El primer paso para iniciarse en la programacin es conocer adecuadamente los objetos con los que puedes trabajar en la calculadora, ya que la variedad y la flexibilidad de estos nos servir para elegir de manera adecuada el mtodo de trabajo al realizar determinado programa. Los objetos con los que trabaja la HP son bastante potentes, hablamos por ejemplo de las listas que tienen una gran variedad de usos. Pasemos a ver entonces un poco acerca de los objetos HP, no los vamos a ver en gran detalle ya que para ello tienes tu manual de usuario. 2.1. Nmeros Reales y Complejos: Creo que aqu no hay mucho que explicar, pienso que los conoces bastante, excepto que los nmeros complejos pueden ser usados como coordenadas ya sean cartesianas o polares y que muchas de las funciones utilizan este tipo de objetos como argumentos que requieren coordenadas (sobre todo las funciones grficas). Ejemplo:
(5,8) -> esto sera coordenada X=5, Y=8. el complejo 5+8i, pero tambin puede ser la

2.2. Secuencia de Caracteres: Las secuencias de caracteres son bastante flexibles y su uso se da generalmente para describir pasos en los programas, la flexibilidad de estos nos permitir por ejemplo guiar al usuario en la introduccin de datos. Ejemplo:
"INGRESE EL DATO N 1", ahora ustedes se preguntaran como hago para obtener el dato 2, pues nada ms hay que sumar el nmero como veremos ms adelante; no es recomendable pero funciona.

2.3. Sistema Real y Complejo: Son las matrices y aunque en la HP48 no son tan flexibles como en la HP49, nos servirn de mucha utilidad al momento de programar. Ejemplo:
[ [ 1 2 ] [ 3 4 ] ]

Curso de Programacin de User RPL

Los Objetos HP

2.4. Listas: Las listas son a mi parecer el objeto mejor elaborado de la HP, su flexibilidad y facilidad de uso la convertir en el objeto con el que posiblemente siempre tengamos que trabajar ya que tiene la capacidad de almacenar todos los objetos de la HP incluidas las listas. Tambin son usadas para representar coordenadas con la funciones grficas. Ejemplo:
{ 1 "HOLA" [ 1 2 3 ] { (1,2) } }

2.4. Nombre Global y Local: En este caso estamos hablando de las variables, en el curso me referir a los nombres globales y locales como variables. Son usados para representar con nombres a los objetos de la HP, debemos tener en cuenta que hay ciertas reglas para usar estos nombres como por ejemplo, que no pueden contener caracteres especiales o no pueden usarse comandos, etc. (Ver su manual de usuario). Ejemplo: los nombres de objetos que tienes almacenado en tu HP, como programas, directorios, listas, ecuaciones son ejemplos de nombres globales, los nombre locales se usan dentro de los programas. 2.5. Programa: Pues estos son los objetos que harn el trabajo pesado. Los programas tambin pueden usarse como funciones dentro de las ecuaciones, ya que son capaces de recoger y devolver argumentos. Y aqu empezaremos el curso con el ejemplo ms comn:
<< "HOLA MUNDO" >>

2.6. Objeto Algebraico: Son las ecuaciones y son de uso regular dentro de los programas. Ejemplo:
'X+Y'

2.7. Entero Binario: Son nmeros especiales en la HP, ya que poseen caractersticas que no se pueden ejecutar con los nmeros reales como por ejemplo el cambio de bases numricas, desplazamiento de bits, etc. Tambin son usados por las funciones grficas junto con las listas para representar coordenadas. Ejemplo:
# 2d (nmero decimal), # 45FDh (nmero hexadecimal), { # 4d # 6d } (Coordenadas).

Curso de Programacin de User RPL

Los Objetos HP

2.8. Objeto de Grficos: El uso de los grficos se da sobre todo en la graficacin de funciones, para la representacin de datos y los infaltables juegos. 2.9. Objeto Etiquetado: Son usados para representar un objeto con su descripcin. Al usar la calculadora se dan cuenta por ejemplo al resolver ecuaciones hay resultados que se devuelven a la pila con un texto descriptivo, pues esos son los objetos etiquetados. Un aspecto muy importante a tener en cuenta es que al momento de realizar operaciones con objetos etiquetados es que estos siguen manteniendo su valor de objeto primario, es decir si tengo dos nmeros reales debidamente etiquetados y deseo sumarlos lo puedo hacer sin necesidad de quitar la etiqueta de los objetos y obtendr como resultado la suma de los dos nmeros reales. Ejemplo:
:BASE: 4, :ALTURA: 5, si los sumo obtendr 9.

Seguidamente vamos a plantear algunas convenciones para distinguir sobre todo los delimitadores y algunos smbolos que voy a usar en el curso:
<< >>:

son los delimitadores de un programa, ojo en la HP no son dos signos de mayor (>) o menor (<). son la flechitas de algunos comandos como ->OBJ el objeto encargado de recoger variables locales.

->:

Otro aspecto a tomar en cuenta dentro de la programacin es el de trabajar de manera ordenada y repartir el trabajo (recuerda: "DIVIDE Y VENCERAS"). Si se trata de proyectos grandes es mejor dividir el programa en varios mdulos que te permitan editar y depurar tus programas con facilidad. Por ejemplo para proyectos grandes puedes crear un directorio donde almacenes todo el programa. Con el que tendras el siguiente esquema.
DIRECTORIO |- PROGRAMA PRINCIPAL |- MODULO 1 |- MODULO 2 |- MODULO 3 |- ...

En muchos casos recomiendo el evitar el uso de ecuaciones dentro de los programas amenos que sean necesarios ya que son lentas, ocupan mucho ms espacio y demora su edicin. La HP utiliza lo que se denomina como notacin polaca inversa (RPN: Reverse Polish Notation), que requiere primero los argumentos y despus la funcin para realizar sus operaciones y si te acostumbras a trabajar de esta manera vers lo sencillo que resulta programar y si te resulta un tanto dificultoso puedes hacerlo mediante ecuaciones aunque no en todos los casos es posible. Veamos el siguiente ejemplo:

Curso de Programacin de User RPL

Los Objetos HP

<< 1 'A' STO 2 'B' STO 3 'C' STO 'A^2+B^2+C^2+2*A*B*C' ->NUM >>

Esto se vera de la siguiente manera sin utilizar ecuaciones:

<< 1 'A' STO 2 'B' STO 3 'C' STO A 2 ^ B 2 ^ + C 2 ^ + 2 A * B * C * + >>

Comprueba ambos casos y ahora te toca a ti definir tu mtodo de trabajo.

Curso de Programacin de User RPL

Variables Locales y Globales

3. Variables Locales y Globales. 3.1. Variables Globales: Como ya habamos mencionado en el captulo anterior la variables globales son todos los objetos que tienes almacenados en tu HP y las que se van a crear de manera permanente por medio de los programas. Su uso dentro de los programas representa una desventaja ya que aparte de ser ms lentas, si deseas crearlas tienes que hacer uso del comando STO y para borrarlas necesitas del comando PURGE. En la mayora de casos no vas a tener necesidad de crear variables globales, ya que solo las utilizars temporalmente y es aqu donde entran las variables locales. Pero veamos un ejemplo del uso de variables globales. Ejemplo:
<< 6 'X' STO 8 'Y' STO 'X^2+Y^2' EVAL >>

al ejecutar el programa notaremos que han aparecido dos nuevas variables en el directorio actual. Si queremos que las variables no aparezcan tendramos que hacer lo siguiente:
<< 6 'X' STO 8 'Y' STO 'X^2+Y^2' EVAL 'X' PURGE 'Y' PURGE >>

Uno de los aspectos que siempre me ha preocupado es la optimizacin, entonces si se han fijado en el programa anterior estoy usando el comando PURGE 2 veces cuando podra haber hecho lo siguiente:
<< 6 'X' STO 8 'Y' STO 'X^2+Y^2' EVAL { X Y } PURGE >>

Cdigo con el que me ahorrado algunos bytes, he hecho el programa ms legible y ms rpido. Para algunos no puede significar mucho, pero si sumas esas milsimas de segundo en una iteracin los resultados seran obvios. Adems debemos tener en cuenta que hay muchos comandos como PURGE que aceptan argumentos individuales o grupales como listas. 3.2. Variables Locales: Las variables locales son aquellas variables temporales dentro de los programas, es decir solo estn presentes en la ejecucin de los programas y sern las variables con las que vamos a trabajar frecuentemente. Existen ciertos pasos para crear variables locales, los que pasamos a describir a continuacin:
<< -> A B C << (secuencias del programa) >> >>

Como se puede apreciar en el ejemplo, esa es la secuencia para crear variables locales. El comando (->) es el encargado de recoger 3 valores de la pila y almacenarlos en las variables definidas; en este caso el nivel 3 se almacenar en A, el nivel 2 en B y el nivel 1 en C.

Curso de Programacin de User RPL

Variables Locales y Globales

Seguidamente se ha iniciado otro programa subprograma, esto se har generalmente cuando se tengan programas complejos cuya secuencia de comandos sea mucho ms extensa. Debemos aclarar que estas variables solo se pueden usar dentro de este subprograma y que no existen en otros entornos o subprogramas. Si por ejemplo tenemos la necesidad de crear una funcin tendramos lo siguiente:
<< -> A B C '(A+B)/C' >>

Ntese que no es necesario evaluar la ecuacin ya que esta se evaluar inmediatamente despus de recoger los argumentos. Esta sera una forma de elaborar funciones para utilizarlas dentro de otras ecuaciones. Claro que las funciones tambin podran ser mucho ms complejas y simplemente debemos de hacer que el programa retorne un valor o valores. En el caso de las variables locales no es necesario el proceso de eliminacin ya que estas son desechadas una vez terminado el programa. Adems para los nombre puedes utilizar cualquier carcter como los caracteres del alfabeto griego, algunos smbolos y nmeros, siguiendo siempre la convencin para nombres de la HP. Puedes utilizar un nombre lo suficientemente descriptivo para tus variables, pero recuerda que cuanto ms largos sean ocupan ms espacio dentro de los programas. Adems de este tipo de variables locales existen lo que se denomina como variables locales compiladas. Su uso depende de la necesidad y requerimientos de programacin, pero por lo general no sern necesarias. Las variables locales compiladas vienen a ser variables que no slo estn existen dentro de un subprograma sino dentro de otro mdulo que se ejecute bajo el programa principal. Veamos el ejemplo.
<< -> A <-B << FUN1 A * A >> >>

En el ejemplo estamos recogiendo dos valores, una en A que es una variable local y otra en B que es una variable local compilada. Como se habr notado la variable B posee un smbolo (<-) que lo precede y es la manera como se le har referencia en otros subprogramas. Dentro del programa se hace referencia al subprograma FUN1, la definicin de este sera:
<< 2 <-B ^ <-B / >>

Ntese que no hay necesidad de crear la variable B pues esta es visible desde el programa que lo llam. Cabe recalcar adems que si ejecutas slo la funcin FUN1, sin llamarlo desde ningn programa recibirs el error "Undefined Local Name" ya que no existe ninguna instancia programa que haya creado la variable.

10

Curso de Programacin de User RPL

Estructuras de Control Condicionales

4. Estructuras de Control Condicionales Las estructuras de control condicionales permiten que el programa tome una decisin en el transcurso de su ejecucin, las estructuras de las que dispone la HP son: 4.1. IF ... THEN ... END Usado para realizar determinadas acciones si se cumple una condicin. Sintaxis:
<< (secuencias del programa) IF (condicin) THEN (secuencias a ejecutar si se cumple la condicin) END (secuencias del programa) >>

ejemplo:
<< -> A << IF 'A>0' THEN "NUMERO POSITIVO" END >> >>

El programa tomar un valor (variable local A), comprueba que el nmero sea mayor que 0, si lo es entonces devolver un mensaje, si no lo es no devolver ningn valor. Debemos notar que la condicin puede ser algebraica o en RPN, las condiciones algebraicas sern evaluadas por la estructura, as que no ser necesario evaluarlas. 4.2. IF ... THEN ... ELSE ... END Usado para realizar determinadas acciones si se cumple una condicin, adems de poseer la estructura correspondiente si no se cumple la condicin. Sintaxis:
<< (secuencias del programa) IF (condicin) THEN (secuencias a ejecutar si se cumple la condicin) ELSE (secuencias a ejecutar si no se cumple la condicin) END (secuencias del programa) >>

ejemplo:
<< -> A << IF 'A>0' THEN "NUMERO POSITIVO"

11

Curso de Programacin de User RPL

Estructuras de Control Condicionales

ELSE "NUMERO NEGATIVO" END >> >>

El programa tomar un valor (variable local A), comprueba que el nmero sea mayor que 0, en cualquier caso devolver mensajes de acuerdo al nmero introducido. 4.3. CASE ... END Usado para realizar determinadas acciones si se cumplen una serie de condiciones, su uso es alternativo a los IFs anidados. Sintaxis:
<< (secuencias del programa) CASE (condicin 1) THEN (secuencias a ejecutar si se cumple la condicin) END (condicin 2) THEN (secuencias a ejecutar si se cumple la condicin) END (secuencias a ejecutar por defecto) END >>

ejemplo:
<< -> A << CASE A 0 > THEN "NUMERO POSITIVO" END A 0 < THEN "NUMERO NEGATIVO" END "CERO" END >> >>

El programa tomar un valor (variable local A), comprueba que el nmero sea mayor que 0 y devuelve un mensaje positivo, si no lo es comprueba que sea menor que cero y devuelve un mensaje negativo, si no ninguno de los dos casos devolver el mensaje cero. 4.4. Ejemplos de Condiciones: Pero las condiciones no solo puedes ser de este tipo, la HP dispone de una infinidad de maneras para realizar comprobaciones segn el caso en el que nos encontremos. Podemos hacer uso por ejemplo de los operadores lgicos, del tipo de objeto, los FLAGS banderas de usuario y del sistema, el sistema dispone de 64 banderas (-1 ... -64) as como las del usuario (1 ... 64); en la HP49 estas banderas han sido ampliadas al doble. Aqu van algunos

12

Curso de Programacin de User RPL

Estructuras de Control Condicionales

ejemplos: RPN
A 0 > B 0 > AND 5 FS? B 8 > X 5 == Y 10 == OR 1 FC? V TYPE 4 == C "NAME" SAME

Algebraico
'A>0 AND B>0' 'B>8' 'X==5 OR Y==10'

4.5. IFERR ... THEN ... END, IFERR ... THEN ... ELSE ... END Estas estructuras se usan para la deteccin de errores, es decir para controlar tu los errores y no salgan los mensajes de la calculadora, puede ser muy til, pero este proceso es muy lento, yo lo uso para capturar la tecla [cancel]. La sintaxis y las comprobaciones son iguales que para los casos anteriores. Ejemplo:
<< IFERR "DIRECTORIOS:" 15 TVARS 1 CHOOSE THEN 3 DROPN ELSE DROP EVAL END >>

El programa de ejemplo muestra los directorios en la ruta actual, pero ocurrir un error si no existen directorios, en tal caso borramos los argumentos y no se muestra nada, pero si existen mostrar los directorios en un cuadro de eleccin en donde si seleccionas alguno te cambiars a ese directorio.

13

Curso de Programacin de User RPL

Estructuras de control de Bucle

5. Estructuras de Control de Bucle. Las estructuras de control de bucle nos servirn para realizar las iteraciones, la HP dispone de estructuras variadas en este aspecto que nos ayudarn para que nuestro trabajo sea mucho mas fcil. 5.1. START ... NEXT, START ... STEP Esta estructura nos servir para realizar un nmero determinado de iteraciones fijas sin ser controladas por ninguna variable, muy til cuando sepas cuantas iteraciones vas a realizar y no requieras de la variable de control. Sintaxis:
<< (secuencias del programa) Inicio Fin START (secuencias del programa) NEXT (secuencias del programa) >>

La estructura requiere de un nmero inicial y final para comenzar a iterar, START inicia la iteracin, NEXT realiza la comprobacin y continua finaliza la iteracin, el contador para las iteraciones se incrementa en 1. La estructura START... STEP es similar, la nica diferencia es que antes de la palabra STEP debemos colocar el valor en el que deseamos incrementar el contador, en el caso de la estructura anterior es 1, pero muchas veces queremos incrementos de 2, 3, etc, o tambin decrementos, en este caso de -1, -2, etc. Ejemplo:
<< -> obj n << 1 n START obj NEXT >> >>

Podramos llamar al ejemplo 'COPY', lo que hace es tomar un objeto cualquiera de la pila y el nmero de copias a realizar, inicia el contador en 1 y continuar hasta el numero de copias, por cada iteracin va devolviendo a la pila una copia del objeto. Veamos un ejemplo con la otra estructura. Ejemplo:
<< 0 -> cad n << cad SIZE 'n' STO "" n 1 START "*" + -1 STEP cad XOR

14

Curso de Programacin de User RPL

Estructuras de control de Bucle

>> >>

Lo que realiza el programa es codificar una cadena cualquiera. Y aqu introducimos otro concepto interesante, no siempre vamos a trabajar con los argumentos que recoge un programa sino que necesitaremos de otras variables y lo que hacemos en el ejemplo es inicializar 'n' en 0, esta es la manera de crear variables que el programa usar internamente. Adems estamos utilizando la estructura START ... STEP, como habrn notado antes de la instruccin STEP hay un -1, ya que la iteracin ser desde n hasta 1, lo que hacemos es decrementar. Sera ms prctico usar la estructura START NEXT, pero es valido para el ejemplo. 5.2. FOR ... NEXT, FOR ... STEP Estas estructuras son idnticas a las anteriores, con la diferencia que estas poseen un contador. En realidad son las estructuras ms utilizadas ya que poseen la mayora de las caractersticas para poder programar. Sintaxis:
<< (secuencias del programa) Inicio Fin FOR Contador (secuencias del programa) NEXT (secuencias del programa) >>

La estructura requiere de un nmero inicial y final para comenzar a iterar, FOR inicia la iteracin, se declara una variable contador y NEXT realiza la comprobacin y continua finaliza la iteracin, por defecto el contador para las iteraciones se incrementa en 1, si deseas decrementos u otros incrementos debes de utilizar STEP, en cuyo caso debemos colocar los incrementos antes de esta instruccin. Ejemplo:
<< -> n << {} 1 n FOR i i + NEXT >> >>

El ejemplo toma un valor n, devolver una lista con valores desde 1 hasta n. Aqu podemos notar algo bastante interesante, que es la posibilidad de adicionar elementos a una lista con solo sumarle el elemento. Existen una serie de comandos de la HP que funcionan de esta manera. Ojo que con las cadenas y otras listas esta operacin tienes diferentes resultados. Puedes probar esto por ti mismo. Ejemplo:
<< 0 -> lista n << lista SIZE 'n' STO {} n 1 FOR i

15

Curso de Programacin de User RPL

Estructuras de control de Bucle

lista i GET + -1 STEP >> >>

En este ejemplo hacemos lo que el REVLIST. Obsrvese que estos utilizando para los nombres de variables locales las minsculas, esta puede ser una buena opcin a la hora de programar ya que te permite hacer un distingo entre las variables que utilizas y los comandos. 5.3. DO ... UNTIL ... END. Esta es otra estructura iterativa, la diferencia con las anteriores es que requiere de una condicin para finalizar. Sintaxis:
<< (secuencias del programa) DO (secuencias del programa) UNTIL Condicin END (secuencias del programa) >>

La estructura se inicia con DO, luego vienen las secuencias a ejecutar. La palabra UNTIL determina el fin de las secuencias y END se encarga de realizar la comprobacin que determinar el fin o repeticin del bucle. Las condiciones son las mismas que para las estructuras IF. Debemos aclarar tambin que la iteracin siempre se lleva a cabo por lo menos una vez, que es un poco el propsito de esta estructura. Ejemplo:
<< 10 RAND * IP 0 -> r n << DO "ADIVINA EL NUMERO MAGICO" "" INPUT OBJ-> 'n' STO n r > "MAS BAJO...!!!" n r < "MAS ALTO...!!!" "ACERTASTE!" IFTE IFTE MSGBOX UNTIL r n == END >> >>

Muy bien, ya vamos avanzando, aqu est un ejemplo mucho mas complejo, pero no se asusten lo voy a explicar. En primer lugar creamos una variable aleatoria 'r' e inicializamos 'n' con cero; iniciamos el bucle y pedimos al usuario que adivine el nmero y lo almacenamos en 'n', seguidamente hacemos la comprobacin si es mayor que 'r' y el mensaje correspondiente. Comprobamos si es mayor que 'r' y colocamos el mensaje correspondiente y finalmente el mensaje si acert, ejecutamos el comando IFTE dos veces ya que hay dos comprobaciones y mostramos el mensaje. Comprobamos que acert y finalizamos el bucle.

16

Curso de Programacin de User RPL

Estructuras de control de Bucle

El uso de IFT IFTE frente a las estructuras IF es aconsejable cuando vas a evaluar pequeas secuencias como por ejemplo elegir entre dos ecuaciones ya que te vas a ahorrar un montn de bytes aunque el programa se te hace poco legible. Te recomiendo que ejecutes el programa paso a paso, as podrs darte cuenta mejor de lo que hace y modifcalo utilizando las estructuras IF ... THEN ... ELSE ... END CASE ... END. Ejemplo: USANDO IF ... THEN ... ELSE ... END
<< -> a b << IF 'a>b' THEN '(a-b)/2' ELSE '(b-a)/2' END ->NUM >> >>

USANDO IFTE
<< -> a b << a b > '(a-b)/2' '(b-a)/2' IFTE >> >>

En el primer caso comprobamos si a es mayor que b y devolvemos una ecuacin para el caso verdadero y otra para el caso contrario y la evaluamos. Aqu tambin una recomendacin importante: vean que estoy ejecutando ->NUM al final de la estructura y no despus de cada ecuacin, con este tipo de acciones me estoy ahorrando velocidad y bytes ya que se que en cualquier caso me devolver una ecuacin no veo la necesidad de evaluar las ecuaciones de forma separada. En el segundo caso el comando IFTE requiere de tres argumentos: la condicin, la operacin si la condicin es verdadera y la operacin si la condicin es falsa, fjense que no es necesario evaluar los algebraicos, IFTE se encargar de eso. El comando IFTE es muy til sobre todo si lo quieres incluir dentro de una ecuacin, lo que me lleva al siguiente ejemplo donde podrs observar todo lo que se puede hacer con la calculadora y que hace lo mismo que el ejemplo anterior:
<< -> a b 'IFTE(a>b,(a-b)/2,(b-a)/2)' >>

5.4. WHILE ... REPEAT ... END. Esta es otra estructura iterativa, la diferencia con la anterior es que requiere de una condicin para finalizar y no se ejecuta nunca si la condicin de prueba es falsa. Sintaxis:
<< (secuencias del programa) WHILE Condicin REPEAT (secuencias del programa) END (secuencias del programa) >>

La estructura se inicia con WHILE, La palabra REPEAT que determina si se ejecutar el bucle. La palabra END determina el fin de las secuencias a ejecutar. Esta estructura es muy til si no quieres que el bucle se realice ni siquiera una vez si no se cumple la condicin. Ejemplo:

17

Curso de Programacin de User RPL

Estructuras de control de Bucle

<< 0 -> a b c << WHILE a b MOD REPEAT a b MOD 'c' STO b 'a' STO c 'b' STO END b >> >>

El programa calcula el MCD (Mximo Comn Divisor) de 'a' y 'b'.

18

Curso de Programacin de User RPL

Trabajando con Ecuaciones

6. Trabajando con Ecuaciones. El trabajo en la HP con las ecuaciones es bastante lento pero no hay otra forma de hacerlo as que manos a la obra. La HP dispone de muchas maneras para crear, evaluar ecuaciones algebraicos, pero no vamos a estudiar eso, porque eso lo pueden encontrar en su manual. Vamos directamente a los ejemplos: Ejemplo 1:
<< -> x << 'F(X)=EXP(X)-2' DEFINE { } 1 x FOR i i F + NEXT 'F' PURGE >> >>

El programa consiste en un evaluador de una funcin para ciertos valores, en este caso desde el nmero 1 hasta 'x'. La idea del ejemplo es demostrar como se crean las funciones mediante un programa y eliminarla cuando ste termina; muy til en aplicaciones de mtodos numricos ya que tienes la posibilidad de que el usuario ingrese la ecuacin y crear la funcin con diferentes ecuaciones. En este caso se devolver una lista con los valores de la funcin para cada argumento. Si analizas esto en la pila vers que la funcin F, no es ms que un programa. Aclaro que no es la nica forma, ya que podras evaluar las expresiones algebraicas con el comando (|), pero el proceso se hara ms lento ya que tendras que recuperar las ecuaciones por cada iteracin. Ejemplo 2:
<< -> x << { } 1 x FOR i '2^X-X^2' { X i } | + NEXT >> >>

En este caso se recomienda realizar las operaciones de pila: Ejemplo 2:

<< -> x << { } 1 x FOR i 2 i ^ X 2 ^ - + NEXT >> >>

19

Curso de Programacin de User RPL

Trabajando con Ecuaciones

Importante: 1. En general recomiendo las operaciones de pila utilizar por ejemplo OVER, DROP, ROT, DUP ya que son funciones rpidas (por lo menos para User RPL) y tus programas sern mucho ms pequeos. 2. Si se trata de sumatorias utilicen las funciones de la HP, no utilicen FOR ... NEXT algo por el estilo y vern que les resulta ms provechoso. 3. Los programas pueden utilizarse como funciones propias de la calculadora y dentro de las ecuaciones expresiones algebraicas, lo que deben de hacer estos es devolver algn valor valores para efectuar las operaciones. 4. Vuelvo a recalcar que algunos comandos de la HP, evalan directamente las expresiones algebraicas como por ejemplo el IF ... THEN ... END, IFT, IFTE, as que no es necesario evaluarlas. 5. Pueden usarse expresiones para obtener datos de matrices sin que estas sean evaluadas. Veremos con ms detalle este aspecto en el captulo correspondiente a Matrices.

20

Curso de Programacin de User RPL

Trabajando con Matrices

7. Trabajando con Matrices. Para muchos usuarios el trabajo con las matrices representa un dolor de cabeza, pero si empleas las tcnicas adecuadas vers que no es tan difcil. Ejemplo 1:
<< 0 0 -> mat m n << mat SIZE EVAL { m n } STO 1 m FOR i 1 n FOR j mat { i j } GET NEXT NEXT >> >>

En este sencillo ejemplo lo que hacemos es devolver todos los valores de la matriz a la pila. Los pasos son sencillos: obtenemos la matriz, calculamos el tamao con el comando SIZE. En este punto debemos saber que este comando es muy funcional ya que puede calcular el tamao de listas, matrices, cadenas, grficos, etc. Para nuestro caso devolver en una lista el nmero de filas y el nmero de columnas y las almacenamos en las respectivas variables. Ntese tambin la manera de almacenar estas variables, es una manera muy prctica de almacenar varias variables. Luego vamos a un bucle para las filas 'i' y el bucle interno para las columnas 'j' y con el comando GET obtenemos el nmero de la fila columna { i j }. El comando GET tambin trabaja con expresiones algebraicas, de hecho i j son expresiones algebraicas. podemos ver entonces algo como esto: Ejemplo 2:
<< ... mat { 'i+1' 'j-1' } GET ... >>

Para introducir valores en la matriz haremos uso del comando PUT, veamos el ejemplo: Ejemplo 3:
<< 0 0 -> mat << mat SIZE 1 m FOR i 1 n FOR j IF 'i THEN mat { END NEXT NEXT mat >> >> m n EVAL { m n } STO

== j' i j } 1 PUT 'mat' STO

21

Curso de Programacin de User RPL

Trabajando con Matrices

En este ejemplo reemplazamos la diagonal de una matriz por unos. Pero el programa pudo haber sido optimizado de la siguiente forma: Ejemplo 3:
<< 0 0 -> mat << mat SIZE 1 m FOR i 1 n FOR j IF 'i THEN 'mat' END NEXT NEXT mat >> >> m n EVAL { m n } STO

== j' { i j } 1 PUT

El comando PUT dispone de la capacidad de trabajar sobre variables que contienen matrices y en este caso ya no hay necesidad de escribir nuevamente la matriz. Adems que la operacin se llevar a cabo de una manera mucho ms rpida. Existen muchas funciones para trabajar con matrices como por ejemplo REPL, SUB, que te permiten reemplazar y extraer respectivamente partes de una matriz y que son de gran ayuda a la hora de programar. Tambin una matriz puede ser usada dentro de expresiones algebraicas por ejemplo en operaciones de sumatorias en donde los datos fila y columna seran los argumentos de la variable que contiene la matriz, algo as como una especie de funcin: Ejemplo 4:
'mat(2,5)'

Los valores de los argumentos en este caso pueden ser reemplazados por variables, adems pueden ser usados con el comando STO, que trabaja directamente sobre la matriz y realiza las veces del comando PUT y con EVAL que realizara las veces del comando GET.

22

Curso de Programacin de User RPL

Trabajando co Listas

8. Trabajando con Listas. Las listas vienen a ser un arma muy poderosa a la hora de programar, una de las ventajas de usar listas es que stas pueden contener otros objetos, al igual que con las matrices puedes insertar, eliminar, cambiar elementos y una opcin muy importante es la de ejecutar un programa sobre elementos de la lista. Al aplicar un comando sobre listas muchos de ellos se ejecutan sobre la lista y otras actan sobre cada elemento de la lista. Puede resultar entonces muy prctico realizar operaciones sobre la lista que hacerlo sobre cada elemento: Ejemplo 1:
ejecutando { 4 2 } SQ otros comandos. obtendremos { 16 4 }y funciona igual con muchos

Ejemplo 2:
ejecutando { 1 2 } { 3 4 } + obtendremos { 1 2 3 4 }

Como se puede observar se ha aadido la lista 2 a la lista 1, en el caso de que queramos sumar los elementos tendremos que utilizar el comando especial ADD y no +. Adems las listas disponen de funciones relacionadas solo con operaciones de listas con lo que podramos hacer por ejemplo una extensin del comando MAX: Ejemplo 3:
<< SORT REVLIST HEAD >>

El programa requerir una lista en el nivel 1 devolver el nmero mximo de la lista. Supongamos ahora que queremos convertir cada uno de los elementos de una lista en cadenas tendramos que realizar un bucle, pero existe una forma ms prctica: Ejemplo 4:
<< 1 << ->STR >> DOSUBS >>

Ntese que el subprograma no recoge ninguna variable y por lo mismo no se ejecutar sino se devolver a la pila. El comando DOSUBS necesita como argumentos el nmero de elementos sobre los que se ejecutar el programa que es el segundo argumento de DOSUBS. Con este tipo de comandos puedes crear algoritmos mucho ms complejos y que te permitan realizar tus programas de manera ms eficaz.

23

Curso de Programacin de User RPL

Trabajando con Cadenas

9. Trabajando con Cadenas El trabajo con cadenas es similar a lo que se realiza con las listas, por supuesto no tiene la potencia de estas pero para realizar buenas presentaciones la HP dispone de las herramientas adecuadas. Ejemplo 1:
<< 1 -> C x << C C SIZE 21 START " " + NEXT DUP + 'C' STO CLLCD DO C x x 21 + SUB 4 DISP .5 WAIT IF x 22 == THEN 1 'x' STO ELSE 1 'x' STO+ END UNTIL KEY 0 <> END DROP >> >>

Una nota antes de explicar el programa, el smbolo <> (diferente) debe ser reemplazado por su correspondiente de la HP. El ejemplo es bastante completo y se demuestra el uso de las estructuras aprendidas a lo largo del curso. El programa necesita como argumento una cadena, la cual har rotar por toda la pantalla, para ello realiza operaciones de relleno con espacios y un bucle que se encarga de obtener una porcin de la cadena y hacerla rotar. Tambin se incluye un mtodo para obtener la pulsacin del teclado y detener el programa. Existen adems otros comandos para poder trabajar con cadenas como modificarlas, visualizarlas, etc.

24

Curso de Programacin de User RPL

Trabajando con Grficos

10. Trabajando con Grficos. Los grficos son muy importantes a la hora de programar y la HP nos brinda la oportunidad de realizar programas interesantes. Uno de los aspectos a tocar es la grfica de funciones datos. Mediante la programacin y el manejo de las variables del sistema como PPAR podemos graficar funciones del tipo y escala que nosotros queramos. La HP nos brinda un gran nmero de comandos para realizar estas funciones y obtener buenos resultados. Tambin podemos crear presentaciones que no tengan que ver con grfica de funciones datos y para esto slo debemos trabajar sobre la variable del sistema PICT sobre grficos creados por nosotros mismos. Estos comandos estn disponibles en los grupos GROB y PICT de men PRG. Para trabajar con grficos es necesario tener una idea sobre las coordenadas de pantalla sea cual sea el modo en el que trabajemos. Las coordenadas se pueden representar de dos maneras:
(5,8) { # 11 # 30 }

Por ejemplo si queremos dibujar una lnea haramos lo siguiente:

{ # 11 # 30 } { # 60 # 100 } LINE

Las operaciones de este tipo se realizan sobre PICT y para visualizarlas debes utilizar PVIEW detener las operaciones con el teclado, lo que vimos en el captulo anterior. Las operaciones como REPL y SUB tambin son aplicables a los grficos y puedes hacer cosas interesantes con ellos. Tambin en el grupo GROB puedes encontrar comandos como GXOR que te permitirn crear efectos en los grficos. Puedes crear grficos de textos y en general de cualquier objeto, recuperar la pantalla actual, etc. Todos estos comandos estn explicados en el manual de usuario.

25

Curso de Programacin de User RPL

Depuracin de Programas

11. Depuracin de Programas. Al terminar un programa este no siempre te funciona y hallar el error representa una tarea tediosas. La HP dispone de la capacidad de depurar de los programas, basado en las operaciones de pila. Para depurar un programa debes de ir al grupo [RUN] del men [PRG] ingresa el nombre del programa a depurar en el nivel 1 de la pila y ejecuta DEBUG lo cual inicializar el programa. Para ir por el programa paso a paso ejecuta SST; si el programa necesita argumentos estos deben ser introducidos en la pila antes de ejecutar este comando. Hay otra funcin anloga que es SST!, la diferencia con el anterior es que ste comando tambin depurar los subprogramas que se encuentran dentro del programa principal. Para detener la depuracin en cualquier momento puedes utilizar KILL. Pero no necesariamente puedes realizar de esta manera la depuracin. Puedes detener la ejecucin de tu programa colocando la instruccin HALT en la posicin que consideres dentro de tu programa. Al ejecutarse tu programa y llegar a sta instruccin ste se detendr y podrs hacer el seguimiento como en el caso anterior. Hemos llegado al fin del curso y espero que lo hayan disfrutado y les haya sido de utilidad. Este texto es propiedad intelectual Roger Broncano Reyes y no puede ser utilizado ni modificado sin su permiso expreso. rgbinnet@hotmail.com http://hpuser.8m.com

HPUSER

26