Machine Translated by Google
www.scilab.org
INTRODUCCIÓN A SCILAB
Consorcio sCilab
Domaine de Voluceau - Rocquencourt - BP 105 - 78153 Le Chesnay Cedex Francia
Machine Translated by Google
!
#
"
Machine Translated by Google
noviembre de 2010
Resumen
En este documento, hacemos una descripción general de las características de Scilab para que podamos
familiarizarse con este entorno. El objetivo es presentar el núcleo de habilidades
necesario para empezar con Scilab. En la primera parte, presentamos cómo obtener y
instalar este software en nuestro ordenador. También presentamos cómo obtener ayuda.
con la documentación en línea proporcionada y también gracias a los recursos web y
foros En las secciones restantes, presentamos el lenguaje Scilab, especialmente
sus características de programación estructurada. Presentamos una característica importante de
Scilab, que es el manejo de matrices reales y una visión general del álgebra lineal
biblioteca. La definición de funciones y la gestión elemental de entrada.
y se presentan las variables de salida. Presentamos las características gráficas de Scilab y
mostrar cómo crear un gráfico 2D, cómo configurar el título y la leyenda y
cómo exportar ese gráfico a un formato vectorial o de mapa de bits.
Contenido
5
1 Descripción
general 1.1 Introducción . . . . . . . .
. . . . . . ...
. . ...
. . . . . . ...
.5
1.2 Descripción general de Scilab . . . .
. . ...
. . ...
. . . . . . ...
.5
. . . . . . ...
. . . . . . ...
.6
1.3.1 Instalación de Scilab en Windows . .
. . ...
. . . . . . ...
.7
1.3.2 Instalación de Scilab en Linux . . .
. . ...
. . . . . . ...
.7
. . ...
. . . . . . ...
.8
. . . . . . ...
.8
. . . . . . ...
.9
...
1.3 Cómo obtener e instalar Scilab .
. ...
1.3.3 Instalación de Scilab en Mac OS . .
1.4 Cómo obtener ayuda . . . . . . . . . . . . . . . . . . . .
1.5 Listas de correo, wiki e informes de errores . . . . . . . . . .
1.6 Obtener ayuda de demostraciones y macros de Scilab .
. ...
. . ...
. . . . . . ...
1.7 Ejercicios .
...
. . ...
. ...
. . . . . 10
. . ...
. 11
11
2 Primeros pasos 2.1 La
consola . . .
. . ...
. . . . . . ...
. . ...
. ...
. . ...
. 11
2.2 El editor .
...
. . ...
. . . . . . ...
. . ...
. ...
. . ...
. 12
2.3 Atraque .
. ...
. . ...
. . . . . . ...
. . ...
. ...
. . ...
. 14
. . . . . . ...
. . ...
2.4 Uso de exec . . .
. . ...
2.5 Procesamiento por lotes . . . . .
. ...
. . ...
2.6 Ejercicios .
. ...
. . ...
. . ...
. dieciséis
. ...
. . ...
. . . . . . ...
. 17
. . . . . . ...
. . ...
. ...
. 19
1
. . ...
Machine Translated by Google
3 Elementos básicos del lenguaje 3.1 Creación
. . ...
de variables reales . .
3.2 Nombres de variables . . . . . .
20
. . . . . . ...
. . . . . . ...
. . ...
. . . . . . ...
3.3 Comentarios y líneas de continuación .
3.4 Funciones matemáticas elementales .
3.5 Variables matemáticas predefinidas .
. . . . . . ...
. 20
. ...
. 21
. . ...
. . . . . . ...
. 22
. . . . . ...
. . ...
. ...
. 22
. . . . . ...
. . ...
. ...
. 22
. ...
. . ...
. . . . . . ...
. . ...
. ...
. . ...
. 23
3.7 Números complejos .
3.8 Números enteros . . . . .
. ...
. . . . . . ...
. . ...
. ...
. . ...
. 24
. . ...
. . . . . . ...
. . ...
. ...
3.6 Booleanos .
3.8.1 Resumen de números enteros . . . .
3.8.2 Conversiones entre enteros .
. . ...
. 25
. . . . . . ...
. . ...
. ...
. 25
. . . . ...
. . ...
. ...
. 26
. . . . . 27
3.8.3 Números enteros circulares y problemas de portabilidad . . . . . . . .
. . ...
. . . . . . ...
. . . . . . ...
. 28
3.9 Enteros de punto flotante . .
. ...
. . . . . . ...
. . ...
. ...
. . ...
. 29
. . ...
. . . . . . ...
. . ...
. ...
. . ...
. 29
3.12 Tipo dinámico de variables .
. ...
. . ...
3.13 Ejercicios .
. ...
. 30
. . . . . . ...
. . . . . . ...
. 30
3.10 La variable ans .
3.11 Cuerdas . .
. ...
. ...
. . . . . . ...
. . ...
. . ...
4 Matrices 4.1
Resumen .
31
...
. . ...
. . . . . . ...
. ...
4.3 La matriz vacía [] . . .
4.4 Matrices de consulta .
. . ...
. . ...
. . . . . . ...
4.2 Crear una matriz de valores reales . . .
. . ...
. . ...
. ...
. . . . . . ...
. . ...
. . . . . . ...
. . ...
. . . . . ...
4.5 Acceso a los elementos de una matriz .
. . . . . . ...
. . ...
4.6 El operador de dos puntos ”:” . .
. 31
. . . . . 32
. . ...
. 33
. . . . . . ...
. 33
. . ...
. ...
. 34
. . . . . . ...
. 35
. . . . . . ...
. . ...
. ...
. . ...
. 38
4.8 Las matrices son dinámicas . . .
. . ...
. ...
. . ...
. . . . . . ...
. 39
4.9 El operador dólar ”$” . .
. . . . . . ...
. . ...
. . . . . . ...
. 39
4.10 Operaciones de bajo nivel . . .
. . ...
. . . . . . ...
. . . . . . ...
. 40
4.11 Operaciones elementales . .
. . ...
. ...
. . . . . . ...
. 41
4.7 La matriz del ojo .
. . ...
. . ...
4.12 Transpuesta conjugada y transpuesta no conjugada .
...
. . . . . . ...
4.13 Multiplicación de dos vectores .
. . ...
. . . . . 42
. . ...
. ...
. 43
4.14 Comparación de dos matrices reales . . . .
. . . . . . ...
. . ...
. ...
. 44
4.15 Problemas con los números enteros de punto flotante . . . . . . . . . .
. . ...
. ...
. 45
. 46
. . . . . . ...
. . ...
. ...
4.17 Características del álgebra lineal de alto nivel . . . . . . . . .
. ...
. . ...
. . . . . . ...
. . ...
4.18 Ejercicios .
. . ...
. . . . . 48
4.16 Más sobre funciones elementales . . .
5 Bucles y bifurcaciones 5.1 La
sentencia if .
. 48
49
. ...
. . . . . . ...
. . . . . . ...
. . ...
. ...
. . ...
. 50
...
. . . . . . ...
. . ...
. ...
. . ...
. 52
5.2 La instrucción select . .
5.3 La sentencia for .
. . . . . . ...
5.4 La sentencia while . . .
. . . . . . ...
5.5 Las sentencias break y continue . . .
2
. . ...
. ...
. . ...
. 49
. . ...
. ...
. . ...
. 53
. . ...
. ...
. . ...
. 54
Machine Translated by Google
6 Funciones 6.1
55
. . ...
. . . . . . ...
. . ...
. . . . . . ...
. 55
...
. . . . . . ...
. . ...
. . . . . . ...
. 57
6.3 Bibliotecas de funciones . . . . .
. . . . . . ...
Resumen .
...
6.2 Definición de una función .
. . ...
. . . . . . ...
. 59
6.4 Gestión de argumentos de salida .
6.5 Niveles en la pila de llamadas . .
...
. . . . . . ...
. . . . . . ...
. 61
. . ...
. . . . . . ...
. . . . . . ...
. 62
6.6 La declaración de devolución . .
. . . . . . ...
. ...
. . ...
. 63
. . . . . . ...
. . ...
. 64
. . . . . . ...
. 66
. . ...
6.7 Funciones de depuración con pausa .
. . ...
66
7 Trazado 7.1
Descripción general . . . .
. . ...
. ...
. . ...
. . . . . . ...
. . ...
. . . . . . ...
. . ...
. ...
. . ...
. 66
7.3 Gráficos de contorno . . . . . . .
. . ...
. ...
. . ...
. . . . . . ...
. 68
7.4 Títulos, ejes y leyendas .
. ...
7.5 Exportación . .
. . ...
. ...
. . ...
. . . . . . ...
. 71
. . . . . . ...
. . ...
. ...
. 73
7.2 Gráfico 2D .
. . ...
. . ...
8 Notas y referencias
74
9 Agradecimientos
75
10 Respuestas a los ejercicios 10.1
76
. . ...
. . . . . . ...
. . . . . . ...
. 76
10.2 Respuestas para la sección 2.6 . . . . . . .
. . . . . . ...
. . . . . . ...
. 76
10.3 Respuestas para la sección 3.13 . . . . . .
. . . . . . ...
. . . . . . ...
. 79
10.4 Respuestas para la sección 4.18 . . . . . .
. . . . . . ...
. . . . . . ...
. 82
Respuestas al apartado 1.7 . .
Referencias
83
Índice
84
3
Machine Translated by Google
Copyright c 2008-2010 - Consorcio Scilab - Digiteo - Michael Baudin
Este archivo debe usarse bajo los términos de Creative Commons Attribution
Licencia ShareAlike 3.0 Unported:
http://creativecommons.org/licenses/by-sa/3.0
4
Machine Translated by Google
1. Información general
En esta sección, presentamos una descripción general de Scilab. La primera subsección presenta
el proyecto de código abierto asociado con la creación de este documento. Luego presentamos el
software, la licencia y los aspectos científicos de Scilab. En la tercera subsección, describimos los
métodos para descargar e instalar Scilab en los sistemas operativos Windows, GNU/Linux y Mac.
En las subsecciones restantes, describimos varias fuentes de información necesarias cuando
tenemos que obtener ayuda de Scilab o de otros usuarios.
Describimos las páginas de ayuda integradas y analizamos las listas de correo y wiki que están
disponibles en línea. Finalmente, nos tomamos un momento para ver las demostraciones que se
proporcionan con Scilab.
1.1 Introducción
Este documento es un proyecto de código abierto. Las fuentes LATEX están disponibles en Scilab
Forge:
http://forge.scilab.org/index.php/p/docintrotoscilab/
Las fuentes de LATEX se proporcionan bajo los términos de la licencia Creative Commons
Attribution ShareAlike 3.0 Unported:
http://creativecommons.org/licenses/by-sa/3.0
Los scripts de Scilab se proporcionan en Forge, dentro del proyecto, en el subdirectorio scripts.
Los scripts están disponibles bajo la licencia CeCiLL:
http://www.cecill.info/licencias/Licence_CeCILL_V2-en.txt
1.2 Descripción general de Scilab
Scilab es un lenguaje de programación asociado con una rica colección de algoritmos numéricos
que cubren muchos aspectos de los problemas de computación científica.
Desde el punto de vista del software, Scilab es un lenguaje interpretado. Esto generalmente
permite obtener procesos de desarrollo más rápidos, porque el usuario accede directamente a un
lenguaje de alto nivel, con un rico conjunto de funciones proporcionadas por la biblioteca. El
lenguaje Scilab está destinado a ampliarse para que los tipos de datos definidos por el usuario
puedan definirse con operaciones posiblemente sobrecargadas. Los usuarios de Scilab pueden
desarrollar sus propios módulos para que puedan resolver sus problemas particulares. El lenguaje
Scilab permite compilar y vincular dinámicamente otros lenguajes como Fortran y C: de esta
manera, las bibliotecas externas se pueden usar como si fueran parte de las funciones integradas de Scilab.
Scilab también interactúa con LabVIEW, una plataforma y entorno de desarrollo para un lenguaje
de programación visual de National Instruments.
Desde el punto de vista de la licencia, Scilab es un software libre en el sentido de que el
usuario no paga por él y Scilab es un software de código abierto, proporcionado bajo la licencia
Cecill [2]. El software se distribuye con código fuente, para que el usuario tenga acceso a los
aspectos más internos de Scilab. La mayoría de las veces, el usuario descarga e instala una
versión binaria de Scilab, ya que el consorcio Scilab proporciona Windows,
5
Machine Translated by Google
Versiones ejecutables de Linux y Mac OS. La ayuda en línea se proporciona en muchos idiomas locales.
Desde el punto de vista científico, Scilab viene con muchas características. Al principio de Scilab, las
funciones se centraban en el álgebra lineal. Pero, rápidamente, la cantidad de funciones se extendió para
cubrir muchas áreas de la computación científica. La siguiente es una breve lista de sus capacidades:
• Álgebra lineal, matrices dispersas,
• Polinomios y funciones racionales,
• Interpolación, aproximación,
• Optimización lineal, cuadrática y no lineal,
• Solucionador de ecuaciones diferenciales ordinarias y ecuaciones algebraicas diferenciales
solucionador,
• Control clásico y robusto, optimización de desigualdad de matriz lineal,
• Optimización diferenciable y no diferenciable,
• Procesamiento de la señal,
• Estadísticas.
Scilab proporciona muchas funciones gráficas, incluido un conjunto de funciones de trazado, que
permiten crear gráficos en 2D y 3D, así como interfaces de usuario. El entorno Xcos proporciona un
modelador y simulador de sistemas dinámicos híbridos.
1.3 Cómo obtener e instalar Scilab
Sea cual sea su plataforma (es decir, Windows, Linux o Mac), los archivos binarios de Scilab se pueden
descargar directamente desde la página de inicio de Scilab
http://www.scilab.org
o desde el área de Descargas
http://www.scilab.org/download
Los archivos binarios de Scilab se proporcionan para plataformas de 32 y 64 bits para que coincidan
con la máquina de instalación de destino.
Scilab también se puede descargar en forma de fuente, de modo que pueda compilar Scilab usted
mismo y producir su propio binario. Compilar Scilab y generar un binario es especialmente interesante
cuando queremos comprender o depurar una función existente, o cuando queremos agregar una nueva
función. Para compilar Scilab, se necesitan algunos archivos binarios de requisitos previos, que también
se proporcionan en el Centro de descargas. Además, se requiere un compilador Fortran y C. La compilación
de Scilab es un proceso que no se detallará más en este documento, porque este capítulo está dedicado
principalmente al comportamiento externo de Scilab.
6
Machine Translated by Google
Figura 1: consola Scilab en Windows.
1.3.1 Instalación de Scilab en Windows
Scilab se distribuye como un binario de Windows y se proporciona un instalador para que la
instalación sea realmente fácil. La consola Scilab se presenta en la figura 1. Se pueden hacer
varios comentarios sobre este proceso de instalación.
En Windows, si su máquina está basada en un procesador Intel, Intel Math Kernel Library
(MKL) [7] permite que Scilab realice cálculos numéricos más rápidos.
1.3.2 Instalación de Scilab en Linux
En Linux, las versiones binarias están disponibles en el sitio web de Scilab como archivos .tar.gz.
No es necesario un programa de instalación con Scilab en Linux: simplemente descomprima el
archivo en un directorio de destino. Una vez hecho esto, el archivo binario se encuentra en
<ruta>/scilab 5.xx/bin/scilab. Cuando se ejecuta este script, la consola aparece inmediatamente
y se ve exactamente igual que en Windows.
Tenga en cuenta que Scilab también se distribuye con el sistema de empaquetado disponible
con las distribuciones de Linux basadas en Debian (por ejemplo, Ubuntu). Este método de
instalación es extremadamente simple y eficiente. Sin embargo, tiene un pequeño inconveniente:
la versión de Scilab empaquetada para su distribución de Linux puede no estar actualizada.
Esto se debe a que existe cierto retraso (de varias semanas a varios meses) entre la disponibilidad
de una versión actualizada de Scilab en Linux y su lanzamiento en las distribuciones de Linux.
Por ahora, Scilab viene en Linux con una biblioteca de álgebra lineal binaria que garantiza
la portabilidad. Bajo Linux, Scilab no viene con una versión binaria de ATLAS [1], por lo que el
álgebra lineal es un poco más lento para esa plataforma, en comparación con Windows.
7
Machine Translated by Google
1.3.3 Instalación de Scilab en Mac OS
En Mac OS, las versiones binarias están disponibles en el sitio web de Scilab como un archivo .dmg.
Este binario funciona para las versiones de Mac OS a partir de la versión 10.5. Utiliza el instalador
de Mac OS, que proporciona un proceso de instalación clásico. Scilab no está disponible en los
sistemas Power PC.
Scilab versión 5.2 para Mac OS viene con una biblioteca Tcl/Tk que está deshabilitada por
razones técnicas. Como consecuencia, existen algunas pequeñas limitaciones en el uso de Scilab
en esta plataforma. Por ejemplo, la interfaz Scilab/Tcl (TclSci), el editor gráfico y el editor de variables
no funcionan. Estas funciones se reescribirán en Java en futuras versiones de Scilab y estas
limitaciones desaparecerán.
Aún así, usar Scilab en un sistema Mac OS es fácil y utiliza los accesos directos que son
familiares para los usuarios de esta plataforma. Por ejemplo, la consola y el editor usan la tecla Cmd
(tecla Apple) que se encuentra en los teclados Mac. Además, no hay clic derecho en esta plataforma.
En cambio, Scilab es sensible al evento de teclado Control-Click.
Por ahora, Scilab viene en Mac OS con una biblioteca de álgebra lineal que está optimizada y
garantiza la portabilidad. Bajo Mac OS, Scilab no viene con una versión binaria de ATLAS [1], por lo
que el álgebra lineal es un poco más lento para esa plataforma.
1.4 Cómo obtener ayuda
La forma más sencilla de integrar la ayuda en línea en Scilab es utilizar la función de ayuda. La
Figura 2 presenta la ventana de ayuda de Scilab. Para usar esta función, simplemente escriba
"ayuda" en la consola y presione la tecla <Enter>, como en la siguiente sesión.
ayuda
Suponga que desea ayuda sobre la función optim. Puede intentar navegar por la ayuda
integrada, encontrar la sección de optimización y luego hacer clic en el elemento de optimización
para mostrar su ayuda.
Otra posibilidad es utilizar la ayuda de la función, seguida del nombre de la función, para la cual
se requiere ayuda, como en la siguiente sesión.
ayudar a optimizar
Scilab abre automáticamente la entrada asociada en la ayuda.
También podemos utilizar la ayuda proporcionada en el sitio web de Scilab
http://www.scilab.org/product/man
Esta página siempre contiene la ayuda para la versión actualizada de Scilab. Al usar la función
de "búsqueda" de mi navegador web, la mayoría de las veces puedo encontrar rápidamente la
página de ayuda que necesito. Con ese método, puedo ver las páginas de ayuda para varios
comandos de Scilab al mismo tiempo (por ejemplo, los comandos derivative y optim, de modo que
pueda proporcionar la función de costo adecuada para la optimización con optim calculando
derivadas con derivada).
En la página de inicio de Scilab se presenta una lista de libros comerciales, libros gratuitos,
tutoriales en línea y artículos:
http://www.scilab.org/publicaciones
8
Machine Translated by Google
Figura 2: ventana de ayuda de Scilab.
1.5 Listas de correo, wiki e informes de errores
La lista de correo users@lists.scilab.org está diseñada para todas las preguntas sobre el uso de
Scilab. Para suscribirse a esta lista de correo, envíe un correo electrónico a userssubscribe@lists.scilab.org. La lista de correo dev@lists.scilab.org se enfoca en el desarrollo de
Scilab, ya sea el desarrollo del núcleo de Scilab o de módulos complicados que interactúan
profundamente con el núcleo de Scilab. Para suscribirse a esta lista de correo, envíe un correo electrónico a dev-subscribe
Estas listas de correo están archivadas en:
http://dir.gmane.org/gmane.comp.mathematics.scilab.user
y:
http://dir.gmane.org/gmane.comp.mathematics.scilab.devel
Por lo tanto, antes de hacer una pregunta, los usuarios deben considerar buscar en el
archivo si la misma pregunta o tema ya ha sido respondido.
Una pregunta publicada en la lista de correo puede estar relacionada con un punto técnico muy
específico, por lo que requiere una respuesta que no es lo suficientemente general como para ser
pública. La dirección scilab.support@scilab.org está diseñada para este propósito. Los desarrolladores
del equipo de Scilab brindan respuestas precisas a través de este canal de comunicación.
El wiki de Scilab es una herramienta pública para leer y publicar información general
sobre Scilab:
http://wiki.scilab.org
9
Machine Translated by Google
Figura 3: Ventana de demostraciones de Scilab.
Lo utilizan tanto los usuarios como los desarrolladores de Scilab para publicar información sobre Scilab.
Desde el punto de vista de un desarrollador, contiene instrucciones paso a paso para compilar Scilab
desde las fuentes, dependencias de varias versiones de Scilab, instrucciones para usar el repositorio
de código fuente de Scilab, etc.
El Scilab Bugzilla http://bugzilla.scilab.org permite enviar un informe cada vez que encontramos un
nuevo error. Puede suceder que este error ya haya sido descubierto por otra persona. Esta es la razón
por la que se recomienda buscar en la base de datos de errores los problemas relacionados existentes
antes de informar de un nuevo error. Si el error aún no se informa, es muy bueno informarlo, junto con
un script de prueba. Este script de prueba debe ser lo más simple posible, lo que permite reproducir el
problema e identificar el origen del problema.
Una forma eficaz de obtener información actualizada es utilizar fuentes RSS. el rss
feed asociado con el sitio web de Scilab es
http://www.scilab.org/en/rss_en.xml
Este canal emite regularmente comunicados de prensa y anuncios generales.
1.6 Obtener ayuda de demostraciones y macros de Scilab
El consorcio Scilab mantiene una colección de scripts de demostración, que están disponibles desde la
consola, en el menú ? > Demostraciones de Scilab. La figura 3 presenta la ventana de demostración.
Algunas demostraciones son gráficas, mientras que otras son interactivas, lo que significa que el usuario
debe presionar la tecla <Enter> para pasar al siguiente paso de la demostración.
Los scripts de demostración asociados se encuentran en el directorio de Scilab, dentro de cada
módulo. Por ejemplo, la demostración asociada al módulo de optimización se encuentra en el archivo
<ruta>\scilab-5.2.0\modules\optimization\demos\datafit\datafit.dem.sce
Por supuesto, la ruta exacta del archivo depende de su instalación particular y su sistema operativo.
10
Machine Translated by Google
Analizar el contenido de estos archivos de demostración suele ser una solución eficiente
para resolver problemas comunes y comprender características particulares.
Otro método para encontrar ayuda es analizar el código fuente de Scilab (¡Scilab es de hecho
de código abierto!). Por ejemplo, la función derivada se encuentra en
<ruta>\scilab-5.2.0\modules\optimization\macros\derivative.sci
La mayoría de las veces, las macros de Scilab están muy bien escritas, cuidando todas las
combinaciones posibles de argumentos de entrada y salida y muchos valores posibles de los
argumentos de entrada. A menudo, los problemas numéricos difíciles se resuelven en estos scripts
para que proporcionen una profunda fuente de inspiración para desarrollar sus propios scripts.
1.7 Ejercicios
Ejercicio 1.1 (Instalación de Scilab) Instale la versión actual de Scilab en su sistema: en el momento en que se escribe
este documento, esta es Scilab v5.2. Es instructivo instalar una versión anterior de Scilab para comparar el
comportamiento actual con el anterior. Instale Scilab 4.1.2 y vea las diferencias.
Ejercicio 1.2 (Ayuda en línea: derivada) La función derivada permite calcular la derivada numérica de una función. El
propósito de este ejercicio es encontrar la página de ayuda correspondiente, por varios medios. En la ayuda en línea,
busque la entrada correspondiente a la función derivada.
Busque la entrada correspondiente en la ayuda en línea. Utilice la consola para encontrar la ayuda.
Ejercicio 1.3 (Hacer una pregunta en el foro) Probablemente ya tenga una o más preguntas. Publique su pregunta en
la lista de correo de usuarios users@lists.scilab.org.
2 Primeros pasos
En esta sección, hacemos nuestros primeros pasos con Scilab y presentamos algunas tareas
simples que podemos realizar con el intérprete.
Hay varias formas de usar Scilab y los siguientes párrafos presentan tres métodos:
• usar la consola en el modo interactivo,
• usar la función exec contra un archivo,
• utilizando el procesamiento por lotes.
2.1 La consola
La primera forma es utilizar Scilab de forma interactiva, escribiendo comandos en la consola,
analizando los resultados y continuando este proceso hasta calcular el resultado final.
Este documento está diseñado para que los ejemplos de Scilab que se imprimen aquí se puedan
copiar en la consola. El objetivo es que el lector pueda experimentar por sí mismo el comportamiento
de Scilab. De hecho, esta es una buena manera de comprender el comportamiento del programa
y, la mayoría de las veces, permite una forma rápida y sencilla de realizar el cálculo deseado.
En el siguiente ejemplo, la función disp se usa en el modo interactivo para
imprima la cadena "¡Hola mundo!".
11
Machine Translated by Google
Figura 4: La finalización en la consola.
-->s="¡Hola mundo!"
s=
Hola Mundo !
--> mostrar ( s)
Hola Mundo !
En la sesión anterior, no escribimos los caracteres ”-->”, que es el indicador y que Scilab administra.
Solo escribimos la instrucción s="Hello World!" con nuestro teclado y luego presione la tecla <Enter>. La
respuesta de Scilab es s = y ¡Hola mundo!. Luego escribimos disp(s) y la respuesta de Scilab es Hello
World!.
Cuando editamos un comando, podemos usar el teclado, como con un editor normal.
Podemos usar las flechas izquierda ÿ y derecha ÿ para mover el cursor en la línea y usar las teclas
<Backspace> y <Suppr> para corregir errores en el texto.
Para obtener acceso a los comandos ejecutados anteriormente, use la tecla de flecha hacia arriba ÿ.
Esto permite navegar por los comandos anteriores utilizando las teclas de flecha arriba ÿ y abajo ÿ.
La tecla <Tab> proporciona una función de finalización muy conveniente. En el siguiente
session, escribimos la declaración disp en la consola.
--> disipar
Luego podemos escribir en la tecla <Tab>, que hace que aparezca una lista en la consola, como se
presenta en la figura 4. Scilab muestra un cuadro de lista, donde los elementos corresponden a todas
las funciones que comienzan con las letras "disp". Luego podemos usar las teclas de flecha arriba y
abajo para seleccionar la función que queremos.
El autocompletado funciona con funciones, variables, archivos y controladores gráficos.
y hace que el desarrollo de scripts sea más fácil y rápido.
2.2 El redactor
Scilab versión 5.2 proporciona un nuevo editor que permite editar scripts fácilmente. La figura 5 presenta
al editor durante la edición del anterior "¡Hola mundo!" ejemplo.
12
Machine Translated by Google
Figura 5: El editor.
Se puede acceder al editor desde el menú de la consola, en Aplicaciones
> menú Editor, o desde la consola, como se presenta en la siguiente sesión.
--> redactor ()
Este editor permite administrar varios archivos al mismo tiempo, como se presenta en
figura 5, donde editamos cinco archivos al mismo tiempo.
Hay muchas características que vale la pena mencionar en este editor. lo mas
Las funciones más utilizadas se encuentran en el menú Ejecutar.
• Cargar en Scilab permite ejecutar las declaraciones en el archivo actual, como si hiciéramos un
copiar y pegar. Esto implica que las declaraciones que no terminan con el punto y coma ”;”
character producirá una salida en la consola.
• Evaluate Selection permite ejecutar las sentencias que se encuentran actualmente
leccionado
• Execute File Into Scilab permite ejecutar el archivo, como si usáramos la función exec. Los
resultados que se producen en la consola son únicamente aquellos que están asociados a
funciones de impresión, como disp por ejemplo.
También podemos seleccionar algunas líneas en el script, hacer clic con el botón derecho (o Cmd+Click
en Mac) y obtener el menú contextual que se presenta en la figura 6.
El menú Editar proporciona una función muy interesante, comúnmente conocida como "impresora
bonita" en la mayoría de los idiomas. Esta es la función Editar > Sangría correcta, que
13
Machine Translated by Google
Figura 6: Menú contextual en el editor.
Sangría automáticamente la selección actual. Esta característica es extremadamente conveniente,
ya que permite formatear algoritmos, de modo que if, for y otros bloques estructurados sean fáciles
de analizar.
El editor proporciona un acceso rápido a la ayuda en línea. De hecho, supongamos que hemos
seleccionado la declaración disp, como se presenta en la figura 7. Cuando hacemos clic con el
botón derecho en el editor, obtenemos el menú contextual, donde la entrada Ayuda sobre ”disp”
permite abrir la página de ayuda asociada con la disp. función.
2.3 Acoplamiento
Los gráficos de la versión 5 de Scilab se han actualizado, por lo que muchos componentes ahora
se basan en Java. Esto tiene una serie de ventajas, incluida la posibilidad de administrar las
ventanas de acoplamiento.
El sistema de acoplamiento utiliza Flexdock [10], un proyecto de código abierto que proporciona
un marco de acoplamiento Swing. Supongamos que tenemos tanto la consola como el editor
abiertos en nuestro entorno, como se muestra en la figura 8. Puede ser molesto manejar dos
ventanas, porque una puede ocultar a la otra, por lo que tenemos que moverlas constantemente
para que realmente funcione. mira qué pasa.
El sistema Flexdock permite arrastrar y soltar el editor en la consola, de modo que finalmente
tenemos una sola ventana, con varias subventanas. Todas las ventanas de Scilab son acoplables,
incluida la consola, el editor, la ayuda y las ventanas de trazado. En la figura 9, presentamos una
situación en la que hemos acoplado cuatro ventanas a la ventana de la consola.
Para acoplar una ventana a otra ventana, debemos arrastrar y soltar el
14
Machine Translated by Google
Figura 7: Ayuda contextual en el editor.
Arrastra desde
aquí y suéltalo
en la consola
Figura 8: La barra de título en la ventana de origen. Para acoplar el editor a la consola,
arrastre y suelte la barra de título del editor en la consola.
15
Machine Translated by Google
Haga clic aquí
para desacoplar
Click aquí para
cerrar el muelle
Figura 9: Acciones en la barra de título de la ventana acoplable. La flecha redonda en la barra de título de la ventana permite
desacoplar la ventana. La cruz permite cerrar la ventana.
ventana de origen en la ventana de destino. Para hacer esto, hacemos clic con el botón izquierdo en la barra de título de la
ventana acoplable, como se indica en la figura 8. Antes de soltar el clic, pasemos el mouse sobre la ventana de destino y
notemos que se muestra una ventana rodeada de líneas punteadas. Esta ventana "fantasma" indica la ubicación de la futura
ventana acoplada. Podemos elegir esta ubicación, que puede estar en la parte superior, inferior, izquierda o derecha de la
ventana de destino. Una vez que hemos elegido la ubicación de destino, soltamos el clic, lo que finalmente mueve la ventana de
origen a la ventana de destino, como en la figura 9.
También podemos liberar la ventana de origen sobre la ventana de destino, lo que crea
pestañas, como en la figura 10.
2.4 Usando exec
Cuando se van a ejecutar varios comandos, puede ser más conveniente escribir estas declaraciones en un archivo con el editor
Scilab. Para ejecutar los comandos ubicados en dicho archivo, se puede usar la función exec, seguida del nombre del script.
Este archivo generalmente tiene la extensión .sce o .sci, dependiendo de su contenido:
• los archivos que tienen la extensión .sci contienen funciones de Scilab y al ejecutarlos se cargan las funciones en el
entorno de Scilab (pero no se ejecutan),
• los archivos que tienen la extensión .sce contienen tanto funciones de Scilab como ejecutables
declaraciones.
dieciséis
Machine Translated by Google
Las pestañas
del muelle
Figura 10: Pestañas de acoplamiento.
La ejecución de un archivo .sce generalmente tiene un efecto, como calcular varias variables
y mostrar los resultados en la consola, crear gráficos 2D, leer o escribir en un archivo, etc.
Suponga que el contenido del archivo myscript.sce es el siguiente.
disp("¡Hola mundo!")
En la consola de Scilab, podemos usar la función exec para ejecutar el contenido de este
script.
--> exec ("miscript. sce") --> disp ("
Hola Mundo !" )
Hola Mundo !
En situaciones prácticas, como la depuración de un algoritmo complicado, el modo
interactivo se usa la mayor parte del tiempo con una secuencia de llamadas a las funciones
exec y disp.
2.5 Procesamiento por lotes
Otra forma de utilizar Scilab es desde la línea de comandos. Varias opciones de línea de
comando están disponibles y se presentan en la figura 11. Sea cual sea el sistema operativo,
los archivos binarios se encuentran en el directorio scilab-5.2.0/bin. Las opciones de la línea
de comandos se deben agregar al binario para la plataforma específica, como se describe a
continuación. La opción -nw permite deshabilitar la visualización de la consola. La opción
-nwni permite iniciar el modo no gráfico: en este modo, la consola no se muestra y las
funciones de trazado están deshabilitadas (usarlas generará un error).
17
Machine Translated by Google
-e instrucción ejecuta la instrucción Scilab proporcionada en la instrucción -f archivo
ejecuta el script Scilabusuario
proporcionado
en el archivo
-l lang
configura
el idioma
del
'fr' para francés
y 'en' para
inglés
(el valor
predeterminado
es 'en') establece el tamaño de pila inicial
-mem N
-ns
si esta opción está presente, el archivo de inicio scilab.start no se ejecuta si esta
-nouserstartup no ejecuta
opción
losestá
archivos
presente,
de inicio
entonces
del usuario
el banner
SCIHOME/.scilab
de bienvenidaode
SCIHOME/scilab.ini
Scilab no se muestra
start
-nb
Scilab como línea de comando con funciones avanzadas (p. ej., gráficos) inicie Scilab como línea de comando
sin funciones avanzadas imprima la versión del producto y salga
-noroeste
-nwni
-versión
Figura 11: Opciones de la línea de comandos de Scilab.
• En Windows, se proporcionan dos ejecutables binarios. El primer ejecutable es WScilex.exe, la
habitual consola gráfica e interactiva. Este ejecutable corresponde al icono que está disponible en
el escritorio después de la instalación de Scilab. El segundo ejecutable es Scilex.exe, la consola
no gráfica.
Con el ejecutable Scilex.exe, la consola basada en Java no se carga y la terminal de Windows se
usa directamente. El programa Scilex.exe es sensible a las opciones -nw y -nwni.
• Bajo Linux, el script scilab proporciona opciones que permiten configurar su comportamiento. De
forma predeterminada, se inicia el modo de gráficos. El script scilab es sensible a las opciones -nw
y -nwni. Hay dos ejecutables adicionales en Linux: scilab-cli y scilab-adv-cli. El ejecutable scilabadv-cli es equivalente a la opción -nw, mientras que scilab-cli es equivalente a la opción -nwni[8].
• Bajo Mac OS, el comportamiento es similar a la plataforma Linux.
En la siguiente sesión de Windows, lanzamos el programa Scilex.exe con la opción -nwni. Luego
ejecutamos la función de trazado para comprobar que esta función no está disponible en el modo no
gráfico.
D :\ Programas \ scilab -5.2.0\ bin > Scilex . exe - nwni
___________________________________________
scilab-5.2.0
Consorcio Scilab (DIGITEO)
Copyright (c) 1989 -2009 (INRIA)
Copyright (c) 1989 -2007 (ENPC)
___________________________________________
Ejecución de inicio: cargando
entorno inicial --> trama ()
!- - error 4
Variable indefinida: parcela
18
Machine Translated by Google
La opción de línea de comandos más útil es la opción -f, que permite ejecutar los comandos
desde un archivo dado, un método generalmente llamado procesamiento por lotes. Suponga que
el contenido del archivo myscript2.sce es el siguiente, donde se usa la función de salida para salir
de Scilab.
disp ("¡Hola mundo!") salir ()
El comportamiento predeterminado de Scilab es esperar la nueva entrada del usuario: es por
eso que se usa el comando de salida, para que la sesión finalice. Para ejecutar la demostración
bajo Windows, creamos el directorio ”C:\scripts” y escribimos las sentencias en el archivo C:
\scripts\myscript2.sce. La siguiente sesión, ejecutada desde la terminal de MS Windows, muestra
cómo usar la opción -f para ejecutar el script anterior.
Tenga en cuenta que usamos la ruta absoluta del ejecutable Scilex.exe.
C :\ scripts >D :\ Programas \ scilab -5.2.0\ bin \ Scilex . exe -f myscript2 . escena
___________________________________________
scilab-5.2.0
Consorcio Scilab (DIGITEO)
Copyright (c) 1989 -2009 (INRIA)
Copyright (c) 1989 -2007 (ENPC)
___________________________________________
Ejecución de inicio: cargando
entorno inicial
Hola Mundo !
C :\ guiones >
Scilab considera cualquier línea que comience con los dos caracteres de barra inclinada ”//”
como un comentario y la ignora. Para comprobar que Scilab permanece de forma predeterminada
en modo interactivo, comentamos la declaración de salida con la sintaxis ”//”, como en el siguiente
script.
disp ("¡Hola mundo!") // salir ()
Si escribimos el comando "scilex -f myscript2.sce" en la terminal, Scilab ahora esperará la
entrada del usuario, como se esperaba. Para salir, escribimos interactivamente la instrucción
quit() en la terminal.
2.6 Ejercicios
Ejercicio 2.1 (La consola) Escriba la siguiente declaración en la consola.
átomos
Ahora escriba en la tecla <Tab>. ¿Lo que sucede? Ahora escriba la letra "I" y vuelva a escribir en <Tab>.
¿Lo que sucede?
Ejercicio 2.2 (Uso de exec) Cuando desarrollamos un script Scilab, a menudo usamos la función exec en combinación
con la función ls, que muestra la lista de archivos y directorios en el directorio actual. También podemos usar pwd,
que muestra el directorio actual. La variable SCI contiene el nombre del directorio de la instalación actual de Scilab.
Lo usamos muy a menudo para ejecutar los scripts que se proporcionan en Scilab. Escriba las siguientes
declaraciones en la consola y vea qué sucede.
personas con discapacidad
SCI
ls (SCI +"/módulos")
19
Machine Translated by Google
ls ( SCI +" / módulos / gráficos / demostraciones
") exec ( SCI +"/ módulos / gráficos / demostraciones /2 d_3d_plots / contornof . dem . sce ")
exec ( SCI +"/ módulos / gráficos / demostraciones /2 d_3d_plots / contornof . dem . sce " );
3 Elementos básicos del lenguaje
Scilab es un lenguaje interpretado, lo que significa que permite manipular variables de forma muy
dinámica. En esta sección, presentamos las características básicas del lenguaje, es decir, mostramos
cómo crear una variable real y qué funciones matemáticas elementales se pueden aplicar a una variable
real. Si Scilab proporcionara solo estas funciones, solo sería una súper calculadora de escritorio.
Afortunadamente, es mucho más y este es el tema de las secciones restantes, donde mostraremos
cómo administrar otros tipos de variables, es decir, booleanos, números complejos, enteros y cadenas.
Parece extraño al principio, pero vale la pena decirlo desde el principio: en Scilab, todo es una
matriz. Para ser más precisos, deberíamos escribir: todas las variables reales, complejas, booleanas,
enteras, de cadena y polinómicas son matrices. Las listas y otras estructuras de datos complejas (como
tlists y mlists) no son matrices (pero pueden contener matrices). Estas estructuras de datos complejas
no se presentarán en este documento.
Es por esto que podríamos comenzar presentando matrices. Aún así, elegimos presentar primero
los tipos de datos básicos, porque las matrices de Scilab son, de hecho, una organización especial de
estos bloques de construcción básicos.
En Scilab podemos manejar números reales y complejos. Esto siempre lleva a cierta confusión si el
contexto no es lo suficientemente claro. En lo que sigue, cuando escribamos variable real, nos referiremos
a una variable cuyo contenido no es complejo. Las variables complejas se tratarán en la sección 3.7
como un caso especial de variables reales. En la mayoría de los casos, las variables reales y las variables
complejas se comportan de manera muy similar, aunque se debe tener un cuidado especial cuando se
procesan datos complejos. Debido a que haría que la presentación fuera engorrosa, simplificamos la
mayoría de las discusiones al considerar solo variables reales, teniendo especial cuidado con las
variables complejas solo cuando sea necesario.
3.1 Creando variables reales
En esta sección, creamos variables reales y realizamos operaciones simples con ellas.
Scilab es un lenguaje interpretado, lo que implica que no es necesario declarar una variable antes
de usarla. Las variables se crean en el momento en que se crean por primera vez.
establecer.
En el siguiente ejemplo, creamos y establecemos la variable real x en 1 y realizamos una
multiplicación en esta variable. En Scilab, el operador ”=” significa que queremos establecer la variable
en el lado izquierdo al valor asociado con el lado derecho (no es el operador de comparación, cuya
sintaxis está asociada con el operador ”==”) .
--> x = 1
x=
1.
--> x = x * 2
20
Machine Translated by Google
+ suma - resta
ÿ multiplicación /
división derecha, es
decir x/y = xyÿ1 \ división izquierda, es
ÿ1
año
decir x\y = x potencia, es decir x ÿÿ potencia
ˆ
y
(igual que ˆ) ' transponer
conjugado
Figura 12: Operadores matemáticos elementales de Scilab.
x=
2.
El valor de la variable se muestra cada vez que se ejecuta una declaración. Ese comportamiento se
puede suprimir si la línea termina con el punto y coma ”;” carácter, como en el siguiente ejemplo.
-->y =1; ->y=y *2;
Todos los operadores algebraicos comunes presentados en la figura 12 están disponibles en Scilab.
Observe que el operador de potencia está representado por el carácter de sombrero ”ˆ” de modo que
en Scilabx.es
por la expresión
”xˆ2”
o de manera
equivalente
porSe
el revisará
operadorde
”x**2”
calcular la 2expresión
Larealizado
comilla simple
ción 3.7, que
presenta
números
complejos.
”' ”
se presentará
con más
nuevo en la sección 4.12, que trata de la transpuesta
conjugada
deprofundidad
una matriz. en la sec.
3.2 Nombres de variables
Los nombres de las variables pueden ser tan largos como el usuario desee, pero en Scilab solo se tienen
en cuenta los primeros 24 caracteres. Por consistencia, debemos considerar solo nombres de variables
que no tengan más de 24 caracteres. Se permiten todas las letras ASCII de la ”a” a la ”z”, de la ”A” a la
”Z” y los dígitos del ”0” al ”9”, con los caracteres adicionales ”%”, ”_”, ”#”, ” ps Tenga en cuenta que los
nombres de las variables, cuya primera letra es "%", tienen un significado especial en Scilab, como
veremos en la sección 3.5, que presenta las variables matemáticas predefinidas.
Scilab distingue entre mayúsculas y minúsculas, lo que significa que Scilab considera que las letras
mayúsculas y minúsculas son diferentes. En el siguiente script, definimos las dos variables A y a y
verificamos que Scilab considere que estas dos variables son diferentes.
--> A = 2
un =
2.
-->a = 1
un =
1.
-->AA
= 2.
21
Machine Translated by Google
-->un
un =
1.
3.3 Comentarios y líneas de continuación
Scilab considera cualquier línea que comience con dos barras inclinadas ”//” como un comentario
y la ignora. No hay posibilidad de comentar un bloque de líneas, como con los comentarios ”/
* ... */” en el lenguaje C.
Cuando una declaración ejecutable es demasiado larga para escribirse en una sola línea,
la segunda línea y las subsiguientes se denominan líneas de continuación. En Scilab, cualquier
línea que termine con dos puntos se considera el comienzo de una nueva línea de continuación.
En la siguiente sesión, damos ejemplos de comentarios de Scilab y líneas de continuación.
--> // Este es mi comentario. -->x =1..
- - >+2..
- - >+3..
- - >+4
x=
10
3.4 Funciones matemáticas elementales
Las tablas 13 y 14 presentan una lista de funciones matemáticas elementales. La mayoría de
estas funciones toman un argumento de entrada y devuelven un argumento de salida. Estas
funciones están vectorizadas en el sentido de que sus argumentos de entrada y salida son
matrices. Esto permite calcular datos con mayor rendimiento, sin ningún bucle.
En el siguiente ejemplo, usamos las funciones cos y sin y comprobamos la igualdad cos(x)
2
2
+ pecado(x) = 1.
-->x = cos (2)
x=
- 0,4161468 -->y =
sen (2) y = 0,9092974
-->x^2+ y^2
respuesta =
1.
3.5 Variables matemáticas predefinidas
En Scilab, varias variables matemáticas son variables predefinidas, cuyos nombres comienzan
con un carácter de porcentaje "%". Las variables que tienen un significado matemático se
resumen en la figura 15.
En el siguiente ejemplo, usamos la variable %pi para comprobar la igualdad matemática
2
2
cos(x)
+ pecado(x) = 1.
22
Machine Translated by Google
acos acosd acosh acoshm acosm acot acotd acoth
acsc acscd acsch asec
asecd asech asin
asinh asinhm asinm atan
atand atanh atanhm atanm
porque
costo
cosh coshm cosm cotd cotg cscd csch secd
cothm csc
sech
segundo
sinc sind
sinh sinhm sinm bronceado
tan tan
tanhm tanm
así como
bata
pecado
Figura 13: Funciones matemáticas elementales de Scilab: trigonometría.
exp
registro expm log10 log1p log2 logm max
maxi min mini modulo pmodulo sign signm sqrt
m2
Figura 14: Funciones matemáticas elementales de Scilab: otras funciones.
-->c= coseno ( %pi )
c=
- 1.
-->s= pecado ( %pi )
s=
1.225D-16
-->c^2+s^2
respuesta =
1.
El hecho de que el valor calculado de sin(ÿ) no sea exactamente igual a 0 es una
consecuencia del hecho de que Scilab almacena los números reales con números de punto flotante,
es decir, con precisión limitada.
3.6 Booleanos
Las variables booleanas pueden almacenar valores verdaderos o falsos. En Scilab, verdadero se escribe con %t
o %T y falso se escribe con %f o %F. La Figura 16 presenta la comparación de varios
operadores que están disponibles en Scilab. Estos operadores devuelven valores booleanos y
tomar como argumentos de entrada todos los tipos de datos básicos (es decir, números reales y complejos, enteros
y cuerdas). Los operadores de comparación se revisan en la sección 4.14, donde el
se hace énfasis en la comparación de matrices.
En el siguiente ejemplo, realizamos algunos cálculos algebraicos con Scilab
booleanos.
%i el número imaginario i
%e constante de Euler e
%pi la constante matemática ÿ
Figura 15: Variables matemáticas predefinidas.
23
Machine Translated by Google
a&b
lógico y
a|b
lógico o
ÿa
no lógico
verdadero si las dos expresiones son iguales
a==baÿ=b o a<>b verdadero si las dos expresiones son diferentes
a<b
verdadero si a es menor que b
a>b verdadero si a es mayor que b
a<=b
verdadero si a es menor o igual que b
a>=b
verdadero si a es mayor o igual que b
Figura 16: Operadores de comparación.
real
parte real
imag
parte imaginaria
imult multiplicación por i, el unitario imaginario
isreal devuelve verdadero si la variable no tiene una entrada compleja
Figura 17: Funciones elementales de números complejos de Scilab.
-->a= %T
un =
T
-->b = ( 0 == 1 )
segundo =
F
-->a&b
respuesta =
F
3.7 Números complejos
Scilab proporciona números complejos, que se almacenan como pares de números de coma flotante.
La variable predefinida %i representa el número imaginario matemático i que
2 me satisface = ÿ1. Todas las funciones elementales presentadas anteriormente, como sin
por ejemplo, están sobrecargados para números complejos. Esto significa que, si su entrada
argumento es un número complejo, la salida es un número complejo. La Figura 17 presenta
funciones que permiten manejar números complejos.
En el siguiente ejemplo, establecemos la variable x en 1 + i, y realizamos varias
operaciones básicas sobre él, como recuperar sus partes reales e imaginarias. Date cuenta cómo
el operador de comillas simples, denotado por ”' ”, se usa para calcular el conjugado de un
Número complejo.
-->x= 1+ %i
x=
1. + yo
--> es real (x)
respuesta =
F
24
Machine Translated by Google
int8 int16 int32
uint8 uint16 uint32
Figura 18: Tipos de datos enteros de Scilab.
--> x
'
respuesta =
1. - yo ->y =1 - %iy = 1.
- yo
--> reales (y)
respuesta =
1.
--> imagen (y)
respuesta =
- 1.
Finalmente comprobamos que la igualdad (1+i)(1ÿi) = 1ÿi
2
= 2 es verificado por Scilab.
-->x*y
respuesta =
2.
3.8 Enteros
Podemos crear varios tipos de variables enteras con Scilab. Las funciones que permiten crear dichos
enteros se presentan en la figura 18.
En esta sección, primero revisamos las características básicas de los números enteros, que
están asociados con un rango particular de valores. Luego analizamos la conversión entre enteros.
En la sección final, consideramos el comportamiento de los números enteros en los límites y nos enfocamos
en los problemas de portabilidad.
3.8.1 Resumen de números enteros
Existe un vínculo directo entre el número de bits utilizados para almacenar un número entero y el
rango de valores que puede manejar el número entero. El rango de una variable entera depende del
número de sus bits.
• Un entero con signo de n bits toma sus valores del rango [ÿ2
nÿ1
,2
nÿ1
ÿ 1].
• Un entero sin signo de n bits toma sus valores del rango [0, 2 n ÿ 1].
Por ejemplo, un entero con signo de 8 bits, creado por la función int8, puede almacenar valores en
7
7
, 2 valores
el rango [ÿ2 ÿ 1], que se simplifica
a [ÿ128,correspondiente
127]. El mapa desde
se presenta
el tipo en
de la
entero
figurahasta
19. el rango de
En la siguiente sesión, comprobamos que un entero de 32 bits sin signo tiene valores ÿ 1], que
dentro del rango [0, 2
32
se simplifica a [0, 4294967295].
--> formato (25) -->n
=32
25
Machine Translated by Google
7
un entero de 8 bits con signo en [ÿ2 , 7 2 ÿ1] = [ÿ128, 127]
y=int8(x)
8
y=uint8(x) un entero sin signo de 8 bits en [0, 2
15
y=int16(x) un entero de 16 bits con signo en [ÿ2
ÿ 1] = [0, 255]
2
, 15
ÿ 1] = [ÿ32768, 32767]
y=uint16(x) un entero sin signo de 16 bits en [0, 2
dieciséis
31
y=int32(x) un entero de 32 bits con signo en [ÿ2
, 2 31 ÿ1] = [ÿ2147483648, 2147483647]
32
y=uint32(x) un entero sin signo de 32 bits en [0, 2
ÿ1] = [0, 65535]
ÿ 1] = [0, 4294967295]
Figura 19: Funciones enteras de Scilab.
conversión de iconvert a representación entera
inttype tipo de enteros
Figura 20: Funciones de conversión de enteros de Scilab.
norte =
32.
- - >2^ n - 1
respuesta =
4294967295.
-->i = uint32 (0)
yo =
0
-->j=yo -1
=
j
4294967295
-->k = j +1
k=
0
3.8.2 Conversiones entre enteros
Hay funciones que permiten convertir desde y hacia tipos de datos enteros. Estas
funciones se presentan en la figura 20.
La función inttype permite consultar el tipo de una variable entera.
Dependiendo del tipo, la función devuelve un valor correspondiente, como se resume
en la tabla 21.
inttipo(x) Tipo
1 entero de 8 bits con signo
entero con signo de 16 bits
24
entero de 32 bits con signo
11
Entero sin signo de 8 bits
12
Entero sin signo de 16 bits
14
Entero sin signo de 32 bits
Figura 21: Tipos de enteros devueltos por la función inttype.
26
Machine Translated by Google
Cuando se suman dos números enteros, se analizan los tipos de los operandos: el tipo de
número entero resultante es el mayor, por lo que se puede almacenar el resultado. En el siguiente
script, creamos un entero i de 8 bits (que está asociado con inttype=1) y un entero j de 16 bits
(que está asociado con inttype=2). El resultado se almacena en k, un entero con signo de 16 bits.
-->i= int8 (1)
yo =
1
--> tipoint (i)
respuesta =
1.
-->j= int16 (2)
=
j
2
--> tipoint (j)
respuesta =
2.
-->k=i +jk =
3
--> tipoint (k)
respuesta =
2.
3.8.3 Números enteros circulares y problemas de portabilidad
El comportamiento de los enteros en los límites del rango merece un análisis particular, ya que
es diferente de un software a otro. En Scilab, el comportamiento es circular, es decir, si se
incrementa un número entero en el límite superior, el siguiente valor está en el límite inferior. En
la siguiente sesión se da un ejemplo de comportamiento circular, donde
--> uint8 (0+( -4:4))
respuesta =
252 253 254 255 0 1 2 3 4
--> uint8 (2^8+( -4:4))
respuesta =
252 253 254 255 0 1 2 3 4 --> int8 (2^7+( -4:4))
respuesta =
124 125 126 127 -128 -127 -126 -125 -124
Esto contrasta con otros paquetes matemáticos, como Octave o Matlab.
En estos paquetes, si un entero está en el límite superior, el siguiente entero permanece en el
límite superior. En la siguiente sesión de Octave, ejecutamos los mismos cálculos que antes.
octava -3.2.4. exe :1 > uint8 (0+( -4:4))
respuesta =
000001234
octava -3.2.4. exe :5 > uint8 (2^8+( -4:4))
respuesta =
252 253 254 255 255 255 255 255 255
octava -3.2.4. exe :2 > int8 (2^7+( -4:4))
respuesta =
27
Machine Translated by Google
124 125 126 127 127 127 127 127 127
La forma circular de Scilab permite una mayor flexibilidad en el procesamiento de números
enteros, ya que permite escribir algoritmos con menos declaraciones if. Pero estos algoritmos
deben verificarse, particularmente si involucran los límites. Además, traducir un script de otro
sistema de computación a Scilab puede generar resultados diferentes.
3.9 Enteros de coma flotante
En Scilab, la variable numérica predeterminada es el doble, es decir, el número de coma flotante
de 64 bits. Esto es cierto incluso si escribimos lo que matemáticamente es un número entero. En
[9], Cleve Moler llama a este número "pedernal", una abreviatura de entero de punto flotante. En la
hincapié en que podemos almacenar números enteros en52el, práctica,
intervalo 2[ÿ2]
52]de
enforma
dobles.
segura,
Hacemos
siempre
que todos los valores enteros de entrada, intermedios y de salida estén estrictamente dentro del
intervalo [ÿ2 2 52]52, ,los
realizamos
cálculos la
enteros
suma son
exacta
exactos.
de dosPor
números
ejemplo,
enteros
en el siguiente
grandes que
ejemplo,
permanecen
en el intervalo "seguro".
--> formato (25)
-->a= 2^40 - 12
un =
1099511627764.
-->b= 2^45 + 3
segundo =
35184372088835.
-->c = a + b
c=
36283883716599.
En cambio, cuando realizamos cálculos fuera de este intervalo, podemos tener resultados
inesperados. Por ejemplo, en la siguiente sesión, vemos que las sumas que involucran términos
ligeramente mayores que 253 producen solo valores pares.
--> formato (25) - >(2^53 + (1:10)) '
respuesta =
9007199254740992.
9007199254740994.
9007199254740996.
9007199254740996.
9007199254740996.
9007199254740998.
9007199254741000.
9007199254741000.
9007199254741000.
9007199254741002.
En la siguiente sesión, calculamos 252 usando el número entero de punto flotante 2 en el
primer caso y usando el número entero de 16 bits 2 en el segundo caso. En el primer caso, no se
produce desbordamiento, incluso si el número está en el límite de los números de punto flotante de 64 bits.
En el segundo caso, el resultado es completamente erróneo, porque el número 252 no se puede
representar como un entero de 16 bits.
- - >2^52
28
Machine Translated by Google
respuesta =
4503599627370496.
--> uint16 (2^52)
respuesta =
0
En la sección 4.15, analizamos los problemas que surgen cuando los índices involucrados para acceder
los elementos de una matriz son dobles.
3.10 La variable ans
Cada vez que hacemos un cálculo y no almacenamos el resultado en una variable de salida, el resultado se
almacena en la variable ans predeterminada. Una vez definida, podemos usar esta variable como cualquier
otra variable de Scilab.
En la siguiente sesión, calculamos exp(3) para que el resultado se almacene en la variable ans. Luego
usamos su contenido como una variable regular.
--> exp (3)
respuesta =
20.08553692318766792368
-->t = log ( respuesta ) t
=
3.
En general, la variable ans debe usarse solo en una sesión interactiva, para avanzar en el cálculo sin
definir una nueva variable. Por ejemplo, es posible que nos hayamos olvidado de almacenar el resultado de
un cálculo interesante y no queramos volver a calcular el resultado. Este podría ser el caso después de una
larga secuencia de pruebas y errores, donde experimentamos varias formas de obtener el resultado sin
preocuparnos de almacenarlo. En este caso interactivo, el uso de ans puede permitir ahorrar algo de tiempo
humano (o de máquina). En cambio, si estamos desarrollando un script utilizado de forma no interactiva, es
una mala práctica confiar en la variable ans y debemos almacenar los resultados en variables regulares.
3.11 Cuerdas
Las cadenas se pueden almacenar en variables, siempre que estén delimitadas por comillas dobles ”" ”. La
operación de concatenación está disponible desde el operador ”+”. En la siguiente sesión de Scilab,
definimos dos cadenas y luego las concatenamos con el ”+”. ” operador.
-->x =
x=
foo
" Foo "
-->y=" barra y
= barra
"
-->x+y
respuesta =
Foobar
Hay muchas funciones que permiten procesar cadenas, incluidas las ex regulares.
presiones No daremos más detalles sobre este tema en este documento.
29
Machine Translated by Google
3.12 Tipo dinámico de variables
Cuando creamos y gestionamos variables, Scilab permite cambiar el tipo de una variable de
forma dinámica. Esto significa que podemos crear un valor real y luego ponerle una variable
de cadena, como se presenta en la siguiente sesión.
--> x = 1
x=
1.
--> x+1
respuesta =
2.
-->x="foo
x=
Foo
--> barra x+"
"
"
respuesta =
Foobar
Hacemos hincapié aquí en que Scilab no es un lenguaje tipado, es decir, no tenemos
que declarar el tipo de una variable antes de establecer su contenido. Además, el tipo de una
variable puede cambiar durante la vida de la variable.
3.13 Ejercicios
Ejercicio 3.1 (Precedencia de operadores) ¿Cuáles son los resultados de los siguientes cálculos (piénselo antes de
intentarlo en Scilab)?
2*3+42+3
*42/3+42
+3/4
Ejercicio 3.2 (Paréntesis) ¿Cuáles son los resultados de los siguientes cálculos (piénselo antes de intentarlo en
Scilab)?
2 * (3 + 4) (2 + 3)
* 4 (2 + 3) / 4 3 /
(2 + 4)
Ejercicio 3.3 (Exponentes) ¿Cuáles son los resultados de los siguientes cálculos (piénselo antes de intentarlo en
Scilab)?
1.23456789 d10
1.23456789 e10
1.23456789 e -5
Ejercicio 3.4 (Funciones) ¿Cuáles son los resultados de los siguientes cálculos (piénselo antes de intentarlo en
Scilab)?
sqrt (4)
sqrt (9)
sqrt ( -1) sqrt
( -2) exp (1)
log ( exp (2))
exp ( log (2))
30
Machine Translated by Google
10^2
log10 (10^2)
10^ log10 (2)
signo (2) signo
(-2) signo (0)
Ejercicio 3.5 (Trigonometría) ¿Cuáles son los resultados de los siguientes cálculos (piénselo antes
de intentarlo en Scilab)?
cos (0)
sen (0)
cos ( %pi )
sen ( %pi )
cos ( %pi /4) - sen ( %pi /4)
4 Matrices
En el lenguaje Scilab, las matrices juegan un papel central. En esta sección, presentamos las
matrices de Scilab y presentamos cómo crear y consultar matrices. También analizamos cómo
acceder a los elementos de una matriz, ya sea elemento por elemento o por operaciones de nivel
superior.
4.1 Resumen
En Scilab, el tipo de datos básico es la matriz, que se define por:
• el número de filas,
• el número de columnas,
• el tipo de datos.
El tipo de datos puede ser real, entero, booleano, cadena y polinomio. Cuando dos matrices tienen
el mismo número de filas y columnas, decimos que las dos matrices tienen la misma forma.
En Scilab, los vectores son un caso particular de matrices, donde el número de filas (o el
número de columnas) es igual a 1. Las variables escalares simples no existen en Scilab: una
variable escalar es una matriz con 1 fila y 1 columna. Es por eso que en este capítulo, cuando
analizamos el comportamiento de las matrices de Scilab, existe el mismo comportamiento para los
vectores de fila o columna (es decir, matrices de n×1 o 1×n) así como para los escalares (es decir, matrices de 1×1).
Es justo decir que Scilab fue diseñado principalmente para matrices de variables reales.
Esto permite realizar operaciones de álgebra lineal con un lenguaje de alto nivel.
Por diseño, Scilab fue creado para poder realizar operaciones matriciales lo más rápido posible.
El componente básico de esta función es que las matrices de Scilab se almacenan en una estructura
de datos interna que se puede administrar a nivel de intérprete. La mayoría de las operaciones
básicas de álgebra lineal, como la suma, la resta, la transposición o el producto punto, se realizan
mediante un código fuente compilado y optimizado. Estas operaciones se realizan con los
operadores comunes ”+”, ”-”, ”*” y la comilla simple ”' ”, por lo que, a nivel de Scilab, el código
es simple
fuente
y rápido.
31
Machine Translated by Google
Con estos operadores de alto nivel, la mayoría de los algoritmos matriciales no requieren el uso
bucles De hecho, un script de Scilab que realiza las mismas operaciones con bucles es
típicamente de 10 a 100 veces más lento. Esta función de Scilab se conoce como vectorización. Para
obtener una implementación rápida de un algoritmo dado, el Scilab
El desarrollador siempre debe usar operaciones de alto nivel, de modo que cada instrucción procese
una matriz (o un vector) en lugar de un escalar.
Tareas más complejas de álgebra lineal, como la resolución de sistemas de ecuaciones lineales Ax
= b, varias descomposiciones (por ejemplo, el pivote parcial de Gauss
PA = LU), los cálculos de valores propios/vectores propios también se realizan mediante
y códigos fuente optimizados. Estas operaciones son realizadas por operadores comunes como la barra
inclinada ”/” o la barra invertida ”\” o con funciones como especificación, que calcula
Valores propios y vectores propios.
4.2 Crear una matriz de valores reales
Hay una sintaxis simple y eficiente para crear una matriz con valores dados. los
siguiente es la lista de símbolos utilizados para definir una matriz:
• los corchetes ”[” y ”]” marcan el principio y el final de la matriz,
• comas "," separan los valores en diferentes columnas,
• punto y coma ”;” separar los valores de diferentes filas.
La siguiente sintaxis se puede utilizar para definir una matriz, donde los espacios en blanco son opcionales
(pero haga que la línea sea más fácil de leer) y "..." denota valores intermedios:
A = [a11
,
a12 , ... ,
a1n; a21
,
a22 , ... ,
a2n; ...; an1
,
En el siguiente ejemplo, creamos una matriz de 2 × 3 de valores reales.
-->A = [1
un =
1.
4.
,
2
2.
5.
,
3; 4
,
5
,
6]
3.
6.
Está disponible una sintaxis más simple, que no requiere el uso de la coma y el punto y coma.
caracteres. Al crear una matriz, el espacio en blanco separa las columnas mientras
la nueva línea separa las filas, como en la siguiente sintaxis:
A = [ a11 a12 ... a1n
a21 a22 ... a2n
...
an1 an2 ... ann ]
Esto permite aligerar considerablemente el manejo de matrices, como en el siguiente
sesión.
-->A = [1 2 3
-- >4 5 6]
un =
1.
4.
2.
5.
3.
6.
32
an2 , ... ,
Ana ].
Machine Translated by Google
ojo
matriz de identidad
linspace
unos
vector espaciado linealmente
matriz hecha de unos
ceros
matriz hecha de ceros
testmatrix genera algunas matrices particulares
generador de números aleatorios
gran
rand
generador de números aleatorios
Figura 22: Funciones que generan matrices.
La sintaxis anterior para matrices es útil en las situaciones donde las matrices son
para ser escrito en archivos de datos, porque simplifica la lectura humana (y la verificación)
de los valores en el archivo, y simplifica la lectura de la matriz en Scilab.
Varios comandos de Scilab permiten crear matrices a partir de un tamaño dado, es decir, a partir de un
número dado de filas y columnas. Estas funciones se presentan en la figura 22. El
los más utilizados son ojo, ceros y unos. Estos comandos toman dos entradas
argumentos, el número de filas y columnas de la matriz a generar.
-->A = unidades (2 ,3)
un =
1.
1.
1.
1.
1.
1.
4.3 La matriz vacía []
Se puede crear una matriz vacía usando corchetes vacíos, como en la siguiente
sesión, donde creamos una matriz 0 × 0.
-->A =[]
un =
[]
Esta sintaxis permite borrar el contenido de una matriz, de modo que el asociado
la memoria se libera.
-->A = unidades (100 ,100);
-->A = []
un =
[]
4.4 Matrices de consulta
Las funciones de la figura 23 permiten consultar o actualizar una matriz.
La función de tamaño devuelve los dos argumentos de salida nr y nc, que son los
número de filas y el número de columnas.
-->A = unidades (2 ,3)
un =
1.
1.
1.
1.
-- >[nr
1.
1.
, nc ]= tamaño (A)
33
Machine Translated by Google
Talla
tamaño de los
diferente matrix matrixobjetos
resize_matrix
cambiar
crear
la forma
una nueva
de un vector
matriz o
con
una
unmatriz
tamaño
a un
diferente
tamaño
Figura 23: Funciones que consultan o modifican matrices.
nc =
3.
nr =
2.
La función de tamaño tiene un valor práctico importante cuando diseñamos una función, ya que el
procesamiento que debemos realizar sobre una matriz dada puede depender de su forma. Por
ejemplo, para calcular la norma de una matriz dada, se pueden usar diferentes algoritmos dependiendo
de si la matriz es un vector columna de tamaño nr × 1 y nr > 0, un vector fila de tamaño 1 × nc y nc >
0, o una matriz general de tamaño nr × nc y nr, nc > 1.
La función de tamaño también tiene la siguiente sintaxis
nr = tamaño ( A
,
sel)
que permite obtener solo el número de filas o el número de columnas y donde sel puede tener los
siguientes valores
• sel=1 o sel="r", devuelve el número de filas,
• sel=2 o sel="c", devuelve el número de columnas.
• sel="*", devuelve el número total de elementos, es decir, el número de columnas
veces el número de filas.
En la siguiente sesión, usamos la función de tamaño para calcular el número total de elementos
de una matriz.
-->A = unidades (2 ,3)
un =
1.
1.
1.
1.
1.
1.
--> tamaño (A , "*" )
respuesta =
6.
4.5 Acceso a los elementos de una matriz
Existen varios métodos para acceder a los elementos de una matriz A:
• toda la matriz, con la sintaxis A,
• elemento por elemento con la sintaxis A(i,j),
• un rango de valores de índice con el operador de dos puntos ”:”.
34
Machine Translated by Google
El operador de dos puntos se revisará en la siguiente sección.
Para hacer un acceso global a todos los elementos de la matriz, la variable simple
nombre, por ejemplo A, se puede utilizar. Todas las operaciones de álgebra elemental están disponibles
para matrices, como la suma con ”+”, la resta con ”-”, siempre que el
dos matrices tienen el mismo tamaño. En el siguiente script, agregamos todos los elementos de
dos matrices.
-->A = unidades (2 ,3)
un =
1. 1. 1. 1.
-->B = 2 * unos (2 ,3)
B=
2.
2.
2.
2.
-->A+B
1.
1.
2.
2.
respuesta =
3.
3.
3.
3.
3.
3.
Se puede acceder directamente a un elemento de una matriz con la sintaxis A(i,j), pro
siempre que i y j sean valores de índice válidos.
Destacamos que, por defecto, el primer índice de una matriz es 1. Esto contrasta
con otros lenguajes, como el lenguaje C por ejemplo, donde el primer índice es
0. Por ejemplo, suponga que A es una matriz nr × nc, donde nr es el número de filas
y nc es el número de columnas. Por tanto, el valor A(i,j) tiene sentido sólo si
los valores de índice i y j satisfacen 1 ÿ i ÿ nr y 1 ÿ j ÿ nc. Si los valores del índice son
no es válido, se genera un error, como en la siguiente sesión.
-->A = unidades (2 ,3)
un =
1.
1.
1.
1.
1.
1.
-->A (1 ,1)
respuesta =
1.
-->A (12 ,1)
!- - error 21
Índice no válido.
-->A (0 ,1)
!- - error 21
Índice no válido.
El acceso directo a los elementos de la matriz con la sintaxis A(i,j) solo debe usarse
cuando no se pueden usar otros comandos de Scilab de nivel superior. De hecho, Scilab proporciona
muchas características que permiten producir cálculos más simples y rápidos, basados en
vectorización. Una de estas características es el operador de dos puntos ”:”, que es muy importante
en situaciones prácticas.
4.6 El operador de dos puntos ”:”
La sintaxis más simple del operador de dos puntos es la siguiente:
v = yo:j
35
Machine Translated by Google
donde i es el índice inicial y j es el índice final con i ÿ j. Esto crea
el vector v = (i, i + 1, . . . , j). En la siguiente sesión, creamos un vector de índice
valores de 2 a 4 en una declaración.
-->v = 2:4
v=
2.
3.
4.
La sintaxis completa permite configurar el incremento utilizado al generar el
valores de índice, es decir, el paso. La sintaxis completa para el operador de dos puntos es
v = yo: s: j
donde i es el índice inicial, j es el índice final y s es el paso. Este comando
crea el vector v = (i, i + s, i + 2s, . . i + ns) donde .n, es el entero mayor
tal que i + ns ÿ j. Si s divide a j ÿ i, entonces el último índice en el vector de índice
valores es j. En otros casos, tenemos i + ns < j. Mientras que en la mayoría de las situaciones, el paso s
es positivo, también puede ser negativo.
En la siguiente sesión, creamos un vector de valores de índice crecientes de 3 a
10 con un paso igual a 2.
-->v = 3:2:10
v=
3.
5.
7.
9.
Observe que el último valor en el vector v es i+ns = 9, que es menor que j = 10.
En la siguiente sesión, presentamos dos ejemplos donde el paso es negativo. En
el primer caso, el operador de dos puntos genera valores de índice decrecientes de 10 a 4. En
el segundo ejemplo, el operador de dos puntos genera una matriz vacía porque no
no hay valores menores de 3 y mayores de 10 al mismo tiempo.
-->v = 10: -2:3
v=
10
-->v = 3: -2:10
v=
8.
6.
4.
[]
Con un vector de valores de índice, podemos acceder a los elementos de una matriz en un determinado
rango, como con la siguiente sintaxis simplificada
A( i:j ,k :l )
donde i,j,k,l son valores de índice inicial y final. La sintaxis completa es
A(i:s:j,k:t:l), donde s y t son los pasos.
Por ejemplo, supongamos que A es una matriz de 4 × 5 y que queremos acceder a la
elementos ai, j para i = 1, 2 y j = 3, 4. Con el lenguaje Scilab, esto se puede hacer
en una sola sentencia, usando la sintaxis A(1:2,3:4), como se muestra a continuación
sesión.
-->A = matriz de prueba ( " " ,5)empuñadura
un =
25.
- 300.
1050.
- 1400.
630.
- 300.
4800. - 18900.
26880.
- 12600.
1050. - 18900.
79380. - 117600.
56700.
- 1400.
26880. - 117600.
179200. - 88200.
36
Machine Translated by Google
toda la matriz
A
A(:,:) toda la matriz
A(i:j,k) los elementos en las filas de i a j, en la columna k
A(i,j:k) los elementos en la fila i, en las columnas de j a k
A(i,:) la fila i
A(:,j) la columna j
Figura 24: Acceso a una matriz con el operador de dos puntos ”:”.
630. - 12600.
56700. - 88200.
44100.
-->A (1:2 ,3:4)
respuesta =
1050.
- 18900.
- 1400.
26880.
En algunas circunstancias, puede suceder que los valores del índice sean el resultado de una
cálculo. Por ejemplo, el algoritmo puede estar basado en un ciclo donde el índice
los valores se actualizan periódicamente. En estos casos, la sintaxis
A( vi , vj ),
donde vi,vj son vectores de valores de índice, se pueden utilizar para designar los elementos de
A cuyos subíndices son los elementos de vi y vj. Esa sintaxis se ilustra en el
siguiente ejemplo.
-->A = matriz de prueba ( " " ,5) empuñadura
un =
25.
- 300.
1050.
- 1400.
630.
- 300.
4800. - 18900.
26880.
- 12600.
1050. - 18900.
79380. - 117600.
56700.
- 1400.
26880. - 117600. - 12600.
179200. - 88200.
630.
56700. - 88200.
44100.
--> vi=1:2
vi =
1.
2.
--> vj =3:4
vj =
3.
-->A(vi , vj )
4.
respuesta =
1050.
- 18900.
--> vi = vi +1
vi =
2.
--> vj = vj +1
vj =
4.
-->A(vi , vj )
- 1400.
26880.
3.
5.
respuesta =
26880. 117600.
- 12600.
56700.
37
Machine Translated by Google
Hay muchas variaciones en esta sintaxis, y la figura 24 presenta algunas de las
posibles combinaciones.
Por ejemplo, en la siguiente sesión, usamos el operador de dos puntos para
intercambiar dos filas de la matriz A.
-->A = matriz de prueba ( " " ,3)empuñadura
un =
9.
- 36.
30
- 36.
192. - 180.
30. - 180. 180.
-->A ([1 2] ,:) = A ([2 1] ,:)
un =
- 36. 192. - 180.
9. - 36. 30.
30. - 180. 180.
También podríamos intercambiar las columnas de la matriz A con el enunciado A(:,[3
1 2]).
En esta sección hemos analizado varios usos prácticos del operador de dos puntos.
De hecho, este operador se usa en muchas secuencias de comandos donde el rendimiento importa, ya que
permite acceder a muchos elementos de una matriz en una sola instrucción. Esto está asociado
con la vectorización de scripts, un tema central en el lenguaje Scilab
y se revisa a lo largo de este documento.
4.7 La matriz del ojo
La función ojo permite crear la matriz identidad con el tamaño que depende de
el contexto. Se ha elegido su nombre en lugar de I para evitar confusiones.
con un índice o con el número imaginario.
En la siguiente sesión sumamos 3 a los elementos de la diagonal de la matriz A.
-->A = unidades (3 ,3)
un =
1.
1.
1.
1.
1.
1.
1.
1.
1.
-->B = A + 3* ojo ()
B=
4.
1.
1.
4.
1.
1.
1.
1.
4.
En la siguiente sesión, definimos una matriz identidad B con la función ojo dependiendo del
tamaño de una matriz A dada.
-->A = unidades (2 ,2)
un =
1.
1.
1.
1.
-->B = ojo (A)
B=
1.
0.
0.
1.
38
Machine Translated by Google
Finalmente, podemos usar la sintaxis eye(m,n) para crear una matriz identidad con
m filas y n columnas.
4.8 Las matrices son dinámicas
El tamaño de una matriz puede crecer o reducirse dinámicamente. Esto permite adaptar el tamaño
de la matriz a los datos que contiene.
Considere la siguiente sesión donde definimos una matriz de 2 × 3.
-->A = [1 2 3; 4 5 6]
un =
1.
2.
4.
5.
3.
6.
En la siguiente sesión, insertamos el valor 7 en los índices (3, 1). Esto crea el
tercera fila en la matriz, establece la entrada A(3, 1) en 7 y llena los otros valores de la
fila recién creada con ceros.
-->A (3 ,1) = 7
un =
1.
4.
7.
2.
5.
0.
3.
6.
0.
El ejemplo anterior mostró que las matrices pueden crecer. En la siguiente sesión, nos
Vea que también podemos reducir el tamaño de una matriz. Esto se hace usando el vacío
operador de matriz ”[]” para eliminar la tercera columna.
-->A (: ,3) = []
un =
1.
4.
7.
2.
5.
0.
También podemos cambiar la forma de la matriz con la función de matriz. La matriz
La función permite remodelar una matriz de origen en una matriz de destino con un tamaño diferente.
La transformación se realiza columna por columna, apilando los elementos de la
matriz fuente. En la siguiente sesión, remodelamos la matriz A, que tiene 3×2 = 6
elementos en un vector fila con 6 columnas.
-->B = matriz (A ,1 ,6)
B=
1.
4.
7.
2.
5.
0.
4.9 El operador dólar ”$”
Por lo general, hacemos uso de índices para hacer referencia desde el inicio de una matriz. Por
oposición, el operador dólar ”$” permite referenciar elementos desde el final de
la matriz. El operador ”$” significa ”el índice correspondiente a la última” fila o
columna, dependiendo del contexto. Esta sintaxis está asociada con un álgebra, de modo que
el índice $-i corresponde al índice `ÿi, donde ` es el número de
filas o columnas. En la figura 25 se presentan varios usos del operador dólar .
En el siguiente ejemplo, consideramos una matriz de 3 × 3 y accedemos al elemento
A(2,1) = A(nr-1,nc-2) = A($-1,$-2) porque nr = 3 y nc = 3.
39
Machine Translated by Google
A(i,$) el elemento en la fila i, en la columna nc
A($,j) el elemento en la fila nr, en la columna j
A($-i,$-j) el elemento en la fila nr ÿ i, en la columna nc ÿ j
Figura 25: Acceso a una matriz con el operador dólar ”$”. El operador ”$” significa
”el último índice”.
-->A= matriz de prueba ( " hilb
un =
9.
- 36.
- 36.
192. - 180.
30. - 180.
" ,3)
30
180.
-->A($ -1 ,$ -2)
respuesta =
- 36.
El operador dólar ”$” permite agregar elementos dinámicamente al final de las matrices.
En la siguiente sesión, agregamos una fila al final de la matriz de Hilbert.
-->A($ +1 ,:) = [1 2 3]
un =
9.
- 36.
- 36.
192. - 180.
30. - 180. 1. 2.
30
180.
3.
El operador ”$” se usa la mayor parte del tiempo en el contexto de la instrucción ”$+1”,
que permite sumar al final de una matriz. Esto puede ser conveniente, ya que evita
la necesidad de actualizar el número de filas o columnas continuamente aunque debería
debe usarse con cuidado, solo en las situaciones en las que el número de filas o columnas no puede
ser conocido de antemano. La razón es que el intérprete tiene que reasignar internamente
memoria para toda la matriz y para copiar los valores antiguos al nuevo destino.
Esto puede conducir a penalizaciones de rendimiento y es por eso que debemos ser advertidos contra
malos usos de este operador. Con todo, el único buen uso de la instrucción "$+1" es
cuando no sabemos de antemano el número final de filas o columnas.
4.10 Operaciones de bajo nivel
Todos los operadores de álgebra comunes, como ”+”, ”-”, ”*” y ”/”, están disponibles con
matrices. En las siguientes secciones, nos enfocamos en el significado exacto de estos operadores,
de modo que se evitan muchas fuentes de confusión.
Las reglas para los operadores ”+” y ”-” se aplican directamente del álgebra habitual.
En la siguiente sesión, sumamos dos matrices de 2 × 2.
-->A = [1 2
-- >3 4]
un =
1.
3.
2.
4.
-->B =[5 6
-- >7 8]
B=
40
Machine Translated by Google
5.
7.
-->A+B
6.
8.
respuesta =
6.
10
8.
12
Cuando realizamos una suma de dos matrices, si un operando es una matriz 1 × 1
(es decir, un escalar), el valor de este escalar se suma a cada elemento de la segunda matriz.
Esta característica se muestra en la siguiente sesión.
-->A = [1 2
-- >3 4]
un =
1.
3.
-->A + 1
2.
4.
respuesta =
2.
4.
3.
5.
La suma es posible solo si las dos matrices son conformes a la suma. En
la siguiente sesión, tratamos de sumar una matriz de 2 × 3 con una matriz de 2 × 2 y comprobamos
que esto no es posible.
-->A = [1 2
-- >3 4]
un =
1.
3.
2.
4.
-->B = [1 2 3
-- >4 5 6]
B=
1.
2.
4.
5.
-->A+B
!- - error 8
Adición inconsistente.
3.
6.
Los operadores elementales que están disponibles para matrices se presentan en la figura 26.
El lenguaje Scilab proporciona dos operadores de división, es decir, la división correcta ”/”
y la división izquierda ”\”. La división correcta es tal que X = A/B = ABÿ1 es el
solución de XB = A. La división de la izquierda es tal que X = A\B = Aÿ1B es la solución
de AX = B. La división izquierda A\B calcula la solución del mínimo asociado
problema del cuadrado si A no es una matriz cuadrada.
La Figura 26 separa los operadores que tratan las matrices como un todo y las
operadores por elementos, que se presentan en la siguiente sección.
4.11 Operaciones elementales
Si un punto ”.” se escribe antes de un operador, se asocia con un elemento
operador, es decir, la operación se realiza elemento a elemento. Por ejemplo, con
el operador de multiplicación habitual ”*”, el contenido de la matriz C=A*B es cij =
41
Machine Translated by Google
+
-
suma
.+ adición por elementos
resta
.- resta por elementos
ÿ
multiplicación
.ÿ multiplicación por elementos
/
división derecha
división izquierda
./ división elemental por la derecha
.\ división por elementos a la izquierda
\
ˆ
o ÿÿ potencia, es decir, x
'
y
.ˆ potencia elemental
transponer y conjugar .' transponer (pero no conjugar)
Figura 26: Operadores matriciales y operadores elementales.
PAGS
k=1, n
aikbkj _ Con el operador de multiplicación por elementos ”.*”, el contenido de la
matriz C=A.*B es cij = aij bij .
En la siguiente sesión se multiplican dos matrices con el operador ”*” y
luego con el operador elementwise ”.*”, para que podamos comprobar que los resultados son
diferente.
-->A = unidades (2 ,2)
un =
1.
1.
1.
1.
-->B = 2 * unos (2 ,2)
B=
2.
2.
2.
2.
-->A*B
respuesta =
4.
4.
-->A .* B
4.
4.
respuesta =
2.
2.
2.
2.
4.12 Transpuesta conjugada y transpuesta no conjugada
Puede haber cierta confusión cuando se utiliza la comilla simple ”. " y el
definiciones regulares
”' ”
los operadores se utilizan sin un conocimiento cuidadoso de su ex
”'
de acto de comillas simples. Con una matriz de dobles que contiene valores reales, la comilla simple
”
El operador solo transpone la matriz. En cambio, cuando una matriz de dobles que contiene
se utiliza valores complejos, la matriz de comillas
”' ”
operador transpone y conjuga el
simples. Por lo tanto, la operación A=Z' produce una matriz con entradas Ajk = Xkj ÿiYkj ,
2 = ÿ1 y X e Y son los reales y
donde i es el número imaginario tal que i
partes imaginarias de la matriz Z. La comilla simple elemento a elemento ”.' ” transpone siempre sin
conjugar la matriz, sea real o compleja. Por lo tanto, la operación
A=Z.' produce una matriz con entradas Ajk = Xkj + iYkj .
En la siguiente sesión, una matriz asimétrica de dobles que contienen complejos
se utilizan valores, de modo que la diferencia entre los dos operadores es obvia.
-->A = [1 2;3 4] + %i * [5 6;7 8]
un =
42
Machine Translated by Google
1. + 5. yo 3. +
2. + 6. yo
7. yo
4. + 8. yo
-->A'
respuesta =
1. - 5. yo
3. - 7. yo
2. - 6. yo
4. - 8. yo
-->A.'
respuesta =
1. + 5. yo
3. + 7. yo
2. + 6. yo
4. + 8. yo
En la siguiente sesión, definimos una matriz no simétrica de dobles que contienen reales
valores y ver que los resultados de ”' ” y ”.' son los mismos en este particular
caso.
-->B = [1 2;3 4]
B=
1.
2.
3.
4.
-->B'
respuesta =
1.
3.
2.
4.
-->B.'
respuesta =
1.
3.
2.
4.
Muchos errores se crean debido a esta confusión, por lo que es obligatorio preguntar
usted mismo la siguiente pregunta: ¿qué pasa si mi matriz es compleja? Si el
”
”
.'
la respuesta es "Solo quiero transponer", entonces el operador de comillas por elementos
es
para ser utilizado.
4.13 Multiplicación de dos vectores
T
Sea u ÿ R n un vector columna y v
ÿ R n sea un vector columna. La matriz
A = uvT tiene entradas Aij = uivj . En la siguiente sesión de Scilab, multiplicamos el
vector columna u por el vector fila v y almacenar el resultado en la variable A.
-->u = [1
-- >2
- - >3]
tu =
1.
2.
3.
-->v = [4 5 6]
v=
4.
5.
6.
-->u*v
respuesta =
4.
5.
6.
8.
10
12
12
15.
18
43
Machine Translated by Google
and(A,"r") en fila ”y” y(A,"c") en
columna ”y” o(A,"r") en fila ”o”
o(A,"c") en columna ”o”
Figura 27: Operadores especiales de comparación para matrices. Los operadores habituales
”<”, ”&”, ”|” también están disponibles para matrices, pero and y or permiten realizar operaciones
por filas y por columnas.
Esto podría generar cierta confusión porque los libros de texto de álgebra lineal consideran
solo vectores columna. Usualmente denotamos por u ÿ R n un vector columna, de modo que
el .vector
En la de
implementación asociada de Scilab,
el vector de fila correspondiente se denota porTua
fila se puede almacenar directamente en la variable u. También podría ser una fuente de
errores, si se espera que el vector esperado sea un vector de fila y, de hecho, es un vector de
columna. Esta es la razón por la cual cualquier algoritmo que funcione solo en un tipo particular
de matriz (vector de fila o vector de columna) debe verificar que el vector de entrada tenga la
forma correspondiente y generar un error si no.
4.14 Comparación de dos matrices reales
La comparación de dos matrices solo es posible cuando las matrices tienen la misma forma.
De hecho, los operadores de comparación presentados en la figura 16 se realizan cuando los
argumentos de entrada A y B son matrices. Cuando se comparan dos matrices, el resultado
es una matriz de valores booleanos. Esta matriz se puede combinar con operadores como y,
o, que se presentan en la figura 27. Los operadores habituales ”&”, ”|” también están
disponibles para matrices, pero and y or permiten realizar operaciones por filas y por columnas.
En la siguiente sesión de Scilab, creamos una matriz A y la comparamos con el número 3.
Observe que esta comparación es válida porque el número 3 se compara elemento por
elemento con A. Luego creamos una matriz B y comparamos las dos matrices A y B.
Finalmente, la función o se usa para realizar una comparación por filas de modo que
obtengamos las columnas donde un valor en la columna de la matriz A es mayor que un valor
en la columna de la matriz B.
-->A = [1 2 7 -->6 9 8]
A = 1.
6.
2.
9.
7.
8.
-->A >3
respuesta =
FFT
TTT
-->B =[4 5 6 -->7
8 9]
B=
4.
5.
7.
8.
-->A >B
6.
9.
44
Machine Translated by Google
respuesta =
FFT
FTF --> o
(A >B , "r" )
respuesta =
FTT
4.15 Problemas con los números enteros de coma flotante
En esta sección, analizamos los problemas que pueden surgir cuando usamos números enteros
que se almacenan como números de coma flotante. Si se usan sin precaución, estos números
pueden conducir a resultados desastrosos, como vamos a ver.
Suponga que la matriz A es una matriz cuadrada de 2×2. Para acceder al elemento (2,1) de
esta matriz, podemos usar un índice constante, como A(2,1), que es seguro.
Además, podemos acceder al elemento (2,1) usando valores de coma flotante, como en la
siguiente sesión.
-->A = matriz de prueba ( " " ,2) hilb
un =
4.
- 6. 12.
- 6.
Ahora, para acceder al elemento de la matriz, podemos usar las variables i y j y usar el
enunciado A(i,j), como en la siguiente sesión.
-->yo = 2
yo =
2.
--> j = 1 j
=
1.
-->A(i,j)
respuesta =
- 6.
En la sesión anterior, enfatizamos que las variables i y j son dobles. Es por esto que la siguiente
afirmación es válida.
-->A( 2
,
[1.0 1.1 1.5 1.9] )
respuesta =
- 6.
- 6. - 6. - 6.
La sesión anterior muestra que los valores de punto flotante 1.0, 1.1, 1.5 y 1.9 se convierten
todos al número entero 1, como si la función int se hubiera utilizado para convertir el número de
punto flotante en un número entero. De hecho, la función int devuelve el número de punto
flotante que almacena la parte entera del número de punto flotante dado: en cierto sentido, se
redondea hacia cero. Por ejemplo, int(1.0), int(1.1), int(1.5) e int(1.9) todos devuelven 1 mientras
que int(-1.0), int(-1.1), int(-1.5) e int(-1.9) todos devuelve -1.
Tenga en cuenta que el comportamiento de redondeo puede explicarse mediante la función
int y no mediante la función floor. Esto se puede ver cuando consideramos valores enteros
negativos, donde los valores devueltos de las dos funciones no son los mismos. De hecho,
suponga que la matriz A es una matriz de 4 × 4, creada por A = testmatrix("hilb",4) para
45
Machine Translated by Google
ejemplo. La función triu devuelve la parte superior del triángulo de la matriz de entrada.
Las sentencias triu(A,-1), triu(A,int(-1.5)) y triu(A,-1.5) producen el mismo resultado. En cambio,
la instrucción triu(A,piso(-1.5)) produce el mismo resultado que triu(A,-2).
Este sistema permite tener un lenguaje a la vez simple y eficiente. Pero también puede
tener consecuencias desafortunadas, que a veces conducen a resultados inesperados.
Por ejemplo, considere la siguiente sesión.
--> unos (1 ,1)
respuesta =
1.
--> unos (1 ,(1 -0.9)*10)
respuesta =
[]
Si los cálculos se realizaron con aritmética exacta, el resultado de (1 ÿ 0,9) ÿ 10 debería ser
igual a 1, lo que daría lugar a una matriz de 1×1. En cambio, la declaración ones(1,(1-0.9)*10) crea
una matriz vacía, porque el valor devuelto por la función int es igual a cero, como se presenta en la
siguiente sesión.
--> entero ((1 -0.9)*10)
respuesta =
0.
De hecho, el número decimal 0,9 no se puede representar exactamente como un número de
punto flotante de doble precisión. Esto conduce a un redondeo, de modo que la representación
de coma flotante de 1-0,9 es ligeramente menor que 0,1. Cuando se realiza la multiplicación
(1-0.9)*10, el resultado de coma flotante es, por lo tanto, ligeramente menor que 1, como se
presenta en la siguiente sesión.
--> formato (25) - - >1
-0.9
respuesta =
0.0999999999999999777955
- - >(1 -0.9)*10
respuesta =
0.9999999999999997779554
Luego, el número de coma flotante 0.999999999999999 se considera como el número entero
cero, lo que hace que la función de los unos devuelva una matriz vacía. Por lo tanto, el origen
de este problema es el uso del número de coma flotante 0.1, que no debería haberse usado
sin precaución para realizar aritmética de enteros con números de coma flotante.
4.16 Más sobre funciones elementales
En esta sección, analizamos varias funciones elementales, especialmente funciones
trigonométricas basadas en grados, funciones logarítmicas y funciones elementales basadas en matrices.
Las funciones trigonométricas como seno y coseno se proporcionan con el argumento de
entrada clásico en radianes. Pero algunas otras funciones trigonométricas, como la función
cosd, por ejemplo, toman un argumento de entrada en grado. Esto significa que, en el sentido
matemático, tand(x) = tan(xÿ/180). Estas funciones se pueden identificar fácilmente porque su
nombre termina con la letra ”d”, por ejemplo, cosd, sind, entre otras. La ventaja clave de las
funciones elementales basadas en grados es que
46
Machine Translated by Google
proporcionar resultados exactos cuando su argumento tiene valores matemáticos especiales, como
múltiplos de 90ÿ . De hecho, la implementación de las funciones basadas en grados se basa
en una reducción de argumento que es exacta para valores enteros. Esto permite obtener exactamente
resultados de punto flotante para casos particulares.
En la siguiente sesión, calculamos sin(ÿ) y sind(180), que son matemáticas
icamente iguales, pero están asociados con diferentes resultados de coma flotante.
--> pecado ( %pi )
respuesta =
1.225D-16
--> pecado (180)
respuesta =
0.
El hecho de que sen(ÿ) no sea exactamente cero está asociado con la precisión limitada de
Números de punto flotante. De hecho, el argumento ÿ se almacena en la memoria con un límite
número de dígitos significativos, lo que conduce al redondeo. En cambio, el argumento 180 es
representado exactamente como un número de punto flotante, porque es un entero pequeño. Por eso,
el valor de sind(180) es calculado por la función sind como sin(0). Una vez más,
el número cero está representado exactamente por un número de coma flotante. Además, el pecado
función está representada en el intervalo [ÿÿ/2, ÿ/2] por un polinomio de la forma p(x) =
x+x 3 q(x 2 ) donde q es un polinomio de bajo grado. Por lo tanto, obtenemos sind(180)=sin(0)=0,
cual es el resultado exacto.
La función log calcula el logaritmo natural del argumento de entrada, es decir,
X
la inversa de la función exp= e
, donde e es la constante de Euler. Para calcular
la función logaritmo para otras bases, podemos usar las funciones log10 y log2,
asociado con las bases 10 y 2 respectivamente. En la siguiente sesión calculamos
los valores de las funciones log, log10 y log2 para algunos valores específicos de x.
-->x = [ exp (1) exp (2) 1 10 2^1 2^10]
x=
2.7182818
7.3890561
1.
10
2.
1024.
-- >[x ' log (x ') log10 (x ') log2 (x ')]
respuesta =
1.
2.
0.
2.3025851
0.6931472
6.9314718
2.7182818
7.3890561
1.
10
2.
1024.
0.4342945
0.8685890
0.
1.
0.30103
3.0103
1.442695
2.8853901
0.
3.3219281
1.
10
La primera columna de la tabla anterior contiene varios valores de x. La columna
el número 2 contiene varios valores de log(x), mientras que las columnas 3 y 4 contienen
varios valores de log10(x) y log2(x).
La mayoría de las funciones son por elementos, es decir, dada una matriz de entrada, aplican el mismo
función para cada entrada de la matriz. Aún así, algunas funciones tienen un significado especial.
con respecto al álgebra lineal. Por ejemplo, la matriz exponencial de una función
X
1
k!Xk , donde X es una matriz cuadrada n × n. Con el fin de
calcular la exponencial de una matriz, podemos usar la función expm. Obviamente,
se define por e
= PAG
k=0,ÿ
la función exponencial elemento a elemento exp no devuelve el mismo resultado. Más
generalmente, las funciones que tienen un significado especial con respecto a las matrices tienen
un nombre que termina con la letra ”m”, ej. expm, sinm, entre otros. En el
47
Machine Translated by Google
chol
Factorización de Cholesky
matriz de compañeros de compañía
número de condición
det
determinante condicional
inversión
matriz inversa
linsolve
solucionador de ecuaciones lineales
lsq lu
problemas de mínimos cuadrados lineales
Factores LU de eliminación gaussiana
qr
segundo
descomposición QR
número de condición inversa
valores propios
especificación svd
valor singular de descomposición
testmatrix una colección de matrices de prueba
rastro
rastro
Figura 28: Algunas funciones comunes para álgebra lineal.
siguiente sesión, definimos una matriz de 2 × 2 que contiene múltiplos específicos de ÿ/2 y
utilice las funciones sin y sinm.
-->A = [ %pi /2 %pi ; 2* %pi 3* %pi /2]
un =
1.5707963
3.1415927
6.2831853
4.712389
--> pecado (A)
respuesta =
1.
- 2.449 D -16 - 1.
1.225D-16
--> sen ( A)
respuesta =
- 0.3333333
1.3333333
0.6666667
0.3333333
4.17 Funciones de álgebra lineal de nivel superior
En esta sección, presentamos brevemente las funciones de álgebra lineal de alto nivel de Scilab.
Scilab tiene una biblioteca de álgebra lineal completa, que es capaz de gestionar tanto densos
y matrices dispersas. Se necesitaría un libro completo de álgebra lineal para hacer
una descripción de los algoritmos proporcionados por Scilab en este campo, y esto es obviamente
fuera del alcance de este documento. La Figura 28 presenta una lista de los más comunes
funciones de álgebra lineal.
4.18 Ejercicios
Ejercicio 4.1 (Más uno) Crea el vector (x1 + 1, x2 + 1, x3 + 1, x4 + 1) con la siguiente x.
x = 1:4;
Ejercicio 4.2 (Multiplicación vectorizada) Crea el vector (x1y1, x2y2, x3y3, x4y4) con la
siguiendo x e y.
48
Machine Translated by Google
x = 1:4; y =
5:8;
1
Ejercicio 4.3 (Invertido vectorizado) Crear el vector
x1
, 1 , 1 , 1
x2
con la siguiente x.
x4
x3
x = 1:4;
x1
Ejercicio 4.4 (División vectorizada) Crear el vector
y.
y1
,
x2
y2
,
x3
y3
,
x4
y4
con la siguiente x y
x = 12*(6:9); y = 1:4;
Ejercicio 4.5 (Elevación al cuadrado vectorizada) Crea el vector x
2
1,
x22 , x23 , x24
con x = 1, 2, 3, 4.
Ejercicio 4.6 (Seno vectorizado) Crea el vector (sin(x1), sin(x2), . . . , sin(x10)) con x es un vector de 10 valores
elegidos linealmente en el intervalo [0, ÿ].
Ejercicio 4.7 (Función vectorizada) Calcular los valores de y = f(x) de la función f definida por la ecuación
f(x) = log10 (r/10x + 10x )
(1)
con r = 2.220.10ÿ16 y xa vector de 100 valores elegidos linealmente en el intervalo [ÿ16, 0].
5 Bucles y ramificaciones
En esta sección, describimos cómo hacer sentencias condicionales, es decir, presentamos
la sentencia if. Presentamos la instrucción select, que permite crear selecciones más
complejas. Presentamos los bucles de Scilab, es decir, presentamos las declaraciones for y
while. Finalmente presentamos dos herramientas principales para administrar bucles, es
decir, las instrucciones break y continue.
5.1 La sentencia if
La declaración if permite realizar una declaración si se cumple una condición. El if usa una
variable booleana para realizar su elección: si el booleano es verdadero, entonces se ejecuta
la declaración. Una condición se cierra cuando se cumple la palabra clave final. En el
siguiente script, mostramos la cadena "¡Hola!" si se cumple la condición %t, que siempre es
verdadera.
si ( %t ) entonces
disp ("¡Hola!") fin
El script anterior produce:
Hola !
Si la condición no se cumple, la sentencia else permite realizar una sentencia alternativa,
como en el siguiente script.
si ( %f ) entonces
disp ("¡Hola!") else disp
("¡Adiós!") end
49
Machine Translated by Google
El script anterior produce:
Adiós !
Para obtener un valor booleano, se puede utilizar cualquier operador de comparación, por
ejemplo, ”==”, ”>”, etc... o cualquier función que devuelva un valor booleano. En la siguiente sesión,
usamos el operador ”==” para mostrar el mensaje ”¡Hola!”.
yo = 2
if (i == 2) entonces disp
("¡Hola!") else
disp ("¡Adiós!") fin
Es importante no usar el operador ”=” en la condición, es decir, no debemos usar la declaración
si ( i = 2 ) entonces. Es un error, ya que el operador ”=” permite poner una variable: es diferente al
operador de comparación ”==”. En caso de error, Scilab nos avisa de que ha pasado algo malo.
-->yo = 2
yo =
2.
--> if ( i = 2 ) entonces Advertencia :
uso obsoleto de '=' en lugar de '== '.
!
--> disp ("¡Hola!")
Hola !
--> más
--> disp (" ¡Adiós ! ") --> fin
Cuando tenemos que combinar varias condiciones, la declaración elseif es útil.
En el siguiente script, combinamos varias declaraciones elseif para administrar varios valores del
entero i.
yo = 2
if ( i == 1 ) then disp (" ¡Hola !
") elseif ( i == 2 ) then disp
(" ¡Adiós ! ") elseif ( i == 3 ) then disp
(" Tchao ! ") else
disp ("Au Revoir!") fin
Podemos usar tantas declaraciones elseif como necesitemos, y esto permite crear ramas tan
complicadas como sea necesario. Pero si se requieren muchas declaraciones elseif, la mayoría de
las veces eso implica que se debe usar una declaración select en su lugar.
5.2 La declaración de selección
La sentencia select permite combinar varias ramas de forma clara y sencilla. Dependiendo del
valor de una variable, permite realizar la sentencia
50
Machine Translated by Google
correspondiente a la palabra clave case. Puede haber tantas sucursales como se requiera.
En el siguiente script, queremos mostrar una cadena que corresponda al entero i dado.
yo = 2
seleccione yo
caso 1
disp ("Uno") caso
2
disp (" Dos ") caso
3
disp ("Tres") más
final disp ("Otro")
El script anterior imprime "Dos", como se esperaba.
La rama else se usa si todas las condiciones del caso anterior son falsas.
La instrucción else es opcional, pero se considera una buena práctica de programación.
De hecho, incluso si el programador piensa que el caso asociado no puede suceder, aún puede existir
un error en la lógica, de modo que todas las condiciones sean falsas cuando no deberían. En este caso,
si la instrucción else no interrumpe la ejecución, se ejecutarán las demás instrucciones del script. Esto
puede conducir a resultados inesperados. En el peor de los casos, el script sigue funcionando pero con
resultados inconsistentes.
La depuración de dichos scripts es extremadamente difícil y puede provocar una gran pérdida de tiempo.
Por lo tanto, la declaración else debe incluirse en la mayoría de las secuencias seleccionadas. Para
gestionar estos eventos inesperados, a menudo combinamos una declaración de selección con la función
de error.
La función de error genera un error asociado con el mensaje dado. Cuando se genera un error, la
ejecución se interrumpe y el intérprete sale de todas las funciones. Por lo tanto, la pila de llamadas se
borra y el script se detiene.
En el siguiente script, mostramos un mensaje dependiendo del valor del
variable positiva i. Si esa variable es negativa, generamos un error.
yo = -5;
seleccione yo
caso 1
disp ("Uno")
caso 2
disp (" Dos ") caso
3
disp ("Tres") más
error ( " " )
final
Valor inesperado del parámetro i
El script anterior produce el siguiente resultado.
-->i = -5; -->
selecciona yo
--> caso 1
--> disp (" Uno ") --> caso 2
--> disp ("Dos")
51
Machine Translated by Google
--> caso 3 -->
disp (" Tres ") --> else --> error
("
Valor inesperado del parámetro i" )
Valor inesperado del parámetro i
En la práctica, cuando vemos una declaración select sin el else correspondiente, podemos
preguntarnos si el desarrollador escribió esto a propósito o asumiendo que nunca sucederá.
La mayoría de las veces, esta suposición puede ser discutida.
5.3 La sentencia for
La declaración for permite realizar bucles, es decir, permite realizar una acción determinada
varias veces. La mayoría de las veces, un bucle se realiza sobre valores enteros, que van
desde un valor de índice inicial hasta uno final. Veremos, al final de esta sección, que la
declaración for es de hecho mucho más general, ya que permite recorrer los valores de una
matriz.
En el siguiente script de Scilab, mostramos el valor de i, de 1 a 5.
para i = 1 : 5
disp (i) fin
El script anterior produce el siguiente resultado.
1.
2.
3.
4.
5.
En el ejemplo anterior, el bucle se realiza sobre una matriz de números de coma flotante
que contienen valores enteros. De hecho, usamos el operador de dos puntos ”:” para producir
el vector de valores de índice [1 2 3 4 5]. La siguiente sesión muestra que la declaración 1:5
produce todos los valores enteros requeridos en un vector de fila.
--> i = 1:5
yo =
1.
2.
3.
4.
5.
Destacamos que, en el bucle anterior, la matriz 1:5 es una matriz de dobles.
Por lo tanto, la variable i también es un doble. Este punto se revisará más adelante en esta
sección, cuando consideremos la forma general de bucles for.
Podemos usar una forma más completa del operador de dos puntos para mostrar los
números enteros impares del 1 al 5. Para hacer esto, establecemos el paso del operador de
dos puntos en 2. Esto lo realiza el siguiente script de Scilab.
para i = 1 : 2 : 5
disp (i) fin
El script anterior produce el siguiente resultado.
1.
3.
5.
52
Machine Translated by Google
El operador de dos puntos se puede utilizar para realizar bucles hacia atrás. En el siguiente script,
mostramos los números del 5 al 1.
para i = 5 : - 1 : 1
disp (i) fin
El script anterior produce el siguiente resultado.
5.
4.
3.
2.
1.
De hecho, la declaración 5:-1:1 produce todos los números enteros requeridos.
-->i = 5: -1:1
yo =
5.
4.
3.
2.
1.
La declaración for es mucho más general que lo que hemos usado previamente en esta sección.
De hecho, permite navegar a través de los valores de muchos tipos de datos, incluidas matrices de
filas y listas. Cuando realizamos un bucle for sobre los elementos de una matriz, esta matriz puede
ser una matriz de dobles, cadenas, enteros o polinomios.
En el siguiente ejemplo, realizamos un bucle for sobre los valores dobles de una fila
matriz que contiene (1.5, e, ÿ).
v = [1.5 exp (1) %pi ]; para x = v
terminar
(x) fin
El script anterior produce el siguiente resultado.
1.5
2.7182818
3.1415927
Hacemos hincapié ahora en un punto importante sobre la declaración for. Cada vez que usamos
un bucle for, debemos preguntarnos si una declaración vectorizada podría realizar el mismo cálculo.
Puede haber un factor de rendimiento de 10 a 100 entre declaraciones vectorizadas y un bucle for.
La vectorización permite realizar cálculos rápidos, incluso en un entorno interpretado como Scilab.
Esta es la razón por la cual el ciclo for debe usarse solo cuando no hay otra forma de realizar el
mismo cálculo con funciones vectorizadas.
5.4 La sentencia while
La declaración while permite realizar un bucle mientras una expresión booleana es verdadera.
Al comienzo del ciclo, si la expresión es verdadera, se ejecutan las declaraciones en el cuerpo del
ciclo. Cuando la expresión se vuelve falsa (un evento que debe ocurrir en un momento determinado),
el ciclo finaliza.
En el siguiente script, calculamos la suma de los números i del 1 al 10 con
una declaración de tiempo.
53
Machine Translated by Google
s = 0 yo
=1
mientras que ( yo <= 10 ) s = s
+ yo
yo = yo + 1
final
Al final del algoritmo, los valores de las variables i y s son:
s=
55.
yo =
11
Debe quedar claro que el ejemplo anterior es solo un ejemplo de la instrucción while. Si
realmente quisiéramos calcular la suma de los números del 1 al 10, deberíamos usar la función de
suma, como en la siguiente sesión.
--> suma (1:10)
respuesta =
55.
La declaración while tiene el mismo problema de rendimiento que la declaración for. Esta es la
razón por la cual las declaraciones vectorizadas deben considerarse primero, antes de intentar
diseñar un algoritmo basado en un ciclo while.
5.5 Las sentencias break y continue
La sentencia break permite interrumpir un bucle. Por lo general, usamos esta declaración en bucles
donde, una vez que se cumple alguna condición, los bucles no deben continuar.
En el siguiente ejemplo, usamos la instrucción break para calcular la suma de los números
enteros del 1 al 10. Cuando la variable i es mayor que 10, el bucle se interrumpe.
s=0i=
1 mientras
( %t )
si ( i > 10 ) entonces
descanso
final
s = s + yo
yo = yo + 1
final
Al final del algoritmo, los valores de las variables i y s son:
s=
55.
yo =
11
La sentencia continue permite pasar al siguiente bucle, de modo que las sentencias en el
cuerpo del bucle no se ejecutan esta vez. Cuando se ejecuta la declaración de continuación, Scilab
omite las otras declaraciones y va directamente a la declaración while o for y evalúa el siguiente
bucle.
54
Machine Translated by Google
En el siguiente ejemplo, calculamos la suma s = 1 + 3 + 5 + 7 + 9 = 25. La función módulo(i,2) devuelve
0 si el número i es par. En esta situación, el guión pasa al siguiente bucle.
s=0
yo = 0
mientras (yo < 10)
yo = yo + 1
si (módulo (yo
,
2 ) == 0 ) entonces
Seguir
final
s = s + yo
final
Si se ejecuta el script anterior, los valores finales de las variables i y s son:
-->s
s=
25
--> yo
yo =
10
Como ejemplo de cálculo vectorizado, el algoritmo anterior se puede realizar en una sola llamada de
función. De hecho, el siguiente script usa la función de suma, combinada con el operador de dos puntos ”:” y
produce el mismo resultado.
s = suma (1:2:10);
El script anterior tiene dos ventajas principales sobre el algoritmo basado en while.
1. El cálculo utiliza un lenguaje de nivel superior, que es más fácil de entender
comprensión de los seres humanos.
2. Con matrices grandes, el cálculo basado en la suma será mucho más rápido que el algoritmo basado
en while.
Es por esto que se debe hacer un análisis cuidadoso antes de desarrollar un algoritmo basado en un ciclo
while.
6 funciones
En esta sección, presentamos las funciones de Scilab. Analizamos la forma de definir una nueva función y el
método para cargarla en Scilab. Presentamos cómo crear y cargar una biblioteca, que es una colección de
funciones. También presentamos cómo administrar los argumentos de entrada y salida. Finalmente,
presentamos cómo depurar una función usando la declaración de pausa.
6.1 Resumen
Reunir varios pasos en una función reutilizable es una de las tareas más comunes de un desarrollador de
Scilab. La secuencia de llamada más simple de una función es la siguiente:
outvar = mifuncion ( invar )
55
Machine Translated by Google
donde la siguiente lista presenta las diversas variables utilizadas en la sintaxis:
• myfunction es el nombre de la función,
• invar es el nombre de los argumentos de entrada,
• outvar es el nombre de los argumentos de salida.
Los valores de los argumentos de entrada no son modificados por la función, mientras que los valores
de los argumentos de salida son modificados por la función.
De hecho, ya hemos cumplido varias funciones en este documento. La función del pecado,
en la sentencia y=sin(x), toma el argumento de entrada x y devuelve el resultado en la
argumento de salida y. En el vocabulario de Scilab, los argumentos de entrada se denominan derecho
lado de la mano y los argumentos de salida se llaman el lado de la mano izquierda.
Las funciones pueden tener un número arbitrario de argumentos de entrada y salida de modo que
la sintaxis completa para una función que tiene un número fijo de argumentos es la
siguiendo:
[o1 , ... ,
, ... ,
en ] = mifuncion ( i1
en )
Los argumentos de entrada y salida están separados por comas ”,”. Observe que la entrada
argumentos están rodeados por paréntesis de apertura y cierre, mientras que la salida
los argumentos están rodeados por corchetes de apertura y cierre.
En la siguiente sesión de Scilab, mostramos cómo calcular la descomposición LU
de la matriz de Hilbert. La siguiente sesión muestra cómo crear una matriz con el
función testmatrix, que toma dos argumentos de entrada y devuelve una matriz.
Luego, usamos la función lu, que toma un argumento de entrada y devuelve dos o
tres argumentos dependiendo de las variables de salida proporcionadas. Si el tercer argumento
Se proporciona P, se devuelve la matriz de permutación.
-->A = matriz de prueba ( " " ,2)hila A
=
4.
- 6.
- 6.
12
-- >[LU , U] = lu (A)
=
12
- 6.
2.
0.
L=
- 0.6666667
1.
1.
0.
P] = lu (A)
-- >[L ,U ,
PAG =
1.
0.
1.
0.
tu =
12
- 6.
2.
0.
L=
1.
- 0.6666667
0.
1.
Observe que el comportamiento de la función lu en realidad cambia cuando tres salidas
se proporcionan argumentos: las dos filas de la matriz L se han intercambiado. Más
56
Machine Translated by Google
función
función final
abre una definición de función
cierra una definición de función
argn
número de argumentos de entrada/salida en una llamada de función
números variables de argumentos en una lista de argumentos de entrada
varargin
varargoutnúmeros variables de argumentos en una lista de argumentos de salida
fun2string genera una definición ASCII de una función scilab
get_function_path obtener la ruta del archivo fuente de una función de biblioteca
getd
head_comentarios
funciones de lista
obtener todas las funciones definidas en un directorio
macrovar
variables de función
mostrar los comentarios del encabezado de la función Scilab
propiedades de todas las funciones en el espacio de trabajo
Figura 29: Funciones de Scilab para gestionar funciones.
específicamente, cuando se proporcionan dos argumentos de salida, la descomposición A = LU es
proporcionada (la declaración AL*U permite verificar esto). Cuando tres argumentos de salida
se proporcionan, se realizan permutaciones para que la descomposición PA = LU sea
siempre (la declaración P*AL*U se puede utilizar para comprobar esto). De hecho, cuando dos
se proporcionan argumentos de salida, las permutaciones se aplican en la matriz L. Este
significa que la función lu sabe cuántos argumentos de entrada y salida se le proporcionan y cambia su
algoritmo en consecuencia. No presentaremos en este
documentar cómo proporcionar esta función, es decir, un número variable de entrada o salida
argumentos Pero debemos tener en cuenta que esto es posible en el lenguaje Scilab.
Los comandos provistos por Scilab para administrar funciones se presentan en la figura 29.
En las siguientes secciones, presentaremos algunos de los comandos más utilizados.
6.2 Definición de una función
Para definir una nueva función, usamos las palabras clave function y endfunction de Scilab.
En el siguiente ejemplo, definimos la función myfunction, que toma la entrada
argumento x, lo multiplica por 2 y devuelve el valor en el argumento de salida y.
funcion y = mifuncion ( x )
y=2*x
función final
La función de declaración y = myfunction ( x ) es el encabezado de la función
mientras que el cuerpo de la función está hecho del enunciado y = 2 * x. el cuerpo de un
La función puede contener una, dos o más sentencias.
Hay al menos tres posibilidades para definir la función anterior en Scilab.
• La primera solución es escribir el script directamente en la consola de forma interactiva.
modo. Tenga en cuenta que, una vez que la instrucción "función y = mifunción ( x )"
se ha escrito y se ha escrito la tecla Intro, Scilab crea una nueva línea en
la consola, esperando el cuerpo de la función. Cuando la "función final"
se escribe una declaración en la consola, Scilab vuelve a su edición normal
modo.
57
Machine Translated by Google
• Otra solución está disponible cuando el código fuente de la función se proporciona en un archivo.
Este es el caso más común, ya que las funciones son generalmente bastante largas y
complicadas. Simplemente podemos copiar y pegar la definición de la función en la consola.
Cuando la definición de la función es corta (típicamente, una docena de líneas de código
fuente), esta forma es muy conveniente. Con el editor, esto es muy fácil, gracias a la función
Cargar en Scilab.
• También podemos usar la función exec. Consideremos un sistema Windows donde
la función anterior está escrita en el archivo ”C:\myscripts\examples-functions.sce”.
La siguiente sesión da un ejemplo del uso de exec para cargar la función anterior.
--> exec ( "C :\ misscripts \ ejemplos-funciones . sce " ) --> función y =
mifunción ( x ) --> y = 2 * x --> función final
La función exec ejecuta el contenido del archivo como si estuviera escrito de forma interactiva
en la consola y muestra las diversas declaraciones de Scilab, línea tras línea.
El archivo puede contener una gran cantidad de código fuente, por lo que la salida puede ser
muy larga e inútil. En estas situaciones, agregamos el carácter de punto y coma ”;” al final de
la línea. Esto es lo que realiza la función Ejecutar archivo en Scilab del editor.
--> exec("C:\ myscripts\examples-functions. sce");
Una vez que se define una función, se puede usar como si fuera cualquier otra función de Scilab.
--> exec("C:\ myscripts\examples-functions. sce"); -->y = mifuncion ( 3 )
y = 6.
Observe que la función anterior establece el valor del argumento de salida y, con la instrucción
y=2*x. Esto es obligatorio. Para verlo, definimos en el siguiente script una función que establece la
variable z, pero no el argumento de salida y.
funcion y = mifuncion ( x )
z=2*x
función final
En la siguiente sesión, intentamos usar nuestra función con el argumento de entrada x=1.
--> mifuncion ( 1 )
!- - error 4
Variable indefinida: y en la línea
4 de la función myfunction llamada por:
mi función ( 1 )
De hecho, el intérprete nos dice que la variable de salida y no ha sido definida.
Cuando hacemos un cálculo, a menudo necesitamos más de una función para realizar todos los
pasos del algoritmo. Por ejemplo, considere la situación en la que necesitamos optimizar un sistema.
En este caso, podríamos usar un algoritmo proporcionado por Scilab, por ejemplo, optim. Primero,
definimos la función de costo que se va a optimizar, de acuerdo con el formato esperado por optim. En
segundo lugar, definimos un controlador,
58
Machine Translated by Google
que llama a la función optim con los argumentos requeridos. En este esquema simple se utilizan al menos dos
funciones. En la práctica, un cálculo completo suele requerir una docena de funciones o más. En este caso, podemos
recopilar nuestras funciones en una biblioteca y este es el tema de la siguiente sección.
6.3 Bibliotecas de funciones
Una biblioteca de funciones es una colección de funciones definidas en el lenguaje Scilab y almacenadas en un
conjunto de archivos.
Cuando un conjunto de funciones es simple y no contiene ayuda ni código fuente en un lenguaje compilado
como C/C++ o Fortran, una biblioteca es una forma muy eficiente de proceder. En cambio, cuando diseñamos un
componente de Scilab con pruebas unitarias, páginas de ayuda y scripts de demostración, desarrollamos un módulo.
Desarrollar un módulo es fácil y eficiente, pero requiere un conocimiento más avanzado de Scilab. Además, los
módulos se basan en bibliotecas de funciones, por lo que comprender los primeros permite dominar los segundos.
Los módulos no se describirán en este documento. Aún así, en muchas situaciones prácticas, las bibliotecas de
funciones permiten administrar de manera eficiente colecciones simples de funciones y es por eso que describimos
este sistema aquí.
En esta sección, describimos una biblioteca muy simple y mostramos cómo cargarla automáticamente.
automáticamente en el inicio de Scilab.
Hagamos un breve resumen del proceso de creación y uso de una biblioteca. Nosotros
supongamos que se nos proporciona un conjunto de archivos .sci que contienen funciones.
1. Creamos una versión binaria de los scripts que contienen las funciones. La función genlib genera versiones
binarias de los scripts, así como archivos de indexación adicionales.
2. Cargamos la biblioteca en Scilab. La función lib permite cargar una biblioteca
almacenado en un directorio particular.
Antes de analizar un ejemplo, consideremos algunas reglas generales que deben seguirse cuando diseñamos
una biblioteca de funciones. Estas reglas se revisarán en el siguiente ejemplo.
Los nombres de archivos que contienen definiciones de funciones deben terminar con la extensión .sci. Esto
no es obligatorio, pero ayuda a identificar los scripts de Scilab en un disco duro.
Se pueden almacenar varias funciones en cada archivo .sci, pero solo la primera estará disponible desde fuera
del archivo. De hecho, la primera función del archivo se considera la única función pública, mientras que las otras
funciones son (implícitamente) funciones privadas.
El nombre del archivo .sci debe ser el mismo que el nombre de la primera función del archivo. Por ejemplo, si la
función se llamará myfun, entonces el archivo que contiene esta función debe ser myfun.sci. Esto es obligatorio para
que la función genlib funcione correctamente.
Las funciones que permiten gestionar bibliotecas se presentan en la figura 30.
Ahora daremos un pequeño ejemplo de una biblioteca en particular y daremos algunos detalles sobre cómo
proceder realmente.
Supongamos que usamos un sistema Windows y que el directorio samplelib contiene dos archivos:
59
Machine Translated by Google
biblioteca de compilación genlib a partir de funciones en un directorio dado
definición de biblioteca lib
Figura 30: Comandos de Scilab para administrar funciones.
• C:/samplelib/función1.sci:
función y = función1 ( x )
y = 1 * function1_support ( x ) función de función
final y = function1_support ( x ) y = 3 * x función final
• C:/samplelib/function2.sci:
función y = función2 ( x ) y = 2 * x función final
En la siguiente sesión, generamos los archivos binarios con la función genlib, que toma como primer
argumento una cadena asociada al nombre de la biblioteca, y toma como segundo argumento el
nombre del directorio que contiene los archivos. Tenga en cuenta que solo las funciones function1 y
function2 están disponibles públicamente: la función function1_support se puede usar dentro de la
biblioteca, pero no se puede usar fuera.
" ," C :/ muestralib ") -->
--> genlib (" mibiblioteca
mibiblioteca
mylibrary = Ubicación
de los archivos de funciones: C:\samplelib\. función1 función2
La función genlib genera los siguientes archivos en el directorio ”C:/samplelib”:
• function1.bin: la versión binaria del script function1.sci,
• function2.bin: la versión binaria del script function2.sci,
• lib: una versión binaria de la biblioteca,
• nombres: un archivo de texto que contiene la lista de funciones en la biblioteca.
Los archivos binarios *.bin y el archivo lib son multiplataforma en el sentido de que funcionan igual de
bien en Windows, Linux o Mac.
Una vez que se ha ejecutado la función genlib, las dos funciones están disponibles de inmediato,
como se detalla en el siguiente ejemplo.
--> función1 (3)
respuesta =
9.
--> función2 (3)
respuesta =
6.
60
Machine Translated by Google
Sin embargo, en situaciones prácticas, no generaríamos la biblioteca cada vez que se necesita.
Una vez que la biblioteca esté lista, nos gustaría cargar la biblioteca directamente. Esto se hace con
la función lib, que toma como primer argumento el nombre del directorio que contiene la biblioteca y
devuelve la biblioteca, como en la siguiente sesión.
--> mibiblioteca = lib (" C :\ samplelib \")
respuesta =
Ubicación de los archivos de funciones: C:\samplelib\.
funcion1
funcion2
Si hay muchas bibliotecas, puede ser un inconveniente cargar manualmente todas las bibliotecas
al inicio. En la práctica, la instrucción lib se puede escribir de una vez por todas, en el archivo de inicio
de Scilab, de modo que la biblioteca esté disponible inmediatamente al inicio. El directorio de inicio
asociado con una instalación de Scilab en particular se almacena en la variable SCIHOME, como se
presenta en la siguiente sesión, por ejemplo en Windows.
--> SCIHOME
SCIHOME =
C:\Usuarios\nombre de usuario\AppData\Roaming\Scilab\scilab -5.2.0
En el directorio asociado con la variable SCIHOME, el archivo de inicio es .scilab.
Scilab lee automáticamente el archivo de inicio al inicio. Debe ser un script Scilab regular (puede
contener comentarios válidos). Para que nuestra biblioteca esté disponible al inicio, simplemente
escribimos las siguientes líneas en nuestro archivo .scilab.
// Cargar mi biblioteca favorita. mibiblioteca =
lib (" C :/ muestralib /")
Con este archivo de inicio, las funciones definidas en la biblioteca están disponibles directamente
en el inicio de Scilab.
6.4 Gestión de argumentos de salida
En esta sección, presentamos las diversas formas de administrar los argumentos de salida. Una
función puede tener cero o más argumentos de entrada y/o salida. En el caso más simple, el número
de argumentos de entrada y salida está predefinido y usar esta función es fácil. Pero, como veremos,
incluso una función tan simple puede llamarse de varias formas.
Suponga que la función simplef se define con 2 argumentos de entrada y 2 argumentos de salida,
como sigue.
,
función [ y1 , y2 ] = simplef ( x1
y1 = 2 * x1 y2 = 3
* x2
función final
x2)
De hecho, el número de argumentos de salida de dicha función puede ser 0, 1 o 2.
Cuando no hay ningún argumento de salida, el valor del primer argumento de salida se almacena en
la variable ans. También podemos establecer la variable y1 solamente. Finalmente, podemos usar
todos los argumentos de salida, como se esperaba. La siguiente sesión presenta todas estas llamadas
secuencias.
--> simplef ( 1
,
2)
respuesta =
2.
61
Machine Translated by Google
whereami mostrar el árbol de llamadas de instrucciones actual
where
obtener el árbol de llamadas de instrucciones actual
Figura 31: Comandos de Scilab asociados con la pila de llamadas.
--> y1 = simplef ( 1 y1 = 2.
,
2)
-- >[y1 , y2 ] = simplef ( 1 y2 = 6. y1 = 2.
,
2)
Hemos visto que la forma más básica de definir funciones ya permite gestionar un número variable de
argumentos de salida. Existe una forma aún más flexible de gestionar un número variable de argumentos de
entrada y salida, basada en las variables argn, varargin y varargout. Este tema más avanzado no se detallará
en este documento.
6.5 Niveles en la pila de llamadas
Obviamente, las llamadas a funciones se pueden anidar, es decir, una función f puede llamar a una función g,
que a su vez llama a una función hy así sucesivamente. Cuando se inicia Scilab, las variables que se definen
están en el ámbito global. Cuando estamos en una función que se llama desde el ámbito global, estamos un
nivel más abajo en la pila de llamadas. Cuando se producen llamadas a funciones anidadas, el nivel actual en
la pila de llamadas es igual al número de llamadas anidadas anteriores. Las funciones presentadas en la figura
31 permiten consultar el estado de la pila de llamadas.
En la siguiente sesión, definimos 3 funciones que se llaman entre sí y
usamos la función whereami para mostrar el árbol de llamadas de instrucciones actual.
función y = fmain ( x ) y = 2 * flevel1 ( x )
función final
función y = flevel1 ( x ) y = 2 * flevel2 ( x )
función final función y = flevel2 ( x ) y =
2 * x dondeami ()
función final
Cuando llamamos a la función fmain, se produce el siguiente resultado. Como vemos, se muestran los 3
niveles de la pila de llamadas, asociados a la función correspondiente.
--> fmain (1)
donde llamé en la línea 3 de la macro flevel2 flevel2 llamé en la línea 2
de la macro flevel1 flevel1 llamé en la línea 2 de la macro fmain
respuesta =
62
Machine Translated by Google
8.
En el ejemplo anterior, los distintos niveles de llamada son los siguientes:
• nivel 0: el nivel global,
• nivel -1: el cuerpo de la función fmain,
• level -2 : el cuerpo de la función flevel1,
• level -3 : el cuerpo de la función flevel2.
Estos niveles de llamada se muestran en el indicador de la consola cuando depuramos de forma
interactiva una función con la declaración de pausa o con puntos de interrupción.
6.6 La declaración de devolución
Dentro del cuerpo de una función, la declaración de retorno permite regresar inmediatamente, es
decir, sale inmediatamente de la función actual. Esta declaración se puede utilizar en los casos en
que el resto del algoritmo no es necesario.
La siguiente función calcula la suma de enteros desde istart hasta iend. En situaciones regulares,
utiliza la función de suma para realizar su trabajo. Pero si la variable istart es negativa o si la
condición istart<=iend no se cumple, la variable de salida y se establece en 0 y la función regresa
inmediatamente.
función y = mysum ( istart si ( istart < 0 )
entonces y = 0
,
amigo)
devolver
final
si ( iend < istart ) entonces y = 0 return
final
y = suma ( istart : iend ) función final
La siguiente sesión permite comprobar que la función mysum utiliza correctamente la sentencia
return.
--> misuma ( 1
5)
,
respuesta =
15.
,
--> misuma ( -1
5)
respuesta =
0.
--> misuma ( 2
,
1)
respuesta =
0.
Algunos desarrolladores afirman que usar varias declaraciones de retorno en una función es
generalmente una mala práctica. De hecho, debemos tener en cuenta la mayor dificultad de depurar
una función de este tipo, porque el algoritmo puede abandonar repentinamente el cuerpo de la
función. El usuario puede confundirse acerca de qué causó exactamente que la función regresara.
63
Machine Translated by Google
pausa esperar entrada de usuario interactiva
reanudar reanudar la ejecución y copiar algunas variables locales
cancelar la evaluación de interrupción
Figura 32: Funciones de Scilab para depurar manualmente una función.
Es por esto que, en la práctica, la declaración de devolución debe usarse con cuidado, y
ciertamente no en todas las funciones. La regla a seguir es que la función debe devolver
sólo en su última línea. Aún así, en situaciones particulares, el uso de retorno puede realmente
simplificar en gran medida el algoritmo, mientras que evitar el retorno requeriría escribir una gran cantidad de
código fuente innecesario.
6.7 Funciones de depuración con pausa
En esta sección, presentamos métodos de depuración sencillos que permiten solucionar los errores más sencillos.
errores de una manera conveniente y eficiente. Más específicamente, presentamos la pausa,
reanudar y abortar sentencias, que se presentan en la figura 32.
Una sesión de Scilab suele consistir en la definición de nuevos algoritmos mediante la creación de nuevas
funciones. A menudo sucede que un error de sintaxis o un error en el
algoritmo produce un resultado incorrecto.
Considere el cálculo del problema de la suma de los números enteros desde istart hasta
amigo Nuevamente, este ejemplo simple se elige con fines de demostración, ya que el
La función sum lo realiza directamente.
La siguiente función mysum contiene un error: el segundo argumento "foo" pasó
a la función de suma no tiene significado en este contexto.
function y = mysum ( istart y = sum ( iend :
istart endfunction
,
, amigo)
" Foo
")
La siguiente sesión muestra lo que sucede cuando usamos la función mysum.
10)
,
--> misuma ( 1
!- - error 44
Argumento incorrecto 2.
en línea
2 de la función mysum llamada por:
mi suma ( 1
,
10)
Para encontrar el problema de forma interactiva, colocamos una declaración de pausa dentro del
cuerpo de la función.
,
funcion y = mysum ( istart
pausa
y = suma ( iend : istart endfunction
,
amigo)
" Foo
")
Ahora llamamos a la función mysum nuevamente con los mismos argumentos de entrada.
--> misuma ( 1
Escriba
'-1- >
reanudar
10)
,
'
o
'abortar'
para volver al indicador de nivel estándar.
64
Machine Translated by Google
Ahora estamos ubicados de forma interactiva en el cuerpo de la función mysum. el aviso
”-1->” indica que la pila de llamadas actual está en el nivel -1. Podemos comprobar el valor de
las variables istart y iend simplemente tecleando sus nombres en la consola.
-1- > istart
istart =
1.
-1- > amigo
amigo =
10
Para progresar en nuestra función, podemos copiar y pegar las sentencias y ver
lo que sucede de forma interactiva, como en la siguiente sesión.
-1- >y = suma ( iend : istart y = sum ( iend :
,
istart
" Foo "
)
,
" Foo
")
!- - error 44
Argumento incorrecto 2.
Podemos ver que la llamada a la función suma no se comporta como cabría esperar.
El argumento de entrada "foo" es definitivamente un error: lo eliminamos.
-1- >y = suma ( iend : istart )
y=
0.
Después de la primera revisión, la llamada a la función de suma ahora es sintácticamente correcta. Pero
el resultado sigue siendo erróneo, ya que el resultado esperado en este caso es 55. Vemos que
las variables istart e iend se han intercambiado. Corregimos la llamada a la función y
comprobar que la versión fija se comporta como se esperaba
-1- >y = suma ( istart : iend )
y=
55.
El resultado ahora es correcto. Para volver al nivel cero, ahora usamos el
instrucción abort, que interrumpe la secuencia e inmediatamente vuelve a la
nivel global.
-1- > abortar
-->
El mensaje "-->" confirma que ahora estamos de vuelta en el nivel cero en la pila de llamadas.
Arreglamos la definición de la función, que se convierte en:
,
funcion y = mysum ( istart
pausa
y = suma ( istart : iend )
función final
amigo)
Para verificar nuestra corrección de errores, llamamos a la función nuevamente.
--> misuma ( 1
Escriba
'-1- >
reanudar
10)
,
'
o
'abortar'
para volver al indicador de nivel estándar.
Ahora estamos seguros de nuestro código, por lo que usamos la instrucción resume, que
permite que Scilab ejecute el código como de costumbre.
sesenta y cinco
Machine Translated by Google
--> misum ( 1 -1- >
reanudar
,
10)
respuesta =
55.
El resultado es correcto. Todo lo que tenemos que hacer es eliminar la declaración de pausa de la
definición de la función.
,
función y = mysum ( istart y = sum ( istart :
iend ) endfunction
amigo)
En esta sección, hemos visto que, usadas en combinación, las sentencias pause, resume y
abort son una forma muy efectiva de depurar una función de forma interactiva. De hecho, nuestro
ejemplo es muy simple y el método que presentamos puede parecer demasiado simple para ser
conveniente. Este no es el caso. En la práctica, la declaración de pausa ha demostrado ser una
forma muy rápida de encontrar y corregir errores, incluso en situaciones muy complejas.
7 Trazado
Producir diagramas y gráficos es una tarea muy común para analizar datos y crear informes. Scilab
ofrece muchas formas de crear y personalizar varios tipos de diagramas y gráficos. En esta sección,
presentamos cómo crear gráficos 2D y gráficos de contorno. Luego personalizamos el título y la
leyenda de nuestros gráficos. Finalmente exportamos los gráficos para poder usarlos en un informe.
7.1 Resumen
Scilab puede producir muchos tipos de gráficos 2D y 3D. Puede crear gráficos xy con la función de
gráfico, gráficos de contorno con la función de contorno, gráficos 3D con la función de surf,
histogramas con la función histplot y muchos otros tipos de gráficos.
Las funciones gráficas más utilizadas se presentan en la figura 33.
Para obtener un ejemplo de un gráfico 3D, simplemente podemos escribir la instrucción surf()
en la consola de Scilab.
--> navegar ()
Durante la creación de un gráfico, utilizamos varias funciones para crear los datos o configurar
el gráfico. Las funciones que se presentan en la figura 34 se utilizarán en los ejemplos de esta
sección.
7.2 Gráfico 2D
En esta sección, presentamos cómo producir una gráfica xy simple. Hacemos hincapié en el uso de
funciones vectorizadas, que permiten producir matrices de datos en una llamada de función.
Comenzamos definiendo la función que se va a graficar. La función myquadratic eleva al cuadrado
el argumento de entrada x con el operador ”ˆ”.
función f = myquadratic ( x ) f = x ^2 función final
66
Machine Translated by Google
navegar
trama 2D
por la trama
trama 3D
contorno
dibujo de contorno
Gráfico circular
histograma de histplot circular
bar
gráfico de barras
barh
gráfico de barras horizontales
hist3d
histograma 3D
polarplot trazar coordenadas polares
Matplot Gráfico 2D de una matriz usando colores
Sgrayplot gráfico 2D suave de una superficie usando colores
grayplot Trazado 2D de una superficie usando colores
Figura 33: Funciones gráficas de Scilab
linspace vector espaciado linealmente
fiesta
evalúa una función en una grilla
título de
la leyenda
configurar la leyenda de la trama actual
xtitulo
configurar el título y las leyendas de la trama actual
configurar el título de la trama actual
Figura 34: Funciones de Scilab utilizadas al crear un gráfico.
Podemos usar la función linspace para producir 50 valores en el intervalo
[1, 10].
datos x = espacio lineal ( 1
,
10
, 50);
La variable xdata ahora contiene un vector de fila con 50 entradas, donde el primer valor
es igual a 1 y el último valor es igual a 10. Podemos pasarlo a myquadratic
función y obtener el valor de la función en los puntos dados.
ydata = myquadratic ( xdata );
Esto produce el vector de fila ydata, que contiene 50 entradas. Finalmente usamos el
plot para que los datos se muestren como un gráfico xy.
trazar (xdatos
, ydatos )
La Figura 35 presenta la gráfica xy asociada.
Observe que podríamos haber producido la misma gráfica sin generar el arreglo intermedio ydata. De
hecho, el segundo argumento de entrada de la función plot puede
ser una función, como en la siguiente sesión.
trazar (xdatos
, micuadrática )
Cuando el número de puntos a gestionar es grande, utilizando directamente la función permite
ahorra una cantidad significativa de espacio de memoria, ya que evita generar el intermediario
datos vectoriales.
67
Machine Translated by Google
100
90
80
70
60
50
40
30
20
10
0
1
2
3
4
5
6
7
8
9
10
Figura 35: Un gráfico xy simple.
7.3 Gráficos de contorno
En esta sección, presentamos las gráficas de contorno de una función multivariada y hacemos
uso de la función de contorno. Este tipo de gráficos se usa a menudo en el contexto de la
optimización numérica, ya que permiten dibujar funciones de dos variables de una manera
que hace evidente la ubicación del óptimo.
Supongamos que tenemos la función f con n variables f(x) = f(x1, . . . , xn) y x ÿ R n . Para
un ÿ ÿ R dado, la ecuación
f(x) = ÿ,
(2)
define una superficie en el espacio dimensional (n + 1) R n+1 .
Cuando n = 2, los puntos z = f(x1, x2) representan una superficie en el tridimensional. Esto
espacio (x1, x2, z) ÿ R 3 permite dibujar gráficos de contorno de la función de costo, como
vamos a ver. Sin embargo, para n > 3, estas gráficas no están disponibles. Una posible
solución en este caso es seleccionar dos parámetros significativos y dibujar un gráfico de
contorno con estos parámetros variando (únicamente).
La función de contorno de Scilab permite trazar los contornos de una función f. La función
de contorno tiene la siguiente sintaxis
contorno (x, y, z, nz)
dónde
• x (resp. y) es un vector fila de valores x (resp. y) con tamaño n1 (resp. n2),
• z es una matriz real de tamaño (n1,n2), que contiene los valores de la función o una
Función de Scilab que define la superficie z=f(x,y),
• nz los valores de nivel o el número de niveles.
68
Machine Translated by Google
1.0
1.64
1,45
1,27
1,09
0.8
1.45
1.27
1.09
0.6
0.4
0.2
0,727 0,545
0,364 0,182
0.0
-0.2
-0.4
-0.6
1.09
1.27
1.45
1.64
1.82
-0.8
1.09
1.27
1.45
-1.0
-1.0
-0.8
-0.6
-0.4
-0.2
0.0
0.2
0.4
0.6
0.8
1.0
2
1
Figura 36: Gráfico de contorno de la función f(x1, x2) = x
+x
2
2.
En la siguiente sesión de Scilab, usamos una forma simple de la función de contorno,
donde la función myquadratic se pasa como argumento de entrada. el micuadrático
2
1
la función toma dos argumentos de entrada x1 y x2 y devuelve f(x1, x2) = x
+x
2
2.
La función linspace se usa para generar vectores de datos para que la función sea
analizado en el rango [ÿ1, 1]2 .
,
función f = myquadratic2arg ( x1
f = x1 **2 + x2 **2;
función final
x2)
, 1 , 100);
xdata = linspace ( -1 ydata =
, 1 , 100);
linspace ( -1 contorno ( xdata
, ydata , myquadratic2arg ,
10)
Esto produce el gráfico de contorno presentado en la figura 36.
En la práctica, puede suceder que nuestra función tenga el encabezado z = myfunction
( x ), donde la variable de entrada x es un vector fila. El problema es que solo hay
un solo argumento de entrada, en lugar de los dos argumentos requeridos por el contorno
función. Hay dos posibilidades para solucionar este pequeño problema:
• proporcionar los datos a la función de contorno haciendo dos bucles anidados,
• proporcionar los datos a la función de contorno utilizando feval,
• definir una nueva función que llame a la primera.
Estas tres soluciones se presentan en esta sección. El primer objetivo es dejar que el lector
elegir el método que mejor se adapte a la situación. El segundo objetivo es demostrar que
Los problemas de rendimiento se pueden evitar si se hace un uso constante de las funciones proporcionadas por
Scilab está hecho.
En la siguiente sesión ingenua de Scilab, definimos la función cuadrática myquadratic1arg,
que toma un vector como único argumento de entrada. Luego realizamos dos anidados
69
Machine Translated by Google
1.0
0.8
0.6
0.4
0.7
0.2
0.1
0.3
0.5
0.0
-0.2
-0.4
-0.6
-0.8
-1.0
-1.0
-0.8
-0.6
-0.4
-0.2
0.0
0.2
0.4
Figura 37: Gráfico de contorno de la función f(x1, x2) = x
configurado.
0.6
2
1+x
0.8
1.0
2
2 – Los niveles están explícitamente
bucles para calcular la matriz zdata, que contiene los valores z. Los valores de z son
calculado para todas las combinaciones de puntos (x(i), y(j)) ÿ R
2
, para i = 1, 2, . . . ,
nx
y j = 1, 2, . . . , ny, donde nx y ny son el número de puntos en las coordenadas x e y. Al final, llamamos
a la función de contorno, con la lista de niveles requeridos
(en lugar del número anterior de niveles). Esto permite obtener exactamente los niveles que
desee, en lugar de dejar que Scilab calcule los niveles automáticamente.
función f = myquadratic1arg ( x )
f = x (1)**2 + x (2)**2;
función final
, 1 ,
xdata = espaciolin ( -1 100 );
, 1 ,
ydata = espaciolin ( -1 100 );
esto es malo .
// Precaución ! Dos bucles anidados, para i = 1:
longitud (xdata)
para j = 1: longitud ( ydata )
x = [ xdatos (i ) ydatos (j )]. ';
zdata ( i , j ) = myquadratic1arg ( x );
final
final
zdata
contorno (xdatos
, [0,1 0,3 0,5 0,7])
, ydatos ,
El gráfico de contorno se presenta en la figura 37.
El script anterior funciona perfectamente. Aun así, no es eficiente porque utiliza dos
bucles anidados y esto se debe evitar en Scilab por razones de rendimiento. Otro problema es
que teníamos que almacenar la matriz zdata, que podría consumir mucho espacio de memoria
cuando el número de puntos es grande. Es por esto que este método es para evitar, ya que es
un mal uso de las funciones proporcionadas por Scilab.
En el siguiente script, usamos la función feval, que evalúa una función
en una cuadrícula de valores y devuelve los datos calculados. La grilla generada está hecha
2 . Suponemos aquí que hay
de todas las combinaciones de puntos (x(i), y(j)) ÿ R
70
Machine Translated by Google
no hay posibilidad de modificar la función myquadratic1arg, que toma una entrada
argumento. Por lo tanto, creamos una función intermedia myquadratic3, que toma
2 argumentos de entrada. Una vez hecho esto, pasamos el argumento myquadratic3 al feval
función y generar la matriz zdata.
función f = myquadratic1arg ( x )
f = x (1)**2 + x (2)**2;
función final
función f = myquadratic3 ( x1 f = myquadratic1arg
( [ x1 x2 ]
función final
,
,
xdata = espaciolin ( -1 100 );
, 11 ,
ydata = espaciolin ( -1 100 );
zdata = feval ( xdata , ydata , myquadratic3 );
contorno (xdata, ydata, zdata [0.1 0.3 0.5 0.7])
x2)
,
)
,
El guión anterior produce, por supuesto, exactamente la misma trama que antes. Este
El método también debe evitarse cuando sea posible, ya que requiere almacenar la matriz zdata,
que tiene un tamaño de 100 × 100.
Finalmente, hay una tercera forma de crear la trama. En la siguiente sesión de Scilab,
usamos la misma función intermedia myquadratic3 que antes, pero la pasamos
directamente a la función de contorno.
función f = myquadratic1arg ( x )
f = x (1)**2 + x (2)**2;
función final
, x2)
función f = myquadratic3 ( x1 f = myquadratic1arg
)
( [ x1 x2 ]
función final
, 1 , 100);
xdata = linspace ( -1 ydata =
, 1 , 100);
linspace ( -1 contorno ( xdata
, ydata , myquadratic3 ,
[0,1 0,3 0,5 0,7])
El guión anterior produce, por supuesto, exactamente la misma trama que antes. los
La principal ventaja es que no producimos la matriz zdata.
Hemos resumido brevemente cómo producir gráficos 2D simples. ahora estamos interesados
en la configuración de la trama, de modo que los títulos, ejes y leyendas correspondan a
nuestros datos.
7.4 Títulos, ejes y leyendas
En esta sección, presentamos las características gráficas de Scilab que permiten configurar el
título, ejes y leyendas de un gráfico xy.
En el siguiente ejemplo, definimos una función cuadrática y la representamos con el
función de trama.
función f = micuadrática ( x )
f = x.^2
función final
xdata = espaciolin ( 1 50 );
ydata = myquadratic ( xdata );
trazar (xdatos, ydatos)
,
10
,
Ahora tenemos el gráfico que se presenta en la figura 35.
71
Machine Translated by Google
Mi título
100
90
80
70
60
50
eje
Y
40
30
20
10
0
1
2
4
3
5
7
6
8
9
10
eje x
Figura 38: La gráfica xy de una función cuadrática – Esta es la misma gráfica que en la figura 35,
con título y ejes xy configurados.
El sistema de gráficos Scilab se basa en controladores de gráficos. Los identificadores de gráficos
proporcionan un acceso orientado a objetos a los campos de una entidad gráfica. El diseño de gráficos
se descompone en subobjetos como la línea asociada a la curva, la x y
y ejes, el título, las leyendas, etc. Cada objeto se puede descomponer a su vez
en otros objetos si es necesario. Cada objeto gráfico está asociado con una colección.
de propiedades, como el ancho o el color de la línea de la curva, por ejemplo. Estas
las propiedades se pueden consultar y configurar simplemente obteniendo o configurando sus valores,
como cualquier otra variable de Scilab. La gestión de los identificadores es fácil y muy eficiente.
Pero la mayoría de las configuraciones básicas de gráficos se pueden realizar mediante simples llamadas a funciones y, en
En esta sección, nos centraremos en estas características básicas.
En el siguiente script, usamos la función de título para configurar el título
de nuestra parcela.
título ( "
Mi título " );
Es posible que también queramos configurar los ejes de nuestra trama. Para este propósito, utilizamos
la función xtitle en el siguiente script.
xtítulo (
"
"
Mi título
,
" eje x
"
,
"Eje Y
");
La Figura 38 presenta la trama producida.
Puede suceder que queramos comparar dos conjuntos de datos en el mismo gráfico 2D,
es decir, un conjunto de datos x y dos conjuntos de datos y. En el siguiente script, definimos
las dos funciones f(x) = x
2
2
y f(x) = 2x
y grafique los datos en el mismo gráfico xy.
Además, usamos las opciones ”+-” y ”o-” de la función de trazado, para que podamos
2
2.
distinguir las dos curvas f(x) = x
y f(x) = 2x
función f = micuadrática ( x )
f=x^2
función final
función f = myquadratic2 ( x )
72
Machine Translated by Google
Mi título
200
x^2
2x^2
180
160
140
120
100
eje
Y
80
60
40
20
0
1
2
3
4
5
7
6
8
9
10
eje x
Figura 39: El gráfico xy de dos funciones cuadráticas – Hemos configurado la leyenda
2
para que podamos distinguir las dos funciones f(x) = x
y f(x) = 2x
2.
f = 2 * x^2
función final
, 10 ,
xdata = espaciolin ( 1 50 );
ydata = myquadratic ( xdata );
parcela (xdatos "+ -", ydata
)
,
ydata2 = myquadratic2 ( xdata );
trama (xdatos "o -" ) , ydata2 , xtitulo
"
"
" eje x
(
,
Mi título
"
,
"Eje Y
");
Además, debemos configurar una leyenda para saber qué curva está asociada a f(x) = x
2
y qué curva está asociada con f(x) = 2x
2.
Para esto
propósito, usamos la función de leyenda para imprimir la leyenda asociada con
cada curva.
leyenda ("x ^2"
,
"2x^2");
La Figura 39 presenta la gráfica xy producida.
Ahora sabemos cómo crear un gráfico y cómo configurarlo. Si la trama
es lo suficientemente interesante, puede valer la pena ponerlo en un informe. Para hacerlo, podemos
exporte el gráfico a un archivo, que es el tema de la siguiente sección.
7.5 Exportar
En esta sección, presentamos formas de exportar gráficos a archivos, ya sea de forma interactiva o
automáticamente con las funciones de Scilab.
Scilab puede exportar cualquier gráfico a los formatos vectoriales y de mapa de bits presentados
en la figura 40. Una vez que se produce un gráfico, podemos exportar su contenido a un archivo, usando
interactivamente el menú Archivo > Exportar a... de la ventana gráfica. Entonces podemos establecer
el nombre del archivo y su tipo.
73
Machine Translated by Google
vectorial
xs2png
exportar a PNG
xs2pdf
exportar a PDF
xs2svg
exportar a SVG
xs2eps
exportar a PostScript Encapsulado
xs2ps
xs2emf
exportar a Postscript
exportar a EMF (solo para Windows)
mapa de bits
xs2fig
exportar a FIG
xs2gif
exportar a GIF
xs2jpg
exportar a JPG
xs2bmp
exportar a BMP
xs2ppm
exportar a PPM
Figura 40: Funciones de exportación.
Alternativamente, podemos usar las funciones xs2*, presentadas en la figura 40. Todas estas
Las funciones se basan en la misma secuencia de llamada:
,
xs2png ( número_ventana
Nombre del archivo )
donde window_number es el número de la ventana de gráficos y filename es el
nombre del archivo a exportar. Por ejemplo, la siguiente sesión exporta el gráfico que
está en la ventana gráfica número 0, que es la ventana gráfica predeterminada, en la
archivo foo.png.
xs2png ( 0
,
"
foo png
")
Si queremos producir documentos de mayor calidad, los formatos vectoriales deben ser
preferido. Por ejemplo, los documentos LATEX pueden usar gráficos Scilab exportados a PDF
archivos para mejorar su legibilidad, sea cual sea el tamaño del documento.
8 Notas y referencias
Hay una serie de temas que no se han presentado en este documento. Nosotros
Espero que el documento actual sea un buen punto de partida para usar Scilab para que
aprender sobre estos temas específicos no debería ser un problema. Ya hemos mencionado una serie
de otras fuentes de documentación para este propósito al principio.
de este documento.
Los lectores franceses pueden estar interesados en [5], donde se da una buena introducción sobre
cómo crear e interactuar con una biblioteca existente, cómo usar Scilab para calcular la
solución de una Ecuación Diferencial Ordinaria, cómo usar Scicos y muchos otros
asignaturas. El mismo contenido se presenta en inglés en [3]. Los lectores ingleses deben ser
interesado por [4], que da una visión más profunda de Scicos. Estos libros son de gran
interés, pero son bastante obsoletos ya que fueron escritos principalmente para versiones anteriores de
Scilab.
Se pueden obtener lecturas adicionales en la cita web de Scilab [6], en la sección de documentación.
74
Machine Translated by Google
9 Agradecimientos
Quisiera agradecer a Claude Gomez, Vincent Couvert, Allan Cornet y Serge Steer que me
permitieron compartir sus comentarios sobre este documento. También agradezco a Julie Paul
y Sylvestre Ledru que me ayudaron durante la redacción de este documento.
También se agradece a Artem Glebov por corregir este documento.
75
Machine Translated by Google
10 respuestas a los ejercicios
10.1 Respuestas para la sección 1.7
Respuesta al ejercicio 1.1 (Instalación de Scilab) Instalemos la versión actual de Scilab en su sistema: en el momento en que se
escribe este documento, esta es Scilab v5.2. Instalar Scilab es muy fácil, ya que se proporcionan binarios. La Figura 41 presenta
los primeros pasos necesarios para instalar Scilab v5.1.1 en Windows.
Respuesta al ejercicio 1.2 (Ayuda en línea: derivada) La función derivada permite calcular la derivada numérica de una función.
El propósito de este ejercicio es encontrar la página de ayuda correspondiente, por varios medios. Abrimos el navegador de
ayuda desde la consola, en el ? > Menú del navegador de ayuda. Ahora seleccionamos el panel de búsqueda a la izquierda y
escribimos derivada, luego presionamos la tecla <Enter>. Se muestran todas las páginas que contienen la palabra derivada. La
primera es la página de ayuda que estamos buscando. También podemos utilizar la ayuda proporcionada en el sitio web de Scilab
http://www.scilab.org/product/man
Usamos la herramienta de búsqueda de nuestro navegador web favorito y buscamos la palabra derivada. Encontramos
sucesivamente las funciones: diff, bsplin3val, derivada, derivat y dlgamma. La página buscada es la siguiente:
http://www.scilab.org/product/man/derivative.html
Finalmente usamos la consola para encontrar la ayuda.
ayuda derivada La Figura
42 presenta la página de ayuda para la derivada.
10.2 Respuestas para la sección 2.6
Respuesta al ejercicio 2.1 (La consola) Escriba la siguiente afirmación en la consola.
átomos
Ahora escriba en la tecla <Tab>. ¿Lo que sucede? Vemos que se despliegan todas las funciones cuyo nombre comienza con
las letras ”átomos”, como se presenta en la figura 43. Ahora teclee la letra ”I”, y teclee de nuevo en <Tab>. Lo que sucede ?
Vemos que se despliegan todas las funciones cuyo nombre comienza con las letras ”atomsI”, tal como se presenta en la figura
44.
Respuesta al Ejercicio 2.2 (Usando exec) La variable SCI contiene el nombre del directorio de la instalación actual de Scilab. La
declaración SCI+"/módulos" crea una cadena que es la concatenación del nombre del directorio Scilab y la cadena "/módulos",
como se muestra en la siguiente sesión.
--> SCI+" / módulos
"
respuesta =
C :/ PROGRA ~1/ SCILAB ~1.0 - B / módulos
Por lo tanto, cuando ejecutamos la instrucción ls(SCI+"/modules"), Scilab muestra la lista de archivos en el subdirectorio de
módulos de Scilab.
--> ls ( SCI +" / módulos " )
respuesta =
! xpad! !
xcos! !
herramientas_windows!
[...]
!
!!!!!
76
Machine Translated by Google
Figura 41: Primeros pasos durante la instalación de Scilab v5.1.1 bajo Windows.
77
Machine Translated by Google
Figura 42: Página de ayuda para la función derivada.
Figura 43: Uso de la finalización para navegar por las funciones de ATOMS.
Figura 44: Uso de la finalización para navegar por las funciones de ATOMS.
78
Machine Translated by Google
Figura 45: El contorno de demostraciónf.dem.sce.
Ejecutar el script de demostración contourf.dem.sce produce el gráfico que se presenta en la figura 45.
La diferencia entre las dos afirmaciones.
exec ( SCI +"/ módulos / gráficos / demos /2 d_3d_plots / contornof . dem . sce ") exec ( SCI +"/ módulos /
gráficos / demos /2 d_3d_plots / contornof . dem . sce " );
es que el segundo termina con un punto y coma ”;”. Usamos este operador para que Scilab no muestre el
contenido del archivo cuando se ejecuta el script, lo cual es conveniente cuando el script contiene muchas líneas.
10.3 Respuestas para la sección 3.13
Respuesta al Ejercicio 3.1 (Precedencia de operadores) El orden de las operaciones cuando se aplican a una
expresión matemática se llama precedencia. Por ejemplo, cuando la expresión 2 × 3 + 4, es equivalente a la
expresión (2 × 3) + 4. La siguiente sesión muestra que la precedencia de los operadores de Scilab es la misma
que la de los operadores matemáticos habituales.
-- >2 * 3 + 4
respuesta =
10.
-- >2 + 3 * 4
respuesta =
14
-- >2 / 3 + 4
respuesta =
4.6666667
-- >2 + 3 / 4
respuesta =
2.75
Respuesta al Ejercicio 3.2 (Paréntesis) Cuando la precedencia de los operadores no permite calcular el resultado
que queremos, se pueden utilizar paréntesis para forzar el orden de las operaciones. En Scilab, podemos usar
los corchetes habituales ”(” y ”)”.
79
Machine Translated by Google
-- >2 * (3 + 4)
respuesta =
14
- - >(2 + 3) * 4
respuesta =
20
- - >(2 + 3) / 4
respuesta =
1.25
-- >3 / (2 + 4)
respuesta =
0.5
Respuesta al Ejercicio 3.3 (Exponentes) Cuando queremos definir constantes con exponentes, como la constante 1.23456789 × 1010,
usamos la letra ”d” para definir el exponente, como en la siguiente sesión.
- - >1.23456789 d10
respuesta =
1.235 D +10
Alternativamente, podemos usar la letra "e", como en la siguiente sesión que calcula las constantes 1.23456789 × 1010 y 1.23456789 ×
10ÿ5 .
- - >1.23456789 e10
respuesta =
1.235 D +10 - >1.23456789 e -5
respuesta =
0.0000123
Respuesta al ejercicio 3.4 (Funciones) La raíz cuadrada se comporta exactamente como se esperaba matemáticamente
para argumentos positivos.
--> sqrt (4)
respuesta =
2.
--> sqrt (9)
respuesta =
3.
Para argumentos negativos x, Scilab devuelve y como la solución compleja de la ecuación x
2
= y.
--> sqrt (-1)
respuesta =
i
--> sqrt (-2)
respuesta =
1.4142136 yo
La función exp es la función exponencial, donde la base e es la constante de Euler. El logaritmo es el logaritmo natural, que es la función
inversa de la función exponencial.
--> exp (1)
respuesta =
2.7182818
--> registro ( exp (2))
respuesta =
80
Machine Translated by Google
2.
--> exp (registro (2))
respuesta =
2.
La función log10 es el logaritmo en base 10. Observe que si x es un número entero, entonces log10(x) es el número de
dígitos decimales de x.
- - >10^2
respuesta =
100.
--> log10 (10^2)
respuesta =
2.
- - >10^ log10 (2)
respuesta =
2.
La función de signo devuelve el signo de su argumento y devuelve cero cuando x es cero.
--> signo (2)
respuesta =
1.
--> signo (-2)
respuesta =
- 1. -> signo (0)
respuesta =
0.
Respuesta al ejercicio 3.5 (Trigonometría) La siguiente sesión es un ejemplo del uso de las funciones cos y sen.
--> porque (0)
respuesta =
1.
--> pecado (0)
respuesta =
0.
Debido a la precisión limitada de los números de coma flotante, el resultado de una función trigonométrica (como
cualquier otra función) está sujeto a redondeo. En la siguiente sesión, la identidad matemática sen(ÿ) = 0 se aproxima
en el mejor de los casos, dada la precisión de la máquina asociada con las variables dobles.
--> coseno ( %pi )
respuesta =
- 1. -> pecado ( %pi )
respuesta =
1.225 D -16 -> coseno ( %pi /4) - sen ( %pi /4)
respuesta =
1.110 D-16
81
Machine Translated by Google
10.4 Respuestas a la sección 4.18
Respuesta al Ejercicio 4.1 (Más uno) Creamos el vector (x1 + 1, x2 + 1, x3 + 1, x4 + 1) con la siguiente x. La
siguiente sesión realiza el cálculo y utiliza el operador de suma habitual "+". En este caso, el escalar 1 se suma a
cada elemento del vector x.
-->x = 1:4; -->y =
x + 1 y = 2.
3.
4.
5.
Respuesta al Ejercicio 4.2 (Multiplicación vectorizada) Creamos el vector (x1y1, x2y2, x3y3, x4y4) con las siguientes x
e y. La siguiente sesión realiza el cálculo y utiliza la operación de multiplicación por elementos ”.*”.
-->x = 1:4; -->y =
5:8; -->z = x .* y
z=
5.
12
21
32.
Respuesta al ejercicio 4.3 (Vectorizado invertido) Vamos a crear el vector después de
1
x1
,
1
x2
,
1
x3
,
1
x4
. los
que la sesión realice el cálculo y utilice la operación de división por elementos ”./”.
-->x = 1:4; -->y =
1 ./x
y = 1.
0.5
0.3333333
0.25
La siguiente sesión no calcula lo que queremos, sino que calcula la solución y de la ecuación xy = 1.
-->y = 1 / x // ¡Esto no es lo que queremos aquí!
y=
0.0333333
0.0666667
0.1
0.1333333
Respuesta al ejercicio 4.4 (División vectorizada) Vamos a crear el vector después de que
x1
y1
,
x2
y2
,
x3
y3
,
x4
y4
la sesión realice el cálculo y utilice la operación de división por elementos ”./”.
-->x = 12*(6:9); -->y = 1:4;
-->z = x ./ y
z=
72.
42.
32.
27
2
x234.
2 , 3,
, x2
Respuesta al ejercicio 4.5 (Elevación al cuadrado vectorizada) Vamos a crear el vector x con x =1 1,
2,
La
, x2
4
siguiente sesión realiza el cálculo y usa la operación de elevación al cuadrado ”.ˆ”.
-->x = 1:4; -->y =
x .^2 y = 1.
4.
9.
dieciséis.
82
. los
Machine Translated by Google
Respuesta al ejercicio 4.6 (Seno vectorizado) Creamos el vector (sin(x1), sin(x2), . . . , sin(x10))
con x ÿ [0, ÿ]. La siguiente sesión realiza el cálculo y utiliza la función linspace.
-->x = espacio lineal (0 , %pi ,10);
-->y = sen (x)
y=
columna 1 a 6
0.
0.3420201
0.6427876
0.8660254
0.9848078
columna 7 a 10
0.8660254
0.6427876
0.3420201
1.225D-16
0.9848078
Respuesta al ejercicio 4.7 (Función vectorizada) Calculemos los valores de y = f(x) de la
función f definida por la ecuación
f(x) = log10 (r/10x + 10x )
con r = 2.220.10ÿ16 para x ÿ [ÿ16, 0]. La siguiente sesión realiza el cálculo y utiliza
el operador de división por elementos ”./”.
r = 2.220 D-16;
x = espacio lineal ( -16 ,0 ,10);
y = log10 (r ./10.^ x + 10.^ x );
Esta función aparece en el cálculo del paso óptimo a utilizar en una derivada numérica. Muestra que el paso
óptimo para usar con una diferencia finita de orden directo es igual a
h=raíz cuadrada(%eps).
Referencias
[1] Atlas: software de álgebra lineal ajustado automáticamente. http://atlas-de-matemáticas.
sourceforge.net.
[2] Cecill y el software libre. http://www.cecil.info.
[3] C Literas, J.-P. Canciller, F. Delebecque, C. Gómez, M. Goursat,
R. Nikoukhah y S. Steer. Ingeniería y Computación Científica con Scilab.
Birkhauser Boston, 1999.
[4] Stephen L. Campbell, Jean-Philippe Chancelier y Ramine Nikoukhah. Modificación
Aprendizaje y Simulación en Scilab/Scicos. Springer, 2006.
[5] J.-P. Chancelier, F. Delebecque, C. Gómez, M. Goursat,
R. Nikoukhah y
´
S. Steer. Introducción `a Scilab, Deuxi`eme Edition . Springer, 2007.
[6] El Consorcio Scilab. Scilab. http://www.scilab.org.
[7] Intel.
Biblioteca del núcleo matemático de Intel. http://software.intel.com/en-us/
intel-mkl/.
[8] Silvestre Ledru. Diferentes modos de ejecución de scilab. http://wiki.scilab.
org/Different_execution_modes_of_Scilab.
83
(3)
Machine Translated by Google
[9] Cleve Moler. Computación numérica con matlab.
[10] Proyecto Flexdock. Hogar del proyecto Flexdock. https://flexdock.dev.java.net/.
84
Machine Translated by Google
Índice
biblioteca
ˆ, 20
', 39
39 ,.'
de funciones, 56
.. , 21
// , 21
: , 33
sombrero, 20
entero, 24
Intel, 6
; , 20
SCIHOME , 58
contorno ,
disp , 11
lado izquierdo, 53
biblioteca, 56
sesenta y cinco
linux, 7
, 55
fiesta , 67
Mac OS, 7
función
, 52 , 54
genlib , 7 56
matriz, 28
ayuda , 56 lib
módulos, 56
ejecutivo
MKL, 6
,
pronto, 11
linspace , 63 6464
,
,
tamaño parcela
operador de comillas ('), 39
, 30
lado derecho, 53
matriz de prueba , 33
título
, 69
punto y coma,
xtitulo
, 69
SCIHOME , 18
20 forma, 28
cadena, 26
%i , 23
% pi , 22
Y,
transponer, 39
26
nombre variable, 20
lote, 18
ventanas, 6
booleano, 23
dos puntos (:) operador,
33 comentario, 18
, número
21
complejo, 23 conjugado,
39 consola, 11 línea de
continuación, 21
acoplamiento, 14
puntos, 21
funciones elementales, 21 por
elementos, 39
Flexdock, 14
pedernal, 25
85
