Scilab presenta una serie de constantes predefinidas, protegidas (que no pueden ser borradas ni guardadas con el comando save):
%i = raíz cuadrada de -1, es decir, el número imaginario i
%pi = 3.1415927
%e = 2.7182818
%eps : es el mayor número que cumple la ecuación 1+%eps=1, representa la precisión de la máquina.
%inf : Infinito
%nan : "Not a Number"
%s : es el polinomio poly(0,’s’)
%t = true
%f = false
A parte, el usuario podrá definir otras constantes mediante el comando predef.
Scilab considera los escalares y vectores como matrices.
Pueden ser reales o complejos, y se asignan a
variables nombradas por el usuario:
--> a=5+2*%i // se ejecuta inmediatamente después del retorno de carro
a =
5. + 2.i
--> B=-2+%i; // se ejecuta pero no lo escribe en pantalla
--> b=4-3*%i // son diferentes b y B
b =
4. - 3.i
Si son vectores fila los elementos se separan mediante comas o espacios en blanco, y si son vectores columna mediante punto y comas. Las siguientes líneas incluyen varios comandos, operaciones e instrucciones válidas para vectores (y un breve comentario sobre ellos)
--> x=[2,-3+%i,7,%pi] // se pueden separar con comas o blancos
x =
¡ 2. -3.+i 7. 3.1415927 !
--> x=[2 -3+%i 7 %pi];
--> x(2) // segundo elemento del vector x
ans =
-3 + i
--> x($) // último elemento del vector x
ans =
3.1415927
--> v=x(1:3) // se crea el vector v con parte del vector x
v =
¡ 2. -3.+i 7. !
--> v’ // Con la comilla simple se traspone y se obtiene la matriz compleja conjugada
ans =
¡ -2. !
¡ -3.-i !
¡ 2. ! ];
--> w=[-2;-3+%i;2];
--> x=v’+w; // suma de vectores (con las mismas dimensiones)
--> z=v*w; // producto escalar de vectores (dimensiones apropiadas)
--> q=[]; // matriz vacía
--> size(w) // dimensiones del vector w
ans =
¡ 3. 1. !
--> length(w) // nº de elementos del vector w
ans =
3.
--> w’.*v // multiplicación elemento a elemento (./ sería la división)
ans =
¡ -6 8.-6.i 14.!
--> v=5:-.5:3 // primer elemento:incremento o decremento:último elemento
v =
¡ 5. 4.5 4. 3.5 3. !
--> v=[1 5 6];
--> ones(v) // Vector de unos de las mismas dimensiones que v
ans =
¡ 1. 1. 1. ¡
--> 3*ones(1:4) // Vector de "treses" de la longitud indicada
ans =
¡ 3. 3. 3. 3. !
--> zeros(v) // Vector de ceros de las mismas dimensiones que v
ans =
¡ 0. 0. 0. !
--> t1=0:.01:.1;t2=.11:0.01:1;t=[t1 t2]; // Vector de tiempo o abcisas
--> f1=20*t1;f2=2*ones(t2);f=[f1 f2]; // Vector de valores de f(t)
--> plot(t,f) // visualización gráfica de f(t)
Los elementos de cada fila se separan entre sí por comas o espacios en blanco, y las filas entre sí por punto y coma. La suma, resta y multiplicación escalar se realiza como se ha visto con los vectores (que no dejan de ser matrices fila o columna). Igualmente se podrán multiplicar o dividir elemento a elemento con los operadores .* y ./.
Las siguientes líneas incluyen distintas instrucciones relacionadas con las matrices - y por tanto, vectores- (y un breve comentario sobre ellos)
--> A=[1 2;3 4]
A =
¡ 1. 2. !
¡ 3. 4.!
--> b=ones(2,3) // Matriz de unos de las dimensiones especificadas
b =
¡ 1. 1. 1. !
¡ 1. 1. 1. !
--> B=[5 6;7 8];
--> C=[9 10;11 12];
--> D=[A,B,C] // Matriz que se crea a partir de otras matrices
D =
¡ 1. 2. 5. 6. 9. 10. !
¡ 3. 4. 7. 8. 11. 12. !
--> F=eye(A) // Matriz identidad de las mismas dimensiones que A
F =
¡ 1. 0. !
¡ 0. 1. !
--> G=eye(3,3) // Matriz identidad de las dimensiones especificadas
G =
¡ 1. 0. 0. !
¡ 0. 1. 0. !
¡ 0. 0. 1. !
Las operaciones y manipulación de matrices de polinomios es esencialmente idéntica a las realizadas con matrices de constantes. Con la función poly se puede crear un polinomio a partir de sus raíces o de sus coeficientes, y con roots se pueden obtener las raíces de un polinomio.
Las siguientes líneas
incluyen distintas instrucciones relacionadas con los polinomios
(y un breve comentario sobre ellos)
--> p=poly([1 2],’s’) // polinomio definido por sus raíces
p =
2 - 3s + s2
--> q=poly([1 2],’s’,’c’) // polinomio definido por sus coeficientes
q =
1 + 2s
--> p+q
ans =
3 - s + s2
--> w=p*q
w =
2 + s + 5s2 + 2s3
--> roots(w) // raíces del polinomio w
ans =
¡ -0.5 !
¡ 1. !
¡ 2. !
--> p/q
ans =
1 + 2s
------------
2 - 3s + s2
--> s=poly(0,’s’);
--> A=[1 s;s 1+s^2]
A =
¡ 1 s !
¡ s 1+s2 !
--> B=[1/s 1/(1+s);1/(1+s) 1/s^2]
B =
¡ 1 1 !
¡ ----- ------- !
¡ s 1 + s !
¡ !
¡ 1 1 !
¡ ------- ----- !
¡ 1 + s s2 !
Los sistemas lineales se tratan como un tipo especial de listas (tlist) aunque se puede obviar y tratarlos como funciones de transferencia. Se podrá definir previamente la variable s (variable de Laplace) para utilizarla en los polinomios numerador y denominador, o utilizar la constante predefinida %s.
Las siguientes líneas
incluyen distintas instrucciones relacionadas con los sistemas
lineales (y un breve comentario sobre ellos)
--> g1=syslin(’c’,(%s+2)/(%s^2+3*%s+1));
--> s=poly(0,’s’);
--> g1=syslin(’c’,(s+2)/(s^2+3*s+1))
g1 =
2 + s
----------
1 + 3s + s2
--> numer(g1) // obtención del polinomio numerador de g1
ans =
2 + s
--> g1.num // tambien obtiene el polinomio numerador de g1
--> denom(g1) // obtención del polinomio denominador de g1 (igualmente con g1.den)
ans =
1 + 3s + s2
--> inv(g1)
ans =
1 + 3s + s2
-------------
2 + s
--> g2=1/(s+1)^2;g3=(s+1)/(s+2) // g2 no se lanza a pantalla
g3 =
1 + s
-------
2 + s
--> g4=g2+g3;
--> g5=g2*g3 // se simplifica la pareja polo-cero en s=-1
g5 =
1
-----------
2 + 3s + s2
--> g6=g2/g3;
--> g7=g2/.g3 // FTLC con g2 FTCD y g3 la realimentación
g7 =
2 + s
--------------------
3 + 6s + 4s2 + s3
--> [g2 g3] // vector fila de FTs
ans =
¡ 1 1 + s !
¡ ------------- ------- !
¡ 1 + 2s + s2 2 + s !
--> [g2;g3] // vector columna de FTs
ans =
¡ 1 ¡
¡ ------------- ¡
¡ 1 + 2s + s2 ¡
¡ ¡
¡ 1 + s ¡
¡ ------- !
¡ 2 + s !
Las funciones son colecciones de comandos que se ejecutan en un nuevo entorno. Se pueden crear y ejecutar de varias formas. Lo mejor es crearlas en el editor de texto, pero también se pueden crear directamente en el entorno Scilab utilizando la función deff.
--> deff(’[y]=signo(x)’,’if x>0 then, y=1;else,y=-1;end’)
--> signo(5)
ans =
1.
--> signo(-3)
ans =
-1.
Normalmente si la
función es más compleja se define en un fichero mediante el editor y se
carga en Scilab con la función getf(’nombre_fichero’).
// Texto editado en el editor de texto
Function [y]=fact(x)
aux=1
if x>0 then
for i=1:1:x, aux=aux*1, end
end
y=aux
endfunction
// Ejecución en Scilab
--> fact(4)
ans =
24.
--> fact(-2)
ans =
1.
Existen varios tipos de objetos, y para saber qué tipo de objeto es una variable en concreto se puede saber utilizando la función typeof.
En la siguiente tabla se presentan las diferentes operaciones que se pueden realizar con matrices.
Símbolo Operación
[] Definición de matrices, concatenación
; Separador de filas
() Extracción de parte de una matriz: m=a(k)
() Inserción de un elemento en una matriz: a(k)=m
’ Trasponer una matriz
+ , - , * Suma, resta y multiplicación de matrices
\ División por la izquierda
/ División por la derecha
^ Exponenciación
.* , .^ Multiplicación y exponenciación elemento por elemento
.\ , ./ División por la izq. y por la der. Elemento por elemento
Y en los siguientes ejemplos se muestran diferentes
operaciones que se pueden realizar con las matrices.
--> A=[1 2 3 4;5 6 7 8]
A =
¡ 1. 2. 3. 4. !
¡ 5. 6. 7. 8. !
--> A(1,2)
ans =
2.
--> A(:,2) // todas los elementos (:) de la segunda columna
ans =
¡ 2. !
¡ 6. !
--> A(1,2:4) // elementos de la fila 1, de las columnas de la 2 a la 4 ambas inclusive
ans =
¡ 2. 3. 4.!
--> A(1:2,$-1) // elementos de las fila 1 y 2 de la columna anteúltima ($-1)
ans =
¡ 3. !
¡ 7. !
--> A(1,2)=10 // asigna a la componente (1,2) de la matriz un valor
A =
¡ 1. 10. 3. 4. !
¡ 5. 6. 7. 8. !
--> A(2,:)=10 // asigna a todos los elementos de la segunda fila el valor 10
A =
¡ 1. 10. 3. 4. !
¡ 10. 10. 10. 10. !