Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
Autores:
Miguel Condor
Mariela Finetti
Luis Saravia
Colaboradores:
Maiver Villena
Daniel Hoyos
CAPITULO 1 ........................................................................................................................................... 4
INTRODUCCIN ................................................................................................................................................. 4
1.1. LA MOTIVACIN PARA LA ENSEANZA DEL SCILAB.................................................................... 4
1.2. LAS CARACTERSTICAS PRINCIPALES DE SCILAB. ......................................................................... 5
1.3. EL DIRECTORIO SCILAB ......................................................................................................................... 6
1.4. LA VENTANA DE TRABAJO ................................................................................................................... 7
1.5. BIBLIOGRAFA .......................................................................................................................................... 9
CAPITULO 2 ......................................................................................................................................... 11
NOCIONES BSICAS ....................................................................................................................................... 11
2.1. INTRODUCCIN ...................................................................................................................................... 11
2.2. ENTRADA, EJECUCIN Y SALIDA ..................................................................................................... 11
2.3. LAS VARIABLES Y LOS TIPOS DE DATOS ........................................................................................ 12
2.4. OPERADORES Y FUNCIONES ............................................................................................................... 17
2.5. AYUDA...................................................................................................................................................... 18
2.6. CONSTANTES .......................................................................................................................................... 18
2.7. NMEROS COMPLEJOS ......................................................................................................................... 19
2.8. VECTORES Y MATRICES ...................................................................................................................... 20
2.9. EL GENERADOR DOBLE PUNTO ......................................................................................................... 22
2.10. TIRA DE CARACTERES........................................................................................................................ 23
CAPITULO 3 ......................................................................................................................................... 27
PROGRAMACIN............................................................................................................................................. 27
3.1. INTRODUCCIN ...................................................................................................................................... 27
3.2. DIRECTORIO PRINCIPAL DE TRABAJO ............................................................................................. 28
3.3. GUARDANDO LA SESIN DE TRABAJO ............................................................................................ 29
3.4. ENTRADA Y SALIDA SENCILLAS ....................................................................................................... 30
3.5. ESTRUCTURA DE UNA FUNCIN ....................................................................................................... 31
3.6. VARIABLES GLOBALES Y LOCALES ................................................................................................. 34
3.7. OPERADORES RELACIONALES Y LGICOS ..................................................................................... 37
3.8. SENTENCIAS DE CONTROL DE FLUJO .............................................................................................. 39
3.8. DEFINICIN DE FUNCIONES EN LINEA ............................................................................................ 43
CAPTULO 4 ......................................................................................................................................... 45
GRFICOS EN SCILAB.................................................................................................................................... 45
4.1. INTRODUCCIN ...................................................................................................................................... 45
4.2. LA VENTANA GRFICA ........................................................................................................................ 45
4.3. REPRESENTACIN EN 2D ..................................................................................................................... 47
4.5. MANIPULACIN DE LOS PARMETROS DEL GRFICO ................................................................ 55
4.6. GRFICOS COMPUESTOS ..................................................................................................................... 57
4.7. CURVAS DE NIVEL................................................................................................................................. 60
4.8. REPRESENTACIN DE GRFICOS EN 3D .......................................................................................... 62
CAPITULO 5 ......................................................................................................................................... 67
FUNCIONES MATEMTICAS ........................................................................................................................ 67
CAPTULO 1
INTRODUCCIN
Este documento est conformado por apuntes de clase para la enseanza del programa Scilab
en la materia Laboratorio 1, en el departamento de Fsica 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 ms importantes del
mismo y pueda utilizarlo para resolver los problemas ms habituales en la Licenciatura. Es de
esperar que a partir de esta introduccin, en caso de ser necesario, el alumno pueda
profundizar personalmente en los aspectos ms avanzados.
Entre los programas de mayor uso con las caractersticas mencionadas en el prrafo anterior,
se encuentran Mathematica y Matlab (o similares, como Octave y Scilab). El Matlab es el ms
utilizado en cursos de Fsica e Ingeniera, mientras que el primero en general resulta ms
apropiado para matemticos por su manejo del clculo simblico. Estos programas se
caracterizan por disponer, adems de las herramientas habituales de programacin, de un
conjunto muy grande de funciones tiles en las aplicaciones matemticas, que permiten
encarar el estudio de la mayor parte de los problemas que se presentan.
Una ventaja de Scilab es que utiliza la sintaxis de Matlab para el manejo de Matrices
Numricas, adems de poder utilizar objetos ms complejos. Por ejemplo, el manejo de
matrices con racionales, polinomios o funciones es muy fcil de realizar con Scilab.
Resumiendo podemos decir que Scilab es un paquete de software cientfico para el clculo
numrico con un entorno muy amigable para el usuario. Sus principales caractersticas son:
2. Es una aplicacin interactiva. Esto significa que se le puede plantear una operacin
matemtica y el programa entrega la respuesta de inmediato. Ello lo hace muy amigable
cuando se resuelven problemas concretos no muy complicados. Pero tambin es posible
escribir programas, es decir un conjunto sucesivo de operaciones matemticas y lgicas,
para poder resolver problemas ms complicados que requieran un tratamiento ms
cuidadoso.
3. Scilab es Software Libre. Actualmente existe una lnea de trabajo que piensa que el
desarrollo de programas debe realizarse por el trabajo mancomunado de las personas
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 autora
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 direccin:
http://www.scilab.org
Desde este sitio pueden descargarse diferentes versiones del programa y consultar
informacin general, manuales y documentacin adicional. Tambin existe un grupo de
noticias (News) donde pueden intercambiarse experiencias, ideas y programas
desarrollados en Scilab. Adems, existen numerosos sitios en internet donde puede
encontrarse informacin 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 adems otras importantes caractersticas para el programador ms avanzado o con
necesidades especficas, entre las que se pueden mencionar:
directorio tambin contiene los scripts1 que administran los ficheros que se generan
con Scilab y manejan la impresin de los mismos.
examples (ejemplos) contiene ejemplos muy tiles de cmo conectar Scilab con
programas externos, utilizando enlaces dinmicos ( 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 cdigo fuente de todas las rutinas
numricas.
En la figura 1.1 de esta seccin 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 estn disponibles dentro del men:
Get Current Directory: (obtener el directorio corriente) para obtener el camino (path)
al directorio actual.
Un script es un programa sencillo que contiene una secuencia de instrucciones que el programa principal (en
este caso Scilab) deber interpretar. Ver captulo 3.
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 (ingls/francs), color, fuente de las letras, etc.
Control (control) la lista contiene opciones para controlar la ejecucin 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 ejecutarn en Scilab.
Applications (aplicaciones) desde all se pueden ejecutar algunas aplicaciones que
funcinan bajo scilab, como Scicos que es un paquete para la simulacin de sistemas
dinmicos.
? (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 opcin permite acceder a una descripcin de cada uno de los
comandos de Scilab. La informacin es igual a la contenida en el manual de gua.
Los comandos estn agrupados por tipos de funcin y al aparecer la lista, se puede
apretar sobre el nombre de alguno para que aparezca la informacin detallada sobre el
mismo. Recorriendo estas listas se puede apreciar la gran variedad de funciones
disponibles en Scilab.
Figura 1.1
1.5. BIBLIOGRAFA
* Un manual en espaol:
Ttulo: Introduccin al Scilab
Autor: Hctor Mora Escobar Univ. Nacional de Colombia
Fecha de publicacin: Nov/2001
Pginas: 55
Disponibilidad: archivo poscript
* Un manual en ingls:
Ttulo: Introduction to Scilab, usersguide
Autor: Scilab Group
Fecha de publicacin:
Pginas: 126
Disponibilidad: archivo poscript.
10
CAPITULO 2
NOCIONES BSICAS
2.1. INTRODUCCIN
Los ejemplos desarrollados para este libro se realizaron usando la versin 4.1 de Scilab, la
ltima al momento de la edicin de estos apuntes, pero las nociones bsicas son comunes con
las versiones anteriores, siendo las diferencias entre ellas fundamentalmente el agregado de
nuevas funciones y aplicaciones.
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.
-->
11
Scilab es una aplicacin interactiva, por lo tanto se introducen las operaciones que se desean
ejecutar (los comandos) y el programa las ejecuta. Veremos despus que tambin es posible
ejecutar una serie de comandos de Scilab escritos en un archivo (programas), mediante un
editor de texto. Por ello esta versin ya viene con un editor incorporado, llamado SciPad, al
cual se accede desde el men Editor.
La lnea superior es el men bsico desde donde se pueden ejecutar las operaciones
principales. Debajo de este men, presionando F3, se puede agregar o quitar una barra de
herramientas para la ejecucin de comandos especficos.
Scilab muestra el siguiente smbolo, que se conoce como prompt, indicando que el programa
est listo para recibir la instruccin:
-->
Despus del prompt es el lugar donde se comienza a introducir los comandos a ejecutar. En
este caso 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 resultado de la operacin
y a continuacin vuelve a mostrar el prompt indicando al usuario que la aplicacin esta lista
para recibir otra instruccin.
Para salir de Scilab se utiliza el comando exit. Este comando puede ejecutarse escribindolo
a continuacin del prompt o seleccionando esta opcin desde el men File, con lo cual se
vuelve al escritorio del sistema operativo.
-->exit
12
redefina la variable. Una variable es creada simplemente asignndole un valor. Por ejemplo,
anteriormente se defini la variable t introduciendo en ella la suma 2+3.
En computacin suelen usarse distintos tipos de datos: numrico entero, numrico flotante,
texto alfanumrico, 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. Por
ejemplo, podemos cargar en la variable t un nmero flotante y luego un texto alfabtico.
-->t=2.56
t =
2.56
-->t="Scilab"
t =
Scilab
Los tipos de datos bsicos que maneja Scilab son enteros, reales (en sus distintas notaciones),
caracteres, cadenas de caracteres, entre otros. Como ejemplos tenemos:
4532
3.5
-4.1234
3.14e-10
3.14E-10
0.0035e20
-31.45e+11
scilab
scilab 2.7
Como se aprecia, los textos alfanumricos (cadenas de caracteres) deben introducirse entre
comillas para que Scilab los reconozca como tales y no los confunda con identificadores de
variables.
13
Ms adelante veremos que Scilab utiliza tipos ms complejos de variable que permiten
manejar nmeros 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, convirtindolo en un poderoso lenguaje de clculo.
Las maysculas y minsculas 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 =
2.56
=
3100.
Como se aprecia, t y T se guardan por separado y pueden ser utilizadas como tales a
posteriori.
14
LCC
Vemos que la lista contiene a las variables t y T. Al comenzar su trabajo, Scilab define un
conjunto de variables que tambin aparecen en el listado (variables predeterminadas o del
entorno Scilab). No deben usarse identificadores de variables similares a las predeterminadas
por Scilab.
Los nombres (identificadores) de las variables pueden tener hasta 24 caracteres de longitud.
Deben comenzar con una letra o con el smbolo $. El resto de los smbolos pueden ser letras,
nmeros, #, _, $, . Por ejemplo, los siguientes nombres son vlidos:
Primer_valor,
15
Scilab posee la variable predeterminada ans que almacena el ltimo valor calculado. El uso
de la misma permite realizar operaciones posteriores empleando
siguiente ejemplo:
-->4.5+0.23
ans =
4.73
-->ans*2
ans =
9.46
Como se aprecia, ans siempre almacena el ltimo valor calculado. En el ejemplo se realiza
un segundo clculo operando con el resultado anterior, luego de esta segunda instancia ans
adopta el nuevo valor.
Para facilitar el trabajo, Scilab guarda en memoria todas las operaciones sucesivas que se
estn realizando. Si se quiere utilizar una de ellas a posteriori, basta presionar las teclas del
cursor sucesivamente (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 tambin permite realizar varias operaciones en una misma orden, separando cada
comando con una coma.
a2
5.
=
a3
4.35
=
.0023
16
Scilab incluye numerosos operadores, entre ellos los aritmticos. Las cuatro operaciones
bsicas: suma, resta, multiplicacin y divisin estn representadas por: +
potencia por: ^
y la
**.
Adems se dispone de los parntesis: ( , ) para agrupar las operaciones. Las reglas con las
que operan los smbolos precedentes son las habituales en matemtica.
Se dispone tambin de una gran cantidad de funciones, que prcticamente cubren la mayor
parte de las necesidades. Las funciones elementales disponibles son:
17
La mayora son reconocibles por su nombre. Por ejemplo ceil es la parte entera superior, floor
es la parte entera inferior, fix el redondeo hacia cero (igual a int), mdulo(a,b) da el residuo de
a dividido b donde ambos son enteros.
Adems de las funciones elementales existe una gran cantidad de funciones especiales que se
irn viendo a lo largo del curso, muchas de ellas de inters por sus aplicaciones en fsica e
ingeniera.
2.5. AYUDA.
Ya hemos visto que en el men principal se encuentra una ayuda ? donde se detallan todos
los comandos agrupados por temas.
Tambin es posible obtener esa informacin directamente dentro del lenguaje al disponerse de
un comando help. Si, por ejemplo, se escribehelp tan, sin las comillas, obtendremos
directamente la informacin detallada sobre la funcin tangente. Si no se dispone del nombre
especfico de la funcin, se puede solicitar informacin 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.
2.6. CONSTANTES
Es habitual utilizar en matemtica algunas constantes que tienen una importancia especial,
como ser el nmero Pi, el nmero e, etc. Estos nmeros se encuentran predefinidos en Scilab
y pueden ser utilizados directamente en cualquier clculo. Se les llama constantes debido a
que tienen algunas propiedades especiales. Estos nmeros estn 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. Se ve que al
intentar cambiar el nmero pi, dndole el valor 0 el programa marca un error ya que una
constante no se puede cambiar. En el cuadro se observa el nmero e y tambin el nmero
imaginario i que se utiliza para escribir un nmero complejo.
18
-->%pi
%pi =
3.1415927
-->%pi=0
!--error
13
redefining permanent variable
-->%e
%e =
2.7182818
-->2+3*%i
ans =
2. + 3.i
Scilab maneja los nmeros complejos en forma sencilla. Para eso define internamente una
variable, %i, que contiene el nmero imaginario i. Un complejo cualquiera se expresa usando
la parte real ms la imaginaria multiplicada por %i. Por ejemplo:
a = 5+7*%i
Las funciones de Scilab admiten nmeros complejos como variables del clculo y pueden
expresar sus resultados como nmeros. Por ejemplo:
-->b = sqrt(-4)
b =
2.i
-->c=sqrt(1+%i)
c =
1.0986841 +
.4550899i
-->c^2
ans =
1. + i
19
Scilab est preparado para trabajar con arreglos de variables (vectores y matrices) sin
dificultad alguna. Esto convierte al Scilab en un lenguaje de clculo matricial, ya que estn
definidas todas las operaciones que se aplican a matrices en forma de funciones.
Las matrices se definen utilizando corchetes [ , ]. Existen tres formas equivalentes para
definir una matriz, las que se ilustran mejor utilizando los ejemplos que siguen:
-->c = [11,12,13;21,22,23]
c =
!
!
11.
21.
12.
22.
13. !
23. !
11.
21.
12.
22.
13. !
23. !
-->f = [11 12 13
-->
21 22 23]
f =
!
!
11.
21.
12.
22.
13. !
23. !
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 escribindolas en renglones
sucesivos. En todos los casos la expresin 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 ya definida:
-->c(2,3)
ans =
23.
20
11.
12.
13.
21. !
22. !
23. !
El producto de una constante por una matriz se expresa con el signo habitual de producto *.
La constante se multiplica por cada elemento de la matriz. Por ejemplo:
-->1.2*c
ans =
!
13.2
!
25.2
14.4
26.4
15.6 !
27.6 !
.*. Las matrices deben tener las dimensiones correctas para efectuar la
-->A=[1,1;2,2],B=[2,2]',C=[3,3;1,1];
-->A*B
ans =
4.
8.
-->A*C
ans =
4.
8.
4.
8.
-->A.*C
ans =
3.
2.
3.
2.
21
Resulta muy til en el entorno de Scilab la generacin de vectores formados por una sucesin
de valores igualmente separados. A esos efectos dispone de una forma abreviada de
generacin de vectores que se escribe con el siguiente formato:
Esto genera un vector cuyo primer valor es el valor inicial y los valores siguientes estn
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. Por ejemplo:
x = 3 : 0.5 : 7
Debido al uso del doble punto en la notacin se le conoce con el nombre de generador doble
punto.
La notacin doble punto 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:
1 0 0
c = 1 1 0
1 1 0
00
d = 1 0
1 0
[v]=linspace(x1,x2 [,n])
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.
22
Ejemplos:
linspace(1,2,10)
linspace(1+%i,2+2*%i,10)
Una cadena de caracteres (string) es bsicamente una variable que contiene un texto
colocndolo entre comillas simples o dobles. Una cadena de caracteres puede ser manipulada
a travs de comandos especficos. En esta seccin veremos algunos que pueden ser de gran
utilidad cuando se trabaja con archivos de texto.
!
!
w+v
23
La funcin length calcula la cantidad de caracteres en una tira. Para matrices de tiras de
caracteres retorna la longitud de cada uno de los elementos de la matriz.
-->length(123)
ans =
3.
-->M=['a','bb';'ccc','dddd'];
-->length(M)
ans =
1.
2.
3.
4.
La funcin part permite extraer caracteres de una tira, para lo cual debemos indicar la
posicin del o los caracteres a extraer. Para extraer una serie de caracteres, la posicin se
indica como una secuencia de valores.
-->part("abcd",1)
ans =
a
-->part("abcd",[1,3])
ans =
ac
-->c=part(['a','abc','abcd'],[1,1,2])
c =
!aa
aab aab !
-->part(t3,[1:12])
ans =
El resultado
La funcin strindex(str1,str2) proporciona la posicin que la tira str2 tiene en str1. Una vez
que se determina la posicin de str2 se puede utilizar la funcin part para extraerlo de la tira.
-->t3
t3 =
El resultado es positivo
-->strindex(t3,"es")
ans =
!
5.
14. !
24
-->strsubst(t3,"positivo","negativo")
ans =
El resultado es negativo
La funcin 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
-->strcat(s,'-')
ans =
a-b-c
-->s2=string(7)
s2 =
7
-->s3='la suma es '+s2
s3 =
la suma es 7
-->string(5+2)
ans =
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
25
Los caracteres nmeros pueden convertirse a datos tipo nmero mediante la funcin evstr
(evaluate string).
-->n1=evstr(s4)
n1 =
!
1.
2.
3.
-->n1(1)+n1(5)
ans =
6.
-->evstr('2+2')
ans =
4.
4.
5. !
Como se observa en el ltimo ejemplo, la funcin puede usarse para evaluar cualquier
operacin expresada como caracteres, incluyendo las que tienen variables que guardan
nmeros. Tambin pueden ejecutarse sentencias expresadas como tiras de caracteres mediante
la funcin execstr (execute string).
-->execstr('a=1')
-->a
a =
1.
-->execstr(['a=1' 'b=sqrt(9)'])
-->a b
26
CAPITULO 3
PROGRAMACIN
3.1. INTRODUCCIN
La forma interactiva de Scilab resulta cmoda cuando se necesitan realizar clculos que hagan
uso de unos pocos comandos. A medida que el clculo se complica, la lista de comandos se
agranda y por ende se facilitan las equivocaciones. Por otra parte, resulta til que una sucesin
de comandos pueda guardarse para poder usarla posteriormente. A ese conjunto de sentencias
que se puede ejecutar todas las veces que se requiera Scilab las denomina un script.
Es posible guardar la lista de comandos en un archivo de texto, para luego llamar y ejecutar
esos comandos. En Scilab, la lista de comandos se organiza en un tipo de estructura a las que
se les da el nombre de funcin. Esta se guarda en un archivo de texto con extensin sci. Por
ejemplo, un archivo para una funcin que calcula el promedio de una lista de nmeros puede
llamarse promedio.sci. Por lo general se reserva la extensin sci para funciones definidas
por el usuario (aplicacin especfica). Cuando se escriben programas ms extensos, donde se
involucra el uso de varias funciones se lo llama script y se lo identifica con la extensin
.sce. El uso de las extensiones es solo una convencin y Scilab puede ejecutar programas
(funciones y/o scripts) con cualquier extensin e inclusive sin extensin.
La estructura de un programa puede ser ms rica que una simple sucesin de comandos,
puesto que estos debern ser ejecutados con cierta lgica, dependiendo de las necesidades
propias de la aplicacin. En Scilab existen comandos que permiten tomar decisiones de
acuerdo a los resultados obtenidos, o permiten repetir un clculo con distintos datos iniciales.
Estos enriquecen mucho las posibilidades numricas de una funcin y son los llamados
comandos de control que sern detallados ms adelante.
Adems de los comandos de control de flujo, los siguientes comandos son muy tiles para
utilizar en la confeccin de programas.
27
Para correr un archivo de comandos que est en un directorio se usa: --> exec(nombre
de archivo)
-->pwd
ans =
C:\WINDOWS\Profiles\usuario1\Escritorio\
La carpeta Desktop (escritorio) aparece aqu como el directorio de trabajo actual de Scilab.
En la versin de Scilab para Linux el directorio de trabajo por defecto es el home de la
cuenta del usuario que ha iniciado la sesin.
28
-->exec caida.sci ;
En segundo lugar, en la versin para Windows, cualquiera de ellas puede ser copiada
utilizando los comandos copy y paste del men Edit. En particular esto puede usarse para ir
generando informacin sobre los clculos realizados, como se ha hecho en estos apuntes,
donde los cuadros de ejemplos han sido llenados con informacin recogida de esa manera.
Es posible guardar en un archivo todos los comandos y resultados que se van obteniendo en
una sesin del Scilab mediante el comando diary. Si se ejecuta al comienzo de la sesin:
diary(nombre_archivo)
a partir de ese momento, todas las entradas y salidas interactivas van quedando registradas en
el archivo nombre_archivo, que se guarda en el directorio de trabajo inicial.
29
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 del Scilab.
Esto puede tener varios usos. Por ejemplo, si se est probando una posible funcin ensayando
la entrada de cada uno de sus comandos, ellos quedan guardados con diary. Luego se toma el
archivo y eliminando los renglones innecesarios queda escrita la funcin que se estuvo
ensayando, lista para ser usada.
La funcin input se utiliza para la entrada de datos a travs de la consola. Su forma general es:
[x] = input(mensaje,[string])
30
Esta funcin no se utiliza cuando se trabaja en forma interactiva, ya que en ese caso las
variables se ingresan en forma directa. En cambio puede ser de mucha utilidad cuando se
necesita entrar datos en un programa.
disp(x1,[x2,....,xn])
Donde x1, etc. pueden ser nombres de variables, constantes o tiras de caracteres. Esta funcin
requiere al menos un argumento. De haber varios se van mostrando uno por lnea,
comenzando por el ltimo.
-->x=2.5,y=13.2
x =
2.5
y =
13.2
-->disp(y,x,"x=")
x=
2.5
13.2
Supongamos
z
que
queremos
evaluar
numricamente
el
vo
Se supone que aceleracin y velocidad son positivas cuando se orientan hacia arriba.
31
Los comandos para calcular esta expresin en forma interactiva se dan en la pantalla de abajo.
En esta, se han dado valores especficos a la velocidad inicial (2 ms-1), gravedad (9,8 ms-2 ),
tiempo (10 s). Esto se hace a continuacin del primer prompt y en el segundo se introduce la
ecuacin para calcular la posicin. La respuesta es que la bola ha cado 470 m desde donde se
inici el movimiento.
Si deseamos calcular z varias veces convendr colocar este procedimiento dentro de una
funcin. Para ello se debe abrir un editor donde escribir la funcin, se puede utilizar cualquier
editor de texto, pero Scilab dispone del SciPad, que se ejecuta desde el men Editor.
-->vo=2 ,
vo =
2.
g =
9.8
t =
10.
-->z= vo*t
z =
- 470.
g= 9.8
t=10
0.5*g*t^2
La estructura que debe tener la funcin para que Scilab la reconozca es:
.
endfunction
Las lneas de punto indican dnde deben colocarse los comandos de clculo. El nombre
identifica a la funcin y deber ser llamada desde la ventana de trabajo con ese nombre; par1,
par2, etc. son parmetros que se introducen desde fuera de la funcin para que sean usados
por la misma en el clculo; res1, res2, etc. son las variables en las cuales la funcin devuelve
los resultados del clculo.
Tomando el caso del ejemplo anterior, se crea la funcin caida que almacena el resultado
del clculo en la variable z, y que contiene los siguientes comandos:
32
function z = caida(vo,g,t)
// Calculo de la posicin de una bola en cada libre
// vo = velocidad de la bola
// g = aceleracin
// t = tiempo,
// z = distancia resultado
z = vo*t - 0.5*g*t^2
endfunction
Cabe mencionar que en el editor Scipad los distintos tipos de comandos se muestran con
colores caractersticos, lo que facilita la lectura del procedimiento. Tambin ayuda mucho a la
lectura el utilizar sangras (cdigo tabulado) entre bloques de comando que pertenecen a un
mismo nivel de decisin. Los comandos que comienzan con // son comentarios que el Scilab
no procesa. Se colocan en un procedimiento para que el que inspecciona la funcin tenga una
explicacin adecuada del clculo.
Para usar la funcin es necesario que esta est guardada en un archivo, por ejemplo
caida.sci, e indicarle a Scilab donde est para que la encuentre. Eso se realiza mediante el
comando exec como sigue:
-->exec(caida.sci);
Esto basta hacerlo una vez, por ejemplo cuando se pone en marcha Scilab, para que la funcin
est disponible para otros clculos. 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 funcin
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 lneas del programa
aparezcan en la pantalla de trabajo cuando se carga la funcin, 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 funcin tiene una sola respuesta. Si hay varias se
colocarn separadas por coma como se indica en la definicin general de la estructura de una
funcin.
A continuacin ejecutaremos la funcin, para lo cual se la carga con el comando exec desde el
directorio file o se escribe la sentencia directamente en el prompt de la ventana de trabajo.
Luego se llama la funcin con su nombre asignando el resultado a la variable x. En el llamado
hay que introducir el valor de los parmetros. En el ejemplo se asigna a vo el valor 3 m/s, a g
33
el valor 9.8 m/s2 y a t el valor 2 s. El resultado es 13,6 m. Debe tenerse cuidado de colocar
adecuadamente los signos. Obsrvese que se utiliza la variable x para cargar el resultado de la
funcin, mientras que adentro de la misma se utiliz a z. Esto se puede hacer porque las
variables en la funcin 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 el comando exec. Si se llama desde
all se abre una ventana para el manejo de directorios. Desde all se busca el directorio donde
se encuentra la funcin. Esto es cmodo si no recordamos exactamente la ubicacin de la
misma. El cuadro siguiente indica la salida de la ventana de trabajo ante la ejecucin del
comando exec desde el men
-->exec(C:\WINDOWS\Profiles\usuario1\Escritorio\caida.sci);disp('exec
done');
exec done
Cuando se utiliza una funcin, las variables definidas dentro de la funcin no estn
disponibles para el programa principal, se dice que son variables locales a la funcin. Ambos,
funcin y programa principal, se comunican a travs de los parmetros, por ellos se ingresa la
informacin externa necesaria, y por medio de las variables de salida de la funcin, sta
entrega los clculos realizados.
Existe la posibilidad de utilizar una variable que se declara en el programa principal, dentro
de una funcin mediante las llamadas variables globales. Para ello basta definir una variable
dada, por ejemplo vari1, mediante el comando global como se indica a continuacin:
global vari1
global(vari1)
34
Como ejemplo, supongamos que se escribe la siguiente funcin, que se guarda con el nombre
pru.sci
function c=pru(b)
c=b*f
endfunction
35
-->exec pru.sci;
-->global f
-->f=6, b=2
f =
6.
b
=
2.
-->pru(b)
ans =
12.
Es posible definir una variable local de una funcin como global. En ese caso quedar
disponible para ser utilizada en otra funcin, para lo cual la misma debe ser definida tambin
como global en la nueva funcin. Como ejemplo, definamos una funcin pru1 cuyo nico
objetivo es definir la variable z interna a la funcin. Para que ella est disponible para otro
programa se la define como global. Por otro lado, en el otro programa, pru2, tambin se
define z como una variable global y se realiza el producto de esta con el parmetro 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
36
-->pru1()
ans =
3.
-->b=2
b =
2.
-->pru2(b)
ans =
6.
Un caso tpico del uso de variables globales es el de constantes que se utilizan a lo largo del
clculo, que conviene definirlas globales para no repetir definiciones en cada funcin. Fuera
de estos casos y para evitar errores de programacin, 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 informacin a travs de los parmetros formales.
Acabamos de ver la forma en que se define una funcin utilizando un ejemplo muy sencillo
con un solo comando. En la prctica, las funciones constarn de ms de un comando, por lo
que con el fin de plantear clculos de utilidad ser necesario disponer de mayor ductilidad en
dos aspectos:
a) En poder tomar decisiones en el clculo teniendo en cuenta los resultados que se estn
obteniendo. Por ejemplo, el clculo a realizar podra ser distinto si el valor de una
cierta variable es positivo o negativo.
b) En muchos casos es necesario realizar clculos repetitivos. Por ejemplo, obtener el
resultado de un cierto clculo varias veces con distintos valores de los datos.
37
<
menor
mayor
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<f
&
y
o
no
p<q& r>s
Si p es menor que q y r mayor que s esta comparacin lgica dar un valor lgico verdadero.
38
3.7.1. Comando If
verdadero
falso
Condicin 1
Condicin
falso
verdadero
verdadero
Sentencia 1
Sentencia 2
Sentencia 1
Condicin 2
falso
Sentencia 3
Sentencia 2
El comando if es una sentencia de bifurcacin con la que se puede inspeccionar una condicin
descripta mediante un operador relacional o combinaciones lgicas de los mismos. Su forma
ms sencilla es:
if condicin then
..........................
end
39
La condicin del if puede ser una condicin lgica, del tipo A==B, donde A y B son matrices
del mismo tamao. Para que se considere que la condicin 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.
Otra posibilidad es una bifurcacin entre verdadero y falso haciendo uso de la sentencia else.
Si la condicin es verdadera se ejecutan las sentencias dentro del bloque then, si la condicin
resulta falsa se ejecutan las sentencias correspondientes al bloque else.
if condicin then
..........................
else
..
end
If condicin1
elseif condicin 2
else
end
Habitualmente estas condiciones forman parte de una funcin, pero tambin se pueden usar
expresadas en un solo rengln dentro del ambiente interactivo separando las sentencias con
comas. Por ejemplo:
40
Sentencias
condicin
verdadero
falso
El comando for se utiliza si se quiere realizar una accin en forma repetitiva, teniendo en
cuenta una variable que se incrementa en cada paso y que puede ser utilizada para cambiar
algn aspecto del clculo que se repite:
La variable se incrementa desde el limite1 hasta el limite2 avanzando en pasos dados por
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 clculo en cada paso. Se pueden introducir varios
bucles, uno dentro del otro y se suele decir que estn 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.
41
En este caso tambin se ejecuta una accin repetitiva. Se fija la condicin, y mientras sta se
cumpla, el bucle se repite. Al dejar de cumplirse la condicin impuesta se termina el bucle y
se contina con la instruccin siguiente.
while condicin
...................
...................
end
Se diferencia del ciclo for en que necesariamente la accin dentro del bucle debe modificar
la(s) variable(s) de la condicin. Esta condicin debe alcanzar el valor lgico false, en algn
momento de la ejecucin, porque de lo contrario se entrara en un bucle sin salida que
repetira infinitamente las instrucciones dentro del bloque.
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 valor n then
.
else
..
end
42
Al principio se evala la variable de control cuyo resultado debe ser un escalar o una cadena
de caracteres. La condicin selecciona un resultado entre varios valores de variable, estos son
valor1,valor2, etc. Si variable no toma alguno de los valores dados, entonces se contina por
else ejecutando el ltimo conjunto de comandos.
Como en casos anteriores, la palabra then puede ser reemplazada por una coma. Por otra
parte, tambin como en el if, la palabra else es opcional.
Como se vio anteriormente, un usuario define sus propias funciones en un archivo de texto,
los guarda con extensin .sci y los carga en Scilab mediante el comando getf o exec cuando
quiere utilizarlos.
Existe una forma de hacer definicin de funciones en forma en lnea (on-line) en la pantalla
de trabajo y en una sola instruccin a travs de la sentencia deff. Estas son muy tiles para
programas que slo se utilizan una vez o para probar partes de funciones en la etapa de diseo
del programa. La funcin no queda almacenada una ves que se termina la sesin de trabajo.
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 funcin creada, inst1,
inst2, es una secuencia de instrucciones que se colocan como cadena de caracteres. Estas
instrucciones constituyen la definicin de la funcin y deben incluir la asignacin de la
variable de salida.
El comando deff puede ser utilizado dentro de una funcin y la nueva funcin puede ser una
entrada o salida de cualquier otra funcin. A continuacin se dan algunos ejemplos de
definiciones:
43
44
CAPTULO 4
GRFICOS EN SCILAB
4.1. INTRODUCCIN
Scilab dispone de salidas grficas 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
grficos se pueden:
1) Mostrar funciones en dos y tres dimensiones, con gran variacin en la forma en que se
ingresan los datos y una buena disponibilidad de recursos tcnicos 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 irn presentando en forma ordenada desde los recursos
ms sencillos y de uso comn hasta llegar a las representaciones ms elaboradas.
45
Scilab abre una ventana distinta de la interactiva para dibujar los grficos solicitados. Pueden
abrirse varias ventanas grficas a la vez y estn identificadas con un nmero (0,1,2,3....). En la
ventana grfica de Scilab estn disponibles los siguientes mens:
File
Tools
Edit
46
El men Tools contiene comandos para poner o quitar la barra de herramientas, agrandar o
disminuir zonas de la imagen y rotar los grficos 3D. El men Edit contiene los comandos
propios de un editor grfico para cambiar las propiedades de la figura (forma de ejes, letras
color, etc)
Cuando ejecutamos una instruccin para generar grficos, como plot que se explicar a
continuacin, si ninguna ventana grfica est activada Scilab coloca el dibujo en la ventana
nmero 0. Si hacemos otro grfico ste se ubicar encima del primero. Por lo tanto es
necesario borrar el contenido de la ventana grfica, lo que puede hacerse de dos maneras:
Podemos trabajar muy fcilmente con varias ventanas grficas, con la ayuda de las
instrucciones:
xset("window",num)
xselect()
xbasc(num)
xdel(num)
4.3. REPRESENTACIN EN 2D
47
por defecto mediante lneas negras o de acuerdo a otro estilo que se haya especificado
previamente. La calidad de la representacin depender del nmero de puntos ( x(i),y(i)) que
se grafiquen .
plot(x,y,<lasp>,<globprop>)
Con plot tambin se puede graficar un conjunto de curvas, es decir hacer grficos mltiples.
plot(x1,y1,<lasp1>,x2,y2,<lasp2>,...xN,yN,<laspN>,<globprop1>,
<globprop2>,..<globpropN>)
x debe ser una matriz o un vector de nmeros reales. Si se omite se asume un vector de 1:n
donde n es el nmero de puntos de la variable y.
y debe ser una matriz o vector real, pero tambin puede ser una funcin definida con un
procedimiento.
<lasp> es un argumento opcional que especifica la manera en que se dibujan las lneas. Debe
ser una tira de caracteres y determina el estilo, las marcas y el color de las lneas dibujadas.
(ver LineSpec en 4.3.1).
<globprop> 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).
48
Si slo x o y es una matriz, el vector se dibuja versus las filas o las columnas de la matriz. La
eleccin 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.
y tambin puede ser una funcin, en este caso se debe proporcionar x (como un vector o
matriz) y el clculo y(x) se hace implcitamente.
-->x=linspace(0,3*%pi,50); y=x.*sin(x);
-->plot(x,y)
9
-1
-3
-5
0
10
-->x=[0:0.1:2*%pi];
-->plot(x-4,sin(x),x+2,cos(x))
4.3.1 LineSpec
Se utiliza para cambiar rpidamente la apariencia de las lneas de un dibujo. Debe ser una tira
de caracteres, que hace referencias al del estilo de la lnea, el marcador y el color. Estas
49
referencias deben ser especificadas sin ambigedades, el orden no es importante. Por ejemplo,
para una lnea roja de rayas largas con marcador tipo diamante, se puede escribir: 'r--d' o '-dire' o '--reddiam'... o en forma completa 'diamondred--'. A continuacin se proporciona
una lista completa de los tipos que se pueden especificar.
LineStyle: define el estilo de la lnea.
Especificador
Estilo de Lnea
--
Lnea de trazos
Lnea de puntos
-.
Rojo
Verde
Azul
Cian
Magenta
Amarillo
Negro
Blanco
50
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 lnea,
se dibuja solo el marcador.
Especificador
Tipo de Marcador
Signo mas
Circulo
Asterisco
Punto
Cruz
'square' o 's'
Cuadrado
'diamond' o 'd'
Diamante
>
<
'pentagram'
'none'
51
Por ejemplo
clf();
x=1:0.1:10;
plot(x,sin(x),'r-.>')
dibuja la funcin seno con una lnea roja de raya-puntos con un tringulo 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}, pudindose colocar en un grfico 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 lnea 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 lugar a ambigedades.
GlobalProperty predomina sobre cualquier LineSpec previamente especificado.
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 lnea, en forma idntica que con
LineSpec.
Marker o MarkStyle: Una tira de caracteres que define el tipo de marcador. Idntico que con
LineSpec.
MarkerEdgeColor or MarkForeground: Una tira de caracteres definiendo un color en el
formato RGB. Idntico a Color pero para el borde del marcador.
MarkerFaceColor or MarkBackground: Idntico a Color pero para el fondo del marcador.
MarkerSize or MarkSize: un escalar que define el tamao del marcador en unidades de punto.
52
Visible: una cadena de caracteres "on" o "off" definiendo la visibilidad ( "on" por defecto).
X data: un vector o matriz real redefiniendo los datos para todas las lneas o superficies
dibujadas. Debe ajustase con los X data previamente especificados. Es decir, todas las
matrices de datos deben ser de la misma dimensin.
Y data: Idntico 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
lneas 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 lnea de color rojo, con estilo raya-puntos, marcador tringulo hacia la derecha, los
bordes del tringulo de color cian, las caras de color amarillo y tamao 5 puntos.
La representacin de una funcin se pueden hacer con el comando plot, pero para ello es
necesario definir previamente la funcin que se va a representar. Por ejemplo, a continuacin
se grafica el cuadrado de un nmero:
deff('[y]=toto(x)','y=x.*x')
plot(1:10,toto)
Cuando queremos superponer varias curvas en el mismo grfico, se puede usar el comando
plot2d, que permite fijar estilos diferentes para cada curva. La sintaxis general es la siguiente:
53
Los argumentos a partir del tercero son optativos, pero si se fija uno debern fijarse los otros.
El significado de estos argumentos es el siguiente:
abscisas, ordenadas: son matrices de la misma dimensin. Si fueran vectores (para trazar una
sola curva), deben ser fila o columna. Por defecto los puntos sern unidos por segmentos. A
cada curva le corresponde un color ( hay 32 colores).
marco : este parmetro es una cadena de caracteres formado por tres cifras, tales que :
Por defecto el argumento marco vale 021 ( sin leyendas, escalas calculadas
automticamente y con ejes). Si superponemos dos grficos con esta opcin por defecto, las
escalas no sern las mismas. La solucin consiste en trazar todos los grficos a partir del
segundo sobre una misma ventana con la opcin 000 ( sin leyenda, utilizar la escala
precedente, sin trazar los ejes).
leyendas: es una cadena de caracteres que contiene las diferentes leyendas, separadas por @.
54
logflag: Esta opcin puede usarse para fijar las escala ( lineal o logartmica) 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 logartmica 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 lneas continuas para las curvas que se grafican. Si
queremos usar otro tipo de curvas debemos considera el uso de otros comandos grficos como
plot2d2(grficos en escaln), plot2d3(barras verticales), y plot2d4(estilo con flechas).
55
Los parmetros de esta funcin son un string, choice-name (propiedad que se desea cambiar),
y cinco nmeros, , 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:
Cada color est dado por tres nmeros que corresponden a las
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 grfico a travs de una ventana interactiva provista por SCILAB.
Otro comando existente para manejar propiedades de grficos es el plotframe, cuya forma
general es:
plotframe(rect,tics [,arg_opt1,arg_opt2,arg_opt3])
Con este comando pueden fijarse lo valores mximos y mnimos de los ejes (rect), los
intervalos y subintervalos que se marcarn (tics) y con los argumentos optativos podemos
agregar una grilla al grfico, ttulos y dividir la ventana para dibujar varios grficos 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')
57
Si una misma representacin grfica involucra varias escalas diferentes, es mejor especificar
primero el rectngulo de la representacin y las escalas de los ejes mediante plotframe, para
despus superponer los diferentes grficos.
xbasc();
xset("font",2,4);
plotframe([-4,-1,4,1],[2,10,5,10],[%f,%f],["Ttulo","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
Ttulo
1.0
0.8
0.6
0.4
0.2
0.0
-0.2
-0.4
-0.6
-0.8
-1.0
Eje x
0.8
1.6
2.4
3.2
4.0
58
arco de elipse
xfarc
xarrows flechas
xnumb nmeros
xpoly
polgono
rectngulo
xfrect
rectngulo lleno
xbasc()
plotframe([-1,0,2,4],[10,3,5,4],[%f,%f],["Parbola","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 crculo
Parbola
f(x)
ordenada
x
abscisa
0
-1
59
4
0.200
-0.200
-0.600
-0.600
-0.200
0.200
0.600
-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
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
60
4
3
2
1
0
-1
-2
-3
-4
-4
-3
-2
-1
-3
-2
-1
61
histograma
champ
campo de vectores
fchamp
grayplot
//
//
//
//
matriz de
matriz de
matriz de
paralelas
las abscisas
las ordenadas
las cotas
de una esfera
62
x=linspace(-%pi,%pi,50);
// vector de abscisas
y=x;
// vector de ordenadas
z=sin(x'*y);
// matriz de valores de la funcin
help plot3d
xbasc()
plot3d(x,y,z)
// representacin monocroma
plot3d1(x,y,z)
// representacin 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 parmetros
grficos
Z
1
0
-1
-3.1
-3.1
0.0
0.0
X
3.1
3.1
Para representar una superficie definida por dos parmetros, es necesario definirla como una
funcin para despus utilizar eval3dp, que toma como argumento esta funcin y dos vectores
y devuelve los argumentos necesarios para la representacin mediante plot3d. Veamos por
ejemplo la representacin de una esfera. Para obtener colores variables es necesario cambiar
el sentido de uno de los vectores de parmetros.
63
El comando surf dibuja una superficie coloreada en forma paramtrica 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,<GlobalProperty>)
surf(Z,color,<GlobalProperty>)
surf(X,Y,Z,<color>,<GlobalProperty>)
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 dimensin [ 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 rectngulos. 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
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 rectngulos 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 vrtice de la cara. Con 'interp', se hace un
sombreado interpolado sobre la superficie.
66
CAPITULO 5
FUNCIONES MATEMTICAS
5.1. FUNCIONES MATEMTICAS ELEMENTALES
Estas funciones, que comprenden las funciones matemticas trascendentales y otras funciones
bsicas, actan sobre cada elemento de una matriz como si se tratase de un escalar. Se aplican
de la misma forma a escalares, vectores y matrices. Algunas de las funciones de este grupo
son las siguientes:
sin(x) : seno
cos(x) : coseno
tan(x) : tangente
asin(x) : arco seno
acos(x) : arco coseno
atan(x) : arco tangente (devuelve un ngulo entre -/2 y +/2)
sinh(x) : seno hiperblico
cosh(x) : coseno hiperblico
tanh(x) : tangente hiperblica
asinh(x) : arco seno hiperblico
acosh(x) : arco coseno hiperblico
atanh(x) : arco tangente hiperblica
log(x) : logaritmo natural
log10(x) : logaritmo decimal
exp(x) : funcin exponencial
sqrt(x) : raz cuadrada
round(x) : redondeo hacia el entero ms prximo
fix(x) : redondea hacia el entero ms prximo a 0
floor(x) : valor entero ms prximo hacia -
ceil(x) : valor entero ms prximo hacia +
gcd(x) : mximo comn divisor
67
Transpuesta de la matriz A:
1. + i
2. + 2.i
3. + 3.i
4. - 4.i
1. - i
3. - 3.i
2. - 2.i
4. + 4.i
smbolo )
C =
1. + i
3. + 3.i
2. + 2.i
4. - 4.i
Traza de la matriz A
-->A
68
A =
2.
3.
1.
- 3.
4.
0.
1. - 1.
5.
11.
Dimensiones de la matriz A
3.
m =
3.
-->n=size(A)
n =
3.
3.
-->[l,u]=lu(A)
u =
69
- 3.
4.
0.
0.
5.6666667
0.
0.
1.
4.9411765
l =
- 0.6666667
1.
0.
- 0.3333333
1.
0.
0.
0.0588235
1.
Inversa de la matriz A
-->b=inv(A)
b =
0.2380952 - 0.1904762 - 0.0476190
0.1785714
- 0.0119048
0.1071429 - 0.0357143
0.0595238
0.2023810
0.1071429 - 0.0357143
0.0595238
0.2023810
-->d=det(A)
d =
84.
70
84.
-->[X,D]=spec(A)
D =
2.8386444 + 2.7791238i
2.8386444 - 2.7791238i
5.3227111
X =
- 0.6915854
- 0.6915854
0.0959153
0.2167837 + 0.0153119i
0.9713267
Norma de vectores
0.1121355
0.6856896
0.1531217
0.6970851
-->norm(x,1)
ans =
1.6480318
71
0.9960514
-->norm(x,2)
ans =
0.9960514
v =
8.7841258
1.1383597
1.9983377
-->n=length(v)
n =
6.
-->x=1:.0002:2;
-->n=length(x)
n =
5001.
-->zeros(3,3)
ans =
0.
0.
0.
72
0.
0.
0.
0.
0.
0.
-->eye(3,3)
ans =
1.
0.
0.
0.
1.
0.
0.
0.
1.
-->ones(3,3)
ans =
1.
1.
1.
1.
1.
1.
1.
1.
1.
8.4155184
0.
0.
0.
0.
0.
0.
4.0620248
0.
0.
0.
0.
0.
0.
4.0948255
0.
0.
0.
0.
0.
0.
8.7841258
0.
0.
0.
0.
0.
0.
1.1383597
0.
0.
0.
0.
0.
0.
1.9983377
8.4155184
4.0620248
4.0948255
8.7841258
73
1.1383597
1.9983377
-->A
A =
0.3616361
0.3321719
0.2693125
0.0437334
0.2922267
0.5935095
0.6325745
0.4818509
0.5664249
0.5015342
0.4051954
0.2639556
0.4826472
0.4368588
0.9184708
0.4148104
0.3616361
0.3321719 0.2693125
0.0437334
0.
0.5935095 0.6325745
0.4818509
0.
0.
0.4051954
0.2639556
0.
0.
0.
0.4148104
0.3616361
0.
0.
0.
0.2922267
0.5935095 0.
0.
0.5664249
0.5015342 0.4051954
0.
0.4826472
0.4368588 0.9184708
0.4148104
-->A=rand(4,4)
A =
74
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
0.8782165
0.7263507
0.0683740
0.1985144
-->c1=A(:,1)
c1 =
0.2113249
0.7560439
la columna 1
0.0002211
0.3303271
-->f1=A(2,:)
f1 =
0.7560439
0.6283918
0.0683740
0.1985144
-->A=10*rand(10,10);
-->a1=A(2:5,3:7)
a1 =
75
-->a2=A(2:6,$)
a2 =
indica con $.
2.6777665
5.4653349
9.8854077
7.3956566
0.0371731
Tambin 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 varia de 1 a mxn .
-->b=[1 3 7 9 14 80 100];
-->A(b)
ans =
-->A(1)
ans =
2.3122372
76
-->A(11)
ans =
5.6642488
-->A(1,2)
ans =
5.6642488
Concatenacin de vectores
-->a=[1 2 3 5 3 4 1];
-->b=[5 5];
b =
5.
5.
-->c=[a b]
1.
2.
-->e=[b;d]
5.
5.
4.
4.
3.
5.
3.
4.
1.
5.
5.
-->f=[e b']
f =
77
5.
5.
5.
4.
4.
5.
-->g=[e b'; b 1]
g =
5.
5.
5.
4.
4.
5.
5.
5.
Ordenamiento de vectores
-->c=int(10*rand(1,10))
c =
1.
6.
6.
3.
0.
5.
3.
2.
5.
4.
6.
5.
5.
4.
3.
3.
2.
1.
0.
2.
3.
6.
9.
10.
6.
5.
5.
4.
4.
7.
8.
1.
5.
y =
6.
3.
3.
2.
1.
0.
-->A=int(10*rand(4,4))
A =
78
2.
7.
0.
2.
0.
5.
4.
4.
6.
2.
7.
9.
3.
6.
8.
5.
-->[a,k]=sort(A)
k =
15.
3.
10.
7.
12.
8.
14.
13.
5.
6.
4.
11.
16.
2.
1.
9.
a =
9.
6.
4.
2.
8.
6.
4.
2.
7.
5.
3.
0.
7.
5.
2.
0.
79
Ejemplo.
-->y
=
6.
6.
5.
5.
4.
3.
3.
2.
1.
0.
-->sum(y)
ans =
35.
-->prod(y)
ans =
0.
-->max(y)
ans =
6.
-->min(y)
ans =
0.
linsolve calcula todas las soluciones posibles a la ecuacin A*X+b=0, donde A es la matriz
de los coeficientes del sistema de ecuaciones
a11 x1
a12 x 2
a13 x3 L a1n x x + b1 = 0
a n1 x1
a n2 x2
a n 3 x3 L a nn x n + bn = 0
80
4.
2.
1.
3. -1.
3.
1.
0.5 -1.
-->b=[3; 0; -4]
b =
3.
0.
-4.
2.36
- 4.32
- 3.8
-->round(A*X+b)
ans =
0.
0.
0.
-->x=-inv(A)*b
x =
2.36
81
- 4.32
- 3.8
a = 3 + 4*r*%i
b = sqrt(-4)
Las funciones: real, imag y conj permiten obtener la parte real, la parte imaginaria y el
conjugado de un complejo, respectivamente.
82
-->c = 2+%i
c =
2. + i
-->real(c)
ans =
2.
-->imag(c)
ans =
1.
-->conj(c)
ans =
2. - i
Si se utiliza la funcin abs con un complejo, se obtiene la magnitud o mdulo del mismo.
Las funciones de Scilab usadas para funciones reales elementales que tienen generalizaciones
en complejos, se pueden usar tambin para los complejos, por ejemplo, sin, cos, log, ... As, es
completamente licito
z = 3 + 4*%i; r = sin(z)
5.4 POLINOMIOS
Un polinomio se puede definir de dos maneras: por sus coeficientes o por sus races. Es
necesario adems indicar la variable simblica para el polinomio. Se define un polinomio en
base a sus coeficientes con la orden:
83
c = [ ao a1 a2 a3 an ]
Por ejemplo:
Se puede utilizar la funcin roots para hallar las races de un polinomio, sean stas reales o
complejas:
v = p + q + p*q - 3.1*q
84
r = p^3
k = coeff(q, 2)
Si se utiliza simplemente
c = coeff(q)
Por ejemplo horner(q, 1) dar como resultado -8. Si q es un polinomio, es lcito utilizar la
orden
r = horner(p, q)
Para resolver una ecuacin o un sistema de ecuaciones no lineales, se puede usar el comando
fsolve:
85
Donde:
x0 : vector de valores reales conteniendo valores iniciales, aproximados, de la funcin,
fct : nombre de la definicin de la funcin cuya solucin se desea encontrar,
fjac : definicin del jacobiano de la funcin a resolver,
tol : tolerancia del proceso iterativo de bsqueda de la solucin. El proceso iterativo
termina cuando el error relativo de la solucin es menor o igual que tol. (1x10-10 es
el valor por defecto),
Hay tres parmetros de salida, nicamente el primero es obligatorio
x : vector real que contiene el valor final de la solucin aproximada,
v : vector real que contiene el valor de la funcin en x,
info : indicador de culminacin y puede tener 5 valores
0 : nmero inapropiados de parmetros de entrada
1 : se obtuvo solucin con error relativo que satisface condiciones de tolerancia
2 : nmero mximo de iteraciones alcanzado. Muchos llamados a la funcin
3 : la tolerancia (tol) permitida es muy pequea. No se puede mejorar aproximacin a
la solucin
4 : iteracin no se encuentra progresando o avanza muy lentamente.
x12 + x1x2 + x3 3 = 0
2 x1 + 3 x2 x3 5 = 0
( x1 + x2 + x3 ) 2 10 x3 + 1 = 0
86
function fx = f3(x)
n = size(x,1) //dimension de n
fx = zeros(n,1) //crea un
dimensin que n
fx(1) = x(1)^2 + x(1)*x(2) +
vector
fx(2) = 2*x(1) + 3*x(2)*x(3)
fx(3) = (x(1) + x(2) + x(3))^2
endfunction
//
igual a la de x
vector de ceros
con
la
misma
Si se dispone de una funcin donde est definida la matriz jacobiana, entonces fsolve trabajar
mucho mejor.
function J = jacf3(x)
t = 2*(x(1)+x(2)+x(3))
J = [ 2*x(1)+x(2) x(1)
2 3*x(3) 3*x(2)
t t t-10 ]
endfunction
Scilab pone a disposicin del usuario una gran variedad de funciones estadsticas, con las que
es posible operar sobre variables escalares y vectoriales. Dos de las ms utilizadas son el
clculo de regresin lineal y desviacin estndar.
reglin permite obtener una regresin lineal entre pares de puntos x,y del problema y=a*x+b
por el mtodo del cuadrados mnimos:
[a,b,sig]=reglin(x,y)
87
sig es la desviacin estndar del residuo. x e y son dos matrices de dimensiones x(p,n) y
y(q,n), donde n es el nmero de muestras. El estimador a es una matriz de tamao (q,p) y b es
un vector de tamao(q,1).
stdev permite obtener la desviacin estndar de vectores o matrices
y=stdev(x)
y=stdev(x,'r')
y=stdev(x,'c')
x es un vector real o matriz, y ser un escalar o un vector, r especifica la fila de una matriz y
c la columna.
5.7 DERIVADA
derivative(F,x)
Parmetros
F : una funcin Scilab
88
Se realiza mediante la funcin derivat que calcula la derivada de una matriz racional o
polinmica de variables muda. Tiene la siguiente secuencia de llamado:
pd=derivat(p)
5.8.- INTEGRALES
a f ( x)dx
y se interpreta como el rea bajo la curva de la funcin f(x) en un intervalo a < x < b dado. El
trmino dx, referido como el diferencial x, indica la variable de integracin.
La funcin inttrap calcula la integral numrica de una relacin de pares de puntos utilizando
interpolacin lineal por el mtodo trapezoidal. Cuando se trabaja con datos experimentales,
comnmente se obtienen serie de puntos que se correlacionan con una coordenada creciente,
por ejemplo el tiempo. Con los pares de puntos (x(i),y(i)) se ajusta la funcin y(i)=f(x(i))
donde i =1,2...n es un ndice creciente.
x es un vector con las coordenadas x con valores crecientes. Los parntesis rectos indican que
el trmino es opcional, siendo su valor por defecto x = [1, 2, , m], donde m es la medida del
vector y.
89
-->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
Proporciona la integral de una funcin externa, calculada con mtodos que determinan
automticamente el intervalo para tener un error mximo dado: abs(f-x)<= max(ea,er*abs(f))
donde f es el valor exacto de la integral. El llamado general es:
x es el resultado de la integral
f es la funcin definida externamente como matriz de caracteres
v es la variable de integracin ingresada como una tira de caracteres,
a el lmite inferior (nmero)
b el lmite superior (nmero)
ea es el error absoluto (0 por defecto)
er es el error relativo (1.10-8 por defecto).
90
-->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.
I = intsplin([x,] y),
-->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
91
Esta funcin es similar a integrate, pero permite mas opciones para definir la funcin externa
f.
Si f es una lista sta debe ser como sigue list(f,x1,x2,...), donde f es una funcin con
llamado de secuencia f(t,x1,x2,...).
Si f es una cadena de caracteres, esta es el nombre para llamar una funcin 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
92
5.8.5.-Integrales dobles
La funcin int2d puede utilizarse para calcular la integral de la funcin z = f(x,y) sobre una
regin R definida por un nmero n de tringulos. Utiliza el mtodo de cuadratura o curvatura.
El llamado ms simple es:
-->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
-->//Triangulos ABD-BCD:
-->X = [0,1;1,1;0,0]; Y = [0,0;0,1;1,1];
-->[Int,er] =int2d(X,Y,f)
er =
6.088E-14
Int =
.4967514
93
dy
= f ( x, y )
dx
y( xo ) = yo
Scilab permite obtener soluciones numricas a problemas de valor inicial. El comando a ser
utilizado es ode (ecuacin diferencial ordinaria):
[y] = ode([type],y0,x0,x,f)
Type: es un argumento opcional que indica el mtodo numrico de resolucin que se utilizar
y puede ser adams (Adams), rk (Runge-Kutta), rkf (Runge-Kutta modificado), fix,
discrete, roots, stiff. Por defecto hace una seleccin automtica entre todos comenzando
por stiff
94
-->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
95
CAPITULO 6
ENTRADAS Y SALIDAS DE DATOS
6.1. INTRODUCCIN
En este captulo se presentan las funciones para la entrada y salida de datos, como as tambin
las empleadas para el manejo de archivos. En SCILAB, las entradas y salidas son parte
importante de los procedimientos, particularmente cuando se trata 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 lgicas, que se reconocen con un nmero o un string. El vector
%io guarda el nmero con el que se identifica cada dispositivo. La ventana principal
(monitor) es la entrada y salida estndar para Scilab. La entrada al monitor se identifica como
la unidad lgica 5 y la salida al monitor como la unidad lgica 6. Estos nmeros estn
guardados en las dos primeras posiciones de %io. Es decir, %io(1)=5 y %io(2)=6.
save(filename [,x1,x2,...,xn])
donde filename es una tira de caracteres que contiene el nombre y el camino al archivo. Para
recobrar las variables se utiliza la funcin:
load(filename [,x1,...,xn])
96
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 programacin que
las inspira:
TIPO
LECTURA
ESCRITURA
MANEJO
(INPUT)
(OUTPUT)
ARCHIVOS
input
disp
Fortran
Read
write
file
mscanf
mprintf
mopen
mfscanf
mfprintf
mclose
msscanf
msprintf
meof
fscanfMat
fprintMat
Scilab
DE
97
El argumento filename identifica el equipo donde se imprime y las xi las variables a escribir.
Estas se imprimen en el formato de Scilab, es decir colocando delante el nombre de la
variable y el signo igual. Esto lo hace incluso cuando escribe sobre 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
Tanto la funcin print como disp imprimen la ultima variable en la primera fila. En el ltimo
ejemplo la palabra 'valor del dato:' se imprime junto con la palabra 'x = ', la cual es un
comando por default de print.
19.
21.
23.
25. !
98
Si se abre con el Editor el archivo data1.txt. Notar que la salida incluye todos los
identificadores y corchetes (!).
write(file,x,[format])
file es una tira de caracteres que con el nombre del archivo, alternativamente se puede colocar
el nmero lgico asignado al archivo.
x es la matriz, vector o escalar a manejar, slo se puede trabajar una por vez.
m y n son el nmero de filas y columnas de la matriz. Si no conoce el nmero de filas con m=
-1, se lee el archivo completo.
format describe el formato con que se lee o escribe la matriz. Algunos de los items para la
salida formateada se presentan a continuacin:
nueva lnea
iw
fw.d punto flotante con w caracteres incluyendo d dgitos despus del punto decimal. Se
recomienda
w>d+3
ew.d punto flotante con potencia de 10, un ancho de w caracteres con d dgitos despus del
punto decimal. Se recomienda w>d+7
nx
n espacios en blanco
tn
an
El formato es una tira de caracteres, entre comillas, que se encierra entre parntesis y los
items se separan por comas. Estos pueden repetirse cerrndolos entre parntesis y colocando
99
(1x,e10.3,5x,3(f3.0)) ,
(10x,a20)
function inout()
// este programa ilustra el uso de read y write
write(%io(2),'Entrar una variable real x:','(a)');
x = read (%io(1),1,1);
write(%io(2),'Entrar una 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
100
-->getf('C:\inout.sci');disp('getf done');
getf done
-->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 funcin inout no tiene argumento. Entonces, tanto en la definicin de la funcin
como en su ejecucin solo tiene que tener un par de parntesis.
101
Un comando muy til para el manejo de archivos es el comando file se puede utilizar cuando
un archivo se abre tanto para entrada como para salida.
file(action,unit)
Ejemplo 1.
-->x1 = 0:0.5:10
-->x2 = x1^2
-->B = [x1',x2']
-->m = file('open','data4.txt','new')
-->write(m,B,'(2(f10.6,2x))')
-->file('close',m)
Ejemplo 3. suponga que tiene un archivo que se llama signal.txt que contiene los siguientes
valores:
102
Si se conoce el nmero de filas (n=6, en este caso), para leer los valores de la matriz se
utiliza:
-->u=file('open','signal.txt','old')
u =
2.
-->A=read(u,6,3);
-->A
A =
!
1.
2.
4. !
!
2.
3.
9. !
!
3.
4.
16. !
!
4.
5.
25. !
!
5.
6.
36. !
!
6.
7.
49. !
-->file('close',u)
-->file('rewind',u)
una segunda accin disponible para la funcin file es la opcin backspace, que mueve el
puntero de entrada en el archivo una lnea arriba. Una tercera opcin para el manejo de
archivos con la funcin file es la opcin last. Cuando se utiliza esta funcin el puntero se
mueve al final del archivo. Puede ser utilizada para agregar datos a un archivo existente.
-->fil = "testfile101.txt" //string con el nombre del archivo
fil =
testfile101.txt
-->u = file('open',fil,'new') //crea el archivo
u =
2.
-->for j = 1:10 //carga el archivo con datos
--> write(u,[j j+1 j+2],'(f5.0,f5.0,f5.0)')
-->end
-->file('close',u) //cierra el archivo
103
1. 2. 3.
2. 3. 4.
3. 4. 5.
4. 5. 6.
5. 6. 7.
6. 7. 8.
7. 8. 9.
8. 9. 10.
9. 10. 11.
10. 11. 12.
Continuando con el ejemplo, abrimos el archivo y agregamos datos al final del archivo:
1. 2. 3.
2. 3. 4.
3. 4. 5.
4. 5. 6.
5. 6. 7.
6. 7. 8.
7. 8. 9.
8. 9. 10.
9. 10. 11.
10. 11. 12.
-10. -20. -30.
-100.-200.-400.
104
Cuando creamos el archivo usamos la opcin newpara indicar que estbamos creando un
archivo que no existe. Para abrir otra ves el archivo utilizamos la opcin old . Si tratamos de
abrir el archivo como uno nuevo obtenemos un mensaje de error. Podemos almacenar el valor
del error por utilizar el siguiente llamado de la funcin file:
-->[u,errn] = file('open','fil','new')
errn =
240.
u=
[]
-->[u,errn] = file('open','fil','unknown')
errn =
0.
u=
2.
Hay una cuarta opcin que puede ser utilizada en el argumento de la funcin file cuando el
primer argumento es open. Esta es la opcin scratch, que borra el archivo al final de la
sesin.
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
funcin mfprintf tambin puede operar sobre la ventana principal si la referencia del archivo
es reemplazada por %io(2), mientras que la funcin mfscanf puede operar sobre la ventana
principal si la referencia del archivo es reemplazada por %io(1).
105
APLICACIN LECTURA
(INPUT)
ESCRITURA
MANEJO
(OUTPUT)
DE
ARCHIVOS
Ventana
mscanf
mprintf
mopen
Archivo
mfscanf
mfprintf
mclose
String
msscanf
msprintf
moef
Matrices-
fscanfMat
fprintMat
Archivos
mgetl
mputl
LineasArchivos
Las llamadas general para las funciones de lectura de datos mscanf, mfscanf y msscanf son las
siguientes:
En estas llamadas, v1,...vn es una lista de variables de salidas. Para la funcin mfscanf, fd es
la unidad lgica del archivo, y format es un string que incluye la conversin de caracteres
para las variables que estn siendo ledas. Esta conversin es la que tambin utiliza el
lenguaje C. niter es un entero que representa el nmero de veces que se utilizar el formato.
El valor por defector es 1, lee una sola lnea, y si se coloca el valor 1 la funcin lee hasta el
final del archivo. El argumento de salida n se obtiene el nmero de datos leidos. str es una
variable string,
Si todos los datos del archivo son homogeneos ellos pueden ser almacenados en un nico
vector.
La llamada general par las funciones de escritura de datos mprintf, mfprintf y msprintf son las
siguientes:
106
mprintf(format,v1,..,vn)
mfprintf(fd,format,v1,..,vn)
str=msprintf(format, v1,..,vn)
107
Otras funciones de entrada y salida del tipo C que provee SCILAB son fscanfMat, y
fprintfMat. Las funcioes fscanfMat y fprintfMat se utilizan para leer una matriz desde un
archivo o para escribir una matriz a un archivo. El llamado general de estas funciones es:
fprintfMat(file,M [,format,texto])
[M,text] = fscanfMat(file)
Donde file es un string con el nombre del archivo, M es una matriz de nmeros reales, format
es un una cadena de caracteres con las conversiones tipo C, el valor por defecto es %f. text
es una matriz de string con los comentarios no numricos al comienzo del archivo.
-->A = int(10*rand(2,3))
A =
! 2. 0. 6.!
! 7. 3. 6.!
-->fprintfMat('Mat1.txt',A,'%5.3f')
El formato contiene un character de conversion simple '%5.3f'. Este indica que cada elemento
en la matriz ser escrito en un campo de punto-flotante con un ancho de 5 caracteres con 3
caracteres despus del punto decimal. Si el nmero no se ajusta en el campo especificado,
SCILAB lo ajusta de forma tal que ser escrito con el nmero de dgitos decimales requerido.
108
La function fscanfMat se utiliza para leer los datos desde un archivo como una matriz. Para lo
cual los datos en el archivo debern estar en la forma de una matriz, es decir, cada linea en el
archivo debe tener el mismo nmero de columnas.
string de caracteres
En el siguiente ejemplo se cargan primero los valores de las variables a, b, c, y s que sern
utilizados en el llamado de la funcin mprintf. Note que a y b son constantes simples y c es un
vector fila.
109
// imprime la variable
enteros (%i,%d):
utilizando
campos
de
conversin
//imprime a
utilizando tres especificaciones para nmeros de
punto-flotante: %f, %e, y %g.
-->mprintf(' Coeficiente
Coeficiente para el dato
-->mprintf(' Coeficiente
Coeficiente para el dato
-->mprintf(' Coeficiente
Coeficiente para el dato
//el uso
variables
de las
a y b
para el dato
de entrada =
para el dato
de entrada =
para el dato
de entrada =
conversiones
de entrada = %10.5f',a);
-13.54000
de entrada = %10.5e',a);
-1.35400e+001
de entrada = %10.5g',a);
-13.54
%g cuando imprime las
dos
En el ltimo ejemplo se utiliza la combinacin de caracteres \n. Este produce una nueva lnea,
as divide el string del formato en dos lneas como se muestra. A continuacin se presentan
ejemplos de caracteres de conversin para funciones de entrada.
Ejemplo1. Se leen datos del dispositivo de salida standard (%io(2) = 5) con la funcin
mscanf.
-->mprintf('Entre tres valores de punto-flotante:a,b,c:\n');
[a,b,c]=mscanf('%f %f %f')
Entre tres valores de punto-flotante:a,b,c:
-->2.3 3.5 -1.2
c =
- 1.2
b =
3.5
a =
2.3
Ejemplo2. El siguiente archivo de entrada, entrada2.txt, incluye las siguientes filas de datos:
110
y 1.25
Cu 1.486
n 0.012
So 1e-5
El script opendata.sce, ser utilizado para leer los datos e imprimirlos a la pantalla:
111
exec done
file es una cadena de caracteres con el nombre y el camino del archivo a ser abierto, fd
representa la variable de la unidad lgica asignada al archivo, err almacena un posible nmero
de error, mode indica el modo en el cual el archivo ser operado, para escritura, lectura,
agregar, etc. , de acuerdo a las especificaciones: w para escritura, r
agregar. Cualquiera de estas especificaciones seguidas por un signo mas indica que el archivo
est siendo actualizado (sobreescribe), es decir, w+, r+, a+.
mclose([fd]) o mclose(all)
Si se omite fd se cierra el ltimo archivo abierto. La opcin all cierra todos los archivos
abiertos.
La funcin meof puede utilizarse para detectar el fin del archivo (eof=end of file), es decir, la
condicin en la cual el archivo ha agotado las salidas. La funcin retorna el valor %t
(verdadero) si el eof ha sido alcanzado, o %f (falso), de otro modo. El siguiente script muestra
un ejemplo de aplicacin de las funciones mopen, meof, mclose, mfprintf, y mfscanf: Grabe el
script como mfile.sce, y ejecutelo con exec('mfile.sce')
112
113
114
SCILAB cuenta con las funciones mgetl y mputl para leer lneas o grabar lneas de un archivo
de texto. El llamado general de estas funciones es:
Cuando se utiliza la funcin mgetl, str es un vector columna, de strings, que corresponden a m
lneas leidas de un archivo de texto cuya unidad de referencia es fd. Si no se conoce el nmero
de filas a ser leidas utilize m = -1. Cuando usamos la funcin mputl, str es un vector (fila o
columna) de string, cuyos elementos son escritos como lineas en el archivo fd. Para operar las
funciones mputl y mgetl, los archivos deben abrirse previamente con la funcin mopen.
-->u = mopen('address1.txt','w')
u =
2.
-->address1
=
['Dom
Perignon';'47
47470';'USA'];
Degree
Proof';'Champaigne,
IL
-->mputl(address1,u)
-->mclose(u)
ans =
0.
-->mopen('address1.txt','r')
ans =
2.
-->mgetl(2,-1) //lee todas las lineas del archivo
ans =
!Dom Perignon !
! !
!47 Degree Proof !
! !
!Champaigne, IL 47470 !
! !
!USA !
-->mclose(2)
ans =
0.
115
CAPITULO 7
DILOGOS E INTERFACES GRFICAS
7.1. El USO DE DILOGOS E INTERFACES A USUARIO
Se han incorporado a Scilab algunas funciones que permiten manejar a un nivel simple el
intercambio de informacin a travs de ventanas grficas, que son fundamentalmente mens
para seleccin de alternativas y para el ingreso y salida de datos. Estas prestaciones se llevan a
cabo mediante la integracin de Scilab con el lenguaje Tcl y su librera grafica Tk, puesto que
la interfaz grafica de Scilab est escrita en Tcl/Tk. Si se necesita armar algo ms sofisticado es
posible recurrir al intercambio directo con este lenguaje de programacin para su diseo.
Recientemente, se han incorporado tambin 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 programacin orientada a objetos. Estas son las llamadas interfaces
grficas de usuario (GIU)
7.2. DILOGOS
7.2.1 Mensajes
La funcin x_message, es una caja de dialogo que muestra un mensaje y espera por una
respuesta. Retorna al programa principal slo despus de un click sobre un botn.
[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 lnea deber estar separadas
por punto y coma.
botones: Por defecto aparece en la caja un botn Ok para cerrar la caja una vez que se lee el
mensaje. Si quiere utilizar la caja para hacer una decisin, se pueden colocar dos botones. En
ese caso los nombres se colocan en un vector de tiras.
num: guarda el nmero correspondiente al botn seleccionado por el usuario. Esta
informacin se utiliza luego para realizar una accin determinada.
116
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;
valor = x_dialog(titulo,valor_defecto)
En valor se guarda la entrada ingresada en el dialogo despus que se presiona el botn 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 vaco. Si presiona Ok
sin ingresar un nuevo valor, se toma el valor por defecto.
La entrada que se ingresa a la caja de dialogo entra como texto y deber convertirse con la
funcin eval si quiere usarse como un nmero.
117
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");
donde titulo es el ttulo de la caja de dilogos, 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 cada 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));
h = h0 + v0*(tf-t0)-4.903*(tf-t0)^2;
x_message("h = " + string(h) + " m");
118
Otra forma de ingresar datos mltiples a travs de una sola forma de entrada es la funcin
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 lgica que toma los valores %t (true) si se
presiona el botn Ok, o %f (false) si se presiona el botn Cancel; x1, x2, , x14 son los
valores retornados si se presiona el botn Ok. La forma general de tipo es
donde tipe_1, tipe_2, , son tiras que definen la variable y que pueden ser: mat matriz
numrica, col vector columna numrico, row vector fila numrico, vec vector
numrico, str string , lis lista
Los valores dim_1, dim_2, , pueden ser una constante simple o un vector de dos constantes
indicando las dimensiones del dato correspondiente.
119
mode(-1);
desc = "Ingrese los parmetros para el movimiento oscilatorio amortiguado"
etiq = ["Amplitud mxima, A0 (m)",... //leyendas
"Parmetro de amortiguamiento, tau(s)",...
"Frecuencia natural, f(Hz)" ,...
"Cambio de fase, phi(rad)" ,...
"Incremento en el tiempo, Dt(s)" ,...
"Tiempo mximo, 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;
120
La funcin x_matrix puede utilizarse para ingresar una matriz numrica a travs de una caja
de dilogo. El llamado general de la funcin 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 dimensin que la matriz por defecto.
121
7.2.5 Ventana de dilogo para elegir entre varios valores de una entrada
La funcin x_choose permite elegir entre varios valores de entradas posibles. El llamado
general es
donde items es un vector columna de tiras con las varias elecciones posible, title es una tira
con la descripcin 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.
122
Una extensin de la funcin x_choose es la funcin x_choices que permite elegir entre varios
valores para varias variables de entrada. El llamado general de la funcin es
donde titulo es una tira que describe al dialogo, item_lista es una lista cuyos elementos son
tambin listas que contienen la leyenda, la posicin del valor por defecto, y los posibles
valores de cada uno de los tem a ser elegidos, item_vector contiene la posicin de las
elecciones. As la forma de item_lista es
123
h = uicontrol('Prop',Val,...)
h = uicontrol(parent,'Prop',Val,...)
h = uicontrol(uich)
Todos los objetos grficos se comunican a travs de sus propiedades. As, para crear controles
adaptados hace falta conocer el uso de las siguientes propiedad.
124
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 botn).
Enable {on}|off Abilita o desabilita el uicontrol. Lallave indica el valor por defecto.
fontangle. (string) Pone la inclinacin 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. (nmero real) Pone el tamao de las letras de un texto en un control.
fontunits. (string) Selecciona las unidades del tamao 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 alineacin 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
lnea.
Max (escalar) Especifica el mayor valor de 'value'. Sin embargo, tiene significado diferente
segn el control:
o Check Boxes : Max es el valor que toma de la propiedad 'value' cuando es chequeado el
control
o Silders : valor mximo del deslizador
o List boxes : si (Max-Min)>1 la lista permite elecciones mltiples, de otra forma no.
Min (escalar) Especifica el menor valor de 'value'. Sin embargo, tiene significado diferente
segn el control:
o Check Boxes : Min es el valor que toma la propiedad 'value' cuando el control no es
chequeado
o Silders : valor mnimo del deslizador
o List boxes : si (Max-Min)>1 la lista permite elecciones mltiples, de otra forma no.
125
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 configuracin geomtrica del control. Es un
vector x y w h donde x, y corresponden a la posicin 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 estn separados por un '|'.
Style Estilo del control. Debe ser alguna de estas tiras: {pushbutton} | radiobutton | checkbox
| edit | text | slider | frame |listbox | popupmenu
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.
126
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 slo 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', "funcin",...
'callback', "exec(foo(x))")
close(f)
127
Para crea un men adaptado se puede utilizar algunas de las siguientes propiedades:
callback (string) Permite colocar la instruccin 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.
128
set(prop,val)
set(h,prop,val)
h.prop=val
Esta funcin pude utilizarse para colocar una propiedad especifica a una entidad grfica. Esta
entidad grfica 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 grfica.
Con la funcin get se obtiene el valor de la propiedad de una entidad grfica o de un objeto
de interfase de usuario. Las secuencias del llamado es:
129
h=get(prop)
val=get(h,prop)
val=h.prop
Esta funcin 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. Tambin se utiliza para
obtener una lista de todos los hijos, padres, o tipos que dependen de la manija de entrada. A
continuacin se explica el significado de las variables de las secuencias del llamado de ambas
funciones:
En el siguiente ejemplo, con el botn 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 botn Pasa2 la palabra HOLA, en maysculas, 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
130
131
CAPITULO 8
TOMA DE DATOS CON INTERFASE TCL/TK
Existe la posibilidad de complementar a Scilab con el lenguaje Tcl/Tk, con el que se amplan
las prestaciones de Scilab para realizar programas ms elaborados, por ejemplo programacin
orientada a objetos o para la adquisicin de datos. En el captulo anterior se han utilizado los
comandos figure, uicontrol y uimenu que son ejemplos de interfaces TCL para la creacin de
objetos grficos. En este captulo, primero se presentan comandos para ejecutar sentencias o
archivos TCL y luego la aplicacin de stas para la adquisicin de datos mediante la
computadora.
El comando TCL_EvalStr evala 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 : parmetro opcional, de tiras de letras. Nombre del interpretador tcl esclavo donde se
realizarn 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 funcin
TCL_EvalFile que lee y evala un archivo tcl/tk. El llamado general de la funcin es el
siguiente:
TCL_EvalFile(filename [,interp])
filename : es una tira de caracteres que contiene el nombre del archivo a ser ledo y evaluado.
interp : significado idntico al explicado anteriormente.
132
Esta funcin permite crear poderosas interfaces utilizando directamente scripts en tck/tk.
La funcin TCL_GetVar permite obtener el valor de una variable tcl/tk . Su llamado general
es:
value=TCL_GetVar(Varname [,interp])
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 funcin TCL_EvalStr. A continuacin,
se describen funciones creadas con comandos de TCL que permiten tomar datos desde la
puerta serie (COM1), utilizando mdulos de adquisicin ADAM. En particular, se programa
para el ADAM 4018 que es un mdulo para medir hasta 6 canales de seales. Por ejemplo, se
pueden medir temperaturas conectando termocuplas a estos canales. Si bien las funciones que
se muestran a continuacin pueden formar parte de un solo procedimiento, se muestran por
separado como si se tratase de un proceso, lo cual facilita su utilizacin en una interfaz grfica
donde cada una de ellas puede estar asociada a la ejecucin de un control de dicha interfaz. A
continuacin se explican las funciones:
Habilita
Leer Conf
Configurar
Medir
Deshabilita
133
function habilitar_ADAM()
TCL_EvalStr(["set leer [ open /dev/ttyS0 r+]"
"fconfigure $leer -mode 9600,n,8,1 -buffering line eofchar {} "
])
endfunction
La misma funcin puede utilizarse para configurar el mdulo pero en este caso el parmetro
nmero contiene toda la sintaxis de programacin correcta, de acuerdo a lo que se muestra en
la tabla de abajo. Por ejemplo si con un ADAM 4018 el parmetro nmero vale %070F0600
se configura el mdulo 07 para utilizar en todos los canales termocuplas tipo k, que leern a
134
Como se dijo, un mdulo de adquisicin tiene varios canales de entrada anlogas. La funcin
medir_ADAM mide un canal del mdulo, especificado por el parmetro canal, mientras que el
mdulo est especificado por nmero. Este canal de medida del mdulo no debe confundirse
con el fichero $leer habilitado anteriormente como canal de comunicacin con la puerta serie.
La funcin coloca en $leer el comando de programacin #0%d%d, donde se reemplazan los
caracteres de conversin enteros por nmero, que identifica el mdulo, 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, asignndolo a la variable b. Esta se convierte
y se pasa como variable con formato al parmetro de salida medida.
function deshabilitar_ADAM()
TCL_EvalStr("close $leer ")
Endfunction
%AANNTTCCFF
Configuracin
#AAN
Leer el canal N
$AA2
Estado de la configuracin
Descripcin
Ejemplo
Coloca la direccin,
%070F0600
rango de entrada,
velocidad de baudios,
formato del dato del
mdulo
Lee la entrada del canal
#070
N del mdulo AA
Pide la configuracin del $072
mdulo AA
135