Universidad Nacional de Salta Facultad de Ciencias Exactas
INTRODUCCIÓN AL USO DE SCILAB Lenguaje libre para la programación científica
Autores: Miguel Condorí Mariela Finetti Luis Saravia
SALTA, abril de 2011
CAPÍTULO 1 ........................................................................................................................................... 4 INTRODUCCIÓN ................................................................................................................................................. 4 1.1. LA MOTIVACIÓN PARA LA ENSEÑANZA DEL SCILAB.................................................................... 4 1.2. LAS CARACTERÍSTICAS PRINCIPALES DE SCILAB. ......................................................................... 5 1.3. EL DIRECTORIO SCILAB ......................................................................................................................... 6 1.4. LA VENTANA DE TRABAJO ................................................................................................................... 7 1.5. BIBLIOGRAFÍA .......................................................................................................................................... 9 CAPITULO 2 ......................................................................................................................................... 11 NOCIONES BÁSICAS ....................................................................................................................................... 11 2.1. INTRODUCCIÓN ...................................................................................................................................... 11 2.2. ENTRADA, EJECUCIÓN Y SALIDA ...................................................................................................... 11 2.3. LAS VARIABLES Y LOS TIPOS DE DATOS ........................................................................................ 13 2.4. OPERADORES Y FUNCIONES ............................................................................................................... 16 2.5. AYUDA DE SCILAB. ............................................................................................................................... 17 2.6. CONSTANTES .......................................................................................................................................... 18 2.7. NÚMEROS COMPLEJOS ......................................................................................................................... 18 2.8. VECTORES Y MATRICES ...................................................................................................................... 19 2.9. EL GENERADOR DOBLE PUNTO ......................................................................................................... 21 2.10. TIRA DE CARACTERES........................................................................................................................ 23 CAPITULO 3 ......................................................................................................................................... 27 PROGRAMACIÓN ............................................................................................................................................. 27 3.1. INTRODUCCIÓN ...................................................................................................................................... 27 3.2. DIRECTORIO PRINCIPAL DE TRABAJO ............................................................................................. 28 3.3. GUARDANDO LA SESIÓN DE TRABAJO ............................................................................................ 29 3.4. ENTRADA Y SALIDA SENCILLAS ....................................................................................................... 30 3.5. ESTRUCTURA DE UNA FUNCIÓN ....................................................................................................... 32 3.6. VARIABLES GLOBALES Y LOCALES ................................................................................................. 34 3.7. OPERADORES RELACIONALES Y LÓGICOS ..................................................................................... 37 3.8. SENTENCIAS DE CONTROL DE FLUJO .............................................................................................. 38 3.9. DEFINICIÓN DE FUNCIONES EN LÍNEA ............................................................................................ 43 CAPÍTULO 4 ......................................................................................................................................... 45 GRÁFICOS EN SCILAB.................................................................................................................................... 45 4.1. INTRODUCCIÓN ...................................................................................................................................... 45 4.2. LA VENTANA GRÁFICA ........................................................................................................................ 45 4.3. REPRESENTACIÓN EN 2D ..................................................................................................................... 47 4.4. MANIPULACIÓN DE LOS PARÁMETROS DEL GRÁFICO ................................................................ 55 4.5. GRÁFICOS COMPUESTOS ..................................................................................................................... 57 4.6. CURVAS DE NIVEL................................................................................................................................. 60 4.7. REPRESENTACIÓN DE GRÁFICOS EN 3D .......................................................................................... 62 OPERACIONES DE VECTORES Y MATRICES .......................................................................................... 67 FUNCIONES MATEMÁTICAS ........................................................................................................................ 75 6.1. FUNCIONES MATEMÁTICAS ELEMENTALES .................................................................................. 75 6.2. SISTEMA DE ECUACIONES LINEALES............................................................................................... 76 6.3 NÚMEROS COMPLEJOS .......................................................................................................................... 77 6.4 POLINOMIOS ............................................................................................................................................ 77 6.5 RESOLUCIÓN DE ECUACIONES NO LINEALES ................................................................................. 79 6.6 AJUSTE LINEAL ....................................................................................................................................... 80 6.7 DERIVADA ................................................................................................................................................ 81 6.8.- INTEGRALES .......................................................................................................................................... 82
2
6.9 ECUACIONES DIFERENCIALES ORDINARIAS ................................................................................... 87 CAPITULO 7 ......................................................................................................................................... 89 ENTRADAS Y SALIDAS DE DATOS .............................................................................................................. 89 7.1. INTRODUCCIÓN ...................................................................................................................................... 89 7.2. ARCHIVOS BINARIOS (SAVE, LOAD) ................................................................................................. 89 7.3. FUNCIONES TIPO SCILAB (SIN FORMATO) ...................................................................................... 91 7.4. FUNCIONES TIPO FORTRAN (read, write) ............................................................................................ 92 7.5. FUNCIONES TIPO C ................................................................................................................................ 97 7.6. LEYENDO O GRABADO LÍNEAS DE ARCHIVOS DE TEXTOS...................................................... 103 CAPITULO 8 ....................................................................................................................................... 104 PROBLEMAS RESUELOS ............................................................................................................................. 104 8.1. INTRODUCCIÓN .................................................................................................................................... 104 APENDICE A ...................................................................................................................................... 105 DIÁLOGOS E INTERFACES GRÁFICAS ................................................................................................... 105 A.1. El USO DE DIÁLOGOS E INTERFACES A USUARIO ...................................................................... 105 A.2. DIÁLOGOS ............................................................................................................................................. 105 A.3. INTERFACES GRÁFICAS DE USUARIO ........................................................................................... 113 APENDICE B ...................................................................................................................................... 121 TOMA DE DATOS CON INTERFASE TCL/TK .......................................................................................... 121 B.1. EJECUCIÓN DE SENTENCIAS TCL .................................................................................................... 121 B.2. TOMA DE DATOS DESDE LA PUERTA SERIE................................................................................. 122
3
CAPÍTULO 1 INTRODUCCIÓN Este documento está conformado por apuntes de clase para la enseñanza del programa Scilab en la materia Laboratorio 1, en el departamento de Física de la Facultad de Ciencias Exactas, Universidad Nacional de Salta. Este material constituye una primera etapa en el aprendizaje de este programa permitiendo que el alumno aprenda los aspectos más importantes del mismo y pueda utilizarlo para resolver los problemas más habituales de las materias que conforman una carrera de ingeniería o Licenciatura en ciencias. Es de esperar que a partir de esta introducción, en caso de ser necesario, el alumno pueda profundizar personalmente en los aspectos más avanzados. Hay que escribir algo sobre la estructura del libro
1.1. LA MOTIVACIÓN PARA LA ENSEÑANZA DEL SCILAB.
Tradicionalmente, se ha comenzado el proceso de enseñanza de la programación en computadoras con lenguajes simples como el Basic o sus derivados. A medida que se incrementó la capacidad de las computadoras fue posible utilizar programas que permiten manejar problemas de cálculo más complejos aunque su utilización siga siendo sencilla. Los mismos pasan a ser una herramienta poderosa que permite tratar la mayor parte de los problemas matemáticos con los que se enfrentará el alumno en su carrera de grado y en su actividad profesional posterior.
Entre los programas de mayor uso con las características mencionadas en el párrafo anterior, se encuentran Mathematica y Matlab (o similares, como Octave y Scilab). El Matlab es el más utilizado en cursos de Física e Ingeniería, mientras que el primero en general resulta más apropiado para matemáticos por su manejo del cálculo simbólico. Estos programas se caracterizan por disponer, además de las herramientas habituales de programación, de un conjunto muy grande de funciones útiles en las aplicaciones matemáticas, que permiten encarar el estudio de la mayor parte de los problemas que se presentan.
4
Scilab ha sido desarrollado por el INRIA, un Instituto de Investigación francés de prestigio. Recientemente, se creó el Consorcio Scilab que se encarga del servicio de mantenimiento y mejora del programa. Existen versiones para los sistemas operativos Windows y Linux, lo que aumenta su flexibilidad de uso. La popularidad de este programa en el ámbito internacional se ha ido incrementando sustancialmente en los últimos años.
1.2. LAS CARACTERÍSTICAS PRINCIPALES DE SCILAB.
Scilab es un programa compatible con Matlab y se ha desarrollado originalmente para aplicaciones de electrónica, especialmente sistemas de control y tratamiento de señales. Está compuesto de tres partes distintas: un intérprete de los códigos de programación, las librerías de funciones (procedimientos Scilab) y librerías con rutinas en Fortran y C, dos lenguajes distintos compatibles con Scilab.
Una ventaja de Scilab es que utiliza la sintaxis de Matlab para el manejo de Matrices Numéricas, además de poder utilizar objetos más complejos. Por ejemplo, el manejo de matrices con racionales, polinomios o funciones es muy fácil de realizar con Scilab. Resumiendo podemos decir que Scilab es un paquete de software científico para el cálculo numérico con un entorno muy amigable para el usuario. Sus principales características son:
1. Es un programa orientado para la aplicación de las herramientas matemáticas a las distintas ciencias, en especial la física y la ingeniería. Esto se evidencia en la gran cantidad de funciones capaces de resolver la mayor parte de los problemas matemáticos. Scilab dispone de más de 1000 funciones matemáticas.
2. Es una aplicación interactiva. Esto significa que se le puede plantear una operación matemática y el programa entrega la respuesta de inmediato. Ello lo hace muy amigable cuando se resuelven problemas concretos no muy complicados. Pero también es posible escribir programas, es decir un conjunto sucesivo de operaciones matemáticas y lógicas, para poder resolver problemas más complicados que requieran un tratamiento más cuidadoso.
3. Scilab es Software Libre. Actualmente existe una línea de trabajo que piensa que el desarrollo de programas debe realizarse por el trabajo mancomunado de las personas
5
interesadas y que lo mismos deben tener libre disponibilidad de manera que puedan ser usados y eventualmente cambiados sin restricciones, siempre que se reconozca la autoría del programa. Este es el esquema utilizado en el caso del Scilab, que es de libre disponibilidad y se puede encontrar en Internet bajo la dirección: http://www.scilab.org Desde este sitio pueden descargarse diferentes versiones del programa y consultar información general, manuales y documentación adicional. También existe un grupo de noticias (News) donde pueden intercambiarse experiencias, ideas y programas desarrollados en Scilab. Además, existen numerosos sitios en internet donde puede encontrarse información adicional. 4. Se encuentra disponible para diferentes sistemas operativos: Windows y Linux. Es importante decir que el grupo Scilab antes mencionado actualiza con frecuencia su software, creando nuevas versiones, corrigiendo errores e implementando nuevas funciones.
Scilab tiene además otras importantes características para el programador más avanzado o con necesidades específicas, entre las que se pueden mencionar:
Intérprete sofisticado y lenguaje de programación con la sintaxis tipo MATHLAB.
Cientos de funciones matemáticas desarrolladas (el usuario puede ampliarlas).
Muy buenos gráficos (2D, 3D y animación).
Muchas librerías desarrolladas (llamadas toolboxes en MATHLAB ).
Control (control clásico, LQG, H)
Paquete para optimización LMI (Matrices con inecuaciones lineales).
Optimización (diferenciable y no diferenciable).
Scicos (entorno interactivo para la modelización y simulación con sistemas híbridos)
Metanet (análisis de redes y optimización).
1.3. EL DIRECTORIO SCILAB
En el directorio de instalación de Scilab los subdirectorios más significativos son los siguientes:
6
bin (binarios) es el directorio en el que se almacenan los archivos ejecutables. El código ejecutable de Scilab se encuentra allí (scilex para el entorno Windows). Este directorio también contiene los scripts1 que administran los ficheros que se generan con Scilab y manejan la impresión de los mismos.
demos (demostración) es el directorio donde se encuentran todos los ejemplos y demostraciones. El fichero alldems.dem permite añadir una nueva demostración para que pueda ser ejecutada haciendo click sobre el botón Demos del menú. Es muy útil consultar Demos ya que los ejemplos incluidos pueden inspirar al nuevo usuario.
examples (ejemplos) contiene ejemplos muy útiles de cómo conectar Scilab con programas externos, utilizando enlaces dinámicos ( dynamic link ).
man (manuales) es el directorio que contiene la ayuda on-line de Scilab y que está subdividido en submanuales.
routines (rutinas) es el directorio que contiene el código fuente de todas las rutinas numéricas.
En la versión de Scilab para Linux, es posible seleccionar el directorio de instalación para la distribución aunque se recomienda hacerlo en /usr/local.
1.4. LA VENTANA DE TRABAJO
En la figura 1.1 de esta sección se observa la ventana de trabajo del Scilab. En la barra de herramientas se tienen diferentes opciones, entre las cuales se puede mencionar: File – (archivo) aparece una lista con opciones que permiten manejar los archivos que se utilizan, como Open, Load, Save y Print (abrir, cargar, grabar, imprimir). Las siguientes opciones están disponibles dentro del menú:
Exec: (ejecutar) para ejecutar en la ventana un archivo de procedimientos o una función (se guardan con terminación .sci).
Change Directory: (cambiar directorio) para cambiar el directorio de trabajo.
Get Current Directory: (obtener el directorio corriente) para obtener el camino (path) al directorio actual.
Exit: (salir) termina la sesión actual de scilab.
1
Un script es un programa sencillo que contiene una secuencia de instrucciones que el programa principal (en este caso Scilab) deberá interpretar. Ver capítulo 3.
7
Edit – (editar) la lista contiene opciones para copiar parte de un texto, mediante el uso del “clipboard” (porta papeles), un sector de memoria donde se guarda el contenido copiado hasta que se “pega” en otro texto. Preferences – (preferencias) contiene opciones para cambiar la apariencia de la pantalla de trabajo, como el lenguaje (inglés/francés), color, fuente de las letras, etc. Control – (control) la lista contiene opciones para controlar la ejecución de las funciones mediante las instrucciones resume, abort e interrupt, (reasume, aborta, interrumpe) que permiten moverse dentro de diferentes procedimientos y ventanas de trabajo interactivas. Editor – (editor) al elegirlo aparece el programa editor de textos SciPad con el cual se escriben los procedimientos o funciones que se ejecutarán en Scilab. Applications – (aplicaciones) desde allí se pueden ejecutar algunas aplicaciones que funcionan bajo scilab, como Scicos que es un paquete para la simulación de sistemas dinámicos. ? – (ayuda) este menú contiene las opciones Help y Demos.
Demos – (demostraciones) Se abre una ventana con una lista de demostraciones de las posibilidades de Scilab. Se elige una y se presiona OK. Se recomienda probar las posibilidades de Scilab ejecutando las diferentes demostraciones.
Help (ayuda) Esta opción permite acceder a una descripción de cada uno de los comandos de Scilab. La información es igual a la contenida en el “manual de guía”. Los comandos están agrupados por tipos de función y al aparecer la lista, se puede apretar sobre el nombre de alguno para que aparezca la información detallada sobre el mismo. Recorriendo estas listas se puede apreciar la gran variedad de funciones disponibles en Scilab.
8
Figura 1.1
1.5. BIBLIOGRAFÍA
En el sitio de Internet mencionado en 1.2 se dispone de documentos de introducción, aplicaciones específicas y manuales para el usuario. También existen libros sobre el uso de Scilab, algunos de los cuales se detallan a continuación.
* Un manual en español: Título: Introducción al Scilab Autor: Héctor Mora Escobar – Univ. Nacional de Colombia Fecha de publicación: Nov/2001 Páginas: 55 Disponibilidad: archivo poscript
* Un manual en inglés: Título: Introduction to Scilab, users’guide
9
Autor: Scilab Group Fecha de publicación: Páginas: 126 Disponibilidad: archivo poscript.
*Manual de referencia en inglés: Título: Reference manual Autor: Scilab Group Páginas: 722 Disponibilidad: archivo poscript De este libro se disponen dos índices con cada comando del manual, uno ordenado por tema y otro por abecedario (en Word), útiles para encontrar los comandos que se necesiten.
*Un libro muy completo, en inglés: Titulo: Numerical and statistical methods with scilab in science and engineering Author: Gilberto Urroz Fecha de publicación: Febrero/2002 Páginas: 1100 (dos volúmenes) Disponibilidad: 2 archivos pdf
No se mencionar libros porque ahora hay muchísimos otros
10
CAPITULO 2 NOCIONES BÁSICAS 2.1. INTRODUCCIÓN
En este capítulo se introducirá la información básica sobre el funcionamiento del lenguaje y los comandos más comunes a fin de poder comenzar a utilizar el programa. Como con cualquier otra aplicación la destreza en el uso de la misma se irá adquiriendo en la medida del uso del software. En capítulos posteriores se irá profundizando el aprendizaje del lenguaje.
Los ejemplos desarrollados para este libro se realizaron usando la versión 5.3.1 de Scilab para Windows, la última al momento de la edición de estos apuntes, pero las nociones básicas son comunes con las versiones anteriores, siendo las diferencias entre ellas fundamentalmente el agregado de nuevas funciones y aplicaciones.
En el pasado las versiones para Windows eran mucho mas amigables que las de Linux. En la actual versión no existen diferencias sustanciales. La sintaxis de comando y sentencias son las mismas y se corren igual en ambas versiones. Sólo se observan ligeras diferencias de aspectos y traducción al castellano de los menús.
2.2. ENTRADA, EJECUCIÓN Y SALIDA
Comencemos viendo cómo se ejecuta el programa y cómo se cierra al dejar de usarlo. Inicie Scilab simplemente haciendo click en el icono correspondiente en su escritorio (en la versión para Linux, llame una terminal de comandos, generalmente con el botón derecho del mouse, y escriba scilab). Lo primero que se muestra es la ventana de trabajo de Scilab con el siguiente Menú Principal:
11
File
Edit
Preferences Control Editor ? _______________________________ scilab-4.1 Copyright (C) 1989-2006 Consortium Scilab (INRIA/ENPC) _______________________________
Startup execution: loading initial environment -->t= 2+3 t = 5. -->
Scilab es una aplicación interactiva, por lo tanto se introducen las operaciones que se desean ejecutar (“los comandos”) y el programa las ejecuta. Veremos después que también es posible ejecutar una serie de comandos escritos en un archivo (programas), mediante un editor de texto. Por ello esta versión ya viene con un editor incorporado, llamado SciNotes, al cual se accede desde el menú Applications.
En la parte superior está el menú principal desde donde se pueden ejecutar las operaciones principales desplegando los menús. Debajo de este menú, se presenta una barra de herramientas con iconos para la ejecución rápida de comandos específicos como por ejemplo llamar a SciNotes, abrir un archivo, cortar, copiar, pegar, cambiar directorio actual, etc.
Mas abajo, en la ventana de trabajo, Scilab muestra el siguiente símbolo, que se conoce como prompt, indicando que el programa está listo para recibir la instrucción:
-->
Después del prompt es el lugar donde se comienza a introducir los comandos a ejecutar. En el caso de la figura se le ha ordenado que sume 2+3 y almacene el resultado en la variable t. El comando se ejecuta presionando la tecla ENTER. Scilab imprime el contenido de la variable t, con el resultado de la operación, y a continuación vuelve a mostrar el prompt indicando al usuario que esta lista para recibir otra instrucción.
12
Para salir de Scilab se utiliza el comando “exit”. Este comando puede ejecutarse escribiéndolo a continuación del prompt y presionando enter, o seleccionando la opción Salir desde el menú File, con lo cual se vuelve al escritorio del sistema operativo.
-->exit
2.3. LAS VARIABLES Y LOS TIPOS DE DATOS En Scilab se pueden definir variables en las que se almacenan valores numéricos o alfanuméricos. Estas variables quedan guardadas en la memoria RAM de la computadora y pueden utilizarse en diferentes cálculos mientras dure la ejecución del programa o no se redefina la variable. Una variable es creada simplemente asignándole un valor. Por ejemplo, anteriormente se definió la variable t introduciendo en ella la suma 2+3.
En computación suelen usarse distintos tipos de datos: numérico entero, numérico flotante, texto alfanumérico, etc. Scilab determina el tipo de la variable a partir del contenido asignado a la variable, por lo tanto se puede cambiar de tipo simplemente cargando un nuevo valor. Como ejemplo, a continuación se carga en la variable t un número flotante y luego un texto alfabético.
-->t=2.56 t = 2.56 -->t="Scilab" t = Scilab
Los tipos de datos básicos mas importantes que maneja Scilab son enteros, punto flotante (reales en sus distintas notaciones) y cadenas de caracteres. Como ejemplos tenemos:
4532 entero 3.5 punto flotante
13
-4.1234 punto flotante -31.45e+11 punto flotante “scilab” cadena de caracteres
Como se aprecia, los textos alfanuméricos (cadenas de caracteres) deben introducirse entre comillas para que Scilab los reconozca como tales y no los confunda con identificadores de variables.
Más adelante veremos que Scilab utiliza tipos más complejos de variable que permiten manejar números complejos, matrices y polinomios. La posibilidad de almacenar matrices en una variable y realizar diversas operaciones con ellas permite que Scilab pueda llevar a cabo operaciones complejas con suma facilidad, convirtiéndolo en un poderoso lenguaje de cálculo. Las mayúsculas y minúsculas son distinguidas por Scilab. Esto significa que t y T son dos variables diferentes, es decir se guardan por separado en la memoria. Por ejemplo:
-->t = 2.56 t = 2.56 -->T = 3.1e3 T = 3100. -->t, T t = T
2.56 = 3100.
Como se aprecia, t y T se guardan por separado y pueden ser utilizadas como tales a posteriori.
Es posible pedir en cualquier momento un listado de las variables disponibles en la memoria. Para ello se ejecuta el comando “who”, que muestra en pantalla el nombre de todas las variables que está utilizando Scilab durante la sección de trabajo, tanto las definidas por defecto como por el usuario.
14
Con el comando “who_user” se muestra un listado de todas las variables definidas por el usuario, lo cual es muy útil para no redefinir variables. En el ejemplo vemos que la lista contiene a las variables t y T, que se definieron en el ejemplo anterior.
-->who_user Las variables de usuario son: T
t
WSCI
Usando 24 elementos de 4990713
Al comenzar su trabajo, Scilab define un conjunto de variables (variables predeterminadas o del entorno Scilab).
No deben usarse identificadores de variables similares a las
predeterminadas por Scilab ya que su uso está reservado.
Los nombres (identificadores) de las variables pueden tener hasta 24 caracteres de longitud. Deben comenzar con una letra o con el símbolo $. El resto de los símbolos pueden ser letras, números, , _, $, ¡. Por ejemplo, los siguientes nombres son válidos:
Primer_valor,
b33, $signo, $123, masaInicial
Scilab posee la variable predeterminada “ans” que almacena el último valor calculado. El uso de la misma permite realizar operaciones posteriores empleando este valor.
-->4.5+0.23 ans = 4.73 -->ans*2 ans = 9.46
Como se aprecia, la variable “ans” siempre almacena el último valor calculado. En el ejemplo se realiza un segundo cálculo operando con el resultado anterior, luego de esta segunda instancia “ans” adopta el nuevo valor.
15
Para facilitar el trabajo, Scilab guarda en memoria todas las operaciones sucesivas que se están realizando. Si se quiere utilizar una de ellas a posteriori, basta presionar las teclas del cursor (flecha arriba o abajo) para recorrer la lista. Los comandos utilizados van apareciendo y uno puede seleccionar y ejecutar aquel que se quiere utilizar por segunda vez.
Scilab también permite realizar varias operaciones en una misma orden, separando cada orden o comando con una coma.
-->a1=5, a2=4.35, a3=0.0023 a1 = a2
5. =
a3
4.35 = .0023
En la ejecución de una orden, si ésta se encuentra finalizada por un punto y coma, no se muestra el resultado de la ejecución en la ventana de Scilab, pero la operación se lleva adelante. (Esta forma de ejecutar órdenes se utiliza mucho en la confección de programas).
-->a1=5; a2=4.35; a3=0.023; -->
2.4. OPERADORES Y FUNCIONES
Scilab incluye numerosos operadores, entre ellos los aritméticos. Las cuatro operaciones básicas: suma, resta, multiplicación y división están representadas por: + potencia por: ^
ó
-
*
/
y la
**.
Además se dispone de los paréntesis: (
) para agrupar las operaciones. Las reglas con las
que operan los símbolos precedentes son las habituales en matemática.
16
Se dispone también de una gran cantidad de funciones, que prácticamente cubren la mayor parte de las necesidades. Algunas de las funciones elementales disponibles son:
abs, acos, acosh, asin, asinh, atan, atanh, ceil, cos, cosh, cotg, coth, sin, sinh, tan, tanh, sqrt, exp, fix, floor, int, round log, log10, log2 max, min, módulo(a,b)
La mayoría son reconocibles por su nombre. Por ejemplo ceil es la parte entera superior, floor es la parte entera inferior, fix redondea hacia cero (igual a int), módulo(a,b) proporciona el residuo de a dividido b donde ambos son enteros.
Además de las funciones elementales existe una gran cantidad de funciones especiales que se irán viendo a lo largo del curso, muchas de ellas de interés por sus aplicaciones en física e ingeniería.
2.5. AYUDA DE SCILAB. Ya hemos visto que en el menú principal se encuentra un botón “?” para invocar la ayuda de Silab donde se accede a un navegador de ayuda y al detalle de todos los comandos agrupados por temas.
También es posible obtener la información de un comando específico directamente dentro de la ventana de trabajo con el comando “help”. Si, por ejemplo, se escribe después del pront ”help tan”, sin las comillas, obtendremos directamente la información detallada sobre la función tangente. Si no se dispone del nombre específico de la función, se puede solicitar información de todas las funciones de un tema dado utilizando el comando “apropos”. Por ejemplo, se puede pedir “apropos polynomial” para obtener todas las funciones relacionadas con los polinomios.
Si bien la ayuda de Scilab está en inglés es sumamente útil para la confirmación de la sintaxis o ver todas las posibilidades de un comando, y para obtener ejemplos de aplicación y una lista
17
de comandos asociados. Su utilización es altamente recomendable cada vez que se invoca un nuevo comando.
2.6. CONSTANTES
Es habitual utilizar en matemática algunas constantes que tienen una importancia especial, como ser el número pi, el número e, etc. Estos números se encuentran predefinidos en Scilab y pueden ser utilizados directamente en cualquier cálculo, se les llama “constantes”. Estos números están protegidos de modo que no se pueden cambiar. Se distinguen mediante una nomenclatura especial, colocando el signo % delante de su nombre. En el cuadro siguiente se muestran algunos de ellos. En el ejemplo se ve que al intentar cambiar el número pi, dándole el valor 0 el programa marca un error ya que una constante no se puede cambiar. En el cuadro se observa el número e y también el número imaginario i que se utiliza para escribir números complejos. -->%pi %pi = 3.1415927 -->%pi=0 !--error 13 Redefiniendo la variable permanente -->%e %e = 2.7182818 -->2+3*%i ans = 2. + 3.i
2.7. NÚMEROS COMPLEJOS
Scilab maneja los números complejos en forma sencilla. Para eso define internamente una variable, %i, que contiene el número imaginario i. Un complejo cualquiera se expresa usando la parte real más la imaginaria multiplicada por %i. Por ejemplo:
a = 5+7*%i
18
Las funciones de Scilab admiten números complejos como variables del cálculo y pueden expresar sus resultados como números. Por ejemplo: -->b = sqrt(-4) //se obtiene la raiz cuadrada b = 2.i -->c=sqrt(1+%i) c = 1.0986841 +
.4550899i
-->c^2 ans = 1. + i
2.8. VECTORES Y MATRICES
Scilab está preparado para trabajar con arreglos de variables (vectores y matrices) sin dificultad alguna. Esto convierte al Scilab en un lenguaje de cálculo matricial, ya que están definidas todas las operaciones que se aplican a matrices en forma de funciones. Las matrices se definen utilizando corchetes [
]. Existen tres formas para definir una matriz, las que se
ilustran en los ejemplos que siguen:
-->c = [11,12,13;21,22,23] c = 11. 21.
12. 22.
13. 23.
-->d = [11 12 13;21 22 23] d = 11. 21.
12. 22.
13. 23.
-->f = [11 12 13 -->21 22 23] f = 11. 21.
12. 22.
13. 23.
19
Como se aprecia, los elementos de la matriz se pueden separar con comas o con un espacio en blanco. Las filas sucesivas se separan con punto y coma o escribiéndolas en renglones sucesivos. En todos los casos la expresión debe comenzar y terminar con corchetes.
El elemento de una matriz C que ocupa la fila b y la columna d se indica como C(b,d) . Por ejemplo, en la matriz C definida anteriormente:
-->C(2,3) ans = 23.
A continuación expondremos las operaciones más sencillas. Las restantes se verán en el capítulo cuatro. La matriz transpuesta se obtiene con el símbolo ‘ colocado después de la variable. Por ejemplo, refiriéndonos a la matriz C definida anteriormente:
-->c' ans = 11. 12. 13.
21. 22. 23.
El producto de una constante por una matriz se expresa con el signo habitual de producto *, con el que la constante se multiplica por cada elemento de la matriz. -->2*c ans = 22. 42.
24. 44.
26. 46.
El producto entre dos matrices se define mediante el operador para la multiplicación “*”. La operación A*B indica el producto matricial entre las matrices A y B. El producto de dos matrices se puede definir sólo si el número de columnas de la matriz izquierda es el mismo que el número de filas de la matriz derecha. Por ejemplo para matrices de 2x2
20
a b f g a.f b.h a.g b.i * c d h i c.f d.h c.g d.i
-->A=[1,1;2,2];B=[2,2]';C=[3,3;1,1]; -->A*C // product de matrices ans = 4. 8.
4. 8.
Scilab también puede efectuar el producto entre los elementos de dos matrices anteponiendo un punto al signo asterisco, es decir: .*. En el ejemplo siguiente se ve la diferencia entre ambas operaciones. -->A=[1,1;2,2];B=[2,2]';C=[3,3;1,1]; -->A*B ans = 4. 8. -->A.*C //product elemento por elemento ans = 3. 2.
3. 2.
2.9. EL GENERADOR DOBLE PUNTO
Resulta muy útil en el entorno de Scilab la generación de vectores formados por una sucesión de valores igualmente separados. A esos efectos dispone de una forma abreviada de generación de vectores que se escribe con el siguiente formato:
valor inicial : incremento : valor final Esto genera un vector cuyo primer valor es el valor “inicial” y los valores siguientes están igualmente espaciados en la cantidad “incremento” hasta llegar al valor “final”. Se puede omitir el incremento y en este caso se considera por defecto el valor 1.
21
-->x=3:0.5:7 x = 3.
3.5
4.
4.5
5.
5.5
6.
6.5
7.
Debido al uso del doble punto en la notación al operador se le conoce con el nombre de generador doble punto y también se utiliza en otras circunstancias. Por ejemplo si se dispone de una matriz c y se escribe d = c(:,2:3), el primer doble punto significa que se está considerando todas las filas, y luego las columnas de 2 a 3 con saltos de 1, es decir:
-->c=[-1 0 0;1 1 0;-1 1 0] c = - 1. 0. 0. 1. 1. 0. - 1. 1. 0. -->d=c(:,2:3) d = 0. 0. 1. 0. 1. 0.
Otra forma de generar un vector linealmente espaciado es mediante la sentencia linspace, que genera un vector fila de n puntos igualmente espaciados entre x1 y x2. v será un vector fila, real o complejo de acuerdo al valor de x1 y x2; n es un entero. El valor por defecto es 100.
[v]=linspace(x1,x2 [,n])
-->linspace(1,2,5) ans = 1. 1.25
1.5
1.75
2.
-->linspace(1+%i,2+2*%i,5) ans = 1. + i
1.25 + 1.25i 1.5 + 1.5i 1.75 + 1.75i 2. + 2.i
22
2.10. TIRA DE CARACTERES
Una cadena de caracteres (string) es básicamente una variable que contiene un texto que se coloca entre comillas simples o dobles. Una cadena de caracteres puede ser manipulada a través de comandos específicos. En esta sección veremos algunos que pueden ser de gran utilidad cuando se trabaja con archivos de texto.
Dos o más cadenas de caracteres pueden unirse en sucesión mediante la operación de concatenación, que se realiza directamente empleando el símbolo +:
-->t1="El resultado es " t1 = El resultado es -->t2="positivo" t2 = positivo -->t3=t1+t2 t3 = El resultado es positivo
Las matrices de caracteres se construyen como matrices ordinarias, es decir utilizando corchetes. Un uso muy importante de las matrices de caracteres es la manipulación y creación de funciones. El siguiente ejemplo ilustra la creación de una matriz de caracteres.
-->A=['x' 'y';'z' 'w+v'] A = !x ! !z
y w+v
! ! !
La función length calcula la cantidad de caracteres en la tira. Para matrices de tiras de caracteres retorna la longitud de cada uno de los elementos de la matriz.
23
-->length(‘123’) ans = 3. -->M=['a','bb';'ccc','dddd']; -->length(M) ans = 1. 2. 3. 4.
La función part permite extraer caracteres de una tira, para lo cual debemos indicar la posición del los caracteres a extraer. Para extraer una serie de caracteres, la posición se indica como una secuencia de valores. -->part("abcd",1) ans = a -->part("abcd",[1,3]) ans = ac -->t3=“El resultado es positivo”; -->part(t3,[1:12]) ans = El resultado
La función strindex(str1,str2) proporciona la posición que la tira str2 tiene en str1. Una vez que se determina la posición de str2 se puede utilizar la función part para extraerlo de la tira.
-->t3=”El resultado es positivo” -->strindex(t3,"es") ans = 5. 14.
La función strsubst(str1,str2,str3) reemplaza str2 con str3 en la tira str1.
-->strsubst(t3,"positivo","negativo") ans = El resultado es negativo
24
La función strcat(str1,str2) genera una tira insertando str2 entre los caracteres de str1. Este último tiene que ser un vector de caracteres. -->s=['a' 'b' 'c'] s = !a
b
c
!
-->strcat(s,'-') ans = a-b-c
La función string(x) convierte la matriz x en una matriz de caracteres:
-->s2=string(7) s2 = 7 -->s3='la suma es '+s2 s3 = la suma es 7 -->s4=string(1:5) s4 = !1 2 3 4 5 ! -->s5=s4(1)+s4(5) s5 = 15 -->s5+s4 ans = !151 152
153
154
155
!
Los caracteres números pueden convertirse a datos numéricos mediante la función evstr (evaluate string). -->n1=evstr(s4) n1 = ! 1. 2. 3.
4.
5. !
-->n1(1)+n1(5) ans = 6. -->evstr('2+2') ans = 4.
25
Como se observa en el último ejemplo, la función puede usarse para evaluar cualquier operación expresada como caracteres, incluyendo las que tienen variables que guardan números. También pueden ejecutarse sentencias expresadas como tiras de caracteres mediante la función execstr (execute string). -->execstr(['a=1' 'b=sqrt(9)']) -->a b -->a a = 1. -->b b = 3.
El resultado no se muestra pero al llamar las variables de salida se verifica que se ha realizado. Lo mismo se puede hacer con varias sentencias en un vector, como en el caso del último ejemplo. El ejemplo siguiente muestra la ejecución de un programa cuyas líneas se presentan como tiras de un vector:
-->execstr(['a=2' 'x=[]' 'for j = 1:4' 'x = [x a^j]' 'end']) -->x x = 2.
4.
8.
16.
26
CAPITULO 3 PROGRAMACIÓN
3.1. INTRODUCCIÓN
La forma interactiva de la Scilab resulta cómoda cuando se necesitan realizar cálculos que hagan uso de unos pocos comandos. A medida que el cálculo se complica, la lista de comandos se agranda y por ende se facilitan las equivocaciones. Por otra parte, resulta útil que una sucesión de comandos pueda guardarse para poder usarla posteriormente. A ese conjunto de sentencias que se puede ejecutar todas las veces que se requiera se le denomina un programa.
Es posible guardar el programa en un archivo de texto, para luego llamar y ejecutar las líneas de sentencias. En Scilab, la lista de comandos se organiza en un tipo de estructura a las que se les da el nombre de guión (script). Esta se guarda en un archivo de texto con extensión “sci” o “sce”. Por lo general se reserva la extensión “sci” para funciones definidas por el usuario para aplicaciones específicas. Por ejemplo, un archivo para una función que calcula el promedio de una lista de números puede llamarse “promedio.sci”. Cuando se escriben programas más extensos, donde se involucra el uso de varias sentencias y/o funciones se lo identifica con la extensión “.sce”. Esto puede verse cuando se quiere guardar una función, por default, aparece un archivo “*.sci” o en el caso de un listado de comandos, aparece “*.sce”. El uso de las extensiones es solo una convención y Scilab puede ejecutar programas (funciones y/o scripts) con cualquier extensión e inclusive sin extensión.
La estructura de un programa puede ser más rica que una simple sucesión de comandos, puesto que estos deberán ser ejecutados con cierta lógica, dependiendo de las necesidades propias de la aplicación. En Scilab existen comandos que permiten tomar decisiones de acuerdo a los resultados obtenidos, o permiten repetir un cálculo con distintos datos iniciales.
27
Estos enriquecen mucho las posibilidades numéricas de una función y son los llamados comandos de control que serán detallados más adelante.
Además de los comandos de control de flujo, los siguientes comandos son muy útiles para utilizar en la confección y manejos de programas.
; (operador punto y coma) colocado al final de una sentencia evita la impresión en pantalla de la salida del comando.
// permite introducir comentario, líneas que no se ejecutan.
Para ver el directorio actual de trabajo: --> pwd
Para cambiar el directorio de trabajo: --> chdir(‘nombre de nuevo directorio’)
Para listar archivos existentes en el directorio de trabajo: --> ls
Para ejecutar un programa que está en un directorio se usa: --> exec(‘nombre de archivo’)
3.2. DIRECTORIO PRINCIPAL DE TRABAJO Scilab establece al inicio, un directorio de trabajo “por defecto”. Este directorio de trabajo depende del Sistema Operativo que se esté utilizando y de la forma que se instaló Scilab. Se puede visualizar el directorio de trabajo actual de Scilab mediante el comando pwd.
-->pwd ans = C:\Archivos de programa\scilab-5.3.1
La carpeta “scilab-5.3.1” aparece aquí como el directorio de trabajo de Scilab. En la versión de Scilab para Linux el directorio de trabajo por defecto es el “home” de la cuenta del usuario que ha iniciado la sesión.
Generalmente, para evitar la mezcla de archivos, los programas no se guardan en el directorio de trabajo por defecto y puede resultar un poco tedioso indicar el lugar donde está ubicada cada función para ejecutarla. Existe una alternativa. Se puede modificar el directorio de
28
trabajo utilizando el comando chdir (change directory). En el ejemplo siguiente se cambia al directorio “programa-scilab”. -->chdir ('C:\programas-scilab') ans = T -->pwd ans = C:\programas-scilab
Si el archivo de comandos que se desea utilizar se encuentra en el directorio de trabajo actual, basta ejecutar el comando “exec” acompañado del nombre de la función para correr el programa. -->exec caida.sci ;
En el menú de File, de la barra de Scilab, también existen opciones que se pueden utilizar para ejecutar los programas guardados, para cambiar el directorio actual o mostrar el directorio de trabajo, y que facilitan la búsqueda de carpetas y archivos.
3.3. GUARDANDO LA SESIÓN DE TRABAJO
Los comandos que se van ingresando y ejecutando quedan almacenados en el historial de Scilab, éste puede ser recorrido con las teclas “hacia arriba ” y “hacia abajo ”. Los comandos van apareciendo en la línea de entrada del Scilab y el que nos interesa puede ejecutarse sin necesidad de volver a escribirlo en su totalidad, eventualmente pueden introducirse modificaciones en la línea de órdenes mediante las teclas “izquierda ” y “derecha ”.
En las versiones más nuevas de Scilab, cualquiera de ellas puede ser copiada utilizando las opciones copiar y pegar del menú Editar. En particular, esto puede utilizarse para ir generando información sobre los cálculos realizados. Esto es como se ha hecho en estos apuntes, donde los cuadros de ejemplos han sido llenados con información recogida de esa manera.
29
Es posible guardar en un archivo todos los comandos y resultados que se van obteniendo en una sesión de trabajo mediante el comando “diary”. Si se ejecuta al comienzo de la sesión: diary(“nombre_archivo”)
a partir de ese momento, todas las entradas y salidas interactivas van quedando registradas en el archivo nombre_archivo, que se guardará en el directorio de trabajo.
Para interrumpir el registro basta escribir la orden:
diary(0)
De ahí en adelante no se guarda el intercambio. Cabe aclarar que el comando diary guarda las entradas y las salidas tal como aparecen en la ventana de trabajo de Scilab.
Esto puede tener varios usos. Por ejemplo, si se está probando una función ensayando la entrada de cada uno de sus comandos, ellos quedan guardados con diary. Luego se toma el archivo con un editor de textos y eliminando los renglones innecesarios queda escrita la función que se estuvo ensayando, lista para ser usada.
En File, de la barra de menús de Scilab, también existen opciones para guardar y posteriormente recuperar (cargar) el entorno, es decir la sesión de trabajo, lo que genera un archivo de resguardo con extensión “.sav”. A diferencia del archivo generado por el comando diary este no se puede editar.
3.4. ENTRADA Y SALIDA SENCILLAS
La función input se utiliza para la entrada de datos a través de la consola. Su forma general es: [x] = input(mensaje,[“string”])
x es la variable cuyo valor se requiere ingresar, mensaje es un letrero que aparecerá en la consola identificando la entrada requerida, el argumento “string” o “s” sólo se coloca si se solicita el ingreso de una variable tipo tira de caracteres.
30
-->x=input("Entre un valor de x:") Entre un valor de x:2.5 x = 2.5 -->m=input("Entre un titulo para el problema:","s") Entre un titulo para el problema: Problema N° 1 m = Problema N° 1
Esta función no se utiliza cuando se trabaja en forma interactiva, ya que en ese caso las variables se ingresan en forma directa. En cambio si puede ser de mucha utilidad cuando se necesita entrar datos en un programa.
La función disp imprime el contenido de una variable en la salida estándar (monitor). Su forma general es:
disp(x1,[x2,....,xn]) Donde las xn pueden ser nombres de variables, constantes o tiras de caracteres. Esta función requiere al menos un argumento. De haber varios se van mostrando uno por línea, comenzando por el último. -->x=2.5,y=13.2 x = 2.5 y = 13.2 -->disp(y,"y=",x,"x=") x= 2.5 y= 13.2
31
3.5. ESTRUCTURA DE UNA FUNCIÓN
Supongamos z
que
queremos
evaluar
numéricamente
el
movimiento de una bola que se arroja verticalmente. Si se coloca un eje z, ver figura, la posición queda identificada por la coordenada z y el movimiento está descripto por la función z(t) donde t es el tiempo. Si el eje es positivo hacia arriba, la bola
vo
parte del origen, su velocidad inicial vale vo y la aceleración de origen
la gravedad es g. La ecuación del movimiento es:
g
z = vo*t - 0.5*g*t2
FIG.- Movimiento vertical de una bola.
Se supone que aceleración y velocidad son positivas cuando se orientan hacia arriba.
Los comandos para calcular esta expresión en forma interactiva se dan en la pantalla de abajo. En esta, se han dado valores específicos a la velocidad inicial (2 ms-1), gravedad (9,8 ms-2 ), tiempo (10 s). Esto se hace a continuación del primer prompt y en el segundo se introduce la ecuación para calcular la posición. La respuesta es que la bola ha caído 470 m desde donde se inició el movimiento.
Si deseamos calcular z varias veces convendrá colocar este procedimiento dentro de una función. Para ello se debe utilizar un editor de texto donde escribir la función, se puede utilizar cualquier editor, pero Scilab dispone de SciNotes, que se ejecuta desde el menú Applications.
-->vo=2 vo = 2. g = 9.8 t = 10.
,
-->z= vo*t z = - 470.
g= 9.8
-
,
t=10
0.5*g*t^2
32
La estructura que debe tener la función para que Scilab la reconozca es: function [res1,res2,…] = nombre(par1,par2,....) …………………… endfunction
Las líneas de punto indican dónde deben colocarse los comandos de cálculo. El nombre identifica a la función y deberá ser llamada desde la ventana de trabajo con ese nombre; par1, par2, etc. son parámetros que se introducen desde fuera de la función para que sean usados por la misma en el cálculo; res1, res2, etc. son las variables en las cuales la función devuelve los resultados del cálculo. Tomando el caso del ejemplo anterior, se crea la función “caida” que almacena el resultado del cálculo en la variable z, y que contiene los siguientes comandos:
function z = caida(vo,g,t) // Calculo de la posición de una bola en caída libre // vo = velocidad de la bola // g = aceleración // t = tiempo, // z = distancia resultado z = vo*t - 0.5*g*t^2 endfunction
Cabe mencionar que en el editor SciNote los distintos tipos de comandos se muestran con colores característicos, lo que facilita la lectura del procedimiento. También ayuda mucho a la lectura el utilizar sangrías (código tabulado) entre bloques de comando que pertenecen a un mismo nivel de decisión. Los comandos que comienzan con // son comentarios que Scilab no procesa. Se colocan en un procedimiento para que el que inspecciona la función tenga una explicación adecuada del cálculo. Para usar la función es necesario que esté guardada en un archivo, por ejemplo “caida.sci”, e indicarle a Scilab donde está para que la encuentre. Si la función está en el directorio de trabajo, esto se realiza mediante el comando “exec” como sigue:
33
-->exec(“caida.sci”);
Esto basta hacerlo una vez, por ejemplo cuando se pone en marcha Scilab, para que la función esté disponible para otros cálculos. El camino (path) que se colocó antes de llegar al archivo caida.sci es uno en particular y debe coincidir con el directorio donde se guarda la función creada. A menos que definamos otro lugar casi siempre será el directorio de trabajo de cada usuario. El punto y coma al final del comando evita que todas las líneas del programa aparezcan en la pantalla de trabajo cuando se carga la función, esto mejora la lectura de la pantalla de trabajo. Se aprecia en el programa caida.sci que la letra z no se ha puesto entre los corchetes [
]. Esto se puede hacer si la función tiene una sola respuesta. Si hay varias se
colocarán separadas por coma como se indica en la definición general de la estructura de una función.
A continuación ejecutaremos la función, para lo cual se la carga con la opción ejecutar desde el directorio File o con la sentencia exec directamente en el prompt de la ventana de trabajo. Luego se llama la función con su nombre asignando el resultado a la variable x. En el llamado hay que introducir el valor de los parámetros. En el ejemplo se asignan los siguientes valores vo: 3 m/s, g: 9.8 m/s2 y t: 2 s. El resultado es –13,6 m. Debe tenerse cuidado de colocar adecuadamente los signos. Obsérvese que se utiliza la variable x para cargar el resultado de la función, mientras que adentro de la misma se utilizó la variable z. Esto se puede hacer porque las variables en la función son locales y no globales, lo que se explicará mas adelante. -->exec(“caida.sci”); -->x=caida(3,9.8,2) x = - 13.6
Como se indicó anteriormente, bajo el menú File aparece la opción ejecutar. Si se llama desde allí se abre una ventana para el manejo de directorios. Desde allí se busca el directorio donde se encuentra la función. Esto es cómodo si no recordamos exactamente la ubicación de la misma.
3.6. VARIABLES GLOBALES Y LOCALES
34
Cuando dentro de un programa se utiliza una función, las variables definidas dentro de la función no están disponibles para el programa principal, se dice que son variables locales a la función. Ambos, función y programa principal, se comunican a través de los parámetros de la función, por ellos se ingresa la información externa necesaria, y por medio de las variables de salida de la función, ésta entrega los cálculos realizados.
Existe la posibilidad de utilizar dentro de una función una variable que se declara en el programa principal, declarándola como variable global. Para ello basta definir una variable dada, por ejemplo vari1, mediante el comando global como se indica a continuación: global vari1
o
global(“vari1”)
Este comando se escribe en el programa principal, generalmente al inicio. Como se aprecia, el comando puede escribirse en dos formas diferentes. Una vez definida como global, la variable “vari1” puede ser usada dentro de cualquier función con el valor que se le asigna sin necesidad de entrarla como un parámetro de la función. Por supuesto, en ese caso cualquier cambio que se le haga al valor de la variable dentro de la función también va a cambiar el valor de la variable en el programa principal.
Como ejemplo, supongamos que se escribe la siguiente función, que se guarda con el nombre pru.sci
function c=pru(b) c=b*f endfunction
En ella se introduce como parámetro la variable b y se usa directamente la variable “f”, para lo cual deberá estar definida anteriormente como variable global. En el cuadro siguiente, en primer lugar se carga la función pru. Luego se define la variable f como global, y dentro del programa principal, se asignan los valores de las variables f y b, siendo ésta última la única que se introduce como parámetro de la función. Luego se llama la función pru que realiza el producto de b por f. Como se observa, el valor de f es usado directamente por la función, sin que tenga que ser ingresada como un parámetro.
35
-->exec pru.sci; -->global f -->f=6; b=2; -->pru(b) ans = 12.
Es posible definir una variable local de una función como global. En ese caso quedará disponible para ser utilizada en otra función, para lo cual la misma debe ser definida también como global en la nueva función. Como ejemplo, definamos una función “pru1” cuyo único objetivo es definir la variable z interna a la función. Para que ella esté disponible para otro programa se la define como global. Por otro lado, en el otro programa, “pru2”, también se define z como una variable global y se realiza el producto de esta con el parámetro de entrada b; el resultado se guarda en la variable c. function z=pru1() global z z=3 endfunction function c=pru2(b) global z c=b*z endfunction
A continuación, luego de cargarlas en Scilab, llamamos sucesivamente pru1 y pru2, observando como pru2 usa correctamente el valor de z definido por pru1. -->pru1() ans = 3. -->b=2 b = 2. -->pru2(b) ans = 6.
36
Un caso típico del uso de variables globales es el de constantes que se utilizan a lo largo del cálculo, que conviene definirlas globales para no repetir definiciones en cada función. Fuera de estos casos y para evitar errores de programación, en general no se recomienda el uso de variables globales y en la medida de lo posible solamente utilizar variables locales en las funciones, haciendo el intercambio de información a través de los parámetros formales.
3.7. OPERADORES RELACIONALES Y LÓGICOS
Acabamos de ver la forma en que se define una función utilizando un ejemplo muy sencillo con un solo comando. En la práctica, las funciones constarán de más de un comando, por lo que con el fin de plantear cálculos de utilidad será necesario disponer de mayor ductilidad en dos aspectos:
a) En poder tomar decisiones en el cálculo teniendo en cuenta los resultados que se están obteniendo. Por ejemplo, el cálculo a realizar podría ser distinto si el valor de una cierta variable es positivo o negativo. b) En muchos casos es necesario realizar cálculos repetitivos. Por ejemplo, obtener el resultado de un cierto cálculo varias veces con distintos valores de los datos.
La toma de decisiones se hará por comparaciones numéricas o lógicas en el programa. Se necesita disponer de operadores que puedan hacer esas operaciones. Ellos son de dos tipos: operadores relacionales y operadores lógicos.
a) Los operadores relacionales son aquellos capaces de comparar dos cantidades numéricas y decidir cuanto vale una respecto a otra. Los que están disponibles, incluyendo el símbolo que los definen son las siguientes:
<
menor
<= menor o igual >
mayor
>= mayor o igual == igual ~= ó <> diferente
37
Mediante estos operadores se comparan los valores de las variables. Por ejemplo, si se dispone de dos variable, e y f, y se quiere saber si e es menor que f se preguntará:
e
El resultado de la operación será un valor lógico, verdadero (True) o falso (False). -->e=3;f=5; -->e>f ans = F
Estas operaciones pueden combinarse mediante operadores lógicos.
b) Los operadores lógicos compararán valores lógicos derivados de comparaciones relacionales. Los operadores lógicos son:
& ~
y o no
Por ejemplo, si se tienen 4 variables p, q, r y s se podría escribir: p < q &
r > s. Si p es
menor que q y r mayor que s esta comparación lógica dará un valor lógico verdadero. -->p=2;q=5;r=7;s=3; -->ps ans = T
3.8. SENTENCIAS DE CONTROL DE FLUJO
38
Como todo lenguaje de programación, en Scilab podemos encontrar bifurcaciones y bucles que son de suma utilidad a la hora de hacer tomas de decisiones. Las bifurcaciones sirven para realizar una u otra operación, mientras que los bucles nos permiten realizar varias iteraciones de un mismo proceso. A continuación describimos los comandos de control de flujo disponibles, así como algunos comandos especiales asociados con ellos.
3.8.1. Comando If
verdadero
falso
Condición 1
Condición
falso
verdadero
verdadero Sentencia 1
Sentencia 1
Condición 2
Sentencia 2
falso Sentencia 3
Sentencia 2
El comando if es una sentencia de bifurcación con la que se puede inspeccionar una condición descripta mediante un operador relacional o combinaciones lógicas de los mismos. Su forma más sencilla es:
if
condición then
.......................... end
Si la condición tiene un resultado lógico verdadero el programa ejecuta las sentencias indicadas con punteado. De lo contrario, salta directamente a continuación de end.
La condición del if puede ser una condición lógica, del tipo A==B, donde A y B son matrices del mismo tamaño. Para que se considere que la condición se cumple, es necesario que sean iguales todos los elementos de las matrices A y B. Basta que haya dos elementos diferentes para que las matrices no sean iguales, y por tanto las sentencias del if no se ejecuten.
39
Otra posibilidad es una bifurcación entre verdadero y falso haciendo uso de la sentencia else. Si la condición es verdadera se ejecutan las sentencias dentro del bloque then, si la condición resulta falsa se ejecutan las sentencias correspondientes al bloque else.
if
condición then
.......................... else ……………….. end
Otra alternativa son las bifurcaciones anidadas, de acuerdo al resultado de la condición de la sentencia elseif:
If condición1 ……………… elseif condición 2 ……………… else ……………… end
Habitualmente estas condiciones forman parte de una función, pero también se pueden usar expresadas en un solo renglón dentro del entorno interactivo separando las sentencias con comas. Por ejemplo: -->If x<0 , fx=x^3, else, fx= 3*x^2, end
3.8.2. Comando for
Sentencias condición verdadero falso
40
El comando for se utiliza si se quiere realizar una acción en forma repetitiva, teniendo en cuenta una variable que se incrementa en cada paso y que puede ser utilizada para cambiar algún aspecto del cálculo que se repite:
for var= limite1:incremento:limite2 ........................... ........................... end
La variable se incrementa desde el limite1 hasta el limite2 avanzando en pasos de incremento. Se suele decir que se está realizando un bucle. La variable var puede ser usada en los comandos dentro del bucle para variar el cálculo en cada paso. Se pueden introducir varios bucles, uno dentro del otro, anidados. En este caso se requiere que cada for esté terminado por su respectivo end.
Los comandos de flujo pueden ser usados en forma conjunta. Por ejemplo, un comando if puede estar dentro del grupo de comandos de un bucle for, pero cada uno de ellos deberá estar cerrado por su respectivo end.
for x= -3:3; if x=<0 then; fx=x^3 else; fx= x^2 end; end;
En este ejemplo el ciclo for repite las sentencias para los valores de x que van de -3 a +3 con incrementos de 1 (valor por defecto). Si el valor es negativo o cero se calcula el cubo y cuando es positivo se calcula el cuadrado.
3.8.3 Comando while
En este caso también se ejecuta una acción repetitiva. Se fija la condición, y siempre que ésta se cumpla, el bucle se repite. Al dejar de cumplirse la condición impuesta se termina el bucle y se continúa con la instrucción siguiente.
41
while condición ................... end
Se diferencia del ciclo for en que necesariamente la acción dentro del bucle debe modificar la(s) variable(s) de la condición. Esta condición debe alcanzar el valor lógico false, en algún momento de la ejecución, porque de lo contrario se entraría en un bucle sin salida que repetiría infinitamente las instrucciones dentro del bloque, provocando que el programa no continúe. En el siguiente ejemplo se genera la tabla del dos hasta llegar a 10.
e=1; k=1; while k < 11, e=2*k k=k+1; end
3.8.4. El comando select
Este comando es una forma abreviada de sentencias if-elseif sucesivos, donde los valores que puede tomar la variable de control deben estar claramente definidos, para buscar el cumplimiento entre varias alternativas:
select variable case valor1 then ……… case valor2 then ……… . case valor n then ………. else ……….. end
42
Al principio se evalúa la variable de control cuyo resultado debe ser un escalar o una cadena de caracteres. La condición selecciona un resultado entre varios valores de variable, estos son valor1,valor2, etc. Si variable no toma alguno de los valores dados, entonces se continúa por else ejecutando el último conjunto de comandos.
n=round(10*rand(1,1)) select n case 0 then disp(0) case 1 then disp(1) else disp("ni 1 ni 0") end
En la primera línea del ejemplo se genera un número en forma aleatoria y se toma su parte entera. Si el número es cero se muestra el valor, si es uno también se muestra, en caso contrario se muestra un cartel.
3.9. DEFINICIÓN DE FUNCIONES EN LÍNEA
Como se vio anteriormente, el usuario puede definir sus propias funciones en un archivo de texto, los guarda con extensión “sci” y los carga en Scilab mediante el comando getf o exec cuando quiere utilizarlos.
Existe una forma de hacer definición de funciones en línea (on-line) en la pantalla de trabajo y en una sola instrucción a través de la sentencia deff. Estas son muy útiles para programas que sólo se utilizan una vez o para probar partes de funciones en la etapa de diseño del programa. La función no queda almacenada una vez que se termina la sesión de trabajo.
La descripción del comando deff es la siguiente: deff('[s1,s2,...]=nom_fun(e1,e2,....)', [‘inst1’, ‘inst2’, …]) s1, s2,… representan los nombres de las variables de salida, e1, e2,…. representan los nombres de las variables de entrada, nom_fun es el nombre de la función creada, inst1, inst2,… es una secuencia de instrucciones que se colocan como cadena de caracteres. Estas
43
instrucciones constituyen la definición de la función y deben incluir la asignación de la variable de salida.
El comando deff puede ser utilizado dentro de una función y la nueva función puede ser una entrada o salida de cualquier otra función. A continuación se dan algunos ejemplos de definiciones:
-->deff('[y] = f(t)','y = exp(-t)*sin(2*t)') -->y=f(10) y = 0.0000414 -->deff('[x,y] = h(r,theta)',['x = r*cos(theta)','y = r*sin(theta)']) -->r=1; theta=30; -->[x,y]=h(r,theta) y = - 0.9880316 x = 0.1542514
44
CAPÍTULO 4 GRÁFICOS EN SCILAB 4.1. INTRODUCCIÓN
Scilab dispone de salidas gráficas muy variadas, que permiten mostrar los resultados que se obtienen de un programa o los datos que se reciben y es necesario analizar. Con los recursos gráficos de Scilab se pueden:
1) Mostrar funciones en dos y tres dimensiones, con gran variación en la forma en que se ingresan los datos y una buena disponibilidad de recursos técnicos tales como figuras en color, ampliaciones, rotaciones, etc . 2) Generar representaciones especiales como ser curvas de iso-valores, distribuciones con tonos de gris, etc. 3) Mostrar animaciones, es decir, figuras que van cambiando con el tiempo.
Dada la gran variedad de recursos, se irán presentando en forma ordenada desde los recursos más sencillos y de uso común hasta llegar a las representaciones más elaboradas.
4.2. LA VENTANA GRÁFICA Scilab abre una ventana distinta de la ventana de trabajo para dibujar los gráficos solicitados. Pueden abrirse varias ventanas gráficas a la vez y están identificadas con un número (0,1,2,3....). En esta ventana gráfica están disponibles los siguientes menús: File Herramientas Editar ? (ayuda)
Dentro del menú File encontramos las opciones: New: abre una nueva ventana gráfica.
45
Load: permite leer un gráfico grabado en formato SCILAB. Save: permite grabar el gráfico en formato SCILAB , con la extensión . scg ( por defecto). Export: permite grabar el gráfico en formatos como Postscript, GIF, BMP, etc. Copy to clipboard: copia el gráfico al portapapeles para que puede pegarse en otros documentos. Print: imprime el gráfico activo. Close: cierra la ventana gráfica.
El menú Herramientas contiene comandos para poner o quitar la barra de herramientas, agrandar o disminuir zonas de la imagen y rotar los gráficos 3D. El menú Editar contiene los comandos propios de un editor gráfico para cambiar las propiedades de la figura (forma de ejes, letras color, etc)
Cuando ejecutamos una instrucción para generar gráficos, como plot que se explicará a continuación, si ninguna ventana gráfica está activada Scilab coloca el dibujo en la ventana
46
número 0. Si hacemos otro gráfico éste se ubicará encima del primero. Por lo tanto es necesario borrar el contenido de la ventana gráfica, lo que puede hacerse de dos maneras:
Desde el menú Editar ( ítem limpiar figura )
Desde la ventana de trabajo de Scilab con la instrucción clf() o xbasc()
Podemos trabajar muy fácilmente con varias ventanas gráficas, con la ayuda de las instrucciones:
xset("window",num)
xselect()
Convierte la ventana número num en la ventana activa. Si esta ventana no existe, es creada por Scilab. Pone adelante la ventana activa. Si no existe alguna ventana gráfica, Scilab crea una. Borra el contenido de la ventana gráfica número num
xbasc(num)
Si num se omite, Scilab borra el contenido de la ventana activa.
xdel(num)
Elimina la ventana gráfica número num Si num es omitido, Scilab elimina la ventana activa.
4.3. REPRESENTACIÓN EN 2D
La forma más simple para trazar la gráfica de una función de R x R es mediante la instrucción plot. Para ello creamos previamente un vector x para las abcisas y un vector y para las ordenadas. El comando plot(x,y) representa los puntos de coordenadas (x(i),y(i) uniéndolos por defecto mediante líneas negras o de acuerdo a otro estilo que se haya especificado previamente. La calidad de la representación dependerá del número de puntos x(i),y(i) que se grafiquen .
El llamado general de la función es:
plot(x,y,,)
47
Con plot también se puede graficar un conjunto de curvas, es decir hacer gráficos múltiples.
plot(x1,y1,,x2,y2,,...xN,yN,,, ,..)
x debe ser una matriz o un vector de números reales. Si se omite se asume un vector de 1:n donde n es el número de puntos de la variable y. y debe ser una matriz o vector de reales, pero también puede ser una función definida. es un argumento opcional que especifica la manera en que se dibujan las líneas. Debe ser una tira de caracteres y determina el estilo, las marcas y el color de las líneas dibujadas. (ver LineSpec en 4.3.1). es un argumento opcional que define las propiedades globales de los objetos comunes a todas las curvas creadas por plot. Son tiras de caracteres colocadas como pares de sentencias {NombrePropiedad,ValorPropiedad}. (ver GlobalProperty).
Si y es un vector, plot(y) grafica el vector y versus el vector 1:size(y) . Si y es una matriz, plot(y) grafica las columnas de y versus el vector 1:size(y,1) . Si x e y son vectores, plot(x,y) grafica el vector y versus el vector x . Los vectores x e y deben tener el mismo tamaño. Si x es un vector, e y una matriz, plot(x,y) dibuja cada una de las columnas de y versus el vector x . En este caso la dimensión de las columnas de y debe ser igual a las de x. Si x e y son matrices, plot(x,y) dibuja cada columnas de y versus las correspondientes columnas de x . En este caso las dimensiones de x e y deben ser las mismas. Si sólo x o y es una matriz, el vector se dibuja versus las filas o las columnas de la matriz. La elección depende si el vector, fila o columna, ajusta con las dimensiones de las filas o columna de la matriz. En el caso de una matriz cuadrada la prioridad la tienen las columnas.
48
y también puede ser una función, en este caso se debe proporcionar x (como un vector o matriz) y el cálculo y(x) se hace implícitamente. -->x=linspace(0,3*%pi,50); y=x.*sin(x); -->plot(x,y) 9
7
5
3
1
-1
-3
-5 0
1
2
3
4
5
6
7
8
9
10
-->x=[0:0.1:2*%pi]’; -->plot(x-4,sin(x),x+2,cos(x))
4.3.1 LineSpec
Se utiliza para cambiar rápidamente la apariencia de las líneas de un dibujo. Debe ser una tira de caracteres que hace referencias al del estilo de la línea, el marcador y el color. Estas referencias deben ser especificadas sin ambigüedades, el orden no es importante. Por ejemplo, para una línea roja de rayas largas con marcador tipo diamante, se puede escribir: 'r--d' o '--
49
dire' o '--reddiam'... o en forma completa 'diamondred--'. A continuación se proporciona una lista completa de los tipos que se pueden especificar. LineStyle: define el estilo de la línea. Especificador
Estilo de Línea
-
Línea Sólida (default)
--
Línea de trazos
:
Línea de puntos
-.
Línea de trazos y puntos
Color: define el color.
Especificador Color r
Rojo
g
Verde
b
Azul
c
Cian
m
Magenta
y
Amarillo
k
Negro
w
Blanco
Si no se especifica un color cuando se dibujan líneas múltiples, el color rota automáticamente según esta tabla.
50
R
G
B
0.
0.
1.
0.
0.5 0.
1.
0.
0.
0.75 0.75
0.75 0.
0.
0.75
0.75 0.75 0. 0.25 0.25 0.25
Marker type: Define el tipo de marcador. Si se especifica un marcador sin un estilo de línea, se dibuja solo el marcador. Especificador
Tipo de Marcador
+
Signo mas
o
Circulo
*
Asterisco
.
Punto
x
Cruz
'square' o 's'
Cuadrado
'diamond' o 'd'
Diamante
^
Triangulo hacia arriba
v
Triangulo hacia abajo
>
Triangulo hacia la derecha
<
Triangulo hacia la izquierda
'pentagram'
Estrella de cinco puntas
'none'
Sin marcador (default)
Por ejemplo clf();
51
x=1:0.1:10; plot(x,sin(x),'r-.>')
dibuja la función seno con una línea roja de raya-puntos con un triángulo apuntando a la derecha centrado sobre cada punto.
4.3.2. GlobalProperty Es posible modificar la apariencia de todas las curvas en forma global. Se debe especificar el par {Nombre_Propiedad, Valor_Propiedad}, pudiéndose colocar en un gráfico varios pares al mismo tiempo. Nombre_Propiedad es una tira de caracteres con la propiedad a modificar. Valor_Propiedad puede ser un real, entero o tira de caracteres, dependiendo del tipo de propiedad. Por ejemplo, para especificar una línea roja (nombre Color), con raya y puntos (nombre Line Style) con marcador diamante (nombre Marker), la secuencia debe ser: 'Colo','red','LineSt','-.','Marker','diam'. No es necesario colocar el nombre o el valor completo de la propiedad. Tampoco importa el orden, pero no debe haber ambigüedades. GlobalProperty predomina sobre cualquier LineSpec previamente especificado.
A continuación se proporciona una lista de Nombres y sus Valores asociados:
Clipping: caracteres con valor "on" o "off" definiendo el modo de cortado ( "on" por defecto). Color o Foreground: caracteres especificando un color o un vector RGB de 1 x 3. Este último es una 3-upla que corresponde a la intensidad de rojo, vede y azul entre 0 y 1. LineStyle: una tira de caracteres que define el estilo de línea, en forma idéntica que con LineSpec. Marker o MarkStyle: Una tira de caracteres que define el tipo de marcador. Idéntico que con LineSpec. MarkerEdgeColor or MarkForeground: Una tira de caracteres definiendo un color en el formato RGB. Idéntico a Color pero para el borde del marcador. MarkerFaceColor or MarkBackground: Idéntico a Color pero para el fondo del marcador. MarkerSize or MarkSize: un escalar que define el tamaño del marcador en unidades de punto. Visible: una cadena de caracteres "on" o "off" definiendo la visibilidad ( "on" por defecto).
52
X data: un vector o matriz real redefiniendo los datos para todas las líneas o superficies dibujadas. Debe ajustase con los X data previamente especificados. Es decir, todas las matrices de datos deben ser de la misma dimensión. Y data: Idéntico al anterior pero para los datos Y. Z data: cuando se usa con plot , un vector o matriz real agregando datos Z para todas las líneas dibujadas; Este debe tener las mismas dimensiones que los X e Y data previamente especificados.
Por ejemplo clf(); x=1:10; plot(x,sin(x),'colo','red','linest','-.','marker','>','markeredg', 'cyan','markerFace','yellow','markersize',5)
dibuja una línea de color rojo, con estilo raya-puntos, marcador triángulo hacia la derecha, los bordes del triángulo de color cian, las caras de color amarillo y tamaño 5 puntos.
La representación de una función se pueden hacer con el comando plot, pero para ello es necesario definir previamente la función que se va a representar. Por ejemplo, a continuación se grafica el cuadrado de un número:
deff('[y]=toto(x)','y=x.*x') plot(1:10,toto)
Se obtiene el mismo resultado mediante fplot2d -->deff("y=f(x)","y=x.*sin(x)") -->x=linspace(0,3*%pi,100); -->fplot2d(x,f)
Cuando queremos superponer varias curvas en el mismo gráfico, se puede usar el comando plot2d, que permite fijar estilos diferentes para cada curva. La sintaxis general es la siguiente:
53
plot2d(abscisas, ordenadas, estilo, )
Los argumentos a partir del tercero son optativos, pero si se fija uno deberán fijarse los otros. El significado de estos argumentos es el siguiente: abscisas, ordenadas: son matrices de la misma dimensión. Si fueran vectores (para trazar una sola curva), deben ser fila o columna. Por defecto los puntos serán unidos por segmentos. A cada curva le corresponde un color ( hay 32 colores).
estilo: es un vector línea cuya dimensión es el número de curvas a trazar (número de columnas de las matrices abscisas y ordenadas). Las coordenadas son positivas o negativas. Si el estilo es positivo, los puntos se unen por segmentos. Si el estilo es nulo, los puntos se presentan como pixeles negros. Si el estilo es negativo, se presentan como marcas de formas particulares.
marco : este parámetro es una tira de caracteres formado por tres cifras, tales que :
la primera indica la presencia o no de leyendas ( 0 o 1),
la segunda indica la forma de cálculo de las escalas,
la tercera indica el trazado de ejes o del marco.
Por defecto el argumento marco vale “021” (sin leyendas, escalas calculadas automáticamente y con ejes). Si superponemos dos gráficos con esta opción por defecto, las escalas no serán las mismas. La solución consiste en trazar todos los gráficos a partir del segundo sobre una misma ventana con la opción “000” (sin leyenda, utilizar la escala precedente, sin trazar los ejes).
leyendas: es una cadena de caracteres que contiene las diferentes leyendas, separadas por @.
límites: es el rectángulo de la representación, descrito por las dos coordenadas de la esquina inferior izquierda, seguidas de las dos coordenadas de la esquina superior derecha: [xmin,ymin,xmax,ymax].
graduaciones: este vector de cuatro enteros permite precisar las graduaciones y subgraduaciones en abscisa y ordenada. Por ejemplo, con [2,10,4,5], el intervalo de las
54
abscisas de dividirá en 10, siendo cada uno de los subintervalos divididos en dos. Para las ordenadas habrá 5 subintervalos, cada uno dividido en 4.
logflag: Esta opción puede usarse para fijar las escala ( lineal o logarítmica) a lo largo de los ejes. Los valores asociados son tiras de caracteres con los valores posibles: "nn" , "nl" , "ln" and "ll" . "l" para escala logarítmica y n para escala normal. -->x=linspace(0,3*%pi,30); X=x'*ones(1,10); -->y=x.*sin(x); Y=y'*[1:10]; -->colores=matrix([2;5]*ones(1,5),1,10) -->xbasc() -->plot2d(X,Y,colores) -->marcas=-[0:9] -->xbasc() -->plot2d(X,Y,marcas) -->xbasc(); -->plot2d(x,y) -->plot2d(x,y2,1,"000")
-->x=linspace(0,3*%pi,30); -->y=x.*sin(x); -->xbasc() -->plot2d(x,y,1,"011"," ",[0,-10,10,10],[2,10,4,5])
Los comandos plot y plot2d producen líneas continuas para las curvas que se grafican. Si queremos usar otro tipo de curvas debemos considera el uso de otros comandos gráficos como plot2d2(gráficos en escalón), plot2d3(barras verticales), y plot2d4(estilo con flechas).
4.4. MANIPULACIÓN DE LOS PARÁMETROS DEL GRÁFICO Los parámetros globales de un gráfico se refieren a las opciones usadas en el gráfico como el tipo y tamaño de letra de las etiquetas, el tipo y tamaño de marcas para los puntos graficados, el mapa de colores (una matriz de definiciones de colores para las áreas llenas del gráfico), el número de ventanas que se crearán, la posición de la ventana gráfica, etc. Estas propiedades pueden cambiarse mediante el comando xset: xset(choice-name,x1,x2,x3,x4,x5) xset( )
55
Los parámetros de esta función son un string, choice-name (propiedad que se desea cambiar), y cinco números, , x1,x2,x3,x4,x5, que dependen del valor de choice-name y la definen en detalle. Algunas de las propiedades que pueden manejarse con xset son: xset("auto clear","on"|"off"): Cuando está en “on” los gráficos sucesivos no se superponen, se hace una operación xbasc() entre cada gráfico. El valor por defecto es “off”. xset("background",color) : Fija el color del fondo de la ventana gráfica. xset("colormap",cmap): Fija el mapa de colores como una matriz de mx3, donde m es el número de colores.
Cada color está dado por tres números que corresponden a las
intensidades entre 0 y 1 de rojo, verde y azul. xset("default"):Vuelve el entorno gráfico a sus valores por defecto. xset("font",fontid,fontsize): Fija el tipo y tamaño de letra. El fontsize corresponde a los tamaños de font típicos usados en los textos, mientras que fontid se refiere a los siguientes estilos de font: 0 Courier 1 Symbol 2 Times 3 Times Italic 4 Times Bold 5 Times Bold Italic xset("foreground",color):Fija el color del marco del gráfico. xset("thickness",value): Fija el grosor de las líneas en píxeles l (0 y 1 representan 1 pixel de ancho). xset("use color",flag) Si flag=1 se usarán xset("pattern",.) o xset("dashes",.) para cambiar el color por defecto para dibujar o para los patrones de relleno. Si flag=0 volvemos al modo gris y con rayas. xset("window",window-number): Fija como ventana actual la ventana número windownumber y crea la ventana si ésta no existe. El comando window-number tiene que ser un entero no negativo. El valor por defecto es SCILABGraphic0, que corresponde a window_number = 0.
56
-->x = (0.1:0.1:20); -->y = sqrt(1+x^2); -->for j = 0:5 -->xset('window',j), xset('font',j,4) -->plot(x,y,"x","y","titulo") -->end
El comando xset() o el comando xsetm(), ambos sin argumentos, pueden usarse para cambiar propiedades del gráfico a través de una ventana interactiva provista por SCILAB.
Otro comando existente para manejar propiedades de gráficos es el plotframe, cuya forma general es:
plotframe(rect,tics [,arg_opt1,arg_opt2,arg_opt3])
Con este comando pueden fijarse lo valores máximos y mínimos de los ejes (rect), los intervalos y subintervalos que se marcarán (tics) y con los argumentos optativos podemos agregar una grilla al gráfico, títulos y dividir la ventana para dibujar varios gráficos en ella. El ejemplo siguiente ilustra su uso: -->x=[-0.3:0.8:27.3]'; y=rand(x); // generador de numerous aleatorios -->rect=[min(x),min(y),max(x),max(y)]; -->tics=[4,10,2,5]; //4 x-intervalos and 2 y-intervalos -->plotframe(rect,tics,[%f,%f],['Mi grafico','x','y'],[0,0,0.5,0.5]); -->plot2d(x,y,2,'000')
4.5. GRÁFICOS COMPUESTOS
57
Si una misma representación gráfica involucra varias escalas diferentes, es mejor especificar primero el rectángulo de la representación y las escalas de los ejes mediante plotframe, para después superponer los diferentes gráficos.
xbasc(); xset("font",2,4); plotframe([-4,-1,4,1],[2,10,5,10],[%f,%f],["Título","Eje x","Eje y"]); x=linspace(-%pi,%pi,50); y=sin(x); plot2d(x,y,1,"000"); // traza una curva x=linspace(-%pi/2,%pi/2,5); y=sin(x); xset("mark",1,4); plot2d(x,y,-3,"000"); // 5 marcas x=linspace(-%pi,%pi,20); y=sin(x)/2; xset("use color",0); xset("pattern",13); xfpoly(x,y); // superficie gris
Eje y
Título
1.0 0.8 0.6 0.4 0.2 0.0 * -0.2 -0.4 -0.6 * -0.8 -1.0 * -4.0 -3.2 -2.4 -1.6 -0.8 0.0
* *
Eje x 0.8
1.6
2.4
3.2
4.0
Es frecuente que un gráfico contenga no sólo una o más representaciones de funciones, sino también cadenas de caracteres, rectángulos, elipses u otros agregados al gráfico. Las coordenadas de estos agregados son relativas a la ventana corriente.
58
Agregados sobre el gráfico xarc
arco de elipse
xfarc
arco de elipse lleno
xarrows flechas xnumb números xpoly
polígono
xfpoly polígono lleno xrpoly polígono regular xrect
rectángulo
xfrect
rectángulo lleno
xstring cadena de caracteres (a partir de un punto) xstringb cadena de caracteres (dentro de un rectángulo) xtitle
título del gráfico y de los ejes
xbasc() plotframe([-1,0,2,4],[10,3,5,4],[%f,%f],["Parábola","x","f(x)"]) x=linspace(-1,2,100); y=x.*x; plot2d(x,y,2,"000") // representa la curva plot2d([1,1,-1],[0,1,1],3,"000") // traza dos segmentos help xstring xstring(1.1,0.1,"abscisa") // cadena de caracteres xstring(-0.9,1.1,"ordenada") // otra cadena help xarc xarc(-0.5,1,1,1,0,360*64) // traza un círculo
4
Parábola
f(x)
3
2
1
ordenada x
abscisa 0 -1
0
1
2
59
4.6. CURVAS DE NIVEL Hay funciones predefinidas que permiten efectuar representaciones planas particulares, como histogramas, proyecciones de superficies por curvas de nivel o niveles de gris, o campos vectoriales. Los ejemplos que siguen conciernen a la función f(x,y)=sin(x*y). xbasc() // Curvas de nivel x=linspace(-%pi,%pi,50); // vector de abscisas y=x; // vector de ordenadas z=sin(x'*y); // matriz de valores de la función help contour2d xbasc() contour2d(x,y,z,4) // traza 3 curvas de nivel // Superficies por niveles de colores xbasc() grayplot(x,y,z) // gráfico no verdaderamente gris xbasc() R=[0:255]/256; G=R; B=R; RGB=[R;G;B]'; // nueva matriz de colores xset("colormap",RGB); grayplot(x,y,z) // niveles de gris xset("default") // reinicializa los parámetros gráficos // Campo de vectores tangentes x=linspace(-%pi,%pi,10); // abscisas y=x; // ordenadas fx=cos(x'*y)*diag(y); // matriz de las abscisas de los vectores fy=diag(x)*cos(x'*y); // matriz de las ordenadas de los vectores champ(x,y,fx,fy) // campo de los vectores
4 0.200 -0.200 -0.600 -0.600 -0.200 0.200 0.600
3
-0.200 0.200 0.600 0.600 0.200 -0.200 -0.600 -0.600 -0.200 0.200 0.600
0.600 0.200 -0.200 -0.600
2 1 0
-0.600 -0.200
0.600 0.200
0.200 0.600
-0.200 -0.600
-1 0.600 0.200 -0.200 -0.600 -0.600 -0.200 0.200 0.600 0.600 0.200 -0.200
-2 -3
-0.600 -0.200 0.200 0.600 0.200 -0.200 -0.600 -0.600 -0.200 0.200
-4 -4
-3
-2
-1
0
1
2
3
4
Figura 3-Representación por curvas de nivel
60
4 3 2 1 0 -1 -2 -3 -4 -4
-3
-2
-1
0
1
2
3
4
Figura 4-Representación en escala de grises 4 3 2 1 0 -1 -2 -3 -4 -4
-3
-2
-1
0
1
2
3
4
Figura 5-Representación de un campo de vectores
61
Representaciones planas particulares histplot
histograma
champ
campo de vectores
fchamp
idem, definición para una función
grayplot
superficie por rectángulos de colores
fgrayplot idem, definición para una función Contour2d curvas de nivel proyectadas Fcontour2d idem, definición para una función
4.7. REPRESENTACIÓN DE GRÁFICOS EN 3D El trazado de una curva en 3D se hace mediante la función param3d , de acuerdo a los mismos principios que en dimensión 2. xbasc() t=linspace(0,2*%pi,50); x=sin(t); y=sin(2*t); z=sin(3*t); param3d(x,y,z) // curva de Lissajous xbasc() t=linspace(-%pi/2,%pi/2,1000); x=cos(t*50).*cos(t); y=sin(t*50).*cos(t); z=sin(t); param3d(x,y,z) // hélice esférica
Para representar una familia de curvas en dimensión 3 es necesario utilizar la función param3d1. Los argumentos son tres matrices de coordenadas para las cuales las diferentes curvas están en columnas. xbasc() t=linspace(0,2*%pi,100); a=linspace(-%pi,%pi,10); X=cos(t')*cos(a); Y=sin(t')*cos(a); Z=ones(t')*sin(a); param3d1(X,Y,Z)
// // // //
matriz de matriz de matriz de paralelas
las abscisas las ordenadas las cotas de una esfera
La representación de superficies se hace con plot3d o plot3d1. Tomaremos como ejemplo la función f(x,y)=sin(x*y).
62
x=linspace(-%pi,%pi,50); // vector de abscisas y=x; // vector de ordenadas z=sin(x'*y); // matriz de valores de la función help plot3d xbasc() plot3d(x,y,z) // representación monocroma plot3d1(x,y,z) // representación coloreada xbasc() R=[0:255]/256; G=R; B=0.5*ones(R); RGB=[R;G;B]'; // nueva matriz de colores xset("colormap",RGB); plot3d1(x,y,z) // colores dependientes de z xset("default") // reinicializa los parámetros gráficos
Z 1 0 -1 -3.1
-3.1
0.0
0.0
Y
X 3.1
3.1
Figura 7-Representación de una superficie
Para representar una superficie definida por dos parámetros, es necesario definirla como una función para después utilizar eval3dp, que toma como argumento esta función y dos vectores y devuelve los argumentos necesarios para la representación mediante plot3d. Veamos por ejemplo la representación de una esfera. Para obtener colores variables es necesario cambiar el sentido de uno de los vectores de parámetros.
63
deff("[x,y,z]=sphere(u,v)",.. // definición de la función ["x=cos(u).*cos(v);.. // abscisas y=sin(u).*cos(v);.. // ordenadas z=sin(v)"]) // cotas u = linspace(-%pi,%pi,50); v = linspace(-%pi/2,%pi/2,25);// parámetros [x,y,z] = eval3dp(sphere,u,v);// cálculo de la superficie plot3d1(x,y,z); // representación monocroma u = linspace(%pi,-%pi,50); // cambio de sentido [x,y,z] = eval3dp(sphere,u,v);// nuevo cálculo xbasc() plot3d1(x,y,z) // los colores dependen de z
El comando surf dibuja una superficie coloreada en forma paramétrica utilizando grillas rectangulares definida por las coordenadas X e Y, si no se especifican, la grilla se determina utilizando las dimensiones de la matriz Z (el único dato obligatorio).
surf(Z,) surf(Z,color,) surf(X,Y,Z,,)
Z es una matriz real de m x n. que define la altura de la superficie. No se puede omitir. X,Y: matrices reales o vectores, siempre se colocan juntas, que definen una nueva grilla estándar. Las componentes X e Y deben corresponderse con las dimensiones de Z. color: una matriz real opcional que define un color para cada punto (X(j),Y(i)) de la grilla. : argumento opcional con una secuencia de pares de sentencias {Nombre,Valor} que definen las propiedades globales de los objetos de todas las curves creadas por el dibujo.
Si Z es la única matriz que se especifica, surf(Z) dibuja la matriz Z versus la grilla definida por 1:size(Z,2) para el eje x y 1:size(Z,1) para el eje y. Si se especifica el triplete {X,Y,Z}, Z debe ser una matriz de dimensión [ m x n ], y X o Y pueden ser : a) un vector con, length(X)= n y length(Y)= m respectivamente; b) una matriz , en este caso size(X) o size(Y) deben ser igual a size(Z).
La superficie es creada sobre una grilla de rectángulos. Las entradas X, Y, Z pueden ser consideradas como 3 funciones x(i,j), y(i,j), z(i,j) especificando la superficie deseada. Por
64
defecto, cuando no se agrega ninguna matriz de color al llamado de la superficie, el parámetro color depende de la entrada Z. Cuando se proporciona la matriz color, este puede aplicarse al parche en dos formas distintas : en los vértices o en el centro de cada parche. Esto es porque, si Z es una matriz [ m x n ], la dimensión de la matriz de color puede ser [ m x n ] (un color por vértice) o [ m-1 x n-1 ] (un color por parche). Z= [ 0.0001 0.0013 0.0053 -0.0299 -0.1809 -0.2465 -0.1100 -0.0168 -0.0008 -0.0000 0.0005 0.0089 0.0259 -0.3673 -1.8670 -2.4736 -1.0866 -0.1602 -0.0067 0.0000 0.0004 0.0214 0.1739 -0.3147 -4.0919 -6.4101 -2.7589 -0.2779 0.0131 0.0020 -0.0088 -0.0871 0.0364 1.8559 1.4995 -2.2171 -0.2729 0.8368 0.2016 0.0130 -0.0308 -0.4313 -1.7334 -0.1148 3.0731 0.4444 2.6145 2.4410 0.4877 0.0301 -0.0336 -0.4990 -2.3552 -2.1722 0.8856 -0.0531 2.6416 2.4064 0.4771 0.0294 -0.0137 -0.1967 -0.8083 0.2289 3.3983 3.1955 2.4338 1.2129 0.2108 0.0125 -0.0014 -0.0017 0.3189 2.7414 7.1622 7.1361 3.1242 0.6633 0.0674 0.0030 0.0002 0.0104 0.1733 1.0852 2.6741 2.6725 1.1119 0.1973 0.0152 0.0005 0.0000 0.0012 0.0183 0.1099 0.2684 0.2683 0.1107 0.0190 0.0014 0.0000]; surf(Z); // Note que X e Y se determinan por las dimensiones de Z
//la misma superficie con color de cara roja y bordes azul surf(Z,'facecol','red','edgecol','blu")
Las propiedades globales que pueden cambiarse con sus pares {Nombre,Valores} son: CData o ColorData: una matriz real que especifica el color de los puntos definidos por la matriz Z. CDataMapping o ColorDataMapping: cadena de caracteres con valor 'scaled' o 'direct'. Cdata_mapping Determina si los índices de color son escalado linealmente ( 'scaled') o apunta directamente ( 'direct ') a un color definido. Por defecto Plot3d tiene el modo “direct” y surf el modo “scaled” . EdgeColor o Foreground: Cambia el color de los bordes de los rectángulos de la grilla. FaceColor: caracteres con valor 'none', 'flat' o 'interp' especificando la forma de los colores de las caras 'none' dibuja una malla en la superficie; con 'flat' (modo por default) determina
65
un color por cara utilizando el color del primer vértice de la cara. Con 'interp', se hace un sombreado interpolado sobre la superficie.
66
CAPITULO 5 OPERACIONES DE VECTORES Y MATRICES Algunas operaciones ya se vieron en los capítulos anteriores. En esta sección se hará un resumen de las funciones más importantes mediante ejemplos de aplicación.
Norma de un vector -->x=rand(1,4) x = 0.1121355
//genera un vector aleatorio de 1x4 0.6856896
0.1531217
0.6970851
-->norm(x) //Norma euclídea ans
= 0.9960514
El número de elementos de un vector -->x=1:500; -->n=length(x) n = 500.
Transpuesta de una matriz: -->A=[1+%i 2+2*%i; 3+3*%i 4-4*%i] //se introduce la matriz A A = 1. + i 2. + 2.i 3. + 3.i 4. - 4.i -->A' // matriz transpuesta conjugada de A ans
= 1. - i
3. - 3.i
2. - 2.i
4. + 4.i
-->A.' // matriz transpuesta sin conjugar (se agrega el punto) ans = 1. + i
3. + 3.i
2. + 2.i
4. - 4.i
67
Traza de una matriz -->A=[2 3 1;-3 4 0;1 -1 5] A
= 2.
3.
1.
- 3.
4.
0.
1.
- 1.
5.
-->t=trace(A) // devuelve la suma de los elementos de la diagonal de la matriz A t
= 11.
Dimensión de una matriz -->[m,n]=size(A) // Devuelve el número de filas m y de columnas n de una matriz n
= 3. m
= 3.
Determinante de la matriz -->d=det(A) // devuelve el determinante de la matriz A d
= 84.
Inversa de la matriz -->b=inv(A) //equivale a 1/A b
= 0.2380952
- 0.1904762
- 0.0476190
0.1785714
0.1071429
- 0.0357143
- 0.0119048
0.0595238
0.2023810
Solamente tienen inversa las matrices cuadradas cuyo determinante es distinto de cero.
68
Valores y vectores propios de una matriz
-->[X,D]=spec(A) D = 2.8386444 + 2.7791238i 0 0
0 2.8386444 - 2.7791238i 0
0 0 5.3227111
X = 0.6915854 0.2655926 + 0.6355632i - 0.2167837 + 0.0153119i
0.6915854 0.2655926 - 0.6355632i - 0.2167837 - 0.0153119i
0.0959153 - 0.2175426 0.9713267
La matriz A es cuadrada, y spec(A) calcula los valores propios (diagonal de D) y vectores propios (columnas de X). Con frecuencia el resultado es complejo, si A no es simétrica.
Matrices especiales
-->zeros(3,3) // matriz de ceros ans
= 0.
0.
0.
0.
0.
0.
0.
0.
0.
-->eye(3,3) // matriz identidad ans
= 1.
0.
0.
0.
1.
0.
0.
0.
1.
-->ones(3,3) // matriz de unos ans
= 1.
1.
1.
1.
1.
1.
1.
1.
1.
69
Creación o extracción de una matriz diagonal -->v=rand(1,4) v = 0.6283918
0.8497452
0.6857310
0.8782165
-->a=diag(v) // creación de matriz con los elementos de un vector v en la diagonal. a = 0.6283918
0.
0.
0.
0.
0.8497452
0.
0.
0.
0.
0.6857310
0.
0.
0.
0. 0.8782165
-->x=diag(a) // extracción de los elementos diagonales de una matriz x = 0.6283918 0.8497452 0.6857310 0.8782165
Matriz triangular -->v=rand(4,4) v = 0.0683740 0.5608486 0.6623569 0.7263507
0.1985144 0.5442573 0.2320748 0.2312237
0.2164633 0.8833888 0.6525135 0.3076091
0.9329616 0.2146008 0.312642 0.3616361
-->triu(v) ) // triangular superior ans = 0.0683740 0.1985144 0.2164633 0.9329616 0. 0.5442573 0.8833888 0.2146008 0. 0. 0.6525135 0.312642 0. 0. 0. 0.3616361 -->tril(v) // triangular inferior de A ans = 0.0683740 0.5608486 0.6623569 0.7263507
0. 0. 0. 0.5442573 0. 0. 0.2320748 0.6525135 0. 0.2312237 0.3076091 0.3616361
70
Extracción de bloques de una matriz Se puede fragmentar una matriz extrayendo bloques de la misma.
-->A=rand(4,4) A = 0.2113249
0.6653811
0.8782165
0.7263507
0.7560439
0.6283918
0.0683740
0.1985144
0.0002211
0.8497452
0.5608486
0.5442573
0.3303271
0.6857310
0.6623569
0.2320748
-->a=A(1:2,3:4)// Intersección de las filas 1 hasta 2 y las columnas 3 a 4 a = 0.8782165
0.7263507
0.0683740
0.1985144
-->c1=A(:,1) // Extrae de todas la filas ( operador :) la columna 1 c1 = 0.2113249 0.7560439 0.0002211 0.3303271
-->f1=A(2,:) // Extrae de todas las columnas la fila 2 f1 = 0.7560439
0.6283918
0.0683740
0.1985144
-->a2=A(2:4,$) //“$” indica la última fila o columna de una matriz a2 = 0.1985144 0.5442573 0.2320748
También podemos extraer los elementos de una matriz mediante un vector que indique sus posiciones dentro de la misma. Una matriz puede leerse con dos índices, ej. A(i,j), o con un índice que varía de 1 a mxn .
71
-->A A = 0.2113249
0.6653811
0.8782165
0.7263507
0.7560439
0.6283918
0.0683740
0.1985144
0.0002211
0.8497452
0.5608486
0.5442573
0.3303271
0.6857310
0.6623569
0.2320748
->b=[1 3 7 9 14];
-->A(b) ans = 0.2113249 0.0002211 0.8497452 0.8782165 0.1985144 -->A(1,3) // El elemento A(1,3) es el elemento A(11) ans = 0.8782165
Concatenación de vectores Pueden construirse vectores y matrices concatenando bloques de menor tamaño.
-->a=[1 2 3 5 3 4 1]; -->b=[5 5]; -->c=[a b] c
//a y b como elementos de una fila
= 1.
2.
3.
5.
3.
4.
1.
5.
5.
-->d=[4 4]; -->e=[b;d] //b y d como elementos de una columna e
= 5.
5.
4.
4.
72
Ordenamiento de vectores Los elementos de vectores y matrices pueden ordenarse empleando la instrucción sort -->c=int(10*rand(1,10)) c = 1.
6.
6.
3.
0.
5.
3.
2.
5.
4.
-->y=sort(c) //ordena los elementos en forma decreciente y = 6.
6.
5.
5.
4.
3.
3.
2.
1.
0.
-->[y,k]=sort(c) //k vector con los índices que los elementos ocupan en el vector original. k = 2.
3.
6.
9.
10.
6.
5.
5.
4.
4.
7.
8.
1.
5.
y = 6.
3.
3.
2.
1.
0.
Máximo y mínimo de un vector
-->y=[ 6 6 5 5 4 3 3 2 1 0 ] y = 6.
6.
5.
5.
4.
3.
3.
2.
1.
0.
-->max(y) //calcula el máximo del vector ans = 6. -->[m,k]=max(y) //k es un vector que indica la posición donde está el máximo. k = 1. m = 6. -->min(y) //el elemento de valor mínimo ans = 0.
73
Funciones suma, producto y promedio
-->y=[ 6 6 5 5 4 3 3 2 1 0 ] y = 6.
6.
5.
5.
4.
3.
3.
2.
1.
0.
-->sum(y) ans = 35. -->prod(y) // producto de los elementos del vector ans = 0. -->mean(y) //calcula el promedio entre los elementos ans = 3.5
74
CAPITULO 6 FUNCIONES MATEMÁTICAS 6.1. FUNCIONES MATEMÁTICAS ELEMENTALES Estas funciones se aplican a escalares y matrices, y actúan sobre cada elemento de una matriz como si se tratase de un escalar. Comprenden funciones matemáticas trascendentales y otras funciones básicas, como por ejemplo las siguientes:
sin(x) : seno
asin(x) : arco seno
cos(x) : coseno
acos(x) : arco coseno
tan(x) : tangente
atan(x) : arco tangente
sinh(x) : seno hiperbólico
asinh(x) : arco seno hiperbólico
cosh(x) : coseno hiperbólico
acosh(x) : arco coseno hiperbólico
tanh(x) : tangente hiperbólica
atanh(x) : arco tangente hiperbólica
log(x) : logaritmo natural
sqrt(x) : raíz cuadrada
log10(x) : logaritmo decimal
gcd(x) : máximo común divisor
exp(x) : función exponencial
lcm(x) : mínimo común múltiplo
round(x): redondeo a entero más próximo
fix(x): redonde entero más próximo a 0
floor(x) : valor entero más próximo hacia -∞ ceil(x) : valor entero más próximo hacia +∞ sign(x): signo
abs(x) : valor absoluto
En estas funciones, los argumentos de entrada y salidas pueden ser matrices, lo que permite calcular un conjunto de datos con mayor facilidad, sin necesidad de utilizar bucles o ciclos. En el siguiente ejemplo se comprueba la relación pitagórica cos(x)+sin(x)=1.
-->a=1:10 a = 1. 2. 3.
4.
5.
6.
7.
8.
9.
10.
1.
1.
1.
1.
1.
-->cos(a)^2+sin(a)^2 ans = 1.
1.
1.
1.
1.
75
6.2. SISTEMA DE ECUACIONES LINEALES
La función linsolve calcula todas las soluciones posibles a la ecuación A*X+b=0, donde A es la matriz de los coeficientes del sistema de ecuaciones
a11x1 a n1x1
a12 x 2 a n2 x 2
a13 x 3 a1n x x b1 0 a n 3 x 3 a nn x n b n 0
X es el vector de las incógnitas a encontrar y b el vector que contiene los términos independientes. Por ejemplo, se resolverá el sistema
4x 2 y z 3 0 3x y 3z 0 x 0.5y z 4 0
-->A=[4 2 1; 3 -1 3; 0.5 -1] A = 4. 2. 1. 3. -1. 3. 1. 0.5 -1. -->b=[3; 0; -4] b = 3. 0. -4.
//b tiene que introducirse como vector columna
-->X=linsolve(A,b) X = 2.36 - 4.32 - 3.8 -->round(A*X+b) //comprobación de la solución ans = 0. 0. 0.
76
6.3 NÚMEROS COMPLEJOS Para el complejo i = -1, Scilab utiliza %i, y las operaciones con números complejos (suma, resta, multiplicación, división) utilizan los mismos símbolos que para los reales (+, - ,* ,/ ).
-->z=3+4*%i z = 3. + 4.i -->real(z) ans = 3. -->imag(z) ans = 4. -->conj(z) ans = 3. - 4.i -->abs(z) ans = 5. -->[r,tita]=polar(z) tita = 0.9272952 - 8.327D-17i r = 5. -->atan(imag(z)/real(z)) ans = 0.9272952
Las funciones de Scilab usadas para funciones reales elementales que tienen generalizaciones en complejos, se pueden usar también para los complejos, por ejemplo, sin, cos, log, ...
6.4 POLINOMIOS
Un polinomio se puede definir por sus coeficientes o por sus raíces. Se define un polinomio en base a sus coeficientes con la función: poly(v,’x’,’coef’) donde v es un vector que contiene los coeficientes en orden creciente y “x” indica la variable simbólica para el polinomio.
77
-->p=poly([2 3 5 7],"x","coef") p = 2 3 2 + 3x + 5x + 7x
Para definir un polinomio en base a sus raíces se utiliza la orden: poly(r,’x’,”roots”), donde r es un vector que contiene las raíces del polinomio.
-->q=poly([2 3 5],"x") q = 2 3 - 30 + 31x - 10x + x
Escribir q = poly([2 3 5], "x") produce exactamente el mismo resultado, o sea, "roots" es el tipo de definicion por defecto. Se puede reemplazar 'coeff' por 'c' y 'roots' por 'r' .
Se puede utilizar la función roots para hallar las raíces de un polinomio, sean éstas reales o complejas:
-->raices=roots(q) raices = 2. 3. 5.
Con polinomios se pueden hacer sumas, multiplicaciones, restas, multiplicación por un número. Deben ser polinomios en la misma variable. También se puede elevar un polinomio a una potencia. Por ejemplo:
-->v=p+q+p*q-3.1*q v = 2 3 4 5 6 5 - 90.1x - 51x - 78.1x + 170x - 65x + 7x
78
La función coeff se utiliza para obtener los coeficientes del polinomio.
-->p p = 2
3
2 + 3x + 5x + 7x -->k=coeff(p) k = 2. 3.
5.
7.
-->c=coeff(p,2) c = 5.
Para evaluar un polinomio en un valor dado se utiliza la función horner(Polinomio,x) -->p p = 2
3
2 + 3x + 5x + 7x -->r=horner(p,1) r = 17.
Si q es un polinomio, es lícito utilizar la función horner(p, q) para obtener p(q(x)).
6.5 RESOLUCIÓN DE ECUACIONES NO LINEALES
Para resolver una ecuación o un sistema de ecuaciones no lineales, se puede usar el comando fsolve:
[x [,v [,info]]]=fsolve(x0,fct [,fjac] [,tol])
Donde: x0 : vector de valores reales conteniendo valores iniciales, aproximados, de la función, fct : nombre de la definición de la función cuya solución se desea encontrar, fjac : definición del jacobiano de la función a resolver, tol : tolerancia del proceso iterativo de búsqueda de la solución. El proceso iterativo
79
termina cuando el error relativo de la solución es menor o igual que tol. (1x10-10 es el valor por defecto), Hay tres parámetros de salida, únicamente el primero es obligatorio x : vector real que contiene el valor final de la solución aproximada, v : vector real que contiene el valor de la función en x, info : indicador de culminación y puede tener 5 valores 0 : número inapropiados de parámetros de entrada 1 : se obtuvo solución con error relativo que satisface condiciones de tolerancia 2 : número máximo de iteraciones alcanzado. Muchos llamados a la función 3 : la tolerancia (tol) permitida es muy pequeña. No se puede mejorar aproximación a la solución 4 : iteración no se encuentra progresando o avanza muy lentamente.
El ejemplo resuelve el siguiente sistema de ecuaciones x 7 y 10 0 2x 8y 11 0 -->a=[1,7;2,8];b=[10;11]; -->deff('[y]=fsol1(x)','y=a*x+b'); -->[xres]=fsolve([100;100],fsol1) xres = 0.5 - 1.5 -->a*xres+b //prueba ans = 0. 0.
6.6 AJUSTE LINEAL
Scilab tiene una gran variedad de funciones estadísticas, con las que es posible operar sobre variables escalares y vectoriales.
reglin permite obtener una regresión lineal entre pares de puntos (x,y) del problema y=a*x+b por el método del cuadrados mínimos:
80
[a,b,sig]=reglin(x,y)
sig es la desviación estándar del residuo. x e y son dos vectores con los datos de la muestra. El estimador a es la pendiente de la recta ajuste y b es la ordenada.
-->x=[1 2 3 4 5]; y=[1.1 1.9 3.1 3.984 5.05]; -->[a,b,sig]=reglin(x,y) sig
= 0.0763403
b
= 0.0316
a
= 0.9984
-->yy=a*x+b yy
= 1.03
2.0284
3.0268
4.0252
5.0236
6.7 DERIVADA
La derivada de una función se realiza mediante el comando derivative que realiza una aproximación numérica de la primera y segunda derivada de una función F: Rn --> Rm en el punto x. En la forma más simple, la secuencia de llamado es la siguiente
derivative(F,x)
[J [,H]] = derivative(F,x [,h ,order ])
Parámetros F : una función Scilab
o una lista (F,p1,...,pk), donde F es una función de la forma
y=F(x,p1,...,pk) , donde p1, ..., pk son cualquier objeto (matrices, listas,...). x : vector columna real de dimensión n.
81
h : (opcional) real, el tamaño del paso utilizado en la aproximación de diferencias finitas. order : (opcional) entero, el orden de la formula de diferencia finita utilizada para aproximar las derivadas (orden = 1,2 o 4, por defecto el orden es =2 ).
La derivada de un polinomio se realiza mediante la función derivat que calcula la derivada de una matriz racional o polinómica de variables muda. Tiene la siguiente secuencia de llamado:
pd=derivat(p)
p : es una matriz de polinomios o racional -->s=poly(0,'s') s = s -->derivat(1/s) ans =
// -1/s^2;
- 1 2 s
6.8.- INTEGRALES
Una integral definida se escribe: b
a f ( x)dx El término dx, referido como el diferencial x, indica la variable de integración.
6.8.1. Integración por método trapezoidal (inttrap)
La función inttrap calcula la integral numérica de una relación de pares de puntos utilizando interpolación lineal por el método trapezoidal. Cuando se trabaja con datos experimentales, comúnmente se obtienen serie de puntos que se correlacionan con una coordenada creciente,
82
por ejemplo el tiempo. Con los pares de puntos (x(i),y(i)) se ajusta la función y(i)=f(x(i)) donde i =1,2...n es un índice creciente.
La descripción del comando es:
[v] = inttrap([x,] y),
x es un vector con las coordenadas x con valores crecientes. Los paréntesis rectos indican que el término es opcional, siendo su valor por defecto x = [1, 2, …, m], donde m es la medida del vector y. y es un vector de coordenadas de la ordenada que debe tener igual dimensión que x, v es el valor de la integral.
En el siguiente ejemplo se realiza la integral de la función g(x) = sin(x) + sin(2x) en el intervalo [0, ]. Se genera el vector con incremento /5, /20 y /100, es decir el intervalo discretizado en forma creciente para mejorar la precisión del calculo. Luego se muestran distintas formas de utilizar la función.
-->deff('[y]=g(x)','y=sin(x)+sin(2*x)') -->x = [0:%pi/20:%pi];inttrap(x,g(x)) ans = 1.995886 -->x = (1.0:0.1:2.0); -->y=x^(-1); -->inttrap(x,y) ans = .6937714
6.8.2. Integración por cuadratura (integrate)
Proporciona la integral de una función externa, calculada con métodos que determinan automáticamente el intervalo para tener un error máximo dado: abs(f-x)<= max(ea,er*abs(f)) donde f es el valor exacto de la integral. El llamado general es:
[x]=integrate(f,v,a,b [,ea [,er]])
83
x es el resultado de la integral f es la función definida externamente como matriz de caracteres v es la variable de integración ingresada como una tira de caracteres, a el límite inferior (número) b el límite superior (número) ea es el error absoluto (0 por defecto) er es el error relativo (1.10-8 por defecto).
-->v=integrate('sin(x)','x',0,%pi/2) v = 1. -->integrate(['if x==0 then 1, else sin(x)/x, end'],'x',0,%pi) ans = 1.8519371 -->deff('[y]=f(x)','y=sin(x)+sin(2*x)') -->integrate('f(x)','x',0,%pi) ans = 2.
6.8.3.- Integración mediante spline (intsplin) Es una integración por interpolación, parecido a inttrap, solo que la función entre los valores discretos se interpola utilizando splines, pedazos discretos de curva empleados para ajustar datos entre puntos consecutivos. Se utiliza la función intsplin, que tiene el siguiente llamado general: I = intsplin([x,] y),
x es un vector con las coordenadas x (tiene que ser creciente) y es el vector de las coordenadas y, es decir los valores de la función f(x) -->x = 0:0.1:%pi; -->y = sin(x) + sin(2*x); -->intsplin(x,y) ans = 2.0008637 -->x = (-4:0.1:0); -->y = exp(-x^2/2)/sqrt(2*%pi); -->intsplin(x,y) ans = .4999685
84
6.8.4.- Integrales definidas con la función (intg) La función intg calcula la integral definida desde a a b de la función f(t)dt que debe ser continua. La descripción general es:
[I, err]=intg(a, b, f [,ea [,er])
a,b son los límites de integración f la función externa a integrar. Puede ser una función, una lista o una cadena de caracteres, ea es el error absoluto requerido en el resultado ( por defecto 1x10-14) er error relativo requerido (por defecto1x10-8 ) I valor de la integral , err error absoluto estimado del resultado.
Esta función es similar a integrate, pero permite mas opciones para definir la función externa f.
Si f es una función su definición debe ser como sigue y = f(t).
Si f es una lista ésta debe ser como sigue list(f,x1,x2,...), donde f es una función con llamado de secuencia f(t,x1,x2,...).
Si f es una cadena de caracteres, esta es el nombre para llamar una función definida en Fortran o C.
-->deff('[y]=f(x)','y=cos(x)+0.5*cos(2*x)+1.5*cos(3*x)') -->[I,err] = intg(0,1,f) err = I
1.668E-14 = 1.1393553
85
6.8.5.-Integrales dobles La función int2d puede utilizarse para calcular la integral de la función z = f(x,y) sobre una región R definida por un número n de triángulos. Utiliza el método de cuadratura o curvatura. El llamado más simple es:
[I ,err] = int2d(X, Y, f), I es el valor de la integral, err es el error estimado para el cálculo, X e Y son matrices de 3 filas y n columnas representando las abscisas y las ordenadas, respectivamente, de los n triángulos en los cuales se ha dividido la región R. f es la función externa (función, lista o caracteres)
Como ejemplo consideremos la integral de la función f(x,y) = cos(x+y) en la región R = {0 < x <5, 0 < y < 5}. La figura de abajo muestra las formas posibles de triangular la región. y D(0,1)
C(1,1)
x A(0,0)
B(1,0)
-->deff('z=f(x,y)','z=cos(x+y)') -->//Triangulos ABC-ACD: -->X = [0,0;1,1;1,0]; Y = [0,0;0,1;1,1]; -->[Int,er] =int2d(X,Y,f) er = 3.569E-11 Int = .4967514
86
6.9 ECUACIONES DIFERENCIALES ORDINARIAS
La resolución de un problema de valor inicial requiere resolver una ecuación diferencial de primer orden con condición inicial. Generalmente se escribe en la forma:
dy f ( x, y ) dx y ( xo ) y o
Scilab permite obtener soluciones numéricas a problemas de valor inicial. El comando a ser utilizado es ode (ecuación diferencial ordinaria):
[y] = ode([type],y0,x0,x,f)
type: es un argumento opcional que indica el método numérico de resolución que se utilizará y puede ser ‘adams’ (Adams), ‘rk’ (Runge-Kutta), ‘rkf’ (Runge-Kutta modificado), ‘fix’, ‘discrete’, ‘roots’, ‘stiff’. y0 : es un vector o matriz real conteniendo las condiciones iniciales de la función x0 : es un escalar real que corresponde al valor inicial de la variable independiente x : es un vector real. Contiene los valores de la variable independiente para los cuales se calcula la solución. f : definición de la función a ser integrada y: es la matriz de los vectores solución. y=[y(x(0)),y(x(1)),...].
Por ejemplo, el programa que se muestra a continuación, resuelve el siguiente problema:
dy y 2 y sin( t ) cos(t ) dt y(0) 0
Antes de utilizar la función ode , es necesario crear en Scilab la función f y cargarla. La función ode evalúa aproximaciones del valor de y en valores t1, t2, ..., tp.
87
-->deff('ydot=f(t,y)','ydot=y^2-y*sin(t)+cos(t)') -->y0=0;t0=0;t=0:0.1:%pi; -->y=ode(y0,t0,t,f); -->plot(t,y)
1.0 0.9
0.8 0.7
0.6
0.5 0.4
0.3 0.2
0.1 0.0 0.0
0.5
1.0
1.5
2.0
2.5
3.0
3.5
Se puede resolver un sistema de varias ecuaciones diferenciales ordinarias con un solo llamado de ode. Para ello se debe utilizar como entrada de la función f una matriz. Es decir, se resuelve dY/dt=F(t,Y) donde Y es una matriz p x q , la condición inicial, Y0 , debe ser también una matriz p x q y el resultado de ode es la matriz [Y(t_0),Y(t_1),...,Y(t_T)].
88
CAPITULO 7 ENTRADAS Y SALIDAS DE DATOS 7.1. INTRODUCCIÓN En este capítulo se presentan las funciones para la entrada y salida de datos, como así también las empleadas para el manejo de archivos. En SCILAB, las entradas y salidas son parte importante de los programas, particularmente cuando se maneja una gran cantidad de datos almacenados en archivos.
Los dispositivos a los que se pueden ingresar datos o desde los cuales pueden extraerse datos son: el monitor, teclado, impresora y unidades de almacenamiento. Estos equipos son identificados como “unidades lógicas”, que se reconocen con un número o un string. El vector %io guarda el número con el que se identifica cada dispositivo. La ventana principal (monitor) es la entrada y salida estándar para Scilab. La entrada al monitor se identifica como la unidad lógica 5 y la salida al mismo como unidad lógica 6. Estos números están guardados en las dos primeras posiciones de %io. Es decir, %io(1)=5 y %io(2)=6.
7.2. ARCHIVOS BINARIOS (SAVE, LOAD)
Un conjunto de datos puede ser archivado en una unidad de almacenamiento en dos formas: como archivo de texto o archivo binario. Cuando se guarda como texto se la codificación estándar (ASCII) y el archivo puede ser leído o modificado con cualquier editor de texto simple. Cuando se guardan como binarios, los archivos tienen un formato determinado y no pueden ser editados ni visualizados con cualquier editor de texto, pero ocupan menos espacio en disco. Para grabar variables en archivos binarios se utiliza la función:
save(filename [,x1,x2,...,xn])
donde filename es una tira de caracteres que contiene el nombre y el camino al archivo. Para recobrar el archivo se utiliza la función:
89
load(filename [,x1,...,xn])
-->A = [1. 2. 3.; -3. 4. 5.; 2. 4. 5.; 1. 3. 2.]; b = 1:10; -->save('DataAb.dat', A,b) -->clear -->load('DataAb.dat') -->A,b A = 1. - 3. 2. 1. b =
2. 4. 4. 3.
3. 5. 5. 2.
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
En el ejemplo anterior se guarda el archivo DataAb en formato binario. Si se utiliza SciNotes, para abrir el archivo, notará que no puede ver los datos del archivo. Luego se borran las variables de la memoria iterativa de Scilab y se recargan los valores de A y b usando el comando load. Con lo que se comprueba que fueron guardados en archivos externos.
Scilab posee funciones, con distintos grados de complejidad para la entrada y salida de datos con formato de texto. En general se pueden clasificar de acuerdo al tipo de programación que las inspira:
TIPO
Scilab
LECTURA
ESCRITURA
MANEJO
(ENTRADA)
(SALIDA)
ARCHIVOS
input
disp
DE
print Fortran
read
write
file
C
mscanf
mprintf
mopen
mfscanf
mfprintf
mclose
msscanf
msprintf
meof
fscanfMat
fprintMat
90
7.3. FUNCIONES TIPO SCILAB (SIN FORMATO)
Las funciones input y disp constituyen las más sencillas de realizar y fueron descritas anteriormente. Otra función de salida que tiene Scilab es print que proporciona una salida sin formato. Esta función es similar a disp, pero también permite escribir en archivos. La forma general de la función es: print (“filename”, x1, [x2,… ,xn])
El argumento filename identifica al equipo donde se imprime y xi son las variables a escribir. Estas se imprimen en el formato Scilab, es decir colocando el nombre de la variable y el signo igual. Esto lo hace incluso cuando se guarda en un archivo.
-->x = 2.7 ; y = 5.4; -->print(6,x,y) y = 5.4 x = 2.7 -->print(%io(2),x,”valor del dato:”) valor del dato: x = 2.7
La función print como disp imprimen la ultima variable primero. En el último ejemplo la tira de caracteres 'valor del dato:' se imprime junto con la tira 'x = ', la cual es una salida por defecto de print. También puede utilizarse la función print para guardar variables en un archivo de texto.
--> r = 1:2:25; A = rand(5,3); -->print(“data1.txt”,A,r)
91
Si se abre el archivo data1.txt con el Editor, notará que la salida incluye todos los identificadores.
7.4. FUNCIONES TIPO FORTRAN (read, write)
Scilab también maneja las funciones read y write similares a las de Fortran, con la diferencia que se puede colocar un argumento por vez. Es decir, están orientadas para la entrada o salida de matrices, por lo que si se tienen varias variables es mejor juntarlas en una sola matriz antes de imprimirlas. La secuencia de llamado general es:
[x]=read(file,m,n,[format])
write(file,x,[format])
file es una tira de caracteres que con el nombre del archivo, como alternativa se puede colocar el número lógico asignado al archivo. x es la matriz a manejar, sólo se puede colocar una por vez. m y n son el número de filas y columnas de la matriz. Si no conoce el número de filas a leer con m= -1, se lee el archivo completo. format es el formato con que se lee o escribe la matriz. Algunos de los items para la salida formateada se presentan a continuación:
/
nueva línea
iw
campo entero con w caracteres
fw.d punto flotante con w caracteres incluyendo d dígitos después del punto decimal. Se recomienda ew.d
w>d+3
punto flotante como potencia de 10, con una longitud de w caracteres incluyendo d dígitos después del punto decimal. Se recomienda w>d+7
nx
n espacios en blanco
tn
mover el cursor a la posición n
an
cadena de caracteres de longitud n
El formato es una tira de caracteres, entre comillas, que se encierra entre paréntesis. Si la matriz tiene varias columnas se puede dar formato a cada una si se separan por comas. Si
92
quiero dar el mismo formato a varias columnas se encierra el formato entre paréntesis y se colocando
el
número
de
repeticiones
adelante.
Por
ejemplo
en
el
formato
‘(1x,e10.3,5x,3(f3.0))’ luego de un espacio en blaco se dejarán 10 caracteres para mostrar un numero real con lugar para 3 decimales despues del punto, luego se dejan 5 espacios en blanco y se colocan 3 columnas con el mismo formato, un número real con 3 espacios para la parte entera y ninguno para la parte decimal.
La lectura desde el teclado se realiza utilizando el comando read y especificando la unidad lógica %io(1). La salida en pantalla se realiza con el comando write y especificando la unidad lógica %io(2). Para leer un valor simple se utiliza la dimensión m=1, n=1. -->x=read(%io(1),2,2,'(2(f5.1,2x))') -->444.2 555.6 -->222.1 333.1 x = 444.2 222.1
55.6 33.1
-->write(%io(2),m,'(5x,3(f10.2))') 2.00 0.00 6.00 7.00 3.00 6.00
Para mostrar el uso de read y write en un programa, se escribe la siguiente función en un archivo que se guarda como inout.sci:
function inout() // este programa ilustra el uso de read y write write(%io(2),' la variable real x:','(a)'); x = read (%io(1),1,1); write(%io(2),' la variable real y:','(a)'); y = read (%io(1),1,1); z = x+y; write(%io(2),'la suma de x e y es:','(a)') write(%io(2),z,'(10x,e13.7)') endfunction
93
Luego se carga la función en la ventana de trabajo de Scilab mediante el comando getf -->getf('C:\inout.sci'); -->inout() Entrar una variable real x: -->1.2 Entrar una variable real y: -->2.4 la suma de x e y es: .3600000E+01
Note que la función inout no tiene argumento. Entonces, tanto en la definición de la función como en su ejecución se tiene que colocaar un par de paréntesis vacios ().
7.4.2. El manejo de archivos El comando file permite abrir o crear un archivo de datos:
[unit [,err]]=file('open', file-name [,status] [,access [,recl]] [,format])
file-name: string, nombre del archivo a ser abierto status: string, el estado del archivo a ser abierto. El estado puede ser "new" : el archivo es nuevo, no existe (opción por defecto) "old" : el archivo ya existe. "unknown" : estado desconocido, Sirve para archivos nuevos o viejos. "scratch" : el archivo será borrado al final de la sección. access: string, tipo de acceso al archivo "sequential" : acceso secuencial (por defecto) "direct" : acceso directo format: string, "formatted" : para un archivo formateado (por defecto) "unformatted" : grabación binaria recl: entero, es el tamaño de los datos en bytes cuando access="direct" unit: descripción logica del archivo abierto err: entero, número del mensaje de error si falla la apertura.
94
El comando file también permite cerrar o mover el puntero del archivo, se puede utilizar cuando un archivo se abre tanto para entrada como para salida.
file(action,unit)
donde action es uno de los siguientes strings: "close": cierra el archivo "rewind": pone el puntero al inicio del archivo "backspace": pone el puntero al inicio del último dato "last": pone el puntero después del último dato.
Los siguientes ejemplos son pequeños programas para ejecutar desde SciNotes. Crea la matriz de 11x2, crea el archivo dataB. Txt en el directorio de trabajo (¡cuidado! debe haber creado uno), graba los datos con formato en el archivo y luego cierra el archivo. x1 = 0:0.5:10;x2 = x1^2;B = [x1',x2']; m = file('open','dataB.txt','new') //abre el archivo y le asigna a m write(m,B,'(2(f6.2,2x))') //graba la matriz en el archivo file('close',m) //cierra el archivo
Si se conoce el número de filas del archivo (n=11, en el caso del archivo dataB.txt), para leer los valores de la matriz se utiliza: u=file('open','dataB.txt','old'); A=read(u,11,2); file('close',u); write(%io(2),A); //muestra la matriz A en pantalla
Si el número de filas es desconocido, con n=-1 el archivo completo será leído. En el siguiente ejemplo se incluyen tira de caracteres, estas se escriben separadas de la matriz. C = rand(2,3)+ rand(2,3); //suma dos matrices creadas aleatoriamente u = file('open','dataC.txt','new') write(u,'esta es la matriz C','(a)') //graba la tira de caracteres write(u,C,'(3(f10.6,2x))')// seguido graba la matriz C file('close',u)
95
7.4.3. Usos adicionales de la función (file)
El comando read dirige el puntero al comienzo del archivo, ejecuta la lectura y coloca el puntero al final de la lectura pedida, quedando disponible para el próximo llamado de entrada. Si quiere leer los datos del archivo otra vez, puede usar la función file con la opción ‘rewind’:
file('rewind',u) una segunda acción disponible es la opción ‘backspace’, que mueve el puntero solo una línea arriba de la última lectura. Una tercera opción es ‘last’, con la que el puntero se mueve al final del archivo sin necesidad de hacer una lectura. Puede ser utilizada para agregar datos a un archivo existente. Una cuarta opción que puede ser utilizada en el argumento de la función file cuando el primer argumento es ‘open’. Esta es la opción ‘scratch’, que borra el archivo al final de la sesión de trabajo.
En el siguiente ejemplo, abrimos el archivo y agregamos datos al final del archivo:
fil="dataC.txt" u = file('open',fil,'old') //abre el archivo file('last',u) //mueve al puntero al fin del archivo write(u,[10, 20, 30],'(3f5.0)') //graba un vector con nuevos datos file('close',u) // cierra el archivo
Se pueden observar los cambios introducidos abriendo el archivo con SciNotes. Cuando creamos un archivo que no existe usamos la opción ‘new’, para abrirlo otra vez utilizamos la opción ‘old’. Si tratamos de abrir un archivo viejo como nuevo obtenemos un mensaje de error. Podemos almacenar el codigo del error por utilizar el siguiente llamado:
-->[u,errn] = file('open','fil','new') errn = 240. u = []
96
El número del error es almacenado en la variable errn y se le asigna a la variable u un vector vacío (indicando la falla de la apertura del archivo). Si en el ejemplo anterior utilizamos la opción ‘unknown’ en vez de ‘new’ evitamos el mensaje de error:
7.5. FUNCIONES TIPO C
Las funciones mprintf y mscanf operan directamente en la ventana principal del SCILAB, mientras que las funciones mfprintf, mfscanf, fprintMat y fscanfMat operan sobre archivos. La función mfprintf también puede operar sobre la ventana principal si la referencia del archivo es reemplazada por %io(2), mientras que la función mfscanf puede operar sobre la ventana principal si la referencia del archivo es reemplazada por %io(1).
APLICACIÓN LECTURA (ENTRADA)
ESCRITURA
MANEJO
(SALIDA)
DE ARCHIVOS
Ventana
mscanf
mprintf
mopen
Archivos
mfscanf
mfprintf
mclose
String
msscanf
msprintf
moef
Matrices
fscanfMat
fprintMat
Lineas
mgetl
mputl
Las secuencia de llamada general para las funciones de lectura mscanf, mfscanf y msscanf son las siguientes:
[n,v1,...vn] = mscanf ([niter,]format); [n,v1,...vn] = mfscanf ([niter,] fd, format) [n,v1,...vn] = msscanf ([niter,] str, format)
En estas llamadas, v1,...vn es una lista de variables de salidas. Para la función mfscanf, fd es la unidad lógica del archivo, y format es una tira de caracteres con el formato para escribir las variables que están siendo leídas. Esta conversión es similar que la del lenguaje C. niter indica el número de veces que se utilizará el formato. La variable de salida n es un entero que
97
proporciona el número de datos leidos o –1 si se encuentra el fin de linea (EOF) antes de leer un dato. str indica que se trabaja con una o un vector de tira de caracteres.
Si los datos del archivo son homogeneos, pueden ser almacenados en un único vector.
L= mfscanf ([niter,] file, format)
La llamada general par las funciones de escritura de datos mprintf, mfprintf y msprintf son las siguientes:
mprintf(format,v1,..,vn) mfprintf(fd,format,v1,..,vn) str=msprintf(format, v1,..,vn)
En estas, v1,...vn especifican los datos a ser convertidos e impresos de acuerdo a los parametros del format, fd es un entero positivo que describe la unidad logica asignada cuando se utiliza mopen. Si fd es 6 la salida será a la ventana de trabajo de Scilab. -->for j=1:5;mfprintf(6,'El cuadrado de %f es %f \n',j,j^2);end El cuadrado de 1.000000 es 1.000000 El cuadrado de 2.000000 es 4.000000 El cuadrado de 3.000000 es 9.000000 El cuadrado de 4.000000 es 16.000000 El cuadrado de 5.000000 es 25.000000
La tira de caracteres 'El cuadrado de %f es %f' incluye dos argumentos %f,
que son
caracteres de conversión porque serán reemplazados por los valores de las variables colocadas inmediatamente después del string; en este caso los valores de j, j^2. En este ejemplo, %f representa campos de puntos flotantes de ancho variable.
Otras funciones de entrada y salida del tipo C son fscanfMat, y fprintfMat que se utilizan para leer o escribir una matriz en archivos. La secuencia de llamado de estas funciones es:
fprintfMat(file,M [,format,texto]) [M,text] = fscanfMat(file)
98
Donde file es un string con el nombre del archivo, M es una matriz de números reales, format es un una tira con los caracteres de conversiones, el valor por defecto es “%f”, text es una matriz de string con los comentarios no numéricos al comienzo del archivo.
-->A = int(10*rand(2,3)) A = 2. 0. 6. 7. 3. 6. -->fprintfMat('Mat1.txt',A,'%5.3f')
Abriendo el archivo “Mat1.txt” se observa que la matriz A se grabó con el siguiente formato:
2.000 0.000 6.000 7.000 3.000 6.000
El formato tiene un caracter de conversion simple '%5.3f'. que indica que cada elemento de la matriz se escribe como un campo de punto-flotante con 5 caracteres de ancho, de los cuales 3 son para decimales. Si el número no se ajusta con el campo especificado, Scilab lo ajusta de forma tal que será escrito con el número de decimales requerido.
El comando fscanfMat se utiliza para leer los datos desde un archivo como una sola matriz. Para lo cual los datos en el archivo deberán estar en el formato de una matriz, es decir, cada linea en el archivo debe tener el mismo número de columnas.
7.5.1. Control del Formato (Caracteres de Conversión)
En algunos de los ejemplos anteriores se utilizaron en el formato, caracteres tales como %f, %5.3f, conocidos como caracteres de conversión o control del formato. Siempre que se encuentra la especificación de un caracter de conversión se reemplaza, en el caso de comandos de salidas, con el valor correspondiente de una lista de variables que sigue a la tira que especifica el formato o, en el caso de comandos de entrada, se lee el valor correspondiente con el formato especificado.
Cada especificación de conversion comienza con % y termina con un codigo de conversión. Entre el % y el código de conversión puede haber un número (precisión) que especifica el
99
máximo número de caracteres para la tira, el número de dígitos despues del punto decimal de punto flotante. Se pueden utilizar los siguientes códigos de conversión: ___________________________________________________________________________ d,i entero decimal u
entero decimal sin signo
c caracter simple s
cadena de caracteres
f número de doble precisión (punto flotante); [-]m.dddddd, d es la precision (defecto 6) e número en notación exponencial; [-]m.dddddde±xx o [-]m.ddddddE±xx g usa %e si el exponente es < -4, o la presición ≥ 4; de otra manera, usa %f * vacio % no convierte ningún argumento; imprime solo un % ___________________________________________________________________________
En el siguiente ejemplo se cargan primero los valores de las variables a, b, c, y s que serán utilizados en el llamado de la función mprintf. Note que a y b son constantes simples y c es un vector fila.
-->a = -13.54; c = [4.35,3.22]; -->//imprime tres especificaciones flotante: %f, %e, y %g.
para
número
de
punto-
-->mprintf(' Coeficiente = %10.5f',a); Coeficiente = -13.54000 -->mprintf(' Coeficiente = %10.5e',a); Coeficiente = -1.35400e+001 -->mprintf(' Coeficiente = %10.5g',a); Coeficiente = -13.54 -->//se especifican dos campos de conversión para c. -->mprintf('Vector = [%f,%f]',c); Vector = [4.350000,3.220000] -->//ejemplos con salto de línea -->mprintf('\n Estos son los valores: \n x = %f \n y = %f \n',2.4,5.3) Estos son los valores: x = 2.400000 y = 5.300000
100
En el último ejemplo se utiliza el caractere \n. Este produce una nueva línea, así divide el string del formato en dos líneas. A continuación se presentan ejemplos de caracteres de conversión para funciones de entrada.
En el siguiente ejemplo se leen datos del dispositivo de salida standard (%io(2) = 5) con la función mscanf. -->mprintf('Entre tres valores:'); [a,b,c]=mscanf('%f %f %f') Entre tres valores: -->2.3 3.5 -1.2 c = - 1.2 b = 3.5 a = 2.3
7.5.2 Manejo de archivos Las funciones mopen, mclose y meof permiten manejar archivos. La función mopen se utiliza para abrir un archivo. La secuencia de llamado general es
[fd, err] = mopen(file, mode)
file es una cadena de caracteres con el nombre y el camino del archivo a ser abierto, fd representa la variable de la unidad lógica asignada al archivo, err almacena el posible número de error, mode indica el modo en el cual el archivo será abierto, para escritura, lectura, agregar, etc. , de acuerdo a las especificaciones: w para escritura, r
para lectura, a para
agregar. Cualquiera de estas especificaciones seguidas por el signo mas, es decir, w+, r+, a+, indica que el archivo está siendo actualizado (sobreescrito).
La función mclose es utilizada para cerrar un archivo. La secuencia de llamado es mclose([fd]) o mclose(“all”) Si se omite fd se cierra el último archivo abierto. La opción “all” cierra todos los archivos abiertos.
101
La función meof puede utilizarse para detectar el fin del archivo (eof=end of file), es decir, la condición en la cual el archivo ha agotado las salidas. La función retorna el valor %t (verdadero) si el eof ha sido alcanzado, o %f (falso), de otro modo.
Los siguientes programas muestra un ejemplo de aplicación de las funciones mopen, meof, mclose, mfprintf, y mfscanf: En el primer ejemplo se abre con mopen el archivo datos.txt para escritura y se guardan allí, con el comando mfprintf, en una sola fila las variables k, x, y, z. Estas variables cambian de valor y se guardan en las filas subsiguientes del archivo hasta que se agota el vector k del ciclo for. Finalmente el archivo se cierra con mclose.
mode(-1) //no se ven los comando //Creando el archivo e imprimiendo datos en este arch = 'datos.txt'; fd = mopen(arch,'w'); for k = 1:5 x = k^2; y = 2*k-2; z = sin(5*k);//graba datos al archivo mfprintf(fd,'%i %6.2f %6.2f %6.2f \n',k,x,y,z); end mclose(fd);//cierra el archivo
Este otro ejemplo abre el archivo creado anteriormente (datos.txt) para lectura y lee cada linea del archivo mediante el comando mfscanf. Como no se conoce el número de filas a leer, se utiliza un ciclo while con la condición de qsue no sea el final del archivo. mode(-1) [u,err] = mopen(arch,'r');//abre el archivo para entrada cont = 0;//inicializa el contador k = []; x = []; y = []; z = [];//vectores vacios while ~meof(u) cont = cont + 1; r = mfscanf(u,'%f %f %f %f'); k = [k r(1)]; x = [x r(2)]; y = [y r(3)]; z = [z r(4)]; end close(u);//cierra el archivo [nr,nc] = size(k); //pone el formato para imprimir en pantalla sformat = ""; for j = 1:nc sformat = sformat + "%5.2f "; end; mprintf('\nDatos leidos como vectores\n'); //imprime los vectores leidos mprintf("k: "+sformat,k); mprintf("\nx: "+sformat,x); mprintf("\ny: "+sformat,y); mprintf("\nz: "+sformat,z);
102
7.6. LEYENDO O GRABADO LÍNEAS DE ARCHIVOS DE TEXTOS
Scilab cuenta con los comandos mgetl y mputl para leer líneas o grabar líneas de un archivo de texto. La secuencia de llamado general de estas funciones son:
str = mgetl(fd [,m]) mputl(str [,fd])
Cuando se utiliza en el comando mgetl, str es un vector columna de tiras de caracteres, que contiene las m líneas leidas del archivo de texto cuya unidad de referencia es fd. Si no se conoce el número de filas se utiliza m = -1. Con el comando mputl, str es un vector (fila o columna) de tiras de caracteres, cuyos elementos se escriben como lineas en el archivo de referencia fd. Para operar los comandos mputl y mgetl, los archivos deben abrirse previamente con el comando mopen.
mode(-1) //abre el archivo y guarda la dirección como vector u = mopen('direccion.txt','w') direc1 = ['Avda. Bolivia 5150';'Campo Castañares';'Salta, cp: 4408FVY';'Argentina']; mputl(direc1,u) mclose(u) //lee el archivo r=mopen('direccion.txt','r') d=mgetl(r,-1) //lee todas las líneas del archivo mclose(r) disp(d)
En el siguiente ejemplo se crea el archivo “direccion.txt” y se guarda un vector de tiras de caracteres con la dirección de la universidad, mediante el comando mputl. Luego se abre el archivo y se lee el contenido mediante el comando mgetl.
103
CAPITULO 8 PROBLEMAS RESUELOS 8.1. INTRODUCCIÓN
104
APENDICE A DIÁLOGOS E INTERFACES GRÁFICAS A.1. El USO DE DIÁLOGOS E INTERFACES A USUARIO
Se han incorporado a Scilab algunas funciones que permiten manejar a un nivel simple el intercambio de información a través de ventanas gráficas, que son fundamentalmente menús para selección de alternativas y para el ingreso y salida de datos. Estas prestaciones se llevan a cabo mediante la integración de Scilab con el lenguaje Tcl y su librería grafica Tk, puesto que la interfaz grafica de Scilab está escrita en Tcl/Tk. Si se necesita armar algo más sofisticado es posible recurrir al intercambio directo con este lenguaje de programación para su diseño. Recientemente, se han incorporado también algunas funciones que permiten utilizar objetos de interfase de usuario que enriquece las presentaciones de los procedimientos para el ingreso de datos y permite la programación orientada a objetos. Estas son las llamadas interfaces gráficas de usuario (GIU)
A.2. DIÁLOGOS
A.2.1 Mensajes La función x_message, es una caja de dialogo que muestra un mensaje y espera por una respuesta. Retorna al programa principal sólo después de un click sobre un botón.
[num]=x_message(mensaje [,botones])
mensaje: vector de tiras que constituye el mensaje que aparece en la caja de dialogo. Si el mensaje es simple no hacen falta los corchetes rectos, sino cada línea deberá estar separadas por punto y coma. botones: Por defecto aparece en la caja un botón Ok para cerrar la caja una vez que se lee el mensaje. Si quiere utilizar la caja para hacer una decisión, se pueden colocar dos botones. En ese caso los nombres se colocan en un vector de tiras.
105
num: guarda el número correspondiente al botón seleccionado por el usuario. Esta información se utiliza luego para realizar una acción determinada. mode(-1);//modo silencioso nb = x_message("Elija un Sistema de Unidades:",["S.I.","E.S."]); if nb == 1 then x_message("Sistema Internacional - g = 9.806 m/s^2'); else x_message("Sistema Ingles - g = 32.2 ft/s^2'); end;
A.2.2 Entrada Simple Para pedir una entrada simple a través de una ventana de dialogo se usa la función x_dialog:
valor = x_dialog(titulo,valor_defecto)
En valor se guarda la entrada ingresada en el dialogo después que se presiona el botón Ok, titulo es una tira de caracteres que identifica al dialogo, en valor_defecto se puede dar un valor por defecto en el caso que no se ingrese uno nuevo. En la ventana aparecen botones de Ok y Cancel. Si presiona Cancel se carga en la variable valor un vector vacío. Si presiona Ok sin ingresar un nuevo valor, se toma el valor por defecto.
106
La entrada que se ingresa a la caja de dialogo entra como texto y deberá convertirse con la función eval si quiere usarse como un número.
mode(-1); h0 = eval(x_dialog("Altura inicial (m)","0.00")); v0 = eval(x_dialog("Velocidad inicial (m/s)","0.00")); t0 = eval(x_dialog("Tiempo inicial (s)","0.00")); tf = eval(x_dialog("Tiempo final (s)","10.00")); h = h0 + v0*(tf-t0)-4.903*(tf-t0)^2; x_message("h = " + string(h) + " m");
A.2.3 Entrada Múltiple Para hacer entradas múltiples con una sola caja de dialogo se usa la función x_mdialog:
vector= x_mdialog(titulo, letreros, valor_defecto)
donde titulo es el título de la caja de diálogos, letreros es un vector columna con las etiquetas para las componentes del vector, y que se ponen en cada ventana, valor_defecto son valores por defecto para el vector de entrada., y vector contiene los valores ingresados.
mode(-1); titulo = "Calculo de la distancia de un objeto en caída libre"; etiquetas = [ "Altura inicial (m)"; ... "Velocidad inicial (m/s)"; ... "Tiempo inicial(s)"; ... "Tiempo final (s)"] vector = x_mdialog(titulo, etiquetas,['0';'0';'0';'10']); h0 = eval(vector(1)); v0 = eval(vector(2)); t0 = eval(vector(3)); tf = eval(vector(4));
107
Otra forma de ingresar datos múltiples a través de una sola forma de entrada es la función getvalue, su llamado general es:
[ok,x1,x2,…,x14] = getvalue(descrip,etiq,tipo,val_defect)
donde descrip es un vector columna de tiras con el nombre general del dialogo, etiq es un vector columna de tiras con las etiquetas de cada uno de los ítem de los datos de entrada; tipo es una lista con el tipo de datos y sus dimensiones; val_defect es un vector de valores por defecto para las entradas; ok es una variable lógica que toma los valores %t (true) si se presiona el botón Ok, o %f (false) si se presiona el botón Cancel; x1, x2, …, x14 son los valores retornados si se presiona el botón Ok. La forma general de tipo es tipo = list(tipo_1, dim_1, tipo_2, dim_2, …) donde tipe_1, tipe_2, …, son tiras que definen la variable y que pueden ser: “mat” matriz numérica, “col” vector columna numérico, “row” vector fila numérico, “vec” vector numérico, “str” string , “lis” lista
108
Los valores dim_1, dim_2, …, pueden ser una constante simple o un vector de dos constantes indicando las dimensiones del dato correspondiente.
mode(-1); desc = "Ingrese los parámetros para el movimiento oscilatorio amortiguado" etiq = ["Amplitud máxima, A0 (m)",... //leyendas "Parámetro de amortiguamiento, tau(s)",... "Frecuencia natural, f(Hz)" ,... "Cambio de fase, phi(rad)" ,... "Incremento en el tiempo, Dt(s)" ,... "Tiempo máximo, tmax(s)"]; tipo = list("vec",1,"vec",1,"vec",1,... //lista de tipos "vec",1,"vec",1,"vec",1); def = ["10","50","10","0.75","1","50"]; //valores por default [ok,A0,tau,f,phi,Dt,tmax] = getvalue(desc,etiq,tipo,def); if ok then deff('[x] = foo(t)','x=A0*exp(-t/tau).*cos(2*%pi*t/f-phi)'); t = [0:Dt:tmax]; x = foo(t); xset('window',1);plot(t,x); xtitle("Movimiento Oscilatorio","t(s)","x(m)"); else x_message("No hay entradas ingresadas") end;
109
A.2.4 Ventana de diálogo para entrar una matriz
La función x_matrix puede utilizarse para ingresar una matriz numérica a través de una caja de diálogo. El llamado general de la función es
[matrx] = x_matrix(label,default)
donde label es la leyenda de la caja, default es una matriz real, y matrx es un opcional con el nombre de la variable a donde se asigna la matriz. La matriz que se ingresa no necesita ser de las misma dimensión que la matriz por defecto.
Ejemplo; x_matrix('Entre una matriz de 3x3',rand(3,3))
110
A.2.5 Ventana de diálogo para elegir entre varios valores de una entrada
La función x_choose permite elegir entre varios valores de entradas posibles. El llamado general es
[item_num] = x_choose(items, title)
donde items es un vector columna de tiras con las varias elecciones posible, title es una tira con la descripción del dialogo, item_num es el índice, en el vector, de los valores elegidos. Así, el valor de retorno de x_choose no es el valor en el dialogo, sino el índice de la entrada elegida.
Ejemplo: k = x_choose(['m';'ft';'yd';'km'],'Elija unidades de distancia')
111
Una extensión de la función x_choose es la función x_choices que permite elegir entre varios valores para varias variables de entrada. El llamado general de la función es
item_vector = x_choices(titulo, item_lista)
donde titulo es una tira que describe al dialogo, item_lista es una lista cuyos elementos son también listas que contienen la leyenda, la posición del valor por defecto, y los posibles valores de cada uno de los ítem a ser elegidos, item_vector contiene la posición de las elecciones. Así la forma de item_lista es item_lista = list(list_item_1, list_item_2, …)
y cada uno de los list_item_i es una lista similar a la siguiente: list_item_i = list(‘item tit’, default_num, [‘valor 1’, ‘valor2’, …])
l1=list('elección 1',1,['botón c1','botón c2','botón c3']); l2=list('elección 2',2,['botón d1','botón d2','botón d3']); l3=list('elección 3',3,['botón e1','botón e2']); rep=x_choices('Menu Botón',list(l1,l2,l3));
112
A.3. INTERFACES GRÁFICAS DE USUARIO
A.3.1 La función uicontrol La función uicontrol permite crear una interfaz gráfica para usuarios (GIU). La secuencia de llamado es:
h = uicontrol('Prop',Val,...) h = uicontrol(parent,'Prop',Val,...) h = uicontrol(uich)
h = uicontrol('Prop',Val,...) crea un uicontrol con identificador h y le asigna las propiedades (Prop) y valores (Val) especificados. El estilo por defecto es un botón. El dominio o lugar de creación por defecto es la figura que está en uso.
h = uicontrol(parent,'Prop',Val,...) crea un uicontrol en el objeto especificado por parent.
h=uicontrol(uich) pone el foco en el uicontrol especificado por uich.
Todos los objetos gráficos se comunican a través de sus propiedades. Así, para crear controles adaptados hace falta conocer el uso de las siguientes propiedad.
113
BackgroundColor. Color de fondo del uicontrol. El color puede ser un vector real [R,G,B] o una tira de letras donde cada valor está separado por un |, es decir "R|G|B" callback. (string) Tira que es evaluada por el interprete de scilab cuando se activa un uicontrol (por ejemplo cuando se hace click sobre un botón). Enable {on}|off Abilita o desabilita el uicontrol. Lallave indica el valor por defecto. fontangle. (string) Pone la inclinación de la letra de un texto en el control. Tiene que ser alguna de estas tiras: {'normal'} | italic | oblique. La llaves indica el valor por defecto. fontsize. (número real) Pone el tamaño de las letras de un texto en un control. fontunits. (string) Selecciona las unidades del tamaño de letra especificada por fontsize. Tiene que ser alguna de estas tira: {points} | pixels | normalized. fontweight. (string) Pone el grosor de la letra utilizada en el texto de un control. Tiene que ser alguna de estas tira: light | {normal} | demi | fontname. (string) Contiene el nombre del tipo de letra elegido para mostrar el texto del control. ForegroundColor Color en el frente del control. El color puede ser dado como un vector real [R,G,B] o una tira de letras "R|G|B" donde cada valor está separado por un | Horizontalalignment. (string) Elige la alineación horizontal en el control. Tiene que ser alguna de estas tiras: left | {center} | right. Esta propiedad solo puede ser utilizada enlos estilos 'text', 'edit' y 'checkbox'. ListboxTop (entero) Para un estilo ListBox, elige el ítem de la lista que aparece en la primera línea. Max (escalar) Especifica el mayor valor de 'value'. Sin embargo, tiene significado diferente según el control: o Check Boxes : Max es el valor que toma de la propiedad 'value' cuando es chequeado el control o Silders : valor máximo del deslizador o List boxes : si (Max-Min)>1 la lista permite elecciones múltiples, de otra forma no. Min (escalar) Especifica el menor valor de 'value'. Sin embargo, tiene significado diferente según el control: o Check Boxes : Min es el valor que toma la propiedad 'value' cuando el control no es chequeado o Silders : valor mínimo del deslizador o List boxes : si (Max-Min)>1 la lista permite elecciones múltiples, de otra forma no.
114
Parent (entero) Gestor del control. Cambiando esta propiedad se mueve el control de una figura a otra. Path Esta propiedad es de solo lectura. Permite obtener el camino TK del control como una tira de letras. Position vector real [1,4] o tira de letras. Pone la configuración geométrica del control. Es un vector x y w h donde x, y corresponden a la posición de la esquina inferior izquierda, w al ancho y h a la altura. La unidad la determina la propiedad 'Unit'. SliderStep vector real de [1,2] o tira de letras. Tiene que ser alguna de estas: [small big]. Un paso small corresponde al movimiento que se obtiene cuando se presiona sobre las teclas flechas; El paso big corresponde al movimiento de un Ctrl-keyboard-arrows. String (string) Generalmente representa al texto que aparece en el control. Su significado exacto depende del estilo del control: o List Boxes, menú desplegable, el valor puede ser un vector de letras o una tira de letras donde los ítem están separados por un '|'. Style Estilo del control. Debe ser alguna de estas tiras: {pushbutton} | radiobutton | checkbox | edit | text | slider | frame |listbox | popupmenu
o pushbutton Un botón rectangular generalmente utilizado para correr un procedimiento. o radiobutton Un botón con los estados : on / off. o checkbox Un control pequeño con los estados : on / off o edit Un control de letras que se pueden editar o text un control de textos (generalmente estáticos). o slider Un control barra de desplazamiento utilizada para poner valores en un rango con el mouse. o frame Un control representando un zona utilizada para agrupar controles que están relacionados. o listbox Un control para una lista de ítem. El ítem se elige con el mouse. o popupmenu Ahe aparecer un menú cuando se clickea sobre un botón.
Tag Propiedad generalmente utilizada para identificar el control. Tira de letras para darle un "name". Units Define la unidad utilizada en la propiedad 'position'. Tiene que ser alguna de estas tiras: {points} | pixels | normalized.
115
Userdata Puede utilizarse para asociar algunos objetos (string, matriz de string, matriz mxn) a un control. Value Valor del control. El significado exacto depende de la propiedad estilo. o Checkboxe, Radiobutton. Value se pone Max cuando es on y Min cuando off. o ListBoxe, PopupMenu. Value es un vector de índices que corresponde al índice de la entrada elegida en la lista. 1 es el primer ítem de la lista. o Sliders Valor elegido en la barra de desplazamiento. Verticalalignment Para poner el alineamiento vertical del texto en el control. Tiene que ser alguna de estas tiras: top | {middle} | bottom. Esta propiedad se puede utilizar sólo con los estilos 'text' y 'checkbox'.
h=uicontrol(f,'style','listbox', ... 'position', [10 10 150 160],...// crea un listbox 'string', "item 1|item 2|item3",...// llena la lista 'value', [1 3])// selecciona item 1 y 3 en la lista
x=0:%pi/10:%pi; function y=foo(x) y=sin(x) plot(x,y,'ro-') endfunction f=figure(1); uicontrol(f,'style','pushbutton', ... 'position', [10 10 100 50],... 'string', "seno",... 'callback', "plot(sin(x))") uicontrol(f,'style','pushbutton', ... 'position', [100 10 100 50],... 'string', "función",... 'callback', "exec(foo(x))") close(f)
116
A.3.2 La función uimenu La función uimenu crea un menú o un submenú en una figura. Si el parent es una figura, entonces el menú se agregará a la barra de menú de la figura. Si parent es un menú, entonces el nuevo ítem se agregara a los ítem del parent, permitiendo crear submenú en cascada. La secuencia del llamado es:
h=uimenu([prop1,val1] [,prop2, val2] ...) h=uimenu(parent,[prop1, val1] [,prop2, val2] ...)
parent : Un entero que administra la relación del menú prop{1, 2 ...} : nombre de la propiedad val{1, 2 ...} : valor para afectar a la propiedad correspondiente h : Entero que identifica el menú correspondiente
Para crea un menú adaptado se puede utilizar algunas de las siguientes propiedades:
callback (string) Permite colocar la instrucción a llamar cuando el ítem es elegido por el usuario. label (string) Permite colocar el texto que aparece en el item. tag (string) Esta propiedad generalmente es utilizada para identificar el menú. Permite darle un nombre.
117
f=figure('position', [10 10 300 200]);// crea una figura m=uimenu(f,'label', 'ventanas');// crea un item en la barra de menú m1=uimenu(m,'label', 'operaciones');//crea un segundo item en el menu "windows" m2=uimenu(m,'label', 'salir de scilab', 'callback', "exit") x=0:%pi/10:2*%pi;y=sin(x); m11=uimenu(m1,'label', 'nueva ventana', 'callback',"xselect()",'callback',"plot(x,y)"); m12=uimenu(m1,'label', 'borra la ventana', 'callback',"xbasc()"); // crea un submenu para el item "operaciones" close(f);// cierra la figura
A.3.3 Las funciones set y get
Con la función set se pone o modifica el valor de la propiedad de un objeto de interfase de usuario, como uicontrol. La secuencia del llamado es:
set(prop,val) set(h,prop,val) h.prop=val
Esta función pude utilizarse para colocar una propiedad especifica a una entidad gráfica. Esta entidad gráfica es identificada por su manija h. Si la manija no se especifica el objeto en uso es tomado por defecto. El tipo de valor para poner a la propiedad depende del tipo de propiedad de la entidad gráfica.
Con la función get se obtiene el valor de la propiedad de una entidad gráfica o de un objeto de interfase de usuario. Las secuencias del llamado es:
118
h=get(prop) val=get(h,prop) val=h.prop
Esta función puede utilizarse para obtener el valor de una propiedad de un objeto GUI. Si no se especifica la manija h, el objeto en uso es tomado por defecto. También se utiliza para obtener una lista de todos los hijos, padres, o tipos que dependen de la manija de entrada. A continuación se explica el significado de las variables de las secuencias del llamado de ambas funciones:
h : una manija, el identificador de la entidad a la cual se quiere poner el valor de la propiedad. h puede ser un vector, en cuyo caso pone el valor de la propiedad de todos los objetos identificados por h(i). prop : una tira de caracteres con el nombre de la propiedad que se quiere poner. val : valor para dar a la propiedad.
En el siguiente ejemplo, con el botón Pasa1 se toma el valor de la propiedad string, en este caso la palabra hola, del uicontrol cuya manija es h1 y lo pone como valor de la misma propiedad pero del uicontrol con manija h2. Es decir se paso el texto de una caja a otra caja de estilo edit. Al presionar el botón Pasa2 la palabra HOLA, en mayúsculas, se pone como propiedad de h2.
clf() f=figure(1,'position',[100 100 300 300]) h1=uicontrol(f,'style','edit', 'position', [10 10 100 50],'string','hola'); h2=uicontrol(f,'style','edit', 'position', [150 10 100 50],'string',''); h3=uicontrol(f,'style','pushbutton','position', [10 200 100 50],'string','Pasa1','callback','exec(foo2())'); h4=uicontrol(f,'style','pushbutton','position', [150 200 100 50],'string','Pasa2','callback','exec(foo1())'); function foo1() set(h2,"string",'') set(h2,"string",'HOLA') endfunction function foo2() set(h2,"string",'') p=get(h1,'string') set(h2,"string",string(p)) endfunction
119
120
APENDICE B TOMA DE DATOS CON INTERFASE TCL/TK Existe la posibilidad de complementar a Scilab con el lenguaje Tcl/Tk, con el que se amplían las prestaciones de Scilab para realizar programas más elaborados, por ejemplo programación orientada a objetos o para la adquisición de datos. En el capítulo anterior se han utilizado los comandos figure, uicontrol y uimenu que son ejemplos de interfaces TCL para la creación de objetos gráficos. En este capítulo, primero se presentan comandos para ejecutar sentencias o archivos TCL y luego la aplicación de éstas para la adquisición de datos mediante la computadora.
B.1. EJECUCIÓN DE SENTENCIAS TCL
El comando TCL_EvalStr evalúa una tira de letras dentro del interprete tcl/tk. Es decir, permite ejecutar sentencias escritas en el formato tcl/tk. La forma general del llamado es:
TCL_EvalStr(str [,interp])
str : es una tira de letras o vector de tiras de letras con las instrucciones tcl/tk interp : parámetro opcional, de tiras de letras. Nombre del interpretador tcl esclavo donde se realizarán las operaciones. Si no se proporciona un nombre, se utilaza el interpretador principal creado por scilab.
TCL_EvalStr puede utilizarse para evaluar expresiones sin tener que escribir las instrucciones tcl/tk en un archivo separado. Si las instrucciones son muchas, conviene utilizar la función TCL_EvalFile que lee y evalúa un archivo tcl/tk. El llamado general de la función es el siguiente:
TCL_EvalFile(filename [,interp])
filename : es una tira de caracteres que contiene el nombre del archivo a ser leído y evaluado. interp : significado idéntico al explicado anteriormente.
121
Esta función permite crear poderosas interfaces utilizando directamente scripts en tck/tk.
La función TCL_GetVar permite obtener el valor de una variable tcl/tk . Su llamado general es:
value=TCL_GetVar(Varname [,interp])
varname : cadena de caracteres que contiene el nombre de la variable tcl/tk. interp : con significado idéntico al explicado anteriormente value : puede ser una letra o una matriz de tiras de letras, que contiene el valor de la variable varname.
B.2. TOMA DE DATOS DESDE LA PUERTA SERIE
Como se dijo anteriormente, Scilab no tiene funciones propias para programar directamente sobre las puertas serie de la PC. En cambio, el lenguaje TCL/TK, sí cuenta con este tipo de sentencias y se pueden ejecutar desde SCILAB con la función TCL_EvalStr. A continuación, se describen funciones creadas con comandos de TCL que permiten tomar datos desde la puerta serie (COM1), utilizando módulos de adquisición ADAM. En particular, se programa para el ADAM 4018 que es un módulo para medir hasta 6 canales de señales. Por ejemplo, se pueden medir temperaturas conectando termocuplas a estos canales. Si bien las funciones que se muestran a continuación pueden formar parte de un solo procedimiento, se muestran por separado como si se tratase de un proceso, lo cual facilita su utilización en una interfaz gráfica donde cada una de ellas puede estar asociada a la ejecución de un control de dicha interfaz. A continuación se explican las funciones:
Habilita
Leer Conf
Configurar
Medir
Deshabilita
122
function habilitar_ADAM() TCL_EvalStr(["set leer [ open /dev/ttyS0 r+]" "fconfigure $leer -mode 9600,n,8,1 -buffering line eofchar {} " ]) endfunction
La función habilitar_ADAM habilita el módulo de adquisición. La función TCL_EvalSTr evalúa y ejecuta dos líneas de sentencias. En la primera, el comando set crea y asigna un valor a la variable leer, que está entre corchetes. Cuando se colocan entre corchetes significa que se debe evaluar el contenido. En este caso se abre la puerta ttyS0 para grabar o leer. La variable leer se obtiene luego anteponiendo el signo $. En la segunda sentencia se utiliza el comando fconfigure para poner las opciones al canal de medida $leer, mode establece el protocolo de medida RS232 (velocidad de baudios, paridad, longitud de los bits, bit de stop),
buffering
line establece que se leerá cada ves que ingrese una línea de datos en el buffer, sin esperar que este se llene, eofchar establece cual es el carácter de fin de línea, en este caso un vacío. function b=leer_configuracion_ADAM(número) num= sprintf("puts $leer \$0%d2",número) //para leer configuración // num= sprintf("puts $leer \%d",número) para configurar TCL_EvalStr(num) TCL_EvalStr("set b [ gets $leer]") b=TCL_GetVar('b') endfunction
La función leer_configuración_ADAM permite leer la configuración del módulo. Cada módulo tiene asignado un número. El parámetro de entrada número identifica el módulo que se quiere configurar. El comando puts coloca en el canal $leer el comando $0%d2, que es un comando de programación propio del ADAM. %d es un carácter de conversión que se sustituye por número que identifica al módulo. El comando gets lee la línea de respuesta desde el canal especificado y ésta es puesta como valor de la variable b. En la última línea se convierte este valor de TCL a SCILAB, asignándolo a la variable de salida de la función, b.
La misma función puede utilizarse para configurar el módulo pero en este caso el parámetro número contiene toda la sintaxis de programación correcta, de acuerdo a lo que se muestra en la tabla de abajo. Por ejemplo si con un ADAM 4018 el parámetro número vale %070F0600 se configura el módulo 07 para utilizar en todos los canales termocuplas tipo k, que leerán a
123
una velocidad de 9600 baudios por segundos y el resultado de la lectura se mostrará en unidades de ingeniería. function medida=medir_ADAM(canal,número) num= sprintf("puts $leer #0%d%d",número,canal) TCL_EvalStr(num) TCL_EvalStr("after 100") TCL_EvalStr("set b [ gets $leer]") b=TCL_GetVar('b') medida=sscanf(b,">+%f") endfunction
Como se dijo, un módulo de adquisición tiene varios canales de entrada análogas. La función medir_ADAM mide un canal del módulo, especificado por el parámetro canal, mientras que el módulo está especificado por número. Este canal de medida del módulo no debe confundirse con el fichero $leer habilitado anteriormente como canal de comunicación con la puerta serie. La función coloca en $leer el comando de programación #0%d%d, donde se reemplazan los caracteres de conversión enteros por número, que identifica el módulo, y por canal, que identifica el canal que se quiere medir. Luego de un tiempo de demora de 100 milisegundos, se obtienen el valor que el buffer puso en $leer, asignándolo a la variable b. Esta se convierte y se pasa como variable con formato al parámetro de salida medida. function deshabilitar_ADAM() TCL_EvalStr("close $leer ") Endfunction
La función deshabilitar_ADAM cierra el archivo $leer, mediante el comando close Si se está corriendo un programa de gran tamaño, pueden consumirse muchos recursos si se mantienen abiertos ficheros innecesariamente. La siguiente Tabla contiene la sintaxis de los comando de programación del módulo ADAM que se utilizaron en las funciones.
Sintaxis del Comando
Nombre del Comando
%AANNTTCCFF
Configuración
#AAN
Leer el canal N
$AA2
Estado de la configuración
Descripción
Ejemplo
Coloca la dirección, %070F0600 rango de entrada, velocidad de baudios, formato del dato del módulo Lee la entrada del canal #070 N del módulo AA Pide la configuración del $072 módulo AA
124
