Manual de Introduccion A Scilab

lOMoARcPSD|26831330
Manual de Introduccion a Scilab
Programación (Universidad Nacional Mayor de San Marcos)
Escanea para abrir en Studocu
Studocu no está patrocinado ni avalado por ningún colegio o universidad.

Descargado por MARIA BELEN MUJICA MAGALLANES (maria.mujicam@unmsm.edu.pe)
lOMoARcPSD|26831330
Introducción al lenguaje de programación SCILAB
UNIVERSIDAD NACIONAL MAYOR DE SAN MARCOS

(Universidad del Perú, Decana de América)
FACULTAD DE QUÍMICA E INGENIERÍA QUÍMICA
D.A. de Análisis y Diseño de Procesos
E.P. DE QUÍMICA
E.P. DE INGENIERÍA QUÍMICA
E.P. DE INGENIERIA AGROINDUSTRIAL
N O T A S DE CURSO
TEMA: INTRODUCCION AL LENGUAJE DE PROGRAMACIÓN SCILAB
PREPARADO POR:
MÁXIMO MEDARDO LEYVA CABALLERO
CIUDAD UNIVERSITARIA, 25 DE MARZO DEL 2019
Máximo M. Leyva Caballero – D.A. Análisis y Diseño de Procesos FQIQ-UNMSM

1

lOMoARcPSD|26831330
ÍNDICE GENERAL
INTRODUCCIÓN ............................................................................................................................................ 4
1. DOCUMENTACIÓN Y AYUDA ON-LINE .................................................................................................. 4
2. NATURALEZA Y SINTAXIS BÁSICO ......................................................................................................... 5
2.1 CONSTANTES Y OPERADORES ......................................................................................................... 6
SECCIÓN 1. SCILAB como calculadora científica ........................................................................................... 7
2.2 EMPLEO DE SCILAB COMO CALCULADORA CIENTÍFICA .................................................................. 9
2.3 VARIABLES ..................................................................................................................................... 10
2.4 ALGUNOS UTILITARIOS DE CONSULTA ......................................................................................... 11
2.5 FORMATOS.................................................................................................................................... 12
2.6 FUNCIONES DE LIBRERÍA BÁSICAS ................................................................................................ 12
3. MATRICES............................................................................................................................................ 13
3.1 OPERADORES ELEMENTALES DE CONSTRUCCIÓN DE MATRICES ................................................. 13
3.2 FUNCIONES DE LIBRERÍA MATRICIALES ESPECIALES: ................................................................... 15
3.3 OPERACIONES MATRICIALES......................................................................................................... 15
3.4 FUNCIONES DE LIBRERÍA MATRICIALES ........................................................................................ 17
3.5 MANIPULACIÓN DE LOS ELEMENTOS DE UNA MATRIZ: Extracción, inserción y eliminación ...... 18
3.6 OTROS EJEMPLOS DE MATRICES: ......................................................................................................... 19
4. IMPORTACIÓN Y EXPORTACIÓN DE DATOS (EXCEL) ¿???................................................................... 19
5. SISTEMA DE ECUACIONES LINEALES ................................................................................................... 20
5.1 RESOLUCIÓN INICIAL DE UN SISTEMA DE ECUACIONES LINEALES ............................................... 20
5.2 OTRAS FUNCIONES DE INTERÉS: ................................................................................................... 21
6. POLINOMIOS ....................................................................................................................................... 22
6.1 FUNCIONES DE LIBRERIA............................................................................................................... 22
6.2 INTERPOLACION Y EXTRAPOLACION ............................................................................................ 24
7. REPRESENTACIONES GRAFICAS CON SCILAB ...................................................................................... 25
7.1 CURVAS PLANAS (GRÁFICAS 2D)................................................................................................... 25
7.2 CURVAS EN EL ESPACIO (GRÁFICAS 3D)........................................................................................ 28
8. ENLACE CON LOS PROGRAMAS DE MAT LAB: .................................................................................... 30
SECCIÓN 2. SCILAB como lenguaje de programación ................................................................................. 31
9. CODIFICACION DE PROGRAMAS: ........................................................................................................ 33
9.1 SCRIPTS ......................................................................................................................................... 33
9.2 ESTRUCTURAS DE CONTROL BASICAS........................................................................................... 35

2

lOMoARcPSD|26831330
9.2.1 ENTRADA Y SALIDA (estructura secuencial) ............................................................................. 36

9.2.2 IF (condicional simple) .............................................................................................................. 36
9.2.3 SELECT y CASE (condicional múltiple) ....................................................................................... 37
9.2.4 WHILE (repetitiva mientras)...................................................................................................... 39
9.2.5 FOR (repetitiva desde) .............................................................................................................. 40
9.2.6 OTRAS ÓRDENES ....................................................................................................................... 41
9.2.7 FUNCIONES DE ENTRADA Y SALIDA CON FORMATOS ............................................................... 41
10. FUNCIONES DEFINIDAS POR EL USUARIO ......................................................................................... 43
10.1 ESTRUCTURA DE UNA FUNCIÓN ................................................................................................. 44
10.2 LLAMADA A LA FUNCIÓN ............................................................................................................ 45

3

lOMoARcPSD|26831330
INTRODUCCIÓN
Scilab es un conjunto de programas de código abierto para computación científica, orientado al cálculo
numérico, a las operaciones matriciales y especialmente a las aplicaciones en ciencias e ingeniería.
Puede ser utilizado simplemente como una calculadora matricial, pero su interés principal radica en los
cientos de funciones de librería que posee, tanto de propósito general como especializados en las ciencias.
Así como en sus posibilidades para la visualización gráfica y codificación de programas avanzados.
Scilab posee además un lenguaje de programación propio, muy próximo a los habituales en cálculo
numérico que permite al usuario escribir sus propios scripts (conjunto de comandos escritos en un fichero
que se pueden ejecutar con una única orden) para resolver un problema concreto y también escribir
nuevas funciones con, por ejemplo, sus propios algoritmos. Scilab dispone, además de numerosas
Toolboxes, que le añaden funcionalidades especializadas.
Inicialmente desarrollado por el INRIA (Institut National de Recherche en Informatique et Automatique),

un excelente instituto francés de investigación.
La versión actual es la 6.0.1 Tanto los binarios para varias plataformas (GNU Linux, Windows
2000/XP/Vista, Hp-Ux) como las fuentes están disponibles en http://www.scilab.org/download.
En este manual de iniciación a la programación se supone que el lector ya tiene conocimiento de la

implementación de algoritmos a nivel de pseudocódigo o diagrama de flujo.
El autor estará muy agradecido por los comentarios, sugerencias y observaciones enviados a:
mleyvac@unmsm.edu.pe o maxleyvac2@hotmail.com
1. DOCUMENTACIÓN Y AYUDA ON-LINE
Scilab dispone de un manual de usuario que se puede consultar en una ventana de ayuda (Help Browser).
La ayuda se puede invocar desde la barra de herramientas (?- Scilab Help en Windows, Help-Help
Browser en Linux).

4

lOMoARcPSD|26831330
También escribiendo el tema (sobre valor absoluto) de consulta en la línea de comandos -->help abs se
puede acceder fácilmente a la descripción de la función, que en muchos casos se acompaña de ejemplos
de uso ilustrativo.
También dispone de un conjunto de Demos que pueden ayudar mucho el aprendizaje de Scilab ya que se
acompañan, en general, del código que genera la demostración.
Sin embargo, Scilab no dispone de un tutorial propiamente dicho que facilite los primeros pasos que
explique la filosofía general del lenguaje o que indique como resolver problemas técnicos concretos.
En las páginas http://www.scilab.org/product y http://www.scilab.org/publications se puede encontrar

documentación adicional y referencias a libros y artículos relativos a Scilab.
2. NATURALEZA Y SINTAXIS BÁSICO
La estructura básica de trabajo de Scilab es una matriz bidimensional cuyos elementos son números reales
o complejos. Escalares y vectores son casos particulares de matrices. También es posible construir otro
tipo de estructuras de datos definidos por el usuario.
En Scilab por defecto, los números son codificados como números reales en coma flotante de doble
precisión.
Algunas constantes numéricas están predefinidas. Su nombre comienza con el símbolo %. En particular
%pi es el número π, %e es el número e, %i es la unidad imaginaria, %eps es la precisión de la maquina
(mayor número real doble precisión para el que 1+%eps/2 es indistinguible de 1), %inf es el infinito-
máquina (overflow: cualquier número que supere al mayor número real representable en doble
precisión), %nan es el símbolo de NaN (Not a Number) para una operación inválida (por ejemplo, 0/0 es
%nan)

5

lOMoARcPSD|26831330
La codificación de Scilab es interpretado, esto es, las instrucciones se traducen a lenguaje de máquina una
a una y se ejecutan antes de pasar a la siguiente. Es posible escribir varias instrucciones en la misma línea,
separándolas por una coma o por punto y coma.
Se puede recuperar comandos anteriores, usando las teclas de flecha arriba y abajo. Con las flechas
izquierda y derecha nos podemos desplazar sobre la línea de comando y modificarlo.
2.1 CONSTANTES Y OPERADORES
CONSTANTES:
Reales Complejos Booleanos

3.7 -5.2 .056 1.4e+5 3.14E-10 1+2*%i %t %f
3.14e-10 -.567d-21 8.003D-12 3+5*r*%i
TABLA DE OPERADORES:
Operadores Aritméticos
Operadores Descripción
+ Adición o suma
- Sustracción o resta
* Multiplicación
‘ Traspuesta
^ Potenciación
/ División derecha
\ División izquierda
.* Producto elemento a elemento
. / y .\ División elemento a elemento
.^ Elevar a una potencia elemento a elemento
Operadores de Relación
> Mayor que
>= Mayor que o igual
< Menor que
<= Menor que o igual
== Igual que
~= (ó <>) Diferente
Operadores Lógicos
& y (p AND q)
| o (p OR q)
~ negación (NOT p)

6

lOMoARcPSD|26831330
Sección Uno
SECCIÓN 1. SCILAB como calculadora científica
SCILAB
como
calculadora
científica
1

7

lOMoARcPSD|26831330

8

lOMoARcPSD|26831330
2.2 EMPLEO DE SCILAB COMO CALCULADORA CIENTÍFICA
Se puede utilizar Scilab como simple calculadora, escribiendo las relaciones aritméticas directamente en
la línea de comandos ( -->) finalizados por Enter (<E>). Para la evaluación tener en cuenta los operadores
aritméticos, de relación y lógicos.
Se obtiene el resultado inmediatamente a través de la variable del sistema ans (answer). Si no se desea
que Scilab escriba el resultado en el terminal, debe terminarse la orden por punto y coma (;). Esta
alternativa es útil, sobre todo en la codificación de programas de muchas líneas.
EJEMPLOS
-->(5+3)/(9-1) -->5*(1/2)*4*(2/3)
ans = ans =
1.0 6.6666667
-->(2^3)-(4/(5+3)) -->sqrt(32*exp(2))/(cos(27.3)+10)
ans = ans =
7.5 1.6292082
-->exp(1+2*%i) -->5*exp(5/4)+5.34
ans = ans =
- 1.1312044 + 2.4717267i 22.791715
Orden de las operaciones
En todos los cálculos matemáticos es importante entender el orden en que se realizan las operaciones:
 Primero realiza los cálculos dentro del paréntesis, desde el conjunto más interno hasta el más externo.
 A continuación, realiza operaciones de exponenciación.
 Luego realiza operaciones de multiplicación y división de izquierda a derecho.
 Finalmente, realiza operaciones de suma y resta de izquierda a derecho.

9

lOMoARcPSD|26831330
CASO: EJEMPLOS
--> // valores de las variables -->// cálculo
-->a=3.2 -->m=(𝑎^ 2+b*c+x)
--> b=-2.3 m=
--> c=%pi/3 8.46806540
--> x=2/%pi -->// cálculo
--> y= 2 ^ ½ -->q= (𝑎 + 𝑐) ^2 / b
q=
-7.8429074
EJEMPLOS EJEMPLOS
--> //cálculo --> // cálculo --> // cálculo --> //cálculo
--> a==b -->(2*a+b)/x^2 <1 --> a>=c --> 2*a*c ==2*c*b
--> F --> F -->T --> F
EJERCICIO EJERCICIO
2.3 VARIABLES
Las variables en Scilab nunca son declaradas explícitamente, 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 real, número complejo, a continuación una matriz de 25x40 de
números enteros y luego para almacenar un texto.
EJEMPLOS
-->a=11 -->x=9; y=8;
a= -->x>=y & x<=15
11. ans=
--> pepsi=exp(2.4/3) T
pepsi = -->modulo(y,2)==0 | modulo(y,3)==0
2.2255409 ans=
-->z=a+pepsi*(4-0.5*%i) T
z= -->pepsi <E>
19.902164 - 1.1127705i pepsi =
2.2255409

10

lOMoARcPSD|26831330
Las variables se crean automáticamente al asignarles un contenido. Asimismo, es posible eliminar una
variable de la memoria si ya no se utiliza.
Atención: recuérdese que las variables AB ab Ab y aB SON DISTINTAS, ya que Scilab distingue entre
mayúsculas y minúsculas.
Para conocer en cualquier instante el valor almacenado en una variable, basta con teclear su nombre y
presionar <E>.
Reconocimiento de algunas variables como palabras claves o reservadas:
who muestra las variables que está usando en ese momento

whos como el 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 (atención: sin comas)
browsevar() abre, en ventana aparte, un “ojeador” de la memoria de
trabajo de Scilab: permite “ver” el contenido y características
de las variables e incluso editar su valor.
EJEMPLOS
-->who <E> -->whos
-->chdir -->date()
ans = ans =
2.4 ALGUNOS UTILITARIOS DE CONSULTA
Están disponibles algunos comandos utilitarios, como:
Ls Lista de ficheros del directorio actual (como Unix)

Dir Lista de ficheros del directorio (de otra forma)
pwd Devuelve el nombre y path del directorio actual
cd o chdir Para cambiar de directorio
Clc “Limpia” la ventana de comandos
date() Fecha actual
EJEMPLOS
-->pwd <E> menú File
ans = © Current Working Directory
C:\Users\TOSHIBA\Documents -->
-->chdir ‘E:\PractiC\’ C:\Users\TOSHIBA\Documents
ans = -->date()
T ans =
-->exec serie.txt 22-Nov-2019

11

lOMoARcPSD|26831330
2.5 FORMATOS
Por defecto, Scilab muestra los números en formato “variable” con 10 dígitos. Se puede modificar esto
mediante el comando format:
format(14) 14 dígitos
format(‘e’) formato científico o exponencial, coma flotante
format(‘v’) formato variable (por defecto)
format(‘v’,20) formato variable con 20 dígitos
format(‘e’,15) formato científico con 15 dígitos
Ejemplos
2.6 FUNCIONES BÁSICAS DE BIBLIOTECA
Los nombres de las funciones elementales son los habituales. Algunas de ellas:
sqrt(x) raiz cuadrada sin(x) seno (radianes)

abs(x) Módulo cos(x) coseno (radianes)
conj(z) complejo conjugado tan(z) tangente (radianes)
real(z) parte real cotg(x) cotangente (radianes)
imag(z) parte imaginaria asin(x) Arcoseno
exp(x) Exponencial acos(x) Arcocoseno
log(x) logaritmo natural atan(x) Arcotangente
log10(x) logaritmo decimal cosh(x) cos. Hiperbólico
rat(x) aprox. Racional sinh(x) seno hiperbólico
modulo(x,y) resto de dividir x por y tanh(x) tangente hiperbólica
floor(x) n tal que n<=x<(n+1) acosh(x) arcocoseno hiperb.
ceil(x) n tal que (n-1)<x<=n asinh(x) arcoseno hiperb.
int(x) parte entera inglesa: atanh(x) arcotangente hiperb
floor(x) si x>=0
ceil(x) si x<0
Los argumentos pueden ser, siempre que tenga sentido, reales o complejos y el resultado se devuelve en
el mismo tipo del argumento

12

lOMoARcPSD|26831330
CASO: EJEMPLOS
--> // valores de las variables -->p= 1/(cos(c)+ln(x))
-->a=3.2 -->P=
--> b=-2.3 20.6537746
--> c=%pi/3 -->n=sin(c) +y/c
--> x=2/%pi -->n=
--> y= 2 ^ ½ 2.21649987
-->z=0.50 -->modulo(4,3)
ans =
1.0
x ceil(x) floor(x) int(x) round(x)

3.0 3. 3. 3. 3.
2.8 3. 2. 2. 3.
2.5 3. 2. 2. 3.
2.2 3. 2. 2. 2.
-5.1 -5. -6. -5. -5.
-5.5 -5. -6. -5. -6.
-5.8 -5. -6. -5. -6.
3. MATRICES
Como ya se ha dicho, las matrices bidimensionales de números reales o complejos son los objetos básicos
con los que trabaja Scilab. Los vectores y escalares son casos particulares de matrices.
3.1 OPERADORES ELEMENTALES DE CONSTRUCCIÓN DE MATRICES
La forma más elemental de introducir matrices en Scilab es escribiendo sus elementos, por filas, entre
corchetes rectos ([ ]). Los elementos de una fila se separan unos de otros por comas y una fila de la
siguiente por punto y coma.
Operadores matriciales Descripción

, Separación de los elementos en un vector
; Separación de las filas en una matriz
: Este operador permite definir vectores cuyos elementos obedecen a
una serie. Es de mucha importancia para las operaciones de
extracción, inserción y eliminación de los elementos de una matriz
[] introducir matrices en Scilab escribiendo sus elementos, por filas,
dentro de los corchetes recto.

13

lOMoARcPSD|26831330
EJEMPLOS ( CONSTRUCCIONES ELEMENTALES DE VCTORES )

-->v= 1:1:10 // vector fila de longitud 10
-->w= [0; 1.003; 2; 3; 4; 5%pi] //vector columna de longitud 6
-->a=[1, 2, 3, 4; 5, 6, 7, 8; 9, 10, 11, 12] // matriz 3x4
-->b=[1:4;5:8;9:12] // matriz 3x4 igual a a
-->tam=['Hola','Paty';'¿Como','estas?'] //matriz de caracteres de 2 x 2
-->s=’San Juan’
-->l=’Lurigancho’
-->sjl=[s ‘ de ’ l] // vector de concatenación de caracteres
La forma más elemental de introducir matrices en Scilab es escribiendo sus elementos, por filas, entre
corchetes
EJEMPLOS ( CONSTRUCCIONES ELEMENTALES DE MATRICES )

-->v=[7 2 1 5 4 8]
-->v(3)
-->v([1 $])=9
-->v(10)=1
-->b=[true false true false]
Se pueden también utilizar los vectores/matrices como objetos para construir otras matrices (bloques):
EJEMPLOS (Construcciones elementales de matrices)

--> v1 =4:-1 : 1
--> v2 = [ v1, 5 ; 0.1 : 0.1 : 0.5]
--> v3 = [ v2´ , [11, 12, 13, 14, 15]´]
1 0.1 11
2 0.2 12
1 2 3 4 5
𝑣1 = (1 2 3 4) 𝑣2 = ( ) 𝑣3 = 3 0.3 13
0.1 0.2 0.3 0.4 0.5
4 0.4 14
(5 0.5 15)

14

lOMoARcPSD|26831330
3.2 FUNCIONES DE BIBLIOTECA MATRICIALES ESPECIALES:
Algunas funciones útiles para generar matrices aparecen en la tabla siguiente:
Función Descripción
diag(v) Si v es un vector, diag(v) es una matriz cuadrada de ceros con diagonal principal = v
diag(A) Si A es una matriz, diag(A) es un vector = diagonal principal de A

diag(A,k) Si A es una matriz y k es un entero, diag(A,k) es un vector =
k-ésima sub o super diagonal de A (según sea k<0 ó k>0)
zeros(n,m) matriz nxm con todas sus componentes iguales a cero
ones(n,m) matriz nxm con todas sus componentes iguales a uno
eye(n,m) matriz unidad: matriz nxm con diagonal principal =1 y el resto de las componentes =0
Re-dimensiona una matriz: si A es una matriz hxk, matrix(A,n,m) es otra
matriz con los mismos elementos que A, pero de dimensiones nxm (tiene que ser
matrix(A,n,m) h*k=n*m)
linspace(a,b,n) Si a y b son números reales y n un número entero, genera una partición regular del
intervalo [a,b] con n nodos (n-1 subintervalos)
linspace(a,b) Como el anterior, pero se asume n=100
logspace(e,f,n) Vector con n elementos logarítmicamente espaciados desde 10ê hasta 10^f
logspace (e,f) Como el anterior, pero se asume n=50
EJEMPLOS (creación de matrices por bloques)

--> A = [eye (2, 2), ones (2, 3); linspace (1, 2, 5); zeros (1, 5)]
--> w = diag(A)
--> B = matrix (A, 5, 4)
--> C = diag(diag(A, 1)) +diag(diag(B, -2), 1)
𝟏 𝟏 𝟏. 𝟓 𝟎
𝟏 𝒐 𝟏 𝟏 𝟏 𝟏 𝟎 𝟏 𝟎 𝟎
𝟎 𝟏. 𝟐𝟓 𝟎 𝟏
𝟎 𝟏 𝟏 𝟏 𝟏 𝟏 𝟎 𝟏 𝟏 𝟎
𝑨=( ) w =( )B= 𝟏 𝟎 𝟏 𝟏 C=( )
𝟏 𝟏. 𝟐𝟓 𝟏. 𝟓 𝟏. 𝟕𝟓 𝟐 𝟏. 𝟓 𝟎 𝟎 𝟏. 𝟕𝟓 𝟏. 𝟕𝟓
𝟎 𝟏 𝟏 𝟐
𝟎 𝟎 𝟎 𝟎 𝟎 𝟎 𝟎 𝟎 𝟎 𝟎
(𝟎 𝟏 𝟏. 𝟕𝟓 𝟎)
3.3 OPERACIONES MATRICIALES
Los operadores aritméticos representan las correspondientes operaciones matriciales siempre que
tengan sentido. Cuando van precedidos de un punto deben entenderse en el sentido de que la operación
se efectúa “elemento a elemento”.

15

lOMoARcPSD|26831330
Sean: A y B matrices de elementos aij y bij y k es un escalar

A+B (A-B) Matriz d elementos aij + bij (aij = bij ) (si dimensiones iguales)
A*B Producto matricial a A y B (si dimensiones adecuadas)
A^k Matriz A elevada ala potencia k
A+k Matriz de elementos aij + k
A-k Matriz de elementos aij - k
K*A Matriz de elementos k * aij
A/k =(1/k) A Matriz de elementos aij / k
A^k Matriz A elevada a la potencia k:
Si k entero>0, A^k=A*A*…*A
Si k entero<0, A^k=(inv(A))^(-k)
Si no, A^k se calcula por diagonilización
k./A Matriz de elementos k/aij
A.^k Matriz de elementos ( aij ) ^ k
k.Â Matriz de elementos k ^ ( aij )
A. B Matriz de elementos aij * bij (si dimensiones iguales)
A./B Matriz de elementos aij / bij (si dimensiones iguales)
A.^B Matriz de elementos aij ^ bij (si dimensiones iguales)
EJEMPLO
Usando las matrices A, B y C, hallar las evaluaciones:
--> A=[4 5 -2;1 -2 0;4 -1 -2]
--> B=[-4 5 -%pi;-1 -1 10;0 4 -2]
--> C=[5 2;1 -3;4 2]
--> A+B --> B*A
ans = ans =
0 10 −5.1415927 −23.566371 −26.858407 14.283185
(0 −3 10 ) ( 35 −13 −18 )
4 3 −4 −4 −6 4
--> B*C --> A*B*C

ans = ans =
−27.566371 −29.283185 67.734518 19.867259
( 34 21 ) (−95.566371 −71.283185)
−4 −16 −136.26548 −136.26548

16

lOMoARcPSD|26831330
3.4 FUNCIONES DE BIBLIOTECA MATRICIALES
sum(A) suma de las componentes de la matriz A
sum(A,1), sum(a;'r') es un vector fila (row) conteniendo la suma de los elementos de cada columna de
A
sum(A,2), sum(a;'c') es un vector columna conteniendo la suma de los elementos de cada fila de A
trace(A) traza de A : sum(diag(A))

prod(A) producto de las componentes de la matriz A
prod(A,1), prod(A,'r') es un vector fila (row) conteniendo el producto de los elementos de cada columna
de A
prod(A,2), prod(A,'c') es un vector columa conteniendo el producto de los elementos de cada fila de A
max(A) máximo de las componentes de la matriz A

max(A,'r'), max(A,'c') máximos de columnas y filas resp. (como antes)
mean(A) media de las componentes de la matriz A
mean(A,'r'), mean(A,'c') medias de columnas y filas resp. (como antes)
norm(v) norma euclídea del vector v
norm(v,2)
norm(v,p) norma-p del vector v: sum(abs(v).^p)^(1/p)
norm(v,'i) norm(v,%in) norma infinita del vector v:

max(abs(v))
norm(A) máximo autovalor de la matriz A
norm(A,2)
norm(A,1) norma-1 de la matriz A: máximo entre las sumas de sus columnas:
max(sum(abs(A),'r'))
norm(A,'in) norm(A,%in) norma infinita de la matriz A: máximo entre las
sumas de sus filas: max(sum(abs(A),'c'))
size(A) devuelve, en un vector fila, las dimensiones de la matriz A
size(A,'r') número de filas/columnas de la matriz A

size(A,'c')
devuelve un escalar con el número de elementos de la matriz A: si A es una vector,
length(A) length(A) es su longitud; si A es una matriz length(A) es el producto de sus
dimensiones

17

lOMoARcPSD|26831330
3.5 MANIPULACIÓN DE LOS ELEMENTOS DE UNA MATRIZ: Extracción, inserción y eliminación
Para especificar los elementos de una matriz se usa la sintaxis habitual:
v(i) Si v es un vector es vi
A(i,j) Si A es una matriz, es aij
A(k) Si A es una matriz, es el k-ésimo elemento de A, en el orden en que está
almacenada en la memoria (por columnas)
Pero Scilab posee un buen número de facilidades para designar globalmente un conjunto de elementos
de una matriz o vector, consecutivos o no.
Por ejemplo, si v es un vector y h es un vector de subíndices, v(h) hace referencia al subconjunto de

componentes de v correspondientes a los valores contenidos en h. Análogamente con A(h,k) si A es
una matriz bidimensional y h y k son vectores de subíndices. El símbolo: (dos puntos) en el lugar de
un índice indica que se toman todos. El símbolo $ indica el último valor del subíndice.
EJEMPLOS (referencia de subconjuntos de elementos de una matriz mediante vectores de

subíndices)
--> A=[1.3,1.2,1.1;2.1,2.2,2.3;
3.1,3.2,3.3]
--> A(2:3,1:2)
--> A(:,2) // representa la segunda columna de A
--> A(:,2:$) // representa las columnas desde 2 hasta la última
--> A(:) // representa todos los elementos de A, en una sola columna
Si B es un vector booleano (sus elementos son %t para verdadero y %f para falso) entonces A(B)
especifica la submatriz que se obtiene considerando o no cada elemento en función del valor verdadero
o falso del vector booleano:
EJEMPLOS (referencias a subconjuntos de elementos de una matriz mediante vectores

booleanos)
−−> 𝑣 = 𝑙𝑖𝑛𝑠𝑝𝑎𝑐𝑒(1,5,9)
−−> 𝑏 = [%𝑡, %𝑡, %𝑡 %𝑓 %𝑓 %𝑡 %𝑡 %𝑓 %𝑓]
−−> 𝑤 = 𝑣(𝑏)
Esta sintaxis para designar conjuntos de elementos de un matriz puede usarse tanto para recuperar los
valores que contienen (para, por ejemplo, utilizarlos en una expresión), como para asignarles valores.
Cuando estas expresiones aparecen a la izquierda de un signo igual (es decir, en una instrucción de
asignación) pueden tener distintos significados:

18

lOMoARcPSD|26831330
EJEMPLOS (asignación de valores a partes de una matriz y modificación dimensión)

(se recomienda ejecutarlos para comprender sus efectos)
-->A=rand(4,4) // Se almacena en A una matriz 4x4 de núm
-->A(2,2)=0 // Se modifica el segundo elem. diagonal de A
-->A(5,2)=1 // Obsérvese que A(5,2) no existía:: de hecho, se //
MODIFICAN LAS DIMENSIONES de la matriz, para AÑADIR
// el elemento A(5,2). El resto se llena con ceros.
// Ahora A es una matriz 5x4
-->A(2:3,1:2)=1 // La submatriz A(2:3,1:2) se llena con unos
-->A(:,2)=[] // El símbolo [] representa una “matriz vacía"
// Esta instrucción ELIMINA la segunda columna de A
// Ahora A tiene dimensión 5x3
--> A = [A, [1: 5]’] // Se añade a A una nueva columna al final
3.6 OTROS EJEMPLOS DE MATRICES:
EJEMPLOS (referencia de subconjuntos de elementos de una matriz mediante vectores de

subíndices)
--> N=[20 5 8 11 14 17; 3 16 9 12 15 8;14 7 // creacion de la matriz de notas N
10 3 18 19;5 8 11 14 17 10;16 9 12 15 16 2];
--> prom=mean(N, 'c'); // promedio aritmético simple x alumno
--> [a, b] = max (N(:,1)); // nota mas alta (a) del alumno (b) en el primer curso
-->N(:, 6)=[];
-->f5=N($, :); // extracción de las notas del ultimo alumno
-->[c k]=gsort(f5, ‘c’); // notas del ultimo alumno ordenadas y sus
…..correspondientes cursos
4. IMPORTACIÓN Y EXPORTACIÓN DE DATOS (EXCEL) ¿???

19

lOMoARcPSD|26831330
5. SISTEMA DE ECUACIONES LINEALES
Los sistemas de ecuaciones lineales simultáneas consisten en un conjunto de dos o más ecuaciones, con
igual número de incógnitas, por ejemplo, para resolver un sistema de dos incógnitas se requiere un
sistema con dos ecuaciones linealmente independientes. Para resolver un sistema de tres incógnitas se
requiere un sistema con tres ecuaciones y así para cualquier otro número de incógnitas.
En el siguiente ejemplo veremos un sistema de ecuaciones lineales de 3 incógnitas y se podrá denotar
usando notación de matrices
x+2y+z=8
2x+2y+z=9
3x+3y+5z=24
Se crea la matriz de los coeficientes de las incógnitas y la llamamos matriz A, en este caso será una
matriz de 3x3. Creamos un vector X, con las incógnitas de dimensión 3x1. Y finalmente el vector B, con el
valor de las constantes, que se encuentran en el lado derecho de las ecuaciones, este vector también es
de dimensión 3 x 1.
Ahora lo que queremos es resolver la ecuación A * X = B y obtener el valor del vector X.
A*X=B
A-1 *A * X = A-1 * B
Recordemos que A-1 *A = I (la matriz identidad) y que
A-1 * B = A\B es la división izquierda.
X = A\B
Así que la solución en Scilab de un sistema de ecuaciones lineales se reduce a crear la matriz A de
coeficientes y la matriz B de constantes y hacer la operación de división izquierda.
5.1 RESOLUCIÓN INICIAL DE UN SISTEMA DE ECUACIONES LINEALES
Para la resolución “rápida” de sistemas de ecuaciones lineales Scilab dispone del “operador” \ :
Si A es una matriz cuadrada n x n no singular y b es un vector columna de longitud n, entonces
-->A\b
Calcula la solución del sistema lineal de ecuaciones Ax=b. Para recordar la sintaxis, debe asimilarse el
operador \ con una “división por la izquierda”, es deir A\b es como A-1b.
Este operador debe ser usado con precaución: Si la matriz A es singular o mal condicionada, la instrucción
A\b emite un mensaje de advertencia y devuelve una solución del correspondiente problema de mínimos
cuadrados.
Si la matriz A no es cuadrada (teniendo el mismo número de líneas que el segundo miembro) entonces la
instrucción A\b devuelve directamente una solución de minimos cuadrados sin advertir absolutamente
nada. En el caso en que la solución de mínimos cuadrados no es única (la matriz A no es de rango máximo),
la solución que devuelve NO es la de norma mínima.
Para obtener esta última es mejor utilizar la instrucción siguiente, que utiliza la pseudo-inversa de la
matriz A:
-->pinv(A)*b
Los autovalores de una matriz se pueden calcular mediante la función spec:
-->spec(A)
Si se desean obtener, los vectores propios, hay que llamar a la función spec de la siguiente forma:
--> [x,v]=spec(A)

20

lOMoARcPSD|26831330
Mediante la cual se obtienen: v matriz cuadrada diagonal con los autovalores y x: matriz cuadrada
invertible cuya i-ésima columna es un vector propio asociado al i-esimo autovalor.
5.2 OTRAS FUNCIONES DE INTERÉS:
det(A) Determinante de la matriz cuadrada A

rank(A) Rango de la matriz
xcond(A) Numero de condición de la matriz A en norma 2: λmax/λmin (Si es muy grande, la
matriz está mal condicionada).
rcond(A) Inverso del número de condición de la matriz A en norma 1: ( Si es próximo a 1, la
matriz está bien condicionada; si es próximo a cero está mal condicionada).
inv(A) Inversa de la matriz A
lu(A) Factorización de LU de la matriz A
chol(A) Factorización de Cholesky de la matriz A
qr(A) Factorización QR de la matriz A
También se puede resolver utilizado la función linsolve la cual resuelve una ecuación de forma:
A*X + B = 0
donde:
X = linsolve(A,B)
Hay que tomar en consideración que el signo de los valores del vector B que se utiliza con la función
linsolve son el negativo de los valores del vector b utilizados cuando se utiliza la división izquierda. La
razón es que para resolver linsolve se está pasando el vector del lado derecho de la ecuación al lado
izquierdo de la ecuación.
A*X=b
A*X + (-b) = 0
A*X + B = 0
Donde B = -b
EJEMPLO
// ejem B=-b
A=[1 -1 1; 2 1 0; 0 1 -2]
b=[3 -2 -1 ]
B=[-3 2 1]
linsolve(A,B)
ans =
0.75
-3.5
-1.25

21

lOMoARcPSD|26831330
6. POLINOMIOS
Scilab puede manipular obejtos de tipo “polinomio”. Algunas formas de generar polinomios son las
siguientes:
-->p=poly(a, “x”)
Siendo a una matriz cuadrada nxn es el polinomio característico de la matriz a, con variable simbolica x
-->a=companion(p)
Donde p es un polinomio es la matriz “compañera” de p, también, llamada de frobenius, es decir la matriz

cuyo polinomio característico es p.
-->p=poly(v, “x”, “coeff”)
Siendo v un vector numérico es el polinomio, con variable simbolica s, cuyos coeficientes son las
componentes del vector v( en orden de menor a mayor grado)
-->t=poly(0, “t”)
-->p=1+t-4*t^2+%pi*t^5
Define t como un símbolo que permite definir otros polinomios con variable t mediante su expresión
algebraica.
-->roots(p)
6.1 FUNCIONES DE LIBRERIA
Calcula las raíces del polinomio p

EJEMPLO
// ejem:
--> a=[1,2,3;4,5,6;7,8,-9];
--> p=poly(a, "t")
p =
2 3
-54 -126t +3t +t
--> p=poly([1,2,3,4], "x" ,"coeff")
p =
2 3
1 +2x +3x +4x
--> roots(p)
ans =
-0.0720852 + 0.6383267i
-0.0720852 - 0.6383267i
-0.6058296

22

lOMoARcPSD|26831330
Un polinomio se puede definir de dos maneras: por sus coeficientes o por sus raíces. Es necesario además
indicar la variable simbólica para el polinomio.
La orden p = poly([2 3 5 7], "x", "coeff")
Define en la variable p el polinomio 2 + 3x + 5x^2 + 7x^3 .
La orden q = poly([2 3 5], "x", "roots")
Define en la variable q el polinomio −30 + 31x − 10x 2 + x 3 cuyas raíces son exactamente 2, 3 y 5.
Escribir q = poly([2 3 5], "x") produce exactamente el mismo resultado, o sea, "roots" es el tipo de
definición por defecto.
La doble comilla " puede ser remplazada por la comilla sencilla ’. Más aun, se puede remplazar ’coeff’
por ’c’ y ’roots’ por ’r’ . Es permitido escribir
r = poly([6 7 8], ’y’, ’c’) .
La función roots calcula las raíces de un polinomio, sean éstas reales o complejas. Por ejemplo roots(p)
Con polinomios se pueden hacer sumas, multiplicaciones, restas, multiplicación por un numero. Deben
ser polinomios en la misma variable. Por ejemplo:
v = p + q + p*q - 3.1*q
También se puede elevar un polinomio a una potencia, por ejemplo,
r = p^3
La función coeff tiene dos parámetros, el primero es el polinomio y el segundo la potencia. La siguiente
orden asigna a la variable k el valor −10, el coeficiente de x 2 en el polinomio q.
k = coeff(q, 2)
Si se utiliza simplemente c = coeff(q) Se obtendrán todos los coeficientes. La variable c será un.
Si se utiliza p = poly(a, ’x’), donde a es una matriz cuadrada, se obtiene el polinomio característico de la
matriz a.
Para evaluar un polinomio p en un valor t se usa horner(p, t). Por ejemplo horner(q, 1) dará como
resultado −8. Si q es un polinomio, es lícito utilizar la orden r = horner(p, q) para obtener p(q(x)).
Dados los polinomios P(x)=2x4-8x3+3x2+5 y Q(x)=x2+2x-3, Calcula -3P(x)+5Q(x), P(x).Q(x), Q5(x) y (x)/Q(x).
EJEMPLO
// ejem:
-->P=poly([5,0,3,-8,2],"x","coeff"), Q=poly([-3,2,1],"x","coeff")
P =
2 3 4
5 + 3x - 8x + 2x
Q =
2
- 3 + 2x + x
-->-3*P+5*Q
ans =
2 3 4
- 30 + 10x - 4x + 24x - 6x
-->P*Q
ans =
2 3 4 5 6
- 15 + 10x - 4x + 30x - 19x - 4x + 2x
-->Q^5
ans =
2 3 4 5 6 7 8 9 10

23

lOMoARcPSD|26831330
- 243 + 810x - 675x - 360x + 570x + 92x - 190x - 40x + 25x + 10x + x
-->[R,C]=pdiv(P,Q)
C =
2
33 - 12x + 2x
R =
104 - 102x
-->Q*C+R
ans =
2 3 4
5 + 3x - 8x + 2x
6.2 INTERPOLACION Y EXTRAPOLACION
CASOS:
Temperatura (°C) Presión de vapor (torr)
0 4.6
5 6.5
10 9.2
15 12.8
16 13.6
17 14.5
18 15.5
19 16.5
20 17.5
21 18.6
22 19.8
23 21.2
24 22.4
25 23.8
26 25.2
27 26.7
28 28.3
29 30
30 31.8
40 55.3
50 92.5
60 149.4
70 233.7
80 355.1
90 525.8
100 760
110 1074.6
a) Representación grafica
b) Ajustes del polinomio (grado)
c) Interpolación para 75
d) Extrapolación para 120

24

lOMoARcPSD|26831330
7. REPRESENTACIONES GRAFICAS CON SCILAB
Estas notas pretenden expones algunos de los comandos más básicos de que dispone Scilab para generar
gráficos. En principio se exponen, exclusivamente, los comandos de dibujo y posteriormente se explicará
cómo modificar los distintos (y numerosos) parámetros que determinan sus características.
7.1 CURVAS PLANAS (GRÁFICAS 2D)
El comando básico de Scilab para dibujar curvas planas es plot2d y otras variantes se resume en la
siguiente tabla:
Plot2d
Dados dos vectores (VER(*))

x=[x1,x2,………………xn]e y=[y1,y2,…………yn]
-->plot2d(x,y)
Dibuja la curva que pasa por los puntos (x1,y1)……(xn,yn)
Ejemplo:dibujar, en [-5,5]
𝑥
𝑦 = 2𝑠𝑒𝑛( )cos(3x)
2
x=linspace(-5,5)' ;
y=2*sin(x/2).*cos(3*x); // (VER(**))
plot2d(x,y)
También podría ponerse directamente:
x=linspace(-5,5)’;
plot2d(x,2*sin(x/2).*cos(3*x))
(*) Para dibujar una única curva, es diferente que los vectores x e y sean filas columnas sin embargo,
cuando se desean dibujar varias curvas juntas no lo es. Por ellos, usaremos siempre vectores-columna.
(**) Obsérvese que, puesto que se calculan todas las ordenadas “de una sola vez”, es preciso “vectorizar”
la escritura de la formula, para que, al ser el argumento x un vector, la formula devuelva un vector de las
mismas dimensiones calculando elemento a elemento.
Si se hubiera escrito y=2sin(x/2)*cos(3*x) se hubiera obtenido un error, ya que x es un vector columna

de longitud 100 (i.e. una matriz 100x1), luego también sin(x/2) y cos(3*x) son matrices 100x1 y la
multiplicación (matricial) sin (x/2)*cos(3*x) carece de sentido.

25

lOMoARcPSD|26831330
-->plot2d(y)
Dibuja la curva que pasa por los puntos
(1,y1)…….(n,yn)
Ejemplo:
y=2*sin(x/2).*cos(3*x);
plot2d(y)
-->plot2d(x,y)
Siendo x un vector e y una matriz dibuja una curva
por cada columna de y
y=2*sin(x/2).*cos(3*x);
z=2*sin(x);
w=[y,z];
plot2d(x,w)
-->plot2d(x,y)
siendo x e y matrices de las mismas dimensiones,
dibuja una curva por cada par(columna de x,
columna de y)
Ejemplo:dibujar en [-2 pi, 2 pi] la gráfica de
función:
𝟐𝒔𝒆𝒏(𝒙), 𝒔𝒊 𝒙 ≤ 𝟎
𝒚={ 𝒙 }
𝟐𝒔𝒆𝒏 ( ) 𝒄𝒐𝒔(𝟑𝒙), 𝒔𝒊 𝒙 > 𝟎
𝟐
x1=linspace(-2*%pi,0)’;
x2=linspace(0,2*%pi)’;
y1=2*sin(x1);
y2=2*sin(x2/2).*cos(3*x2);
plot2d([x1,x2],[y1,y2])
Observaciones:
 Obsérvese que, por defecto, graficas sucesivas se superponen. Para evitar, hay que borrar la grafica
anterior antes de dibujar de nuevo. Ello puede hacerse o bien cerrando la ventana grafica o bien
borrando su contenido desde la barra de menús (EditErase Figure) o mediante un comando
(xbasc()).
 Cuando se borra el contenido de la ventana grafica, pero no se cierra, se conservan sus características.
Si por ejemp lo, se ha modificado la carta de colores de esa ventana, se seguirá conservando la
carta al borrarla, pero no al cerrarla.
 Cuando plot2d dibuja varias curvas, les asigna distintos colores. El orden de los colores asignados
viene predeterminado por la carta de colores activa.

26

lOMoARcPSD|26831330
Plot2d2, plot2d3, plot2d4

-->plot2d2(x,y)
es similar a plot2d, pero dibuja una
función constante a trozos(escalonada)
-->plot2d3(x,y)
es similar a plot2d, pero dibuja función
utilizando líneas verticales
-->plod2d4(x,y)
es similar a plot, pero dibuja una curva
utilizando puntas de flecha(por ejemplo
para señala la dirección de una
trayectoria)
Gráficas polares
polarplot
-->polarplot(theta,rho)
siendo theta y rho vectores de la misma
dimensión, dibuja la curva que pasa por
los puntos de coordenadas polares
(theta_1, rho_1)……..(theta_n, rho_n)
Ejemplo: ρ = sen(2θ)cos(3θ)
theta=linspace(0,2*%pi)’;
rho=sin(2*theta).*cos(3*theta);
polarplot(theta,rho)
Esta función se puede utilizar también con otros argumentos, como plot2d y su funcionamiento es
similar.

27

lOMoARcPSD|26831330
7.2 CURVAS EN EL ESPACIO (GRÁFICAS 3D)
Estas funciones en 3D tienen varias aplicaciones y se pueden resumir en la siguiente tabla:
param3d
Param3d1
Param3d
--> param3d(x,y,z)
donde x, y , z son tres vectores de la misma
dimensión
Ejemplo:
t=linspace(0,8*%pi);
param3d(t.*sin(t),t.*cos(t),3*t)
Param3d1
--> param3d1(x,y,z)
es similar a param3d, pero permite dibujar
varias curvas,Aquí x, y , z son tres matrices de
la misma dimensión cuyas columnas
determinan las distintas curvas.
--> param3d1(x,y,list(z,colors))
donde colors es un vector de números
enteros, dibuja la i-esima curva del color
definido por el i-esimo elemento de colors.
Ejemplo:
t=linspace(0,5*%pi)';
x=[zeros(t),12*sin(2*t)];
y=[10*cos(t),12*cos(2*t)];
z=[10*sin(t),12*sin(t)];
param3d1(x,y,list(z,[6,2]))

28

lOMoARcPSD|26831330
EJERCICIOS DE GRAFICAS:
1) En la siguiente tabla se tiene los datos correspondientes a las ventas de una empresa X desde el año
2012 a 2018. Haga una representación gráfica simple de la tendencia.
Año 2012 2013 2014 2015 2016 2017 2018
Ventas(millones) 8 12 20 22 18 24 27
Codificación:
x=[2012 2013 2014 2015 2016 2017 2018];
y=[8 12 20 22 18 24 27];
plot2d(x,y)
2) Dada la función y=3x3-26x+6. Dibujar dicha f(x) así como su primera y segunda derivada, en el
intervalo -2<=x<=4. Todas las funciones deben representarse juntas en el mismo gráfico.
x=linspace(-2,4)';
y=3*x^3-26*x+6;
z=9*x^2-26;
w=18*x;
plot2d(x,y), plot2d(x,z), plot2d(x,w)
3) Dada la función y=2(-0.2x+10). Grafique utilizando distintas combinaciones de escalas logarítmicas y

lineales en el intervalo 0.1<=x<=60.
Escala lineal-lineal:
x=linspace(0.1,6)';
y=2^(-0.2*x+10);
plot2d(x,y,logflag="nn")
Escala logarítmica-lineal:
x=linspace(0.1,6)';
y=2^(-0.2*x+10);
plot2d(x,y,logflag="ln")
Escala lineal- logaritmica
x=linspace(0.1,6)';
y=2^(-0.2*x+10);
plot2d(x,y,logflag="nl")
Escala logarítmica-logaritmica
x=linspace(0.1,6)';
y=2^(-0.2*x+10);
plot2d(x,y,logflag="ll")
4) Para el ejercicio 1 presente una gráfica de barras verticales, otra de barras horizontales y una gráfica
de líneas verticales (grafico detallado).
GRAFICA DE BARRAS VERTICAL
x=[2012 2013 2014 2015 2016 2017 2018];
y=[8 12 20 22 18 24 27];
bar(x,y)

29

lOMoARcPSD|26831330
GRAFICA DE BARRAS HORIZONTAL

x=[2012 2013 2014 2015 2016 2017 2018];
y=[8 12 20 22 18 24 27];
barh(x,y)
GRAFICA DE LINEAS VERTICALES

x=[2012 2013 2014 2015 2016 2017 2018];
y=[8 12 20 22 18 24 27];
plot2d3(x,y)
5) En la siguiente tabla se muestra las notas (en letras: A, B, C, D y E) obtenidas por los alumnos de una
promoción (69)
Utilizar estos datos para crear un gráfico circular.
Notas A B C D E
Número de 11 18 26 9 5
alumnos
5.1)
x=[11 18 26 9 5], sp=[0 0 0 0 0], txt=["A","B","C","D","E"]
scf(0);
pie([11 18 26 9 5],[0 0 0 0 0],["A","B","C","D","E"]);
5.2)
x=[11 18 26 9 5]
pie(x), legend("A","B","C","D","E")
6) Los siguientes datos representan las notas (sobre 100) obtenidos por los alumnos de una promoción
(30) del semestre 2018-2:
58,73,73,53,50,48,56,3,73,69,69,63,74,82,84,91,93,89,91,80,59,69,56,64,63,66,64,74,63,69
Presentar un histograma que represente dichos datos por defecto (tamaño 10).
x=[58 73 73 53 50 48 56 73 73 69 69 63 74 82 84 91 93 89 91 80 59 69 56 64 63 66 64 74 63 69]
histplot(30, x, style=10)
8. ENLACE CON LOS PROGRAMAS DE MAT LAB:

30

lOMoARcPSD|26831330
Sección Dos
SECCIÓN 2. SCILAB como lenguaje de programación
SCILAB
como un
lenguaje de
programación
2

31

lOMoARcPSD|26831330

32

lOMoARcPSD|26831330
9. CODIFICACION DE PROGRAMAS:
En Scilab hay dos tipos de programas: los guiones o libretos (scripts) y las funciones. Un guion es
simplemente una secuencia de órdenes de Scilab. No tiene parámetros (“argumentos”) de entrada ni de
salida. En cambio, una función sí los tiene. Por otro lado, las variables definidas en un guion son globales,
es decir, después del llamado del guion estas variables siguen existiendo. En cambio, en una función, las
variables definidas dentro de la función dejan de existir una vez finalizada la ejecución de la función, son
variables locales.
9.1 SCRIPTS
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 autorizar pequeñas
tareas. También puede hacer las veces de un “programa principal” para ejecutar una aplicación.
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: botón “Editor” de la barra de menús o bien usando el orden.
-scipad()
Por convenio, los scripts de Scilab tienen el sufijo *. Sce y para ejecutar un script se usa la orden
-exec(nombre_fichero) // repite todas las instrucciones en pantalla

-exec(nombre_fichero, -1) // para que no repita las instrucciones
Lógicamente en el nombre del fichero hay que incluir el path, caso de que el fichero no esté en el directorio
actual. El nombre del fichero debe ir entre apóstrofes o comillas dobles, puesto que es una cadena de
caracteres.
** Un guion es simplemente un archivo ASCII en el que hay una sucesión de órdenes de Scilab.
Generalmente tiene la extensión .sce, pero eso no es obligatorio. Puede estar colocado en cualquier
carpeta.

33

lOMoARcPSD|26831330
?? En el ejemplo que sigue se va a hacer lo siguiente:
a) Se crea un vector “n” con las notas.

b) Debes tener el promedio” y “y su resultado debe aproximarse a un entero.
c) Se debe crear una variable “D” para introducir la nota más alta del curso.
d) Ahora procedemos a la resolución
Ya sabiendo lo que se va a hacer, con un editor cualquiera creamos el archivo d:\PractiC\prueba01.txt

cuyo contenido sea el siguiente:
EJEMPLO
// prueba01
n = [12, 14, 8, 16, 10],
y =mean(n)
ans=12
D=max(n)
ans=16
Obviamente el nombre de la carpeta (d:\PractiC) es simplemente un ejemplo y hubiera podido ser

cualquier otra carpeta. Una vez guardado el contenido, desde el ambiente Scilab se da la orden
exec (“d:\PractiC\prueba01.txt”)
exec ("d:\PractiC\prueba01.txt", -1)
Esto hace que se ejecuten todas las ordenes contenidas en el archivo. Mediante who, o de cualquier otra
forma, se puede verificar que las variables n, y, D ... fueron creadas y todavía existen.
Dar la orden exec (“d:\PractiC\prueba01.txt”) también se puede hacer por medio de la barra de menú
con las opciones File y después exec. Subiendo y bajando de nivel se busca la carpeta adecuada y se hace
doble clic con el botón derecho del ratón en el archivo prueba01.txt
Si se desea, se puede editar el archivo, hacer algunos cambios, guardarlos y de nuevo activar el guion
mediante el comando exec.
?? En el siguiente ejemplo: suponemos que se tiene una matriz N de tamaño m × n, n ≥ m, r(N) = n, es

decir, tiene menos filas que columnas y sus columnas son linealmente independientes.
Sea (d:\PractiC\prueba02.sce) el archivo que define los datos y lleva a cabo este proceso. Su contenido
puede ser:

34

lOMoARcPSD|26831330
EJEMPLO
// prueba02
//solución
//En que curso se obtuvo la nota más alta.
N= [20, 5, 8, 11, 14, 17;
3, 16, 9, 12, 15, 8;
14, 7, 10, 3, 18,19;
5, 8, 11, 14, 17, 10;
16, 9, 12, 15, 16, 2]
max(N)
ans=20.
Las líneas que empiezan por // son líneas de comentarios (como en C++)
Obviamente para activar este otro archivo se necesita dar la orden
exec (“d:\PractiC\prueba02.sce”, -1)
De manera natural aparece la pregunta: ¿Cómo hacer el mismo proceso con otro sistema de ecuaciones
sin tener que cambiar el archivo? Las funciones son la respuesta.
9.2 ESTRUCTURAS DE CONTROL BASICAS
En esta parte del manual es bueno reiterar que el lector ya tiene algún conocimiento sobre la
implementación de códigos desde las estructuras básicas de control: estructura secuencial, condicional
simple, condicional múltiple, repetitiva mientras y repetitiva desde.
Es decir aquí ya no se explica cómo es el funcionamiento de la estructura while. Simplemente se presenta
algunos ejemplos sobre su escritura en Scilab.
Las principales estructuras de control de Scilab son:
 entrada y salida
 if
 select y case
 while
 for
 entrada y salida con formato (printf, mprintf (fprintf))
Otras órdenes relacionadas con el control de flujo son:

 break
 return equivalent a resume
 abort

35

lOMoARcPSD|26831330
9.2.1 ENTRADA Y SALIDA (estructura secuencial)
Explicar operaciones de E/S
EJEMPLO
Calcular el pago neto semanal de un trabajador conociendo el número de horas trabajadas,

tarifa horaria y la tasa de impuestos
// pago
//
horas= input ( `horas trabajadas`);
tarifa= input ( ` tarifa del trabajo `);
tasa = input ( ` tasa del impuesto `);
pago-total=horas * tarifa ;
impuesto =( * tasa * pago-total – impuesto ) /100 ;
pago-neto = Pago-total – impuesto;
disp ( `pago-neto es : `) , disp (pago-neto );
9.2.2 IF (condicional simple)
Una forma sencilla de la escritura de la escritura if es la siguiente:
if condición then
...
...
end
La palabra then puede ser reemplazada por una coma o por un cambio de línea. Entonces se puede escribir
if condición
...
...
end
Obviamente también existe la posibilidad else:
if condición
...
else
...
end
Estas estructuras se pueden utilizar directamente dentro del ambiente interactivo de Scilab. Por ejemplo,
se puede escribir directamente, sin necesidad de un guion

36

lOMoARcPSD|26831330
if x < 0, fx = x*x, else fx = x*x*x, end
Resulta ineficiente hacer un guion únicamente para las órdenes de la línea anterior. Pero, cuando hay
muchas órdenes y muchos controles y es necesario depurar el proceso, es casi indispensable hacer un
guion o una función.
EJEMPLO
Escribir un algoritmo para leer 3 números enteros diferentes y a continuación escribir el mayor de
los tres
// mayor
//
a = input('digite valor para a');
b = input('digite valor para b');
c = input('digite valor para c');
if a>b
if a>c
max = a;
else
max = c;
end
else
if b > c
max = b;
else
max = c;
end
end
disp ('el mayor de los tres es:'), disp (max);
9.2.3 SELECT y CASE (condicional múltiple)
La forma general es:

select variable
case valor 1 then
…
case valor 2 then
…
case valor 3 then
…
case valor 4 then
…
else
…
end

37

lOMoARcPSD|26831330
La palabra then puede ser reemplazada por una coma o por un cambio de línea. La parte else es opcional.
Entonces se puede escribir
select variable
case valor 1
…
case valor 2 , …
case valor 3
…
case valor 4
…
end
Por ejemplo
select indic
case 0, a = b;
case 1
a = b*b;
b= 1;
case 3
a = max(a,b);
b= a*a;
else
a = b;
b = 0;
end
EJEMPLO
Diseñar un algoritmo para leer el número del día de la semana y luego visualizar la descripción del
día correspondiente. Asumir:
// diasem // analice el cambio respecto al enunciado
//
ndia=input('ingrese el numero del dia-semana: '); // diasemc
select ndia //
case 1,msj='lunes' ndia=input('ingrese el numero del dia-semana: ');
case 2,msj='martes' switch ndia
case {1 3 5}
case 3
msj='miercoles' msj='dia impar';
case 4,msj='jueves' case {2 4 6}
msj='dia par';
case 5,msj='viernes';
case 6,msj='sabado' case 7, msj='dia feriado';
case 7,msj='domingo' otherwise msj='error';
end
else msj='error'
disp(msj);
end
disp(msj);

38

lOMoARcPSD|26831330
9.2.4 WHILE (repetitiva mientras)
La forma general es:

while condición
…
…
end
por ejemplo
e = 1;
while e + 1 > 1
e = e/2;
end
EJEMPLOS
Elaborar un algoritmo para calcular y visualizar el valor de la suma de la siguiente serie

1+2+3+4+…+100
// serie
//
summa =0;
contador = 1;
while contador <= 100
summa = summa + contador;
contador = contador +1 ;
end
disp (‘ la suma de la serie es: ‘), disp (summa);
Desarrollar un algoritmo, para leer un número entero y visualizar dicho número y un mensaje “si es
primo” o “no es primo”.
// nprimo
primo= 0;
i= 1;
num = input (‘ingrese un numero entero ‘);
while 1 <= num
if (mod(num,i)) == 0
primo = primo + 1 ;
end
i = i + 1;
end
if primo ==2
disp(num) , disp(‘si es primo’);
else
disp(num), disp(‘no es primo’);
end

39

lOMoARcPSD|26831330
9.2.5 FOR (repetitiva desde)
La estructura for tiene la siguiente forma:
for var=lim1:incr:lim2
…
…
end
Esto quiere decir que la variable var empieza en el límite inferior lim1, después va a incrementar el valor
en el incremento incr (puede ser negativo). Si el incremento es 1 , este se puede suprimir.
A continuación algunos ejemplos:
for i= 2:3:14
...
…
end
for j= 2:-3:-10
…
…
end
for k=2:8
…
…
end
EJEMPLO
Desarrollar un algoritmo para visualizar la tabla de multiplicación de orden n

// tabla
//
n = input (‘ingrese el orden de la tabla de multiplicar’);
for i=1:n
disp (‘tabla de multiplicar de: ‘), disp (i) ;
for j=1:n
disp (i) , disp(‘ x ‘) , disp(j) , disp(‘ =’), disp.(i*j);
end
end
Una estructura for puede estar anidada dentro de otro for o dentro de un if.

40

lOMoARcPSD|26831330
9.2.6 OTRAS ÓRDENES
La orden break permite la salida forzada (en cualquier parte interna) de un bucle for o de un bucle while.
La orden return permite salir de una función antes de llegar a la última orden. Todos los parámetros de
salida o resultados deben estar definidos con anterioridad. Otra orden que sirve para interrumpir una
función, en este caso interrumpiendo la evaluación, es abort.
Desarrollar un algoritmo para Crear el vector new desde el vector v

// newv
//
v = [2 -1 -4.5 6 -3.2 7.4];
new = [];
for x=v
if x>=0
new($+1)=x;
end
end
disp(v);
disp(new);
9.2.7 FUNCIONES DE ENTRADA Y SALIDA CON FORMATOS
La orden printf es una emulación de la orden del mismo nombre del lenguaje C. Por ejemplo se podría
utilizar la orden: printf (’ a = %3d b = %3d r = %3d’ , a, b, r).
Esta emulación utiliza una comilla en lugar de la comilla doble. Además, al acabar una orden de escritura,
automáticamente hay cambio de línea. Aquí no se necesita el \n de C.
%i
%f
%5.2f
%d
%3d
%c
%g
Sintaxis de la función printf

41

lOMoARcPSD|26831330
EJEMPLO
Calcular el pago neto semanal de un trabajador conociendo el número de horas trabajadas,

tarifa horaria y la tasa de impuestos
// pagof
//
horas = input ('horas trabajadas ');
tarifa = input ('tarifa del trabajo ');
tasa = input (' tasa del impuesto ');
pago_total = horas * tarifa;
impuesto = (tasa * pago_total)/100;
pago_neto = pago_total - impuesto;
printf('Total de ingresos: %7.2f pago de impuesto: %5.2f', pago_total, impuesto);
Sintaxis de la función mprintf
EJEMPLO
Programa para emular una calculador simple

// calcu
//
op1=input('Ingrese el primer operando: ');
op2=input('Ingrese el segundo operando: ');
ope=input('Ingrese la operacion + - * /','s');
select ope
case '+'
r=op1 + op2;
case '-'
r=op1 - op2;
case '*'
r=op1 * op2;
case '/'
r=op1 / op2;
otherwise
r=0;
ope='e';
end
if ope=='e'
mprintf('Operación incorrecta ? r = %f', r);
else
mrintf('%f %c %f = %f', op1,ope,op2,r);
end
Otras órdenes que se pueden utilizar para escritura son:

 fprintf
 print
 write

42

lOMoARcPSD|26831330
10. FUNCIONES DEFINIDAS POR EL USUARIO
Estas funciones permiten definir procedimientos enteramente análogas a las funciones de librería, con su
nombre, sus argumentos y sus valores de retorno.
Las funciones definidas en ficheros *.sci se caracterizan porque la primera línea (que no sea un
comentario) comienzan por la palabra function, seguida por los valores de retorno (entre corchetes [ ] y
separados por comas, si hay más de uno), el signo igual (=) y el nombre de la función, seguido de los
argumentos (entre paréntesis y separados por comas).
Las funciones se pueden definir on-line o bien escribiéndolas en un fichero (ASCII).
Las funciones definidas on-line están disponibles de modo inmediato, veamos algunos ejemplos:
Dada la función s = f(x,y) = √𝒙𝟐 + 𝒚𝟐 . Evaluar para x=3 e y=4

−→ 𝑓𝑢𝑛𝑐𝑡𝑖𝑜𝑛 [𝑠] = 𝑓𝑢𝑛𝑐1(𝑥, 𝑦), 𝑠 = 𝑠𝑞𝑟𝑡(x^ 2 + 𝑦 ^2), 𝑒𝑛𝑑𝑓𝑢𝑛𝑐𝑡𝑖𝑜𝑛
−−> 𝑓𝑢𝑛𝑐1(3,4)
ans =
5.
Dada las notas de un alumno en el vector n= [12, 14, 8, 16, 10], calcular el promedio aritmético simple.
--> 𝑓𝑢𝑛𝑐𝑡𝑖𝑜𝑛 [𝑝] = 𝑓𝑢𝑛𝑐2( 𝑛), ss=sum(n), p=ss/length(n), 𝑒𝑛𝑑𝑓𝑢𝑛𝑐𝑡𝑖𝑜𝑛

--> n=[12, 14, 8, 16, 10 ]
-->func2(n)
ans =
12.
También es posible definir funciones on-line mediante el comando deff:
−−> 𝑑𝑒𝑓𝑓(‘[arg _𝑜𝑢𝑡] = 𝑛𝑜𝑚𝑏𝑟𝑒(𝑎𝑟𝑔_𝑖𝑛)′, ′𝑖𝑛𝑠𝑡𝑟𝑢𝑐𝑐𝑖𝑜𝑛𝑒𝑠′)
Deff se puede usar para definir funciones de secuencias de instrucciones escritas en cadenas de texto. El
objeto de función resultante tiene las mismas propiedades de cualquier otra función definida en un
archivo de texto y cargada con exec.
Ejemplo
Use la facilidad de ayuda (help) de SCILAB`s para encontrar información acerca de deff y su empleo para
definir la función y = f(x) = 2x+1. Evaluar para x=4.
−−> 𝑑𝑒𝑓𝑓(′[𝑦] = 𝑓𝑢𝑛𝑐3(𝑥)′ , ′𝑦 = 2 ∗ 𝑥 +1’)

−−> 𝑠𝑞𝑟𝑡(𝑓𝑢𝑛𝑐3(4))
ans =
3.

43

lOMoARcPSD|26831330
10.1 ESTRUCTURA DE UNA FUNCIÓN
La primera línea en el editor es la definición de la función que comienza con la palabra clave function,
luego se escribe las instrucciones para obtener algún resultado y se finaliza con endfunction.
Las funciones Scilab responden al siguiente formato de escritura:
function [variables_salida] = nombre_funcion (variables_entrada)
sentencias
endfunction
 nombre_funcion, es el nombre significativo que se le asigna a la función y coincide con el nombre del
fichero de extensión .m en el que se guarda el código de dicha función. Las reglas para nombrar un
función son las mismas que para las variables, los nombres no deben de incluir espacios, ni se pueden
utilizar palabras reservadas.
 variables_entrada, es el conjunto de parámetros que se le pasa a la función. Los nombres de las

variables van entre paréntesis y separadas por coma.
 variables_salida, es el valor o conjunto de valores de las variables devueltos por la función. Las
variables de salida van después de la palabra reservada function entre corchetes cuadrados y
separados por comas si hay varios.
 sentencias, líneas de código que tomando los valores de los parámetros de entrada calculan mediante
expresiones los valores que devuelve la función.
 endfunction, marca el final de la función es opcional (salvo en las funciones anidadas) pero es
conveniente acostumbrarse a ponerlo al finalizar la función.
Veamos unos cuantos ejemplos en esta página de funciones:
SUMA DE DOS NÚMEROS

Empezaremos por una función summa que realiza la siguiente tarea, suma dos números x e y y
devuelve le resultado en z = x + y
function [z] = summa (x,y)
// Esta función suma dos números x e y
// y devuelve el resultado en z
z=x+y
endfunction
A la función suma se le pasan dos datos en las variables x e y, y devuelve el resultado en la variable z.
MEDIA Y DESVIACIÓN ESTÁNDAR DE UN CONJUNTO DE DATOS

Creamos una función denominada estad a la que se le pasa un vector x de datos y devuelve la media prom
y la desviación estándard stdev y la guardamos en un fichero con el mismo nombre que la función.

44

lOMoARcPSD|26831330
function [prom, stdev] = estad(x)

n=length(x)
prom=sum(x)/n
stdev=sqrt(sum((x-prom).^2)/(n-1))
endfunction
A la función estad se le pasan dos datos en el vector x, y devuelve los resultados en las variables prom y
stdev.
10.2 LLAMADA A LA FUNCIÓN
Una función se llama del mismo modo que las funciones de librería. Las funciones se pueden llamar desde
la ventana de comandos, desde un fichero script o desde otra función. Todas las variables en una función
son locales a dicha función, incluyendo las de entrada y las de salida.
La llamada a la función se puede hacer desde la ventana de comandos. Diferenciar archivos creados 0n-
line y los almacenados con extensión *.txt
// se puede hacer de otra forma

-->a=2;
-->b=3;
-->summa(2, 3) -->z=summa(a,b)
ans= z=
5 5
En la llamada a la función summa su parámetro x adquiere el valor del primer argumento a, el segundo
parámetro y toma el valor del argumento b, se efectúa la suma en el cuerpo de la función, se guarda el
resultado en la variable z que devuelve la función. El valor que guarda z se copia en la variable res. Las
variables x, y y z son locales a la función y por tanto, no aparecen en la ventana Workspace, no se puede
acceder a ellas desde la ventana de comandos.
Como hemos visto hay que pasar los valores que guardan las variables a y b a la función summa por que
una función no tiene acceso a las variables declaradas en un script o en la ventana de comandos.
En la llamada a la función estad su parámetro x adquiere el valor de un vector único, y retorna dos
resultados:
// // se puede hacer de otra forma

-->x=[]; -->x=[];
-->estad(x) -->[prom stdev]=stad(x)
ans= stdev=
5 5
ans= prom=
12.

45

lOMoARcPSD|26831330
En la siguiente función se calcula el máximo común divisor por el algoritmo de Euclides.
EJEMPLO
function [maxcd, indic] = mcd(a, b)
// Maximo comun divisor de a, b enteros positivos.
// indic valdrá 1 si se calculó el m.c.d
// 0 si los datos son inadecuados.
indic = 0
maxcd = 0
if round(a) ~= a | round(b) ~= b
return
end
if a < 1 | b < 1
return
end
if a < b
t=a
a=b
b=t
end
indic = 1
while 1 == 1
r = modulo(a, b)
if r == 0
maxcd = b
return
end
a=b
b=r
end
endfunction
En el ejemplo anterior, el último return ésta anidado en un solo bucle y después acaba la función, luego
se podría cambiar por un break. La condición del while siempre es cierta, luego la salida del bucle se
obtiene siempre en la mitad del cuerpo del while.
En una función no es necesario el punto y coma después de una orden, pues de todas maneras Scilab no
muestra el resultado de la asignación. Si definitivamente, en una función, se desea mostrar en pantalla
algunos valores intermedios se debe hacer por medio de disp o por medio de printf. Por ejemplo, después
del cálculo de r se puede utilizar la orden
disp (a, b, r)
Observe que primero escribe el valor de r, después el de b y finalmente el de a.

46

lOMoARcPSD|26831330
A continuación se hará un repaso de varias funciones gráficas:
fplot2d
-->flpot2d
donde x es un vector y f es el nombre de una
función Scilab, dibuja la curva que pasa por
los puntos (xi,f(xi)).La función debe
responder a la forma [y]=f(x).
Ejemplo:
x=linspace(-%pi,%pi);
exec(“gf1.sci”,-1)
fplot2d(x,gf1)
FICHERO gf1.sci
Function [y]=gf1(x) Puede resultar interesante observa cómo se “vectoriza”
y= ones(x); el cálculo de esta función:
y(x>=0)= cos(x(x>=0)); 1.La orden y=ones(x) crea un vector de unos, con las
endfunction mismas dimensiones que x: así y será fila o columna (u
otra matriz) según lo sea x
2.La operación de comparación x>=0 produce un vector
booleano de las mismas dimensiones que x. Así, y(>=0)
extrae de y solo aquellas componentes tales que la
correspondiente componente del vector x es mayor o
igual que cero
Paramfplot2d: animaciones
--> paramfplot2d(f,x,t)
donde f es el nombre de una función Scilab
[y]=f(x,t), y x y t son vectores, dibuja una
animación de la función f(x,t), es decir,
dibuja sucesivamente f(x,t1), f(x,t2),……
f(x,tn).
Ejemplo:
X=linspace(-2*%pi,2*%pi);
t=linspace(-1,1,60);
paramfplot2d(gfun2,x,t)
FICHERO gfun2.sci
Function[y]=gfun2(x,t)
y=zeros(x);
b=-%pi<=x & x<=%pi;
y(b)=-t*sin(x(b));
endfunction

47

Manual de Introduccion A Scilab

Cargado por

Copyright:

Formatos disponibles

Manual de Introduccion A Scilab

Cargado por

Información del documento

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

Manual de Introduccion A Scilab

Cargado por

Copyright:

Formatos disponibles

lOMoARcPSD|26831330

Manual de Introduccion a Scilab

Programación (Universidad Nacional Mayor de San Marcos)

Escanea para abrir en Studocu

Studocu no está patrocinado ni avalado por ningún colegio o universidad.

Introducción al lenguaje de programación SCILAB

UNIVERSIDAD NACIONAL MAYOR DE SAN MARCOS

TEMA: INTRODUCCION AL LENGUAJE DE PROGRAMACIÓN SCILAB

MÁXIMO MEDARDO LEYVA CABALLERO

CIUDAD UNIVERSITARIA, 25 DE MARZO DEL 2019

Máximo M. Leyva Caballero – D.A. Análisis y Diseño de Procesos FQIQ-UNMSM

Descargado por MARIA BELEN MUJICA MAGALLANES (maria.mujicam@unmsm.edu.pe)

Introducción al lenguaje de programación SCILAB

Máximo M. Leyva Caballero – D.A. Análisis y Diseño de Procesos FQIQ-UNMSM

Descargado por MARIA BELEN MUJICA MAGALLANES (maria.mujicam@unmsm.edu.pe)

Introducción al lenguaje de programación SCILAB

9.2.1 ENTRADA Y SALIDA (estructura secuencial) ............................................................................. 36

Máximo M. Leyva Caballero – D.A. Análisis y Diseño de Procesos FQIQ-UNMSM

Descargado por MARIA BELEN MUJICA MAGALLANES (maria.mujicam@unmsm.edu.pe)

Introducción al lenguaje de programación SCILAB

Inicialmente desarrollado por el INRIA (Institut National de Recherche en Informatique et Automatique),

En este manual de iniciación a la programación se supone que el lector ya tiene conocimiento de la

1. DOCUMENTACIÓN Y AYUDA ON-LINE

Máximo M. Leyva Caballero – D.A. Análisis y Diseño de Procesos FQIQ-UNMSM

Descargado por MARIA BELEN MUJICA MAGALLANES (maria.mujicam@unmsm.edu.pe)

Introducción al lenguaje de programación SCILAB

En las páginas http://www.scilab.org/product y http://www.scilab.org/publications se puede encontrar

2. NATURALEZA Y SINTAXIS BÁSICO

Máximo M. Leyva Caballero – D.A. Análisis y Diseño de Procesos FQIQ-UNMSM

Descargado por MARIA BELEN MUJICA MAGALLANES (maria.mujicam@unmsm.edu.pe)

Introducción al lenguaje de programación SCILAB

2.1 CONSTANTES Y OPERADORES

Reales Complejos Booleanos

Máximo M. Leyva Caballero – D.A. Análisis y Diseño de Procesos FQIQ-UNMSM

Descargado por MARIA BELEN MUJICA MAGALLANES (maria.mujicam@unmsm.edu.pe)

Introducción al lenguaje de programación SCILAB

Máximo M. Leyva Caballero – D.A. Análisis y Diseño de Procesos FQIQ-UNMSM

Descargado por MARIA BELEN MUJICA MAGALLANES (maria.mujicam@unmsm.edu.pe)

Introducción al lenguaje de programación SCILAB

Máximo M. Leyva Caballero – D.A. Análisis y Diseño de Procesos FQIQ-UNMSM

Descargado por MARIA BELEN MUJICA MAGALLANES (maria.mujicam@unmsm.edu.pe)

Introducción al lenguaje de programación SCILAB

2.2 EMPLEO DE SCILAB COMO CALCULADORA CIENTÍFICA

Orden de las operaciones

Máximo M. Leyva Caballero – D.A. Análisis y Diseño de Procesos FQIQ-UNMSM

Descargado por MARIA BELEN MUJICA MAGALLANES (maria.mujicam@unmsm.edu.pe)

Introducción al lenguaje de programación SCILAB

Máximo M. Leyva Caballero – D.A. Análisis y Diseño de Procesos FQIQ-UNMSM

Descargado por MARIA BELEN MUJICA MAGALLANES (maria.mujicam@unmsm.edu.pe)

Introducción al lenguaje de programación SCILAB

Reconocimiento de algunas variables como palabras claves o reservadas:

who muestra las variables que está usando en ese momento

2.4 ALGUNOS UTILITARIOS DE CONSULTA

Están disponibles algunos comandos utilitarios, como:

Ls Lista de ficheros del directorio actual (como Unix)

Máximo M. Leyva Caballero – D.A. Análisis y Diseño de Procesos FQIQ-UNMSM

Descargado por MARIA BELEN MUJICA MAGALLANES (maria.mujicam@unmsm.edu.pe)

Introducción al lenguaje de programación SCILAB

2.6 FUNCIONES BÁSICAS DE BIBLIOTECA

--> BC --> AB*C