Baixe Tutorial de Programación HP User RPL en Modo Algebraico v1.2 e outras Notas de estudo em PDF para Introdução à Programação de Computadores, somente na Docsity! TUTORIAL DE PROGRAMACIÓN HP USER APL EN MODO ALGEBRAIGO Versión 1.2 Por David Emique Torres 2 ÍNDICE INTRODUCCIÓN.................................................3 ENTRADA......................................................4 INPUT......................................................4 INFORM.....................................................5 CHOOSE.....................................................7 WAIT.......................................................8 SALIDA.......................................................8 TEXT......................................................10 CLLCD.....................................................10 DISP......................................................10 MSGBOX....................................................11 →TAG......................................................12 COMPARACIONES...............................................12 AND.......................................................12 OR........................................................12 XOR.......................................................12 NOT.......................................................13 SAME......................................................13 TYPE......................................................13 SF........................................................13 CF........................................................13 FS? y FC?.................................................13 BIFURCACIONES E ITERACIONES.................................13 IF – THEN – ELSE..........................................13 IFT e IFTE................................................15 FOR – NEXT................................................15 FOR – STEP................................................15 START – NEXT y START – STEP...............................16 DO – UNTIL................................................16 WHILE – REPEAT............................................17 CASE......................................................17 SEQ.......................................................18 EDICIÓN DE PROGRAMAS........................................18 PROGRAMAS MISCELÁNEOS.......................................18 MATEMÁTICA................................................18 MÉTODOS NUMÉRICOS o ANÁLISIS NUMÉRICO.....................18 ELECTRO...................................................22 ECONOMÍA..................................................25 5 Las variables se deben escribir como objetos etiquetados (con dos puntos a la izq. y dos puntos a la der.). La lista {1,0} indica que se posicionará el cursor inicialmente en la primera variable, y el 0 es un margen. Después de escribir cada dato se presiona [▼] para bajar. Después de escribir el último número se presiona [ENTER]. El comando ∏LIST se usa para multiplicar todos los elementos contenidos en una lista. ◄┘ ( [R-Shift] [.] ) sirve para pasar al renglón siguiente y es como presionar [ENTER] al escribir un archivo de texto en WORD o en bloc de notas. Ejemplo: Ídem, pero mostrando las variables en forma horizontal. « ∏LIST(OBJ→(INPUT(“VOLUMEN DE UN CUBO”, {“:ALTO: :ANCHO: :LARGO:”,{1,0}}))) » ►CUBO INFORM La sintaxis de INFORM es la siguiente: INFORM(“Título”,{{“Variable 1:”,“Ayuda opcional”,tipo de variable}, {“Variable 2:”, “Ayuda opcional”, tipo de variable}, {“Variable N:”, “Ayuda opcional”, tipo de variable}}, {Número de columnas, margen}, {Valores de reset},{valores iniciales}) Una variable podría ser de varios tipos. En dado caso se separarían por comas los tipos. Un número típico para el margen podría ser 0, 1 ó 2. Los valores de reset se escriben (opcionalmente) uno por cada variable. Si se presiona el botón [NXT] cuando aparece el cuadro de diálogo, aparece el menú [RESET] [CALC] [TYPE] [ ] [CANCL] [ OK ] Los valores iniciales se escriben (opcionalmente) uno por cada variable. Dichos valores aparecen al inicio en el cuadro de diálogo. Si se presiona [TYPE] aparece la lista de tipos al que puede pertenecer el objeto que se digitará. La salida de INFORM es una lista que contiene la lista de lo que se introdujo y el número 1 (indicando que se escribió algo). Ejemplo: Cuadro de diálogo que tiene una columna, tres variables, valores iniciales (0, 0, 0) y valores de reset (1, 2, 3). INFORM(“TÍTULO”,{{“X:”,“DIGITE UN NÚMERO”,0,9}, {“Y:”,“DIGITE UN NÚMERO”,0,9}, {“Z:”,“DIGITE UN NÚMERO”,0,9}}, {1,0},{1,2,3},{0,0,0}) 6 Ejemplo: Ídem, pero con tres columnas, margen más grande (2), sin valores iniciales ni de reset. INFORM(“TITULO”,{{“X:”,“DIGITE UN NUMERO”,0,9}, {“Y:”,“DIGITE UN NÚMERO”,0,9}, {“Z:”,“DIGITE UN NÚMERO”,0,9}}, {3,2},{ },{ }) La ayuda se escribe si es realmente necesaria. Entre más pequeño sea un programa, más rápido correrá (aunque es una diferencia de pocos segundos). Suponiendo que se digitan 10 para X, 20 para Y, y 30 para Z, la salida del último ejemplo es: {{10,20,30},1} Como sólo interesa la lista interior se hace uso del comando HEAD, el cual obtiene el primer valor de una lista. Ejemplo: El mismo ejemplo anterior usando HEAD. HEAD(INFORM(“TÍTULO”,{{“X:”,“DIGITE UN NÚMERO”,0,9}, {“Y:”,“DIGITE UN NÚMERO”,0,9}, {“Z:”,“DIGITE UN NÚMERO”,0,9}}, {1,0},{1,2,3},{0,0,0})) La salida será: {10,20,30} 7 El tipo de variable aparece en la página 18 de la Guía de HP 49G Pocket. A continuación se presentan algunos tipos de variables. NÚMERO TIPO EJEMPLO 0 Número real -1.025 1 Número complejo 5+2*i 2 Cadena "HP 49G" 3 Sistema de números reales [[1,2],[3,4]] 4 Sistema de números complejos [[1,2*i],[3+i,-5-10i]] 5 Lista {1,2,3,4,5} 6 Nombre global X 9 Objeto algebraico 'pi' 18 Función incorporada SIN 19 Comando incorporado INPUT 28 Entero 3 29 Vector, matriz simbólica [X,8,Z] CHOOSE La sintaxis es la siguiente: CHOOSE(“Título”,{Variable 1, Variable 2, Variable N}, Número de posición inicial) La salida de CHOOSE es una lista conteniendo lo que se seleccionó y el número 1 (indicando que se seleccionó algo). Ejemplo: Cuadro de selección de funciones trigonométricas. Al inicio está seleccionada la segunda opción. CHOOSE(“TRIGONOMETRÍA”, {“1. SENO”,“2. COSENO”,“3. TANGENTE”},2) Suponiendo que se elige la tercera opción, la salida será: {“3. TANGENTE”, 1} Para obtener sólo lo que se ha seleccionado se usa el comando GET. La sintaxis de GET es: GET(Lista o vector o matriz, Número de elemento seleccionado). Luego se usa el comando OBJ→. 10 {“ANCHO:”,“EN METROS”,0,9},{“LARGO:”,“”,0,9}}, {1,0},{ },{ })) → L « {“VOLUMEN:”+L(1)*L(2)*L(3)+“_m^3”,“SUPERFICIE: ” +2*(L(1)*L(2)+L(1)*L(3)+L(2)*L(3))+“_m^2”} » » ►VOLySUP A continuación se presentan algunos comandos de salida. TEXT Sirve para escribir texto. La sintaxis es: TEXT(“Texto”). No es un comando muy útil. CLLCD Sirve para limpiar la pantalla. No tiene argumentos de entrada ni de salida. La pantalla queda en blanco hasta que se presione alguna tecla. DISP Sirve para desplegar en pantalla momentáneamente lo que se desea en donde se desea. Se combina con WAIT si se quiere que dure más tiempo. La sintaxis es: DISP(“Texto”,Número de línea donde se desea ver). No tiene argumentos de salida. En la HP49G hay siete líneas. La número 1 es la superior y la 7, la inferior. Ejemplo: Se ve “HOLA” en la esquina superior izquierda durante 5 segundos. DISP(“HOLA”,1),WAIT(5) [ENTER] Ejemplo: Se ve “HOLA” en las líneas pares. DISP(“HOLA”,{2,4,6}),WAIT(5) [ENTER] 11 Ejemplo: Ídem, pero limpiando primero la pantalla. CLLCD,DISP(“HOLA”,{2,4,6}),WAIT(5) [ENTER] Ejemplo: Fondo. Se escribe cualquier letra o símbolo 22 veces. DISP(“XXXXXXXXXXXXXXXXXXXXXX”,{1,2,3,4,5,6,7}), WAIT(5) [ENTER] También es posible escribir cosas diferentes en líneas diferentes. Ejemplo: DISP({“X”,“XX”,“XXX”,“XXXX”,“XXXXX”,“XXXXXX”,“XXXXXXX ”},{1,2,3,4,5,6,7}); WAIT(5) [ENTER] MSGBOX Sirve para hacer cuadros de texto que parecen estar sobre la pantalla. La sintaxis es: MSGBOX(“Texto”). El mensaje aparece por tiempo indefinido hasta que se presione ON, ENTER o F6. Sólo se pueden escribir 14 caracteres en una línea. Ejemplo: MSGBOX(“MENSAJE DE TEXTO”) [ENTER] 12 →TAG Sirve para etiquetar objetos. Sintaxis: →TAG(Objeto,“Nombre”). La ventaja de usar un número etiquetado es que se puede operar posteriormente, mientras que no es posible hacerlo con una cadena. Ejemplo: Programa que calcula el volumen de un cubo. « →TAG(∏LIST(OBJ→(INPUT(“VOLUMEN DE UN CUBO”, {“:ALTO: ◄┘ :ANCHO: ◄┘ :LARGO:”,{1,0}}))),“VOLUMEN”) » ►CUBO Si se necesita sumar este valor (6000) con 500 sólo se presiona +500 [ENTER]. La respuesta sería 6500 (sin etiqueta). COMPARACIONES Los operadores lógicos sirven para hacer comparaciones. Una expresión es verdadera si su valor es diferente de 0, y es falsa sólo si su valor es 0. Los operadores lógicos son AND, OR XOR y NOT. AND Su resultado es verdadero (1 lógico) si todas las expresiones que se comparan son verdaderas. En caso contrario el resultado es falso (0 lógico). Ejemplo: 5 AND 3 da como resultado 1. 2 AND -3 AND 1 da como resultado 1. 0 AND 7 da como resultado 0. OR Su resultado es verdadero si al menos una de las expresiones que se compara es verdadera. Su resultado es falso únicamente si todas las expresiones son falsas. Ejemplo: 5 OR 3 da como resultado 1. 2 OR -3 OR 1 da como resultado 1. 0 OR 7 OR 0 da como resultado 1. 0 OR 0 da como resultado 0. XOR Su resultado es falso si las expresiones son iguales, y es verdadero si las expresiones son diferentes. Ejemplo: 1 XOR 3 da como resultado 0. 15 » ►IMPNEG IFT e IFTE Hacen exactamente lo mismo que IF – THEN – ELSE. Sintaxis: IFT(Condición, Proceso) IFTE(Condición, Proceso, Proceso Alternativo) Ejemplo: Si x<0 se grafica x^2. De lo contrario no hay gráfica. « IFT(X<0,X^2) » Los siguientes comandos sirven para hacer iteraciones. FOR – NEXT Sintaxis: FOR(Variable, Inicio, Fin) Proceso NEXT. La variable va aumentando de uno en uno y se ejecuta el proceso (o procesos) hasta que la variable (a veces llamada bandera o contador) toma el último valor especificado. La salida es una lista conteniendo los resultados de la iteración. Ejemplo: Elevar desde 1 hasta 5 a la cuarta potencia. FOR (X,1,5) X^4 NEXT [ENTER] FOR – STEP Hace lo mismo que FOR – NEXT, pero la variable puede aumentar o decrecer según convenga. Sintaxis: FOR(Variable, Inicio, Fin,) Proceso STEP(Incremento o decremento). Ejemplo: Obtener los inversos de los números desde 1 hasta 12, aumentando de dos en dos. FOR (R,1,12) INV(R) STEP(2) [ENTER] [TOOL] [F2] 16 Al ir aumentando de dos en dos, el ultimo número menor o igual que 12 es 11. Ejemplo: El incremento o decremento puede ser una expresión matemática. FOR (R,1,12) INV(R) STEP(2+R) [ENTER] [TOOL] [F2] START – NEXT y START – STEP START hace lo mismo que FOR, pero la variable siempre es X (o la variable en uso actual). Dicha variable no puede ser usada en el código de proceso. Sintaxis: START (Inicio, Fin) Proceso NEXT START (Inicio, Fin) Proceso STEP (Incremento o decremento) Ejemplo: La variable no es reconocida dentro del proceso. START (1,12) INV(X) STEP(3) [ENTER] [TOOL] [F2] Ejemplo: Obtener 4 números reales aleatorios positivos menores que 1. START(2,5) RAND NEXT [ENTER] [TOOL] [F2] Si el inicio es 2 y el final es 5, hay 4 números en ese intervalo. Es como si el inicio fuera 1 y el final fuera 4. DO – UNTIL Se ejecuta el proceso hasta que se cumpla una condición. El proceso se ejecuta al menos una vez. En otras palabras, la iteración deja de repetirse cuando se cumpla la condición. La sintaxis es la siguiente: DO Proceso UNTIL Condición END. 17 Ejemplo: Obtener los múltiplos de 5 menores o iguales que 100. Presentar los resultados en una matriz. Primero la variable Z (bandera o contador) valdrá 5. Luego, en la siguiente iteración, valdrá 10, y en las siguientes iteraciones irá aumentando su valor hasta llegar a 100. « { }►M; 5 → Z « DO M+Z►M; Z+5►Z; UNTIL Z-5 ≥100 END; COL→(AXL(M),1) » »►MULTIPLO MULTIPLO [ENTER] [▼] { }►M crea una lista vacía con el nombre de M. M+Z agrega a M el número Z. No es lo mismo M+Z que Z+M. Si M fuera la lista {1, 2, 3} y Z fuera 4, M+Z produciría {1, 2, 3, 4}, y Z+M produciría {4, 1, 2, 3}. Es importante hacer crecer o decrecer el valor del contador dentro del proceso. De lo contrario podría tenerse una iteración infinita. WHILE – REPEAT Similar a DO – UNTIL, pero primero se evalúa la condición, y si no se cumple, entonces el proceso puede no ejecutarse. El proceso se ejecutará mientras la condición se cumpla. Sintaxis: WHILE Condición REPEAT Proceso END. Ejemplo: Se obtienen los múltiplos de 5 menores o iguales a 100 a partir del número introducido. « OBJ→(INPUT(“Digite un número”,“”)) → Z « { }►M; WHILE 5Z ≤100 REPEAT M+5Z►M; Z+1►Z; END; COL→(AXL(M),1) » »►MULTIPLO CASE Por razones desconocidas para el autor, CASE no está disponible en modo algebraico. 20 2X+COS(X)|(X=5X1) produciría 2*5*X1+COS(5*X1); mientras que 3X|(X=10)+X^2|(X=5) produciría 3*10+5^2 (sin simplificar). PURGE sirve para borrar variables globales innecesarias. A1, B1, ε y F no fueron borradas porque eran variables locales, aunque A1 y B1 también fueron guardadas como variables globales. En INFORM se usa el tipo nombre global ({“F(X):”,“”,9,6}) para la función a evaluar porque X es considerada por la calculadora como una variable global y no como un objeto algebraico. En cambio 2X, COS(X), X-5, LN(X), etc., son objetos algebraicos. Ejercicio: Hacer el programa anterior utilizando variables globales en vez de variables locales para evitar hacer anidamientos. Llamarlo BISECCION2. Después ir al administrador de archivos (FILES). ¿Cuál de los dos programas usa más bytes? Luego hacer que la calculadora opere en modo aproximado, volver al administrador de archivos y editar cualquiera de los programas, no hacer ningún cambio y presionar [ENTER]. ¿Cuántos bytes ocupa ahora el programa? Editar nuevamente el mismo programa. ¿Qué cambió en los números? Método de la bisección. Sólo muestra la respuesta final. « HEAD(INFORM(“BISECCION”, {{“A:”, “”,0,9},{“B:”, “”,0,9}, {“ε:”,“Error”,0},{“F(X):”,“”,9,6}}, {1,0},{ },{ })) → L « L(1) → A « L(2) → B « L(3) → ε « L(4) → F « A+(B-A)/2►P0; →NUM(F|(X=A))►FA; →NUM(F|(X=P0))►FP0; DO IF FA*FP0<0 THEN P0►B; A+(B-A)/2►P; ELSE P0►A; A+(B-A)/2►P; END; ABS(P-P0)►ER; A+(B-A)/2►P0; →NUM(F|(X=A))►FA; →NUM(F|(X=P0))►FP0; UNTIL ε >ER END; PURGE({‘P0’, ‘FA’, ‘FP0’, ‘ER’}); P » » » » » »►BISECCION Método de punto fijo. Muestra todas las respuestas en una tabla, así: P0 P=G(P) Error « HEAD(INFORM(“PUNTO FIJO”, {{“P0:”, “”,0,9},{“G(X):”, “función de X”,9,6}, {“ε:”,“Error”,0}},{1,0},{ },{ })) → L « L(1) → P0 21 « L(2) → G « L(3) → ε « →NUM(G|(X=P0))►P; {P0}►p0; {P}►p; {ABS(P-P0)}►E; DO ABS(P-P0)►ER;P►P0; →NUM(G|(X=P0))►P; p0+P0►p0; p+P►p; E+ER►E; UNTIL ε>ER END; COL→(AXL(p0),AXL(p),AXL(E),3)►R; PURGE({ ‘p’, ‘p0’, ‘E’, ‘ER’, ‘P0’, ‘P’}); MSGBOX(“RESPUESTA: [P0,G(P)=P,ERROR]”);R » » » » »►PuntoFijo Método de punto fijo. Sólo muestra la respuesta final. « HEAD(INFORM(“PUNTO FIJO”, {{“P0:”, “”,0,9}, {“G(X):”, “función de X”,9,6}, {“ε:”,“Error”,0}},{1,0},{ },{ })) → L « L(1) → P0 « L(2) → G « L(3) → ε « →NUM(G|(X=P0))►P; DO ABS(P-P0)►E;P►P0; →NUM(G|(X=P0))►P; UNTIL ε>E END; PURGE(‘E’);P » » » » »►PuntoFijo Método de Newton-Raphson. La respuesta es mostrada en una tabla, así: P0 0 0F(P ) F’(P ) P Error « HEAD(INFORM(“NEWTON-RAPHSON”,{{“P0:”,“”,0,9}, {“F(X):”,“”,6,9},{“ε:”,“”,0}},{1,0},{ },{ })) → L « L(1) → P0 « L(2) → F « L(3) → ε « DERVX(F) → D « { }►p0; { }►p; { }►f; { }►d; { }►E; DO →NUM(F|(X=P0))►F0; →NUM(D|(X=P0))►D0; P0-F0/D0►P; ABS(P-P0)►ER; p0+P0►p0; p+P►p; f+F0►f; d+D0►d; E+ER►E; P►P0; 22 UNTIL ε >ER END; COL→(AXL(p0),AXL(f),AXL(d),AXL(p),AXL(E),5)►R; PURGE({‘p0’,‘p’,‘P’,‘f’,‘d’,‘E’}); R » » » » » » ►NewtonRaphson Método de Newton-Raphson. Sólo muestra la respuesta final. « HEAD(INFORM(“NEWTON-RAPHSON”,{{“P0:”,“”,0,9}, {“F(X):”,“”,6,9},{“ε:”,“”,0}},{1,0},{ },{ })) → L « L(1) → P0 « L(2) → F « L(3) → ε « DERVX(F) → D « DO →NUM(F|(X=P0))►F0; →NUM(D|(X=P0))►D0; P0-F0/D0►P; ABS(P-P0)►ER; P►P0; UNTIL ε >ER END; PURGE({‘F0’,‘D0’,‘ER’}); P » » » » » » ►NewtonRaphson ELECTRO Paralelo. Los valores pueden ser reales o complejos. Los valores son introducidos en una lista. No hay límite de valores de entrada. La salida es un número o una expresión algebraica. « → X ‘EVAL(INV(ΣLIST(INV(X))))’ » ►PARALELO Circuito R-L-C. Puede ser serie o paralelo. Proporciona los valores de α y ω0. Dichos valores quedan almacenados en variables globales para posterior uso. « HEAD(INFORM(“R-L-C”, {{“R:”,“”,0},{“L:”,“”,0},{“C:”,“”,0}}, {1,1},{ },{ })) → M « M(1) → R « M(2) → L « M(3) → C 25 ECONOMÍA Amortización de un préstamo. Primero se establece el formato de número como FIX con dos decimales, pues se trabaja con dinero. Luego se piden los datos con un cuadro de diálogo. S1 es el capital al inicio del año 1. IN es la tasa de interés. A es el plazo para pagar el préstamo y G representa a los años de gracia. C es la cuota que se pagará anualmente en los años que nos son de gracia. La lista S almacena los saldos que se tienen al inicio de cada año. La lista An almacena los años. La lista Cu almacena las cuotas que se pagarán en cada año. La lista Am almacena las amortizaciones que se van haciendo cada año. La lista Inte almacena los intereses que se pagan anualmente. Luego se hace un lazo FOR para los años. Para cada año se determina cuánto se pagará de intereses. Luego se toma una decisión: durante los años de gracia no se paga cuota, así que hay que determinar si un año pertenece al periodo de gracia. Si no se paga cuota, entonces no hay amortización al préstamo. Después se calcula el saldo al inicio del año siguiente, y comienza de nuevo la iteración. Al terminar el lazo FOR a cada lista se le agrega un título. La lista S almacena el saldo al inicio de un año más que el plazo, lo cual no es útil y se elimina con el comando TAIL, que elimina el primer elemento de una lista. Por ello se invierte el orden de los elementos de S antes de aplicar TAIL con el comando REVLIST, y después se vuelve al orden inicial. También interesa saber el total de los intereses que se pagarán al final del plazo, y el total de las amortizaciones debe ser igual a la cantidad que se pidió prestada. Se agrega un cero al final de las listas Cu y S porque todas las listas deben tener igual longitud. Finalmente las listas son convertidas a vectores de columna, y éstos forman una matriz que se mostrará como respuesta. « FIX(2); HEAD(INFORM("AMORTIZACION", {{"CAPITAL:","DINERO QUE SE PIDE PRESTADO",0}, {"TASA DE INTERÉS:","PORCENTAJE ANUAL, EJ.: 10.5",0}, {"AÑOS DE PLAZO:","INCLUYE PERIODO DE GRACIA",0}, {"AÑOS DE GRACIA:", "NO SE PAGA CUOTA, SÓLO INTERESES",0}}, {1,1},{},{})) → L « L(1) → S1 « L(2) → IN « L(3) → A « L(4) → G « S1*(IN/100)*(1+IN/100)^(A-G)/ ((1+IN/100)^(A-G)-1) → C « {S1}►S; {}►An; {}►Cu; {}►Am; {}►Inte; FOR(N,1,A) An+N►An; Inte+S(N)*IN/100►Inte; IF N ≤ G THEN Cu+0►Cu; Am+0►Am 26 ELSE Cu+C►Cu; Am+(C-Inte(N))►Am END; S+(S(N)-Am(N))►S NEXT; AÑO+An+TOTAL►An; SaldoInicioAño+REVLIST(TAIL(REVLIST(S)))+0►S; CuotaAnual+Cu+0►Cu; Intereses+Inte+∑LIST(Inte)►Inte; Amortización+Am+∑LIST(Am)►Am; COL→(AXL(An),AXL(S),AXL(Cu),AXL(Inte),AXL(Am),5) » » » » » » »►AMORTIZACION Este documento no posee copyright. Puede ser utilizado para los fines que el lector crea convenientes tales como mejorarlo, traducirlo, etc., sin previo consentimiento del autor. David E. Torres (davidkike@yahoo.es)