1) Introducción A SCILAB (Guía)

Introducción a SCILAB
Asignatura: Sistemas Dinámicos DIEGO ESTEBAN RAMÍREZ CÁRDENAS

Grupo: 801/802 Periodo: 2023-2
Descripción
Scilab es un software libre y de código abierto para el cálculo
numérico que proporciona un entorno de computación de gran
alcance para aplicaciones de ingeniería y científicas. Tiene código
abierto bajo la licencia CeCILL (GPL compatible), y está disponible
bajo GNU / Linux, Mac OS y Windows.
Incluye cientos de funciones matemáticas y análisis de datos. Tiene

un lenguaje de programación de alto nivel que permite el acceso a
estructuras de datos avanzadas, 2-D y funciones gráficas 3-D.
Permite resolver problemas de optimización continuos y discretos
restringidos y no restringidos, así como algoritmos y herramientas
estándar para modelado de sistemas mecánicos, circuitos
hidráulicos, sistemas de control.
Scilab dispone de un manual de usuario que se puede consultar en una ventana de ayuda (Help Browser). Esta ayuda se
puede invocar de las siguientes maneras:
1. Desde el menú “?” opción “Ayuda de scilab”.

2. Presionando la tecla F1.
3. Escribiendo el comando “help” en la consola.
En la ventana de ayuda se puede acceder fácilmente a la descripción de todas las funciones de Scilab que, en muchos
casos, se acompaña de ejemplos de uso ilustrativos.
En la página https://www.scilab.org/tutorials se pueden encontrar documentación adicional y referencias a libros y

artículos relativos a Scilab.
En la página https://www.scilab.org sección “Download” se puede descargar de manera gratuita la última versión de
Scilab.
Universidad Antonio José Camacho – Sistemas Dinámicos – Ing. Diego Esteban Ramirez Cárdenas - 15/08/2023
Alternativas a Scilab:
Software Comparación con respecto a Scilab.

• Mucho más pesado.
• Cuesta dinero (no tiene versión gratuita).
• Consumo bastantes recursos del computador.
• El lenguaje es prácticamente idéntico.
• Es mucho más poderoso.
Dato para tener en cuenta: Con un correo electrónico

de la Universidad del Valle, se puede tener acceso a la
versión full del software.
• Más pesado.
• Más trabajado; más completo.
• El lenguaje es prácticamente idéntico.
• Es mucho más poderoso.

• El lenguaje es distinto.
• Aprender a programar en Python tomaría mucho
tiempo de curso.
Contenido
Descripción.............................................................................................................................................................................. 1
Alternativas a Scilab: ............................................................................................................................................................... 2
1) Pantalla Principal de SCILAB............................................................................................................................................ 4
2) Funciones ........................................................................................................................................................................ 4
3) Funciones elementales ................................................................................................................................................... 5
4) Uso como calculadora ..................................................................................................................................................... 5
5) Variables.......................................................................................................................................................................... 5
Variables predefinidas ........................................................................................................................................................ 6
6) Formato de Visualización de los Números ...................................................................................................................... 7
7) Constantes y Operadores aritméticos ............................................................................................................................ 8
8) Scripts .............................................................................................................................................................................. 9
Ejecutar un script .................................................................................................................................................................. 11
Punto y coma (;) y comentarios en un script ........................................................................................................................ 13
9) Declaración de funciones .............................................................................................................................................. 14
10) Vectores y Matrices .................................................................................................................................................. 15
11) Polinomios................................................................................................................................................................. 16
12) Solución de ecuaciones ............................................................................................................................................. 18
13) Representación de Gráficas ...................................................................................................................................... 19
Representación gráfica de funciones ................................................................................................................................ 22
1) Pantalla Principal de SCILAB
A. Navegador de Archivos: Permite visualizar el árbol de archivos y documentos del computador; es importante que
antes de comenzar a trabajar en Scilab, se seleccione una ubicación, la recomendación es generar una carpeta
nueva en cualquier ubicación, y trabajar dentro de esta. Todos los archivos generados durante el uso de Scilab se
guardarán en la ubicación de trabajo seleccionada.
B. Consola: La consola es el área de trabajo de Scilab en donde se escribirán y ejecutarán los comandos.
C. Explorador de variables: Es el área de trabajo en el que Scilab muestra las variables creadas y sus características.
D. Historial de comandos: En esta área Scilab muestra los últimos comandos utilizados, incluso los utilizados varios
días antes.
E. Noticias de Scilab: Esta área de Scilab es utilizada por el software para mostrar eventos o novedades
concernientes al programa, por ejemplo, el lanzamiento de una actualización.
F. Barra de menús.
G. Barra de herramientas.
2) Funciones
Una función es un bloque de código que realiza alguna operación. Una función puede definir opcionalmente parámetros
de entrada que permiten a los llamadores pasar argumentos a la función. Una función también puede devolver un valor
como salida.
EJEMPLO
--> sqrt(34) Se utilizó la función “sqrt” la cuál devuelve el resultado
ans = de evaluar la raíz cuadrada del parámetro ingresado, en
este caso la raíz cuadrada de 34, es decir:
5.8309519
√34 = 5.8309519
3) Funciones elementales
Los nombres de las funciones elementales son los habituales. Algunas de ellas:
Los argumentos pueden ser, siempre que tenga sentido, reales o complejos y el resultado se devuelve en el mismo tipo
del argumento.
4) Uso como calculadora
Se puede utilizar Scilab como una calculadora escribiendo expresiones aritméticas, y presionando la tecla “Enter” para
obtener un resultado.
EJEMPLO
--> sqrt(34*exp(2))/(cos(23.7)+12)
ans = √34𝒆2
1.3058717 cos(23.7) + 12
--> 7*exp(5/4)+3.54
ans = 5
7𝒆4 + 3.54
27.972401
--> exp(1+3*%i)
ans =
𝑒 1+3𝑖
-2.6910786 + 0.383604i
5) Variables
Es un elemento de datos cuyo valor puede cambiar durante el curso de la ejecución de un programa, en Scilab las variables
no son declaradas, su tipo y su tamaño cambian de forma dinámica de acuerdo con los valores que le son asignados. Así,
una misma variable puede ser utilizada, por ejemplo, para almacenar un número complejo, a continuación, una matriz
25x40 de números enteros y luego para almacenar un texto. Las variables se crean automáticamente al asignarles un
contenido. Asimismo, es posible eliminar una variable de la memoria si ya no se utiliza.
EJEMPLO
--> a=10 Note que el valor guardado en la variable “a” fue utilizado después en otra
a = secuencia de comandos, usando el nombre de la variable.
10. Además, note que la variable “Pedro” fue utilizada dentro de la secuencia
de comandos para asignar un nuevo valor a la variable “Pedro”.
--> Pedro=exp(2.4/3)
Pedro = Puede observar también, que los valores de las variables se pueden
observar en el área “Explorador de variables”, esto es:
2.2255409
--> Pedro=a+exp(Pedro)
Pedro =
19.258490
-->
Para conocer en cualquier instante el valor almacenado en una variable basta con teclear su nombre (Atención: recuérde
que las variables AB ab Ab y aB SON DISTINTAS, ya que Scilab distingue entre mayúsculas y minúsculas).
Variables predefinidas
Scilab tiene unas variables predefinidas (constantes), las cuales comienzan con %, tales como, %pi para el valor de la
constante pi, %e para la constante de Euler y %i para definir números imaginarios.
EJEMPLO
--> %pi
%pi =
3.1415927
--> %e
%e =
2.7182818
--> %i
%i =
0. + i
6) Formato de Visualización de los Números
Scilab tiene varias formas de mostrar los números.
Número en Scilab Representación Matemática Formato

0.1666667 0.1666667 Convencional
1.667D-01 1.667 ∗ 101 Notación Científica
Se puede configurar para que Scilab muestre los números de la siguiente manera
Variable ‘v’ Scilab toma la decisión de qué formato utilizar.

Científico ‘e’ Siempre muestra el número en notación científica.
Un número está conformado por los siguientes campos:
Signo Números Separador decimal Símbolo de Exponente Signo del Exponente Dígitos del exponente
Por defecto, Scilab muestra los números en formato “variable” con 10 dígitos.
Este código almacena en la variable “a” el número pi,

observe que el resultado muestra 8 números, pero
teniendo en cuenta el signo del número (en el caso
positivo no se muestra el “+”, pero allí está) y el punto
decimal, se completan los 10 dígitos por defecto.
El formato de visualización se puede cambiar usando la función format(), usada de la siguiente manera:
format(‘v’, n) Formato variable con “n” dígitos, por defecto n=10.

format(‘e’, n) Formato científico con “n” dígitos; n debe ser un número entre 8 y 25.
Por ejemplo, al cambiar el formato a variable con 4

dígitos, los 4 dígitos son:
1. Signo positivo (espacio vacío)
2. El número 3.
3. El punto decimal.
4. El número 1.
El mismo número, pero ahora negativo, tiene los
siguientes dígitos:
1. Signo negativo.
2. El número 3.
3. El punto decimal.
4. El número 1.
Ahora cambiemos al formato con notación científica:
Con formato científico y 8 dígitos (cantidad mínima), el

número tiene los siguientes dígitos:
1. Signo negativo.
2. Número 3.
3. Punto decimal.
4. Número 1.
5. Letra D; significa *10 ^ ().
6. Signo exponente.
7. Número 0 del exponente.
Con formato científico y 10 dígitos, el número tiene los
siguientes dígitos:
1. Signo negativo.
2. Número 3.
3. Punto decimal.
4. Número 1.
5. Número 4.
6. Número 2.
7. Letra D; significa *10 ^ ().
8. Signo exponente.
¿Cómo volver al formato por defecto?
7) Constantes y Operadores aritméticos
8) Funciones/comandos de Utilidad
Comando Descripción
who lista las variables actuales.
whos Como el comando anterior, pero más detallado.
clear Elimina todas las variables que existan en ese momento.
clear a b c Elimina las variables a b y c únicamente.
clc Limpia la consola.
9) Scripts
En programación un “script” es un conjunto de instrucciones (de cualquier lenguaje) guardadas en un fichero (usualmente
de texto) que son ejecutadas normalmente mediante un intérprete. Son útiles para automatizar pequeñas tareas. También
puede hacer las veces de un "programa principal" para ejecutar una aplicación.
En otras palabras, un “script” usualmente es un archivo de texto plano, en donde se encuentran escritos y guardados la
secuencia de comandos de un programa.
En Scilab es posible trabajar con “script” para crear archivos de texto en los que podemos guardar nuestra secuencia de
comandos, y así poder utilizar de nuevo el programa cada vez que sea necesario.
Así, para llevar a cabo una tarea, en vez de escribir las instrucciones una por una en la línea de comandos de Scilab, se
pueden escribir una detrás de otra en un fichero. Para ello se puede utilizar el editor integrado de Scilab usando alguna
de las siguientes opciones:
1. Botón “Ejecutar SciNotes”

2. Menú Aplicaciones clic en
“SciNotes”
3. Ejecutar el comando --> scinotes

“scinotes” en la consola
-->
Ventana del editor de Scilab (SciNotes)
Observe que al guardar por primera vez el archivo, este generará un archivo de tipo SCE con extensión “.sce”, estos son
legibles sólo por Scilab.
Recuerde guardar el archivo en la carpeta de trabajo que haya seleccionado, en este caso se ha seleccionado la carpeta
Scilab en el disco D, esto se puede observar en el área de “Navegador de Archivos” de Scilab.
Ejecutar un script
Para ejecutar un “script” existen al menos dos (2) maneras, estas son:
1. Desde el botón Ejecutar en la venta del editor
EJEMPLO
Ejecutamos los comandos clear y clc en el área

de consola. Esto con el fin de limpiar/borrar las
variables existentes, y limpiar/borrar los
comandos en el área de consola.
En el “script” que habíamos guardado escribir
las líneas mostradas, en las que se declaran 2
variables (a y b) y por último se realiza una
operación, usando los valores a y b, para
calcular c.
¿qué operación estamos realizando con

este “script”?
Damos clic en Ejecutar
Note que en el área consola aparece esa línea

de comando cuando le damos clic al botón
Ejecutar en el editor.
Note que ahora las variables a, b y c aparecen

en el área Explorador de variables; esto
quiere decir que el “script” se ha ejecutado,
ejecutando todas las líneas de comandos.
2. Desde la consola usado la función

exec()
Note que esta es la línea de comando que se

generó al dar clic en Ejecutar desde el editor.
Sin embargo, es posible simplemente ejecutar
la misma línea de comando, sin necesidad de
dar clic en Ejecutar.
Esto tiene una ventaja importante, y es que se
puede ejecutar un script sin necesidad de
tenerlo abierto en el editor.
¿Qué sucede ejecutando las siguientes líneas?

Nota: ejecute clear y clc antes y después de ejecutar cada línea para que pueda observar y comparar resultados.
1. --> exec('Ejemplo_1_guia.sce', -1)

2. --> exec("Ejemplo_1_guia.sce",-1)
3. --> exec('Ejemplo_1_guia.sce')
Punto y coma (;) y comentarios en un script
Se usa punto y coma al final de una línea para evitar que el resultado de una línea de comando se imprima en la consola;
a la acción de obtener un resultado en la pantalla se le llama eco.
EJEMPLO
Observe este ejemplo, en ambos casos se está

declarando la variable a con un valor a=10, sin
embargo, en la segunda ocasión se termina con
punto y coma la línea de comando, esto hace
que el compilador de comando interprete que
no es necesario devolver el valor de a, como si
lo hizo en la primera vez.
En un script se utiliza doble slash “//” para informarle al compilador que lo que vendrá después es un comentario, y no
lo debe tener en cuenta en la ejecución.
EJEMPLO
Observe que cada vez que se utiliza “//” el

texto que viene a continuación cambia a color
verde, esto hace referencia a que son
comentarios, y este texto no hace parte de las
líneas de comandos a compilar.
10) Declaración de funciones
Así como vimos que sqrt() es una función dentro de Scilab que realiza el cálculo de la raíz cuadrada de un número, es
posible crear nuestras propias funciones. Para esto se debe tener en cuenta lo siguiente:
En cualquier ambiente la palabra “función” hace referencia a una actividad en particular que debe ser realizada por un
ente o sistema, en todas las ocasiones una función requiere de un recurso y una vez terminada se obtiene un producto.
Ejemplo: la función de un trabajador es empacar en cajas zapatos que vienen en una cinta transportadora; el recurso de
esta función son los zapatos en la cinta transportadora, y el producto es la caja de zapatos con los zapatos adentro.
En programación, al recurso de una función se le llama argumento de entrada, y al producto obtenido se le llama
argumento de salida. En Scilab una función se define de la siguiente manera:
function [argumentos de salida] = nombre_de_la_funcion(argumentos de entrada)

instrucciones;
endfunction
EJEMPLO
Ejecutamos los comandos clear y clc en el área

de consola. Esto con el fin de limpiar/borrar las
Siguiendo el ejemplo de realizar el cálculo de la

hipotenusa de un triángulo rectángulo,
creamos una función para este propósito.
Al igual que todas las líneas de comandos

utilizables en Scilab, las funciones pueden
crearse en la consola de comandos o en un
script. La ventaja es que en este último
podemos almacenarlas, y utilizarlas después.
Creamos entonces la función hipo() siguiendo

la estructura base, de esta manera:
Argumentos de entrada = a y b
Argumentos de salida = c
Ejecutar el script.
Note que ahora no ocurre algo; en el

explorador de variables no debe aparecer
alguna variable.
Sin embargo, lo que ocurrió es que ahora la
función hipo() es una de las funciones
utilizables en el entorno de Scilab.
La función hipo() es una de las funciones

utilizables en el entorno de Scilab. Podemos
por ejemplo, utilizar los mismos argumentos
de entrada utilizados en los ejemplos
anteriores, y corroborar el resultado.
Una vez declarada una función, se puede

utilizar en cualquier entorno dentro de Scilab,
es decir, en consola y también en un script.
Si observamos el Explorador de variables sólo
nos hace referencia de la variable ans que
representa el último valor evaluado, note que
no existen las variables a,b y c declaradas
dentro de la función hipo(), esto se debe a que
las variables sólo existen dentro de la función.
Observe que si ahora utilizamos el comando

who la función hipo() que acabos de declarar
estará en la lista de variables y funciones
utilizables en Scilab, sin embargo, esta función
declarada por el usuario (nosotros) se borrará
al cerrar Scilab, o al ejecutar el comando clear.
11) Vectores y Matrices
En Scilab de puede trabajar con vectores y matrices, de siguiente manera:
EJEMPLO
Ejecutamos los comandos clear y clc en el área de consola.

Esto con el fin de limpiar/borrar las variables existentes, y
limpiar/borrar los comandos en el área de consola.
Para declarar un vector y/o matriz se debe emplear

corchetes [ ]; se usa un espacio para separar las columnas
y punto y coma para separar las filas.
12) Polinomios
En Scilab es posible trabajar con elementos de tipo polinomio, utilizando la función poly().
EJEMPLO

Primero creamos un vector con los coeficientes del
polinomio que queremos crear.
Posteriormente usamos la función poly() con los

siguientes argumentos de entrada:
poly(el vector de coeficientes, la variable del polinomio,

argumento que le dice al compilador que se usaran los
coeficientes del polinomio para construir el polinomio).
Existe otra manera de construir un polinomio, y es escribiendo directamente el polinomio, esto es:
EJEMPLO

Primero hacemos que la variable x sea un polinomio,

posteriormente, usamos la variable x para construir el
polinomio que necesitamos.
Utilizar polinomios permite usar funciones especiales para

polinomios, por ejemplo la función roots() que encuentra
el valor de las raíces del polinomio ingresado.
13) Solución de ecuaciones
EJEMPLO
Calcular la solución a:
2√(𝑥 + 2) + 3𝑥 = 1
Ejecutamos los comandos clear y clc en el área de
consola. Esto con el fin de limpiar/borrar las
Declaramos una función del tipo [y]=f(x) de tal

manera que:
𝑦 = 2√(𝑥 + 2) + 3𝑥 − 1
Observe que el valor de x que satisface la
ecuación hace que:
𝑦=0
Una vez declarada la función objetivo, podemos
usar la función fsolve().
Podemos evaluar el resultado en la ecuación para

corroborar el resultado.
14) Representación de Gráficas
En Scilab existen varios tipos de gráficos, algunas de estas son:
• Curvas planas (2D).

• Animaciones de curvas (2D).
• Curvas en el espacio (3D).
• Superficies (3D).
En este curso nos enfocaremos en la representación de curvas en 2D; en Scilab el comando más simple para realizar
representación de curvas es mediante la función plot(), la utilización de esta función es la siguiente:
plot( [vector de valores en el eje x] , [vector de valores en el eje y] )
EJEMPLO

Creamos el vector x con los puntos que se ubicaran en el
eje X.
Creamos el vector y con los puntos que se ubicaran en el

eje Y.
Nota: los vectores pueden ser vectores fila o columna,

pero ambos deben coincidir.
Ejecutamos la función plot() con los vectores creados.
¿Qué función se está representando?
Al ejecutar la función plot() el compilador abrirá una nueva

ventana con la representación gráfica de los puntos
ingresados. Observe que por defecto la función plot() une
los puntos mediante una línea recta.
Antes de continuar, cerrar la venta de la gráfica.
Ahora usaremos la función plot() agregando después de

los vectores de puntos la letra ‘o’ entre comillas simples.
Ahora la representación gráfica no se realiza uniendo cada
punto con una línea, en su lugar, el compilador ha ubicado
en la ubicación de cada punto un círculo o la letra ‘o’ que
introdujimos.
Al circulo o letra ‘o’ ubicada en cada punto se le llama

marcador.
Sin cerrar esta ventana, pruebe a correr de nuevo el

comando plot(x,y) ¿qué ocurre?
Con la función plot() es posible cambiar el tipo de línea, el tipo de marcador, y el color de la curva, siguiendo las
siguientes indicaciones:
Estilo de Línea Color Marcador
EJEMPLO
Observe que en este caso escogimos la siguiente
configuración:
• Tipo de línea: Punteada.
• Color: Magenta.
• Marcador: Diamante.
El resultado es una representación gráfica con línea

punteada, color magenta y con diamantes en la ubicación
de cada punto.
¡¡Pruebe otras configuraciones!!
Representación gráfica de funciones
Para representar gráficamente una función, primero debemos aprender a crear el vector de puntos del eje X de manera
automática, para eso vamos a utilizar la siguiente estructura:
Nombre_vector = [inicio] : [paso] : [fin]
EJEMPLO
Ejecutamos los comandos clear y clc en el área de

consola. Esto con el fin de limpiar/borrar las variables
existentes, y limpiar/borrar los comandos en el área de
consola.
Observe que creamos un vector fila con la siguiente

configuración:
• Nombre = x
• Inicio = 0
• Paso = 1
• Fin = 10
De esta manera el compilador construyó un vector desde
cero (0) hasta diez (10), contando de uno en uno.
¡¡Pruebe otras configuraciones!!
EJEMPLO
Vamos a representar gráficamente la función seno, esto es:
𝑦 = sin⁡(𝑡)
Construimos el vector de puntos en el eje X; en este caso
denotados por la letra “t” que bien podría ser “tiempo”,
aunque es importante recordar que la función seno recibe
radianes, así que para que “t” represente tiempo habría
que realizar algún tipo de conversión.
Observe que ubicamos el final en 2π, esperando obtener

un período completo de la función.
Ejecutamos esta línea de comando para construir el vector
en el eje Y; observe que el compilador calculará el valor del
seno para cada uno de los puntos de “t” y así obtener el
vector y.
El tipo de vector de “y” (fila o columna) es heredado del

tipo de vector que sea “t”.
Con los vectores “y” y “t” creados, podemos ejecutar la
función plot() con la configuración que deseemos, en este
caso seguiré con la configuración del ejemplo previo.
El resultado es una representación gráfica de la función

seno con puntos entre 0 y 2π, con línea punteada, color
magenta y con diamantes en la ubicación de cada punto.
¡No cerrar la ventana!
Existen otros elementos que se le pueden agregar mediante comandos a una representación gráfica, estos son:
EJEMPLO
Con este comando podemos insertar en la
gráfica una cuadricula.
Observe que ahora la gráfica tiene una

cuadricula que permite guiarse de mejor
manera.
Función title(), con este comando podemos

agregar título a la gráfica en la parte superior de
la misma.
Modificación al comando anterior para

aumentar el tamaño de la letra en el título.
Funciones ylabel() y xlabel(), con estas
funciones podemos agregarle título a los ejes de
la gráfica, e igualmente modificar el tamaño de
la letra.
Vamos a crear la función coseno, para eso

creamos otro vector “y2” con los mismos
valores del eje X, es decir, el vector “t”.
Ejecutamos la función plot() con el vector “y2”,

con tipo de línea de puntos, color verde, y con
triángulos hacía la izquierda como marcadores.
Si no cerramos la ventana, las dos gráficas nos
habrán quedado en la misma ventana, sin
perder la configuración previa.
¿cómo saber cuál función es cada una de las

gráficas?
Función legend(), con esta función podremos

darle nombre a cada una de las curvas que tiene
una gráfica, esta función toma el primer
nombre y lo relaciona con la primera curva
insertada en la gráfica; en este caso
comenzamos graficando primero la función
seno, es por esto que la primera en ser
nombrada.
Nota: la función legend() devuelve valores

asociados a su configuración, es recomendable
finalizar siempre con punto y coma.
Para cambiar el tamaño de la letra del cuadro

de leyenda hay que hacer un procedimiento
diferente a las funciones anteriores.
En lugar de escribir únicamente la función,

vamos a declarar una variable con cualquier
nombre, en este caso “L”; en el Explorador de
variables podemos ver que es una variable de
tipo gráfica.
Posteriormente, podemos cambiar el
parámetro de tamaño de fuente al tamaño que
queramos.
De esta manera el resultado es una letra más

legible, sobre todo para presentaciones o
trabajos escritos.
Ahora un pequeño truco, o recursividad;

podemos graficar elementos de referencia que
nos permitan complementar una gráfica.
Observe que hemos graficado un par de líneas

punteadas negras señalando un punto, además
a esto, en la ubicación del punto hemos
graficado un círculo.
Ahora vamos a usar la función xstring() para
agregar una etiqueta dentro de la gráfica, la
estructura de argumentos de entrada de esta
función es:
xstring(coordenada en X, coordenada en Y,
texto en comilla simple o doble)
Posteriormente las siguientes 2 líneas de

comando son necesarias para modificar el
tamaño de letra.
El resultado es una etiqueta con la palabra

“Intersección” en las coordenadas que se le
indicaron al compilador.
Este ejemplo mostraría la “Intersección” entre

ambas funciones, como punto de interés. Los
puntos de interés dependerán del trabajo que
se esté realizando.
De esta manera ya tendríamos una gráfica con todos los detalles necesarios para realizar una presentación o informe, el
último paso será guardar la imagen.
EJEMPLO
La primera opción es guardarla en un formato
propio de Scilab, para esto hay que ir al menú
Archivo opción Guardar.
Observe que el archivo a guardar tiene la

extensión “.scg”, esto es un formato de archivos
gráficos propio de Scilab.
La ventaja de guardar la imagen en este formato

es que en el futuro se podrá modificar los
elementos de la gráfica, como los títulos, las
etiquetas, etc. así mismo, se le podrá agregar
otras gráficas.
Por otro lado, se podrá guardar la gráfica como

una imagen estándar, usando la opción Exportar a
del menú Archivo.
En las opciones de formato, se puede guardar la
imagen como PNG, JPEG, PDF, EMF, entre otros.
Por último, es importante tener en cuenta que todos los comandos utilizados para llegar hasta la última versión de la
gráfica se pueden escribir en un script y guardar para usarlos en el futuro. Recomiendo que se lleven los archivos
generados durante este trabajo, y los tengan a la mano.
A continuación, se muestra como se ve un script con los comandos utilizados para generar la última versión de la imagen
previa, en cada una de las líneas se ha utilizado comentarios para recordar lo que hace.

1) Introducción A SCILAB (Guía)

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

1) Introducción A SCILAB (Guía)

Cargado por

Copyright:

Formatos disponibles

Introducción a SCILAB

Asignatura: Sistemas Dinámicos DIEGO ESTEBAN RAMÍREZ CÁRDENAS

Incluye cientos de funciones matemáticas y análisis de datos. Tiene

1. Desde el menú “?” opción “Ayuda de scilab”.

En la página https://www.scilab.org/tutorials se pueden encontrar documentación adicional y referencias a libros y

Software Comparación con respecto a Scilab.

Dato para tener en cuenta: Con un correo electrónico

• Es mucho más poderoso.

4) Uso como calculadora

Scilab tiene varias formas de mostrar los números.

Número en Scilab Representación Matemática Formato

Variable ‘v’ Scilab toma la decisión de qué formato utilizar.

Un número está conformado por los siguientes campos:

Este código almacena en la variable “a” el número pi,

format(‘v’, n) Formato variable con “n” dígitos, por defecto n=10.

Por ejemplo, al cambiar el formato a variable con 4

Ahora cambiemos al formato con notación científica:

Con formato científico y 8 dígitos (cantidad mínima), el

¿Cómo volver al formato por defecto?

7) Constantes y Operadores aritméticos

1. Botón “Ejecutar SciNotes”

3. Ejecutar el comando --> scinotes

1. Desde el botón Ejecutar en la venta del editor

Ejecutamos los comandos clear y clc en el área

¿qué operación estamos realizando con

Damos clic en Ejecutar

Note que en el área consola aparece esa línea

Note que ahora las variables a, b y c aparecen

2. Desde la consola usado la función

Note que esta es la línea de comando que se

¿Qué sucede ejecutando las siguientes líneas?

1. --> exec('Ejemplo_1_guia.sce', -1)

Punto y coma (;) y comentarios en un script

Observe este ejemplo, en ambos casos se está

Observe que cada vez que se utiliza “//” el

function [argumentos de salida] = nombre_de_la_funcion(argumentos de entrada)

Ejecutamos los comandos clear y clc en el área

Siguiendo el ejemplo de realizar el cálculo de la

Al igual que todas las líneas de comandos

Creamos entonces la función hipo() siguiendo

Note que ahora no ocurre algo; en el

La función hipo() es una de las funciones

Una vez declarada una función, se puede

Observe que si ahora utilizamos el comando

11) Vectores y Matrices

En Scilab de puede trabajar con vectores y matrices, de siguiente manera:

Ejecutamos los comandos clear y clc en el área de consola.

Para declarar un vector y/o matriz se debe emplear

Ejecutamos los comandos clear y clc en el área de consola.

Posteriormente usamos la función poly() con los

poly(el vector de coeficientes, la variable del polinomio,

Ejecutamos los comandos clear y clc en el área de consola.

Primero hacemos que la variable x sea un polinomio,

Utilizar polinomios permite usar funciones especiales para

Declaramos una función del tipo [y]=f(x) de tal

Podemos evaluar el resultado en la ecuación para

14) Representación de Gráficas

En Scilab existen varios tipos de gráficos, algunas de estas son:

• Curvas planas (2D).

plot( [vector de valores en el eje x] , [vector de valores en el eje y] )

Ejecutamos los comandos clear y clc en el área de consola.

Creamos el vector y con los puntos que se ubicaran en el