• Author / Uploaded
• Ivr Flores

Citation preview

Funciones o Programas dentro de la TI-nspire CX CAS

El Splashscreen del Student Software Como mencioné en un post anterior, hay diferencias entre usar una función o usar un programa. El Program Editor no nos ayuda mucho, pero afortunadamente encontré un poco más de información sobre el lenguaje, de donde obtuve esta pequeña tabla que explica de manera sencilla en qué difieren: Program Function Return a result? No Yes Can be used in an expression? No Yes Can run in applications other than Calculator? No Yes Can use all the commands? Yes No Can use multiple variable types? Yes Yes Can access global variables? Yes Yes Can modify and create global variables? Yes No Can call subprograms? Yes No Can call functions? Yes Yes Básicamente, si escribimos una función, tenemos que regresar un resultado -normalmente al final de ésta-, lo cual es muy familiar para todo aquél que haya trabajado con lenguajes como C, Java, Python, etc. donde las funciones son usadas normalmente para devolver valores, incluso valores vacíos, dependiendo de nuestras necesidades.

Pues bien, como en la calculadora trabajamos con pequeños “Documentos”, cada Documento dividido en “Problemas” -al menos 1 y máximo 30-, podemos crear aplicaciones más o menos complejas, lo cual debe ser evidente desde que compramos la calculadora, pues esa información viene en el manual o folleto. Por si hay alguna duda, dejo un par de imágenes explicado, espero sean de ayuda:

Click en la Imagen para Ampliar

Click en la Imagen para Ampliar

Click en la Imagen para Ampliar

Click en la Imagen para Ampliar

Click en la Imagen para Ampliar ¿Por qué es importante saber sobre los probemas y las hojas? Porque hay algo muy importante y es el “ámbito” de una variable, lo cual significa la visibilidad de la misma, por lo que se aprecia el impacto que posee. Según la tabla, un Programa puede crear y modificar variables Globales, estas pueden ser modificadas u obtenidas incluso despues de la ejecución del mismo, mientras que en una función, todas las variables deben ser Locales, esto implica que una vez que termine la ejecución de la función -o subrutina- no se puede acceder a esos valores, la única manera de recuperar algo operado dentro de una función es mediante el valor de retorno. Haremos una función, llamada “cuadrado”, lo que hará será muy simple: Recibe un argumento, que será llamado „a‟, éste será impreso en la pantalla utilizando Disp, posteriormente, se devolverá el valor de „a‟ elevado al cuadrado. Se puede apreciar aquí:

Click en la Imagen para Ampliar

Ejecutarlo nos dará algo así:

Click en la Imagen para Ampliar ¿Qué ventaja tiene esto? Podemos almacenar el valor que regresa la función “cuadrado”, en este caso, no se almacena, por eso se imprime en la pantalla con un separador. Si observamos las variables, con la tecla Var, veremos que „a‟ no es una variable a la que podamos acceder, los argumentos de una función son “locales” a la función, solamente valen dentro:

Click en la Imagen para Ampliar Vamos a hacer algo, dentro de la función, crearemos b, haremos que b obtenga el valor de a, y luego devolveremos b^2. El resultado, tras presionar b, es el mismo, tampoco podemos acceder a b, porque nos obliga a que b sea declarado como “Local b” si no, no nos deja usarlo.

Click en la Imagen para Ampliar

Click en la Imagen para Ampliar Ahora, vamos a almacenar el valor que devuelve la función, para usarlo en otra cosa, tal vez… en la misma función. Podremos asignar de las 2 maneras conocidas, como ya está utilizada dentro de la función la forma “:=”, usaré la otra, utilizando Control+Var, activando el sto (de storage) en una variable llamada… “cosa”.

Click en la Imagen para Ampliar Se puede apreciar que cosa sí aparece como una variable, y que podemos usarla como argumento hacia la función y re-almacenar un valor en ella. Contamos con muchas funciones en el catálogo, que reciben argumentos y devuelven valores útiles, al igual que Disp, las podemos utilizar tanto en funciones como en programas (prácticamente todas de la misma manera) para tomar la mayor ventaja posible al resolver nuestros problemas, por ejemplo, “cosa” puede ser llamado desde otra hoja, ya sea de gráficos, de cálculo, cualquier otra. En un “programa” no podemos devolver un valor, pero podemos crear una variable global, accesible desde cualquier ámbito sin problemas:

Click en la Imagen para Ampliar

Click en la Imagen para Ampliar La variable b, declarada como el cuadrado de a, dentro del programa, tiene vida fuera de él. Dentro del programa se pueden utilizar variables Locales sin problema, para no llenar de variables al documento, sin embargo, no regresan un valor, por lo que muchas veces, el programa sería lo que intentaríamos ejecutar y podríamos crear funciones para no apelmazar demasiado código, así como declarar Locales nuestras variables temporales, para que no estorben fuera de la ejecución. En lo siguiente, se tomará el ejercicio Polinomios, se creará una función, una diferente asignación y algunos trucos para terminar con un programa mucho más útil, espero hacerlo pronto. Saludos.

Propiedades de la Pantalla TI-nSpire CX CAS LUA

El Splashscreen del Student Software Vamos a ver, de momento hemos mostrado 1 mensaje en pantalla, luego fueron 2, modificando la fuente, también el color. Ahora, nos damos cuenta que colocar un texto puede ser fácil, pero entre más cosas querramos mostrar en pantalla, más difícil se hace colocarlas sin encimarse, además ¿qué pasa si queremos centrar un texto? ¿qué pasa si no sabemos hasta dónde podemos mostrar algo en la pantalla? Pues ahora vamos a explorar las propiedades de la pantalla para asegurarnos de hacer las cosas bien. Al igual que en TI-BASIC, tenemos variables locales y globales, gracias a las cuales podemos manipular datos y conservarlos únicamente donde nos importa para facilitar el trabajo, así que deberíamos procurar utilizarlas cada que podamos, para hacer costubre y lograr códigos limpios. En este caso, utilizaremos como locales los valores de altura y ancho de la pantalla. Estas características las obtienemos del objeto window, que es un miembro de platfrom, al igual que en C, podemos obtener un sub-miembro de una estructura a partir de el “operador punto” y luego accedemos a un método como ya lo habíamos hecho, me explicaré: estrctura.miembro:método(argumentos) entonces, para obtener las dimensiones de la pantalla, basta con:

Click en la Imagen para Ampliar Vamos a analizar por líneas: 1. Declaramos la función on.paint, como ya habíamos hecho 2. Creamos la variable local altura y la llenamos con lo que devuelve el método heitgh() que pertenece a window, un miembro de platform. 3. Hacemos lo mismo que el punto anterior para el ancho de la pantalla, con width(). 4. Modificamos color. 5. Imprimimos en panalla el texto Altura: , concatenando ese texto utilizando dos puntos (..), lo cual funciona igual que en TI-BASIC. 6. Modificamos color. 7. Imprimimos en pantalla, de manera similar a la altura, el ancho de la pantalla. Si dividimos la pantalla (en PC o Calculadora) o cambiamos la vista a Vista de PC dentro de nuestro software, estos valores cambiarán, son totalmente dinámicos:

Click en la Imagen para Ampliar

Click en la Imagen para Ampliar ¿Cómo centras un texto? En lo horizonal, pues… sencillamente tomas el centro, luego el tamaño del texto, y distribuyes la mitad de un lado y la mitad del otro. Ahora, ¿programando?….. de manera similar, como se ve aquí:

Click en la Imagen para Ampliar Al final, obtenemos:

Click en la Imagen para Ampliar Algo muy similar hacemos si lo queremos poner hasta la derecha de la pantalla, sencillamente tomamos el tamaño de la pantalla, le quitamos el tamaño del texto (entero) y ya :D

Click en la Imagen para Ampliar Y como vemos, la lógica funciona :P

Click en la Imagen para Ampliar Ahora, lo que haré será posicionar un texto en la esquina inferior derecha del documento, mostrando una curiosidad para mí, que es crear una variable que contenga el objeto platform.window.

Click en la Imagen para Ampliar El código cambió un poco, se llenó de variables. Para ser un programa pequeño parecería incómodo, pero en programas más grandes no se nota jaja. En este caso usamos getStringHeight para obtener el tamaño del string y poder acomodar el texto sin que se „saliera‟ de la pantalla:

Click en la Imagen para Ampliar

Bueno, creo que se ha entendido un poco más acerca de la sintaxis, he usado el autocompletado para mirar diferentes métodos que existen, todo poco a poco va a ir teniendo más sentido, como siempre, los primeros ejemplos son solo para agarrar familiaridad con el lenguaje y con las herramientas de las que disponemos, pronto haré algo más. Saludos.

Primer Programa LUA TI-nSpire CX CAS

El Splashscreen del Student Software Empecemos, como siempre con el Hola Mundo para poder empezar a familiarizarnos con el lenguaje. Para empezar, vamos a abrir nuestro “TI-nSpire CAS Student Software” para poder comenzar, tras lo cual lanzaremos el editor de scritps que nos ofrece la compañía, que, pese a no ser el mejor que existe, nos da un Autocompletado y nos deja ver en tiempo real el script como lo vamos creando :) Así que vamos a ello. Para abrirlo, creamos un nuevo documento y añadimos un nuevo script desde el menú insertar:

Click en la Imagen para Ampliar Se nos abre el editor de scripts y nos pide el nombre que tendrá, para mí, “Hola Mundo LUA” ya que así estará más que explicado el sentido que tendrá :P :

Click en la Imagen para Ampliar Ahora, tendremos a nuestra disposición un pequeño editor de texto que resalta la sintaxis de este lenguaje con el que no me encuentro para nada familiarizado…. no usa llaves ({ }) o un punto y coma (;) para terminar una línea, también carece de una función de entrada o principal (main) que sea nuestro punto de partida al programa. Su sintaxis no es tan diferente a lo que es TI-BASIC, así que pese a todo espero acostumbrarme a usarla. Para declarar una función (o reescribirla) sencillamente debemos declarar la palabra reservada function, posteriormente entre paréntesis los argumentos que sean necesarios, posteriormente la función y finalizamos con un end. Para nuestro primer script tenemos:

Click en la Imagen para Ampliar Exploremos a través de las líneas: 1. Se declara la función con funcion, se le otorga el nombre on.paint, la cual se manda a llamar cada que se „dibuja‟ la pantalla, recibiendo un argumento llamado gc, que viene siendo el Graphic Context. 2. Dentro de la función, he dado una tabulación para ayudarme a mí a entenderlo mejor, no es necesaria y no se pone por defecto. Posteriormente utilizo el objeto gc, llamando a un método que este objeto posee, entre los cuales tenemos el método drawString, que recibe 3 argumentos: Texto a mostrar, dirección en x (de izquierda a derecha) y dirección en y (de arriba a abjo). La sintaxis es objeto:método. 3. Terminamos el bloque de la función con la palabra reservada end. Con la combinación de teclas Control+S o apretando el botón “Establecer Script” podemos ver el resultado del mismo en nuestro documento:

Click en la Imagen para Ampliar Se se puede notar, el documento ahora no posee ninguna característica de notas, calculadora o nada que se le parezca, ahora no deja escribir y aunque presionemos cualquier tecla o hagamos cualquier especie de cambio dentro de esa hoja…. no pasará nada :) Hemos tomado todo el control de la hoja con LUA, aunque si creamos una hoja que quede como 1.2, sí va a poder ser utilizada como calculadora o como cualquier tipo de documento habitual, lo que nos ofrece una de las ventajas de usar este lenguaje, el combinar todo lo que ya tenemos a nuestra mano: Integrales, Derivadas, todas las funciones de la calculadora y todos los programas que podemos hacer en TI-BASIC combinarlos con LUA. Pero ya llegaremos a eso, no conozco mucho el lenguaje y espero que no se me juzgue muy duro por ir aprendiendo por mi cuenta. Saludos :)

Programación con LUA en la TI-nSpire CX CAS

El Splashscreen del Student Software Hola a quien me lea, siendo ya vacaciones pienso retomar un poco el blog. Tengo que acabar algunas cosas de otras „series‟ que he hecho pero también quiero diversificar y empezar a aprender algo nuevo: Programación con LUA. Así es, además del lenguaje TIBASIC (que seguiré usando), la calculadora puede ser programada, de una forma más poderosa utilizando un lenguaje diferente, el cual nos da acceso a cosas que TI-BASIC no nos da, como dibujar directamente en la pantalla, leer sensores -si se tienen-, contar tiempo y crear aplicaciones interactivas con el usuario de muy diferentes maneras. ¿Qué necesitamos? Primero que nada, un editor de texto que soporte resaltar la sintaxis de LUA, para diferentes sistemas tenemos diferentes opciones, para Windows recomiendo Notepad++ o SublimeText, sin embargo, no es algo tan importante, dado que el software de Texas Instruments con el que hemos estado trabajando ofrece un editor de scripts que nos ayuda a probar su comportamiento antes de tenerlos terminados, el mismo ejemplo en los 3 editores sería:

Click en la Imagen para Ampliar

Click en la Imagen para Ampliar

Click en la Imagen para Ampliar Ahora ¿cómo puedo correr mi script en la calculadora? Originalmente solo era posible en el editor de scritps de Texas Instruments, pero gracias a la creatividad de algunos programadores es posible escribir scripts y probarlos directamente desde la calculadora, para eso necesitamos alguno de estos 2 programas: “Oclua” o “TIDE”. El primero, Ocula (corto para On Calculator LUA) funciona de la siguiente manera: Abres Oclua.tns, abres una nueva pestaña donde se coloca un editor de notas, ahí generas tu código, luego presionas Control+A (para seleccionar todo) y luego Control+C (para copiar todo el texto), posteriormente se regresa a la primer página donde se debe hacer un Control+V para pegar el texto, que será ejecutado en esa página.

Click en la Imagen para Ampliar

Click en la Imagen para Ampliar Otra manera de tener LUA en la calculadora, al menos para poder programar „en el camino‟ es TIDE (TI-Integrated Development Environment), el cual nos ofrece una página de apuntes donde podemos escribir nuestro código con la ventaja de que no es necesario hacer más que escribir, ya que al cambiar a la página siguiente el código corre automáticamente (en caso de estar bien escrito) lo cual es más cómodo que copiar/pegar en OCLUA.

Click en la Imagen para Ampliar

Click en la Imagen para Ampliar ¿Y si acabé mi script, cómo lo convierto en un archivo que pueda ejecutar en mi calculadora sin problemas? Pues fácil, Oclua y TIDE no ofrecen esa opción, tampoco el editor de scripts de Texas Instruments, pero sí ofrecen unas Scripting Tools donde hay una especie de compilador, al cual solo hay que alimentar con el script y te devolverá un archivo .tns para ejecutarlo en la calculadora sin problemas y sin que el código esté a la vista -por eso de las envidias-. Aquí la forma de cómo compilar:

Click en la Imagen Animada para Ampliar Al cargar el script te manda un aviso de que hay algo en el portapapeles, que viene siendo la información de tu programa, solamente necesitas ir a un documento nuevo, presionar Control+K (para seleccionar la página) y luego Control+V para pegar …. y listo, ese documento tns siempre tendrá la información de tu script, aunque desde luego es algo que queremos hacer hasta que ya estemos 100% comprometidos con nuestro trabajo, siempre guardando nuestro archivo .lua con el código :) . Saludos.

Hola Mundo Renovado TI-nSpire CX CAS LUA

El Splashscreen del Student Software El primer programa siempre es el Hola Mundo, nos enseña la manera más básica de comunicarnos con el usuario final de nuestro programa, mostrar un simple mensaje, pero ahora vamos a cambiarlo un poco, añadiremos estilo al mensaje mostrado, así como aprenderemos un poco más del entorno de programación, vamos a ello: Primero vamos a añadir una nueva línea a nuestro viejo programa, antes de la línea del drawString, colocamos gc: y apretamos en nuestro teclado Control+BarraEspaciadora, gracias a lo cual nos saldrá un pequeño menú en el que podemos ver las capacidades que tenemos a nuestro alcance. En el momento en que hagamos esa combinación de teclas podremos ver el autocompletado, auqnue a veces falla pues el programa no es realmente bueno, sin embargo, aquí una muestra:

Click en la Imagen para Ampliar Hasta abajo encontramos setFont, que es un método que recibe 3 argumentos y nos ayuda a cambiar la fuente que estamos ocupando para mostrar un string en pantalla, ¿cuáles fuentes? de momento solamente he encontrado „serif‟ y „sansserif‟. El primer argumento es la fuente, el segundo el estilo (b para bold, i para italic, r para regular) y posteriormente el tamaño. Digamos que escogemos mostrar 2 mensajes, cada uno con una configuración diferente:

Click en la Imagen para Ampliar El resultado:

Click en la Imagen para Ampliar Se ve… interesante, puede jugarse con todo ese tipo de configuraciones, pero hay una más: Colores. Así es, en las notas podemos ver una serie de colores para nuestros textos, pero desde LUA podemos tener aún más, ya que disponemos de toda la gama RGB de 8 bits para cada color. Un valor que va desde 0 a 256 para la combinación de estos en un pixel.

¿Cómo podemos darle color? Con otra método de gc :) setColorRGB, el cual recibe 3 documentos que son los colores para R, G y B (Rojo, Verde, Azul), vemos qué podemos hacer:

Click en la Imagen para Ampliar Desde luego, es más fácil buscar una lista de colores con códigos RGB para guiarnos, a no ser que queramos mover y mover las combinaciones a ver qué encontramos :P

Click en la Imagen para Ampliar

De momento es suficiente, ya aprendimos a personalizar mensajes, lo cual puede ser muy útil, aunque de momento no le hemos dado demasiado uso, nos acercamos ;) Salud

Modificando el Hola Mundo TI-nspire

El Splashscreen del Student Software Bueno, ahora cambiaremos el Hola Mundo que habiamos programado para hacer un Hola Usuario, esto es, que le indiquemos un nombre y la calculadora nos envíe un saludo :) Es algo muy simple y servirá para ver un poco más sobre el lenguaje, y es que ahora ocuparemos un „argumento‟ de nuestro programa. Bueno, empecemos. Teníamos algo así, con la interfaz tipo PC:

Click en la Imagen para Ampliar Vamos a modificarlo, en los paréntesis de la primera línea, añadiremos una variable que se llamara, para nuestro programa, „nombre‟, así podremos saludar a un usuario :) Por lo que quedará así:

Click en la Imagen para Ampliar Y luego modificaremos la línea 3, donde está el Hola Mundo, concatenaremos la variabe „nombre‟ para hacer que se muestre. La manera en que yo encontré que se ejecuta correctamente es añadiendo la variable con una coma (,) entonces el texto queda como se ve en la imagen:

Click en la Imagen para Ampliar Y al ejecutar, nos pedirá que añadamos un argumento, dado que el programa está definido que recibe „algo‟ que, dentro, llamará nombre. Yo le puse René, que es como me llamo, aunque me lo da con minúsculas (aún tengo que aprender por qué), pero ya es un avance, la única manera que me respeta la mayúsucla es ponerlo entre comillas, pero me las imprime también jaja.

Click en la Imagen para Ampliar Si no le pusiéramos el argumento que será tomado como nombre, nos da un error así:

Click en la Imagen para Ampliar Pese a estar „bien escritos‟ y pasado la revisión de sintaxis, nos podemos encontrar con problemas a posteriori, ya que el uso del programa es lo que nos ayuda a depuralo y predecir los errores que puede tener, de momento, dejaremos el Hola Mundo de lado y seguiremos con otras cosas. Saludos. About these ads

Números Complejos en la TI-nSpire CX CAS

El Splashscreen del Student Software Regresamos con pequeños tutoriales sobre la TI-nSpire CX CAS, en esta ocasión toca hablar sobre los números complejos, los cuales aparecen en muy diferentes aplicaciones, en mi área sobre todo para “Fasores” -representaciones complejas- de Voltaje y Corriente. El Álgebra de números complejos no es tan coplicada, pero es muy fácil equivocarse, ya que si bien la suma no supone ningún problema, obtener el inverso de una Matriz Compleja es un proceso delicado. Así que vamos a ello.

Click en la Imagen para Ampliar Primero que nada, tenemos que aprender sobre notaciones, tenemos las notaciones: Rectangular, Trigonométrica, Polar-exponencial y Polar. La calculadora maneja, por lo que he visto, todas menos la notación Trigonométrica. Para los que no lo sepan, el Plano de Argand o el Plano Complejo es muy similar al plano cartesiano, excepto que en la Abcisa

se tiene un eje que representa los Números Reales y en la Ordenada se tiene un eje que representa los Números Imaginarios, formando así, con un punto en cualquier parte del plano, un binomio “(Real,Imaginario)” el cual lo podemos representar de diversas formas. La representación más usual para representar a un complejo suele ser la rectangular: “z = a + bi”. Como se ve en el plano de la imagen más arriba, estamos representando un punto z en el plano de Argand con las cordenadas „a‟ real y „b‟ imaginario. En la calculadora, es sencillo obtener esa representación, solamente necesitamos acceder a la „i‟ especial, dado que si ocupamos la i del teclado, nos la tomaría como una variable. Algo así:

Click en la Imagen para Ampliar Existen diversas funciones destinadas a manejar los números complejos, las cuales aparecen en las Funciones de Número y las Funciones de Álgebra.

Click en la Imagen para Ampliar

Click en la Imagen para Ampliar Realmente no hay mucho qué decir respecto a ellas, si queremos usarlas podemos acceder a ellas a través del menú, el catálogo o aprendiendo el nombre de la función, por ejemplo, para obtener la magnitud de un número, no tenemos que hacer la suma del cuadrado de la parte real y la parte imaginaria (|z|= Raíz ( a^2 + b^2 ) ), con las propias barras de magnitud lo podemos obtener. Así como si queremos el complejo conjugado (z conjugado = a – bi ), todo se maneja de manera nativa y muy sencilla.

Click en la Imagen para Ampliar Ahora, si bien en las configuraciones podemos especificar qué tipo de notación nos interesa ocupar para los resultados, ésta puede cambiar da manera explícita, esto es, ordenar que obtengamos un resultado en una notación u otra. Si queremos ocupar un resultado en notación Polar, pero no queremos manejar todo, sino solamente ese resultado en notación

polar, podemos ocupar en caracter de conversión y escribir la palabra „polar‟ después, así obtendremos la conversión explícita:

Click en la Imagen para Ampliar En la imagen podemos apreciar lo siguiente: En las primeras 2 conversiones, tenemos configurada la calculadora para trabajar con radianes, por eso ocupa la notación Polarexponencial, que, para un número z = a + bi, sería |z|e^(angTan(b/a)). La primera operación se hizo únicamente apretando “enter” (resultado tal cual debe ser), la segunda con Control+Enter (aproximar); Las últimas 2 operaciones fueron realizadas con la calculadora configurada para trabajar con grados, idénticamente con Enter y luego Control+Enter. Para introducir un número complejo en notación polar, lo cual es tremendamente común, hay que tener en cuenta pocas cosas, lo imporante es matener la notación. No importando la entrada, el resultado siempre se mostrará en la cuál esté configurada la calculadora (Rectangular para este caso), pero para la introducción de polares utilizando grados. El motivo de la diferencia entre el uso de radiantes y el uso de grados, mientras que los radianes son usados como unidades de longitud, los grados no lo son. Existe una relación fundamental, llamada „Relación de Euler‟, la cual no explicaré porque me extendería demasiado. Si intentamos introducir un número en notación polar, necesitamos tener cuidado, especialmente si lo hacemos con grados en lugar de radiantes, tenemos que usar el símbolo „ángulo‟, el cual sacamos del catálogo de símbolos Control+Catálogo:

Click en la imagen para Ampliar Algo que me gusta hacer es poner los grados de forma implícita, lo cual obtenemos en el mismo catálogo de símbos -donde también se encuentra la i de imaginario- o en el minicatálogo de la tecla “Pi” donde sacamos por primera vez el símbolo i:

Click en la Imagen para Ampliar Y obtenemos esto como resultado:

Click en la Imagen para Ampliar En la imagen, se coloca un polar, magnitud 20, ángulo de 10 grados. Primero se saca el resultado exacto, luego la aproximación. ¿Pero qué pasa en el tercer caso? Nos da un error de sintaxis para el mismo número, con el mismo símbolo…. porque cada que se ocupe un número complejo en notación polar, debe ir entre corchetes, si no, la calculadora no lo acepa. Yo no sabía eso y pasé un mal tiempo en Análisis de Circuitos Eléctricos, porque no podía usar esos números. Podemos realizar todo tipo de operaciones con estos números, dejaré algunos ejemplos que he utilizado en clase:

Click en la Imagen para Ampliar

El siguiente tutorial tendrá sistemas de ecuaciones con números complejos y posteriormente programas que los ocupen. De momento, me da gusto volver a escribir una entrada :D. Saludos

Programa Polinomios TI-nspire CX CAS

El Splashscreen del Student Software Bueno, ahora exploraremos algo muy importante dentro de este tipo de calculadoras, que es aprovechar la capacidad que tienen y crear programas que nos ayuden a automatizar apoyándonos de lo que ya existe. En este caso, tomaremos un polinomio simple, lo resolveremos (obtenermos sus raíces) y lo mostraremos factorizado, así haremos más de 1 tarea a la vez, ya que cuando tenemos un polinomio con raíces reales o compejas, normalmente nos gusta obtener esos 2 datos. En fin, vamos a ello. Crearemos un nuevo programa, llamado Polinomios, y esta vez recibirá 2 argumentos, el primero será el polinomio a trabajar y el segundo será la variable del mismo, por lo que tendremos algo así:

Click en la Imagen para Ampliar

Click en la Imagen para Ampliar Y ahora, exploraremos el catálogo que existe en la calculadora para ver qué funciones tenemos pre-programadas y las ocuparemos. Para ello damos click en el icono del librito, y buscamos en las funciones de álgebra:

Click en la Imagen para Ampliar Tenemos Solve, Factor, Expand, las culaes, como se puede observar, ocupan sus propios argumentos, usaremos Solve para resolver el polinomio y mostraremos un mensaje con Disp, luego comprobamos la sintaxis y probamos con un polinomio, en mi caso, 3x^2 -x +10 =0, dado que Solve necesita una expresión igualada a 0, así tendremos que enviar muestros polinomios. Se observa muy bien en la imagen:

Click en la Imagen para Ampliar Hasta el momento, todo parece estar bien :) Ahora que ya imprimirmos las raíces de nuestro polinomio, otra cosa que nos conviene es factorizarlo, para lo que ocupamos nuevamente el librito y encontramos “factor”. Lo modificamos un poco para mostar los datos de forma más agradable, y bueno, ahora hice un gif donde se obserba cómo aprovechar el código preescrito en la parte de cálculos, se selecciona un comando del historial, se da enter y así se „arrastra‟ hacia abajo, ya que usaremos lo mismo. Bueno, se entiende mejor en la imagen:

Click en la Imagen para Ampliar. Imagen animada Ahora nos dice qué expresión tenemos, nos la factoriza y nos entrega las raíces :) Si no tenemos bien configurado, y colocamos una expresión que nos devuelva complejos, estaremos en un problema, por lo que también se recomienda usar cSolve, la cual nos entrea un real de tener raíces reales y un complejo si hay raíces complejas.

Click en la Imagen para Ampliar Me gustó mucho. Saludos.

Modificando el programa Polinomios TI-nspire CX CAS

El Splashscreen del Student Software Bien, ahora toca mejorar ese programa que se hizo hace algunos posts para poder darle una funcionalidad más importante. Como se vio, el programa recibía 2 argumentos, un polinomio y la variable independiente de mismo, para que ejecutara sus funciones. Ahora, haremos que grafique dicho polinomio, hay muchos caminos, mostraré uno de los menos elegantes pero sencillos. Vamos a ello. Primero que nada, ocuparemos un comentario para anotar el uso de nuestro programa, para ello ocuparemos Control+Libería y escogeremos el símbolo ocupado para comentarios, como se puede apreciar:

Click en la Imagen para Ampliar Ahí mismo se ve que el comentario está indicando qué tipo de acción deseamos que el usuario realice para utilizar el programa, lo cual se verá si buscamos el mismo en la librería (recordemos que este programa fue público, en la primer línea se ve declarado como LibPub). Primeramente necesitábamos que el usuario introdujece el Polinomio igualado con 0 (esto es: X^2+x-2=0, por poner un ejemplo), pero para fines prácticos, evitaremos ese uso, ya que aprovecharemos tener una función F(x) sin igualación para realizar nuestra gráfica. Una vez hecho eso, crearemos una variable donde grabaremos el Polinomio igualado con 0 dado que así nos lo requieren las funciones para obtener sus raíces y su factorización, por lo que el código se mirará así:

Click en la Imagen para Ampliar Hacemos algo muy simple, declaramos una variale local, llamda poli, en ella guardamos lo que tengamos en polinomio igualado a 0, esto es, si polinomio valía 3s^2+s-10, en poli

tendremos 3s^2+s-10=0. Gracias a eso, podemos ocupar las funciones factor y cSolve sin problemas, enviándoles poli como primer argumento y variable como el segundo argumento. Ahora, hay varias maneras en las que podemos realizar una gráfica, una muy simple sería crear una nueva variable, en este caso, global, y pasársela a una hoja de graficación. Crearemos la variale “grafico” y luego iremos a la pantalla de inicio para añadir una hoja de graficación (que yo ya tengo como la 1.1), donde le diremos que la primer función (f1(x) ) está igualada a nuestra variable grafico. Y esto quedaría así:

Click en la Imagen para Ampliar Si nosotros ocupamos un polinomio con la variable x, podemos obtener su gráfica que se vería de esta forma:

Click en la Imagen para Ampliar Eso no es muy cómodo, ya que si factor y cSolve no dependen de la variable x, no hay motivo para obligar al usuario a introucir siempre expresiones que dependan de esa variable. Anduve buscando un poco en internet y no encontré mucha información para cambiar una variable dentro de una expresión, así que me decidí hacer una función a la cual yo le envíe un polinomio, la variable actual y la variable nueva. Para fines prácticos la nombré “cambiarvariable”, recice “pol”, “a” y “b” como argumentos.

Click en la Imagen para Ampliar Declaro 2 variables locales, ya que en una función no pueden ser de otro tipo, la primera será un contador, la segunda será mi polinomio resultado. Igualo el polinomio de resultado a 0, por si acaso, y lueg comienzo un ciclo For con la siguiente información: Contador: e;Inicio: 1; Fin: Grado del Polinomio +1; Incremento del Contador en cada ciclo: 1. Si, por ejemplo, envío un polinomio de grado 2, se repetirá 3 veces, recordando que hay n+1 miembros en un polinomio de grado n. A pol2 le será asignado el antiguo valor y se le sumará la variable nueva (b) elevada al “el máximo valor (el grado del polinomio) +1 -e”, y multiplicado a esa variable (b) estará el coeficiente correspondiente, que nos lo da el elemento “e” de la lista que nos devuelve polyCoeffs. Así generaremos un nuevo polinomio, con la variable deseada, el cual tendrá los mismos coeficientes que nuestro polinomio original. Puede ser un poco enredado o difícil de entender si uno no está familiarizado con la programación en general, pero se trata de que poco a poco se vea este tipo de cosas con ojos más abiertos. Es nada más una forma de hacerlo, incluso se me ocurre otra en este momento, pero no la usaré más que nada porque esta ya está, una pista: el ciclo For puede empezar en 0, lo que elimina la necesidad del +1 en el exponente y nos crea la necesidad de un +1 en el índice del coeficiente. Ahora, volviendo a nuestro programa, basta cambiar una línea, y asignarle a la variable (global) grafico el valor que retorne la función cambiarvariable. De esta manera:

Click en la Imagen para Ampliar Si lo guardamos y ahora probamos un polinomio que no dependa de x, veremos algo así:

Click en la Imagen para Ampliar Puede ser que haya cosas por mejorar, pero definitivamente creo que resulta mucho mejor y más útil este programa que el primero que se ralizó con la intención de obtener información de polinomios. Sé que no es muy bueno, pero espero que sea de utilidad para alguien. Saludos.

istas en TI-nspire CX CAS

El Splashscreen del Student Software Uno de los elementos más socorridos y útiles de los lenguajes de programación „de alto nivel‟ son las estructuras conocidas como Listas. En C manejamos lo que son Arreglos, que son una formación -contigua en memoria- en la que podemos guardar varios elementos de un mismo timpo; en otros lenguajes, como Python, ocupamos listas, que están íntimamente ligadas a los Arreglos, excepto que en estas podemos guardar elementos de varios tipos, no necesariamente iguales entre sí, aunque con una sintaxis idéntica, lo que quedará más claro con un ejemplo: Comenzaremos por definir una variable llamada lista, en este caso con la sintaxis Define (también es posible con := y con ->), a la que asignaremos 3 valores, estos irán entre llaves, separados con una coma, en este caso: {3,4,1}. Para acceder a un elemento en una lista, necesitamos ocupar el identificador (o nombre) de ella y, entre corchetes cuadrados (“[" "]“) indicar el índice del elemento que querramos recuperar. Cada lenguaje maneja los índices a su manera, mientras que en lenguajes como Fortrand podemos ocupar índices negativos, en otros lenguajes, como C, podemos únicamente positivos, iniciando con 0, para el caso de TI-Basic, nuestro primer índice será el 1. Así pues, podemos recuperar la información de cada elemento de la siguiente forma:

Click en la Imagen para Ampliar Tanto un número inferior a 1 como uno superior al tamaño de la lista, nos dan un error, al tener 3 elementos, podemos recuperarlos con 1, 2 o 3, según nos convenga. Hay muchas maneras de ocupar las listas, estos ejemplos son muy simples, pero prácticos, pues nos dan una idea de las diferentes posiblidades. Por ejemplo, ocupamos la notacón “sistema de ecuaciones” para sustituír el valor que almacena la variable lista y recuperamos cada uno de sus valores:

Click en la Imagen para Ampliar La lista no depende de que cada elemento sea del mismo tipo. Tenemos 2 igualdades y una cadena, recuperados sin problemas con la misma notación. Mientras que en otros lenguajes de progamación uno está muy acostumbrado a Utilizar 2 índice spara manejar matrices, es este no he encontrado -todavía- la manera de operar cada elemento de una matriz de manera

invidual, sin embargo, en una matriz de 2×2, se pueden recuperar los renglones mediante la misma notación:

Click en la Imagen para Ampliar Ya para finalizar esta introducción, utilizaré una función que me devuelve los coeficientes de un polinomio, siendo este resultado devuelto una lista, para demostrar otro más de sus usos, ya que las funciones pueden regresar 1 y solo 1 valor, por qué no regresar una lista donde se guarde toda la información que necesitemos. Se ve esto aquí:

Click en la Imagen para Ampliar Esto nos será de ayuda para completar la aplicación sobre polinomios, que es el siguiente post. Saludos.

Matrices [avanzado] en la TI-nSpire CX CAS

El Splashscreen del Student Software Pasaron los días, semanas y meses… y por fin encontré la manera de trabajar con matrices que había esperado. Como había escrito en una entrada anterior, no estaba seguro de cómo accesar miembro a miembro, como se hace en los diferentes lenguajes que he manejado (C, C++, C#, Pic-C, Python, Java, PHP). Busqué en Google y no encontré mucho -o mejor dicho nada- que se acercara a lo que necesitaba, únicamente encontré algunos pocos tutoriales, incluso desde la página de TI, no encontré satisfacción a mi problema, antes de ponerme a estudiar de pasta a pasta el manual de la calculadora, pude hayar la forma de trabajar :) Así que vamos a ello. Para empezar, hay que saber lo básico sobre las matrices, y es que éstas son „arreglos rectangulares‟ de datos -en programación, en matemáticas es algo muy similar, pero no exactamente igual-. Pueden ser uni-dimensionales (llamadas vectores, de n-elementos) o tener varias dimensiones. La calculadora trabaja con Vectores y Matrices de nxm elementos, lo cual ya se vio en la entrada acerca de las “Listas”. Ahora, ¿cómo se crean las matrices en la calculadora? Hay varios métodos. Dentro de una hoja de Calculadora, debemos apretar la tecla menú, ir a 7. Matrices y Vectores y añadir una nueva. Luego, escogemos las dimensiones. Es un poco incómodo, pero hay otras formas.

Click en la Imagen para Ampliar

Click en la Imagen para Ampliar Tras ello, tendremos una matriz de 3×3 „en blanco‟ lista para ser llenada por literales (números) o variables. Yo uso otro método, más veloz, el cual dejaré en un gif animado:

Click en la Imagen Animada para Ampliar Podemos efectuar diferentes operaciones sobre las matrices, primero que nada, me gustaría tomar la matriz de 3×3 que hice en una variable, llamada „a‟, así que utilizaré la sintaxis que me gusta ( := ) para hacerlo.

Click en la Imagen para Ampliar Empecemos con las multiplicaciones, multiplicación escalar y multiplicación matricial. Veremos el resultado de multiplicar a „a‟ por 2. Lo cual, según las propiedades del producto escalar, nos dará como salida cada miembro multiplicado por 2, lo cual guardaremos en otra matriz, llamada „b‟, con la sintaxis que no me gusta (->).

Click en la Imagen para Ampliar Ahora tenemos 2 matrices, „a‟ y „b‟, donde „b‟ es la matriz „a‟ multiplicada por 2. Tenemos otra sintaxis para poder hacer asignaciones de matrices -o listas- a variabes. Ahora declararemos una matriz llamada „c‟ que sea la multiplicación de „a‟ y „b‟ (en ese orden, pues la multiplicación de matrices no es conmutativa). La sintaxis es „Define variable = matriz‟:

Click en la Imagen para Ampliar ¿Qué pasa si queremos Operar Matrices y no solo escalares? Solamente basta indicar la operación, ya sea en notación matricial o con las variables que las representan, así como se hizo para obtener C como A*B, ejemplos:

Click en la Imagen para Ampliar Vamos a operaciones sobre las matrices que requieren un poco más que los operadores básicos. Empecemos con la matriz inversa. Para ello se necesita únicamente elevar (la matriz o la variable) a -1, lo cual nos dará el inverso tal cual lo hace con reales o complejos. hay que recordar que la matrices singulares (aquellas matrices cuadradas cuyo determinante es 0) no tienen matriz inversa, así como tampoco aquellas que no son cuadradas. Así que declararé una matriz „d‟ totalmente nueva:

Click en la Imagen para Ampliar ¿Cómo sacar el determinante? Esto es válido solamente para matrices cuadradas, lo cual se debería saber de antemano, pero reitero. No importa la dimensión de estas; a mano, una matriz de 5×5, 10×10… serían un poco tardadas, hay diferentes métodos (que luego explicaré), pero de momento me quedaré con la función „det‟ para este fin. Como se puede ver:

Click en la Imagen para Ampliar Transponer una matriz o vector es realmente simple, cambiar renglones por columnas, pero también poseemos una manera simplificada, con una pequeña „T‟ que podemos encontrar en nuestro menú de símbolos. Esto es, más que por dificultad, porque al hacer programas a veces necesitamos transponer y así nos facilitamos el trabajo de crear una función que lo haga.

Click en la Imagen Animada para Ampliar Existen muchas funciones, cuyos nombres explican su función, algunas comunes como intercambiar renglones, otros como las operaciones permitidas en el método de Gauss: multiplicar un renglón por un escalar y sumarlo a otro renglón, como se ve aquí, La función multiplica el rengón 1 de la matriz „a‟, y se lo suma al renglón 2:

Click en la Imagen para Ampliar Para lograr automatizar procesos iterativos, tenemos diferentes herrramientas, algunas de las más cómodas son la “Notación Sigma” o los Ciclos (For, While). Pero hasta la fecha, no sabía cómo aprovechar las matrices en este lenguaje, dado que lo máximo que había hecho era obtener un renglón de la matriz, al igual que con las listas, accediendo con la notación “[índice]“, como se ve en esta imagen del viejo post:

Click en la Imagen para Ampliar Lo que se obtiene en la imagen se conoce, al parecer, como sub-matrices, las cuales no solamente se pueden acceder así, sino también hay una función específica para ello, pero a mí, en este momento, no me sirve para nada útil. Ahora, lo que yo deseaba era obtener acceso a cada elemento por separado, ya sea para tomar el dato o para guardar un nuevo dato en en ese espacio de la matriz. La Sintaxis de C, C#, Python, Java, suele ser

“Matriz[índice1][índice2]“, pero para la TI-nSpire CX CAS utilizaríamos “Matriz[índice1,índice2]“, por ejemplo:

Click en la Imagen para Ampliar Si bien, tenemos una función para obtener la traza de la matriz, por poner un ejemplo, podemos utilizar la notación sigma para obtenerla, lo cual nos da una idea de cómo, con ciclos For, por ejemplo, podemos aprovechar las matrices en nuestros programas:

Click en la Imagen Animada para Ampliar Todo esto funciona para números reales y para números complejos. Con Fracciones, enteros o números en coma flotante. Pronto, más ejemplos (asociados a Análisis de Circuitos Eléctricos). De momento, espero que haya sido útil para alguna persona. Saludos.

Ciclos y condicionales TI-nspire CX CAS

El Splashscreen del Student Software Una parte muy importante de todos los lenguajes de programación son los ciclos y condicionales, estos nos permiten re-dirigir el flujo del programa para repetir instrucciones, evitar errores con lo que podemos reducir drásticamente el tamaño del código que estamos usando además de adecuarlo para su ejecución mediante una generalidad. Por poner un ejemplo, si hiciéramos un programa para resolver un sistema de ecuaciones algebráico, paso por paso, en lugar de que el código esté forzado a trabajar con 3 variables o 2, podemos utilizar un método numérico de tal manera que ese número esté in-determinado hasta que el programa está corriendo, lo que expande las posibilidades del mismo. Empecemos creando un nuevo documento y en él añadiremos una calculadora y abriremos el editor de programas:

Click en la Imagen para Ampliar. Gif Animado Dentro del Program Editor, vamos a colocar algo muy simple. Nuestro programa recibirá 2 argumentos, el primero se llamará „a‟, el segundo, „b‟; a través de los menús (o recordando la sintaxis) escribiremos 3 casos: que „a‟ sea menor, mayor o igual a „b‟. En el menú, podemos encontrar estas „Sentencias de Control‟, en este caso haremos uso de If, Else-if y Else.

Click en la Imagen para Ampliar En un lenguaje como C, que posee llaves (“{” “}”), tendríamos algo un poco más fácil de leer, sin embargo, el lenguaje TI-Basic se basa en el uso de puro texto, así que con algo de imaginación, se puede ver la imagen, el “bloque” de la condicional If, termina con un EndIf, primero se evalúa la primer condición, luego, de ser falsa, se pasa al ElseIf, y si ninguna fue cierta, por defecto, sin evaluar nada, cae en el caso Else, por lo que si no era menor o mayor, asumimos que es igual.

Click en la Imagen para Ampliar Yendo al menú, es posible añadir otra página, en este caso una calculadora donde probaremos el programa que hicimos:

Click en la Imagen para Ampliar Ahora intentaremos utilizar un ciclo, en este caso optaremos por el ciclo For, el cual toma un índice, un inicio, un final y un tamaño de paso, como se verá en el siguiente ejemplo, para el que crearemos un programa llamado “pares”:

Click en la Imagen para Ampliar

Click en la Imagen para Ampliar En este caso ocuparemos la función “remain”, la cual nos devuelve el „restante‟ de una división entera, por ejemplo remain(4,3) nos devolvería 1. La condición para que un número sea par, es que al dividirlo entre 2, nos de 0. (2,4,6,8, todos tienen un residuo igual a 0). Dado que en este lenguaje las asigaciones se hacen con := o ->, el símbolo = se utiliza para comparar. También, no ocuparemos un If-Then, lo que crearía un bloque entero de acción al ser cierta la condición del condicional If, necesitamos únicamente una línea de código qué ejecutar en caso de que la condición sea cierta, en este caso, que el número sea par. El código es muy simple:

Click en la Imagen para Ampliar Declaramos 1 variable local llamada “x”, esto hará que no estorbe fuera de la ejecución del programa, declaramos un ciclo For con la información en este orden: Variable contador: „x‟, Inicio de la cuenta: „inicio‟, Final de la cuenta: „fin‟, Incremento cada que se complete

el ciclo: 1. Ya dentro del ciclo, que se repetirá dándole a x un valor de „inicio‟ y lo aumentará en ‟1′ hasta que sea igual a „fin‟, colocamos un If, que buscará que el número „x‟ sea par, y de serlo, nos imprime mediante Disp el valor de dicho número. Si lo ejecutamos, podemos ver una salida así:

Click en la Imagen para Ampliar Dentro de las Sentencias de Control, tenemos algunas otras, que funcionan de manera muy similar a otros lenguajes de programación, de todas maneras, si hace falta algo de documentación, en este link se pueden encontrar una guía de su uso, para los fines inmediatos que tengo en mente, esto es suficiente por el momento. ¡Saludos!

Funciones o Programas dentro de la TI-nspire CX CAS

El Splashscreen del Student Software Como mencioné en un post anterior, hay diferencias entre usar una función o usar un programa. El Program Editor no nos ayuda mucho, pero afortunadamente encontré un poco más de información sobre el lenguaje, de donde obtuve esta pequeña tabla que explica de manera sencilla en qué difieren: Program Function Return a result? No Yes Can be used in an expression? No Yes Can run in applications other than Calculator? No Yes Can use all the commands? Yes No Can use multiple variable types? Yes Yes Can access global variables? Yes Yes Can modify and create global variables? Yes No Can call subprograms? Yes No Can call functions? Yes Yes Básicamente, si escribimos una función, tenemos que regresar un resultado -normalmente al final de ésta-, lo cual es muy familiar para todo aquél que haya trabajado con lenguajes como C, Java, Python, etc. donde las funciones son usadas normalmente para devolver valores, incluso valores vacíos, dependiendo de nuestras necesidades. Pues bien, como en la calculadora trabajamos con pequeños “Documentos”, cada Documento dividido en “Problemas” -al menos 1 y máximo 30-, podemos crear aplicaciones más o menos complejas, lo cual debe ser evidente desde que compramos la

calculadora, pues esa información viene en el manual o folleto. Por si hay alguna duda, dejo un par de imágenes explicado, espero sean de ayuda:

Click en la Imagen para Ampliar

Click en la Imagen para Ampliar

Click en la Imagen para Ampliar

Click en la Imagen para Ampliar

Click en la Imagen para Ampliar ¿Por qué es importante saber sobre los probemas y las hojas? Porque hay algo muy importante y es el “ámbito” de una variable, lo cual significa la visibilidad de la misma, por lo que se aprecia el impacto que posee. Según la tabla, un Programa puede crear y modificar variables Globales, estas pueden ser modificadas u obtenidas incluso despues de la ejecución del mismo, mientras que en una función, todas las variables deben ser Locales, esto implica que una vez que termine la ejecución de la función -o subrutina- no se puede acceder a esos valores, la única manera de recuperar algo operado dentro de una función es mediante el valor de retorno. Haremos una función, llamada “cuadrado”, lo que hará será muy simple: Recibe un argumento, que será llamado „a‟, éste será impreso en la pantalla utilizando Disp, posteriormente, se devolverá el valor de „a‟ elevado al cuadrado. Se puede apreciar aquí:

Click en la Imagen para Ampliar

Ejecutarlo nos dará algo así:

Click en la Imagen para Ampliar ¿Qué ventaja tiene esto? Podemos almacenar el valor que regresa la función “cuadrado”, en este caso, no se almacena, por eso se imprime en la pantalla con un separador. Si observamos las variables, con la tecla Var, veremos que „a‟ no es una variable a la que podamos acceder, los argumentos de una función son “locales” a la función, solamente valen dentro:

Click en la Imagen para Ampliar Vamos a hacer algo, dentro de la función, crearemos b, haremos que b obtenga el valor de a, y luego devolveremos b^2. El resultado, tras presionar b, es el mismo, tampoco podemos acceder a b, porque nos obliga a que b sea declarado como “Local b” si no, no nos deja usarlo.

Click en la Imagen para Ampliar

Click en la Imagen para Ampliar Ahora, vamos a almacenar el valor que devuelve la función, para usarlo en otra cosa, tal vez… en la misma función. Podremos asignar de las 2 maneras conocidas, como ya está utilizada dentro de la función la forma “:=”, usaré la otra, utilizando Control+Var, activando el sto (de storage) en una variable llamada… “cosa”.

Click en la Imagen para Ampliar Se puede apreciar que cosa sí aparece como una variable, y que podemos usarla como argumento hacia la función y re-almacenar un valor en ella. Contamos con muchas funciones en el catálogo, que reciben argumentos y devuelven valores útiles, al igual que Disp, las podemos utilizar tanto en funciones como en programas (prácticamente todas de la misma manera) para tomar la mayor ventaja posible al resolver nuestros problemas, por ejemplo, “cosa” puede ser llamado desde otra hoja, ya sea de gráficos, de cálculo, cualquier otra. En un “programa” no podemos devolver un valor, pero podemos crear una variable global, accesible desde cualquier ámbito sin problemas:

Click en la Imagen para Ampliar

Click en la Imagen para Ampliar La variable b, declarada como el cuadrado de a, dentro del programa, tiene vida fuera de él. Dentro del programa se pueden utilizar variables Locales sin problema, para no llenar de variables al documento, sin embargo, no regresan un valor, por lo que muchas veces, el programa sería lo que intentaríamos ejecutar y podríamos crear funciones para no apelmazar demasiado código, así como declarar Locales nuestras variables temporales, para que no estorben fuera de la ejecución. En lo siguiente, se tomará el ejercicio Polinomios, se creará una función, una diferente asignación y algunos trucos para terminar con un programa mucho más útil, espero hacerlo pronto. Saludos.