Software de clculo cientfico

Scilab
Esta parte trata de las reglas para la escritura
de cdigo en Scilab
Archivos de cdigo (programa)
Smbolos. Operadores relacionales
Tipos de variables
Arreglos. Dimensionamiento, construccin
Estructuras de control
Instrucciones de entrada / salida. Archivos
Funciones predefinidas
 Principales Caractersticas
Scilab es un lenguaje interpretado, lo cual significa que permite
manipular variables de manera dinmica, es decir, no hay necesidad
de declarar variables antes de usarlas.

El software es libre y puede bajarse de la pgina www.scilab.org en

donde tambin puede encontrarse documentacin.

Las variables son creadas al momento en que se les asigna un

valor.

En Scilab, todo puede pensarse como una matriz, es decir toda

variable real, compleja, booleana, entera, caracter y polinmica son
matrices.
 El Editor de Scilab
Scilab provee un Editor que permite editar archivos fcilmente.

Se puede acceder desde el men de la consola bajo

Aplicaciones > SciNotes

o desde la consola escribiendo --> editor().

Permite editar varios archivos al mismo tiempo.

En el men Editar del mismo, se encuentran herramientas tiles,

como por ejemplo Corregir Indentacin

El Editor tambin provee un acceso rpido a la ayuda, solo

clickeando con el botn derecho sobre la palabra reservada se elige la
opcin correspondiente, entre otras herramientas.
 Tipos de archivos de cdigo.
Los cdigos pueden generarse en dos formatos para Scilab:
Fichero de comandos (script):
Cuando se necesitan ejecutar varios comandos en Scilab, los cuales
no tienen argumentos de entrada ni de salida.
las variables definidas en un script son globales.

Se escriben en el Editor de Scilab o en un editor de texto cualquiera con

extensin .sce o .sci, dependiendo de su contenido:
los archivos con extensin .sci contienen funciones y al ejecutarlas las
carga en el entorno de Scilab (pero no las ejecuta)
los archivos con extensin .sce contienen ambas funciones y sentencias
ejecutables (scripts).

Para ejecutar los comandos localizados en el archivo, se utiliza la funcin

exec seguida del nombre del archivo y si es necesario el camino (path):

-->exec("nombre_archivo.sce")

El nombre del fichero debe ir entre apstrofes o comillas dobles, por ser
una cadena de caracteres.
Funcin (function):

La forma ms simple de llamar a una funcin es

outvar = myfunction(invar)

donde
myfunction es el nombre de la funcin,
invar es el nombre de los argumentos de entrada,
outvar es el nombre de los argumentos de salida.

Los valores de argumentos de entrada no son modificados por la funcin

pero si los de salida. Ejemplo: la funcin y=sin(x)

Las funciones pueden tener un nmero arbitrario de parmetros de

entrada y salida, luego una sintaxis para funcin completa sera

[o1 , ... , on] = myfunction(i1 , ... , in)

Los argumentos, se separan por comas. Observar que los de entrada

estn entre parntesis y los de salida entre corchetes.
 Para definir una nueva funcin se utilizan las palabras reservadas de
Scilab function y endfunction.
Por ejemplo, se define la funcin myfunction, la cual toma como
argumento de entrada a x, lo multiplica por 2, y devuelve el valor de salida y.

function y = myfunction(x)
y = 2 * x
endfunction

La sentencia function y = myfunction(x) es el encabezado de la

funcin mientras que el cuerpo de la misma est compuesto por la sentencia
y = 2*x.
El cuerpo de una funcin puede contener una, dos o ms sentencias.
Hay al menos dos posibilidades para definir una funcin en Scilab:
Escribir el archivo directamente en la consola de Scilab de manera interactiva,
primero el encabezado, luego el cuerpo y finalmente endfunction.
Cuando el cdigo fuente esta en un archivo, se escribe en la consola solo la
definicin, lo cual se lleva a cabo en el Editor mediante la herramienta Load into
Scilab o Ejecutar, o tambin mediante el comando exec.
Tambin es posible definir funciones en la lnea de comando (on-line) mediante
el comando deff, es decir:

deff('[outvar]=nombre(invar)',['instrucciones'])
Ejemplos:
Script

Funcin

Archivo: fun1.sci En la consola

function [y] = fun1(x) deff('[s]=fun2(x,y)','s=sqrt(x^2+y^2)'

y = 2*x+1; )
endfunction
En la pantalla:
En la pantalla:
-->fun2(3,4)
-->sqrt(fun1(4))
ans = 5.
ans = 3.
 Smbolos. Operadores relacionales
Smbolos
// Introduce un comentario, se ignora todo lo que sigue a la doble
barra
; finaliza un comando sin que se imprima el contenido de la variable
en pantalla
.. cualquier lnea que termina con dos puntos se considera como el
comienzo de una lnea de continuacin.

Operadores
* asterisco (multiplicacin)
= asignacin / barra inclinada (divisin)
< menor ** ^ doble asterisco (potencia)
<= menor o igual - signo menos (diferencia)
== igual + signo mas (adicin)
~= distinto & y lgico
> mayor | o lgico
>= mayor o igual ~ no lgico
Otros smbolos soportados por el lenguaje
A..Z y a..z letras (no son equivalentes )
0..9 nmeros
_ guin bajo (underscore)
( ) parntesis izq. y der.
[] corchete izq. y der.
, coma
. punto
: dos puntos
; punto y coma
% signo porciento
comilla doble
\ divisin izq., i.e. x\y=x-1y
transpuesto conjugado
 Tipos de variables. Declaracin de variables.
IMPORTANTE:
A diferencia de FORTRAN en Scilab no se declaran las variables.
Permite cambiar el tipo de variable dinmicamente, por ejemplo en una variable
inicialmente real puede luego guardarse un valor de tipo caracter.
Variables matemticas predefinidas Variables Booleanas
(sus nombres comienzan con el caracter %) (almacenan el valor verdadero o falso)

%i el nmero imaginario i %t o %T verdadero

%e la constante de Euler e %f o %F falso
%pi la constante matemtica

Operadores Booleanos (devuelven valores booleanos y toman como argumentos de

entrada todos los datos tpicos : reales, complejos, enteros y caracteres)

a&b operador lgico y (verdadero si lo son a y b simultneamente)

a|b operador lgico o (verdadero si lo son a, b o ambos (inclusivo))
~a operador lgico negacin
a==b verdadero si las dos expresiones son iguales
a~=b o a<>b verdadero si las dos expresiones son diferentes
a<b verdadero si a es menor que b
a>b verdadero si a es mayor que b
a<=b verdadero si a es menor o igual que b
a>=b verdadero si a es mayor o igual que b
Precedencia de operadores

2 * 3 + 4 se obtiene ans = 10.

2 + 3 * 4 se obtiene ans = 14.

2 / 3 + 4 se obtiene ans = 4.6666667

2 + 3 / 4 se obtiene ans = 2.75

Uso de Parntesis

2 * (3 + 4) se obtiene ans = 14.

(2 + 3) * 4 se obtiene ans = 20.

(2 + 3) / 4 se obtiene ans = 1.25

3 / (2 + 4) se obtiene ans = 0.5.

 Arreglos. Dimensionamiento, construccin
Es el tipo de dato bsico de Scilab, el cual est definido por
el nmero de filas
el nmero de columnas
el tipo de dato (puede ser real, entero, booleano, caracter y polinmico)
Dos matrices con el mismo nmero de filas y de columnas se dice que tienen la
misma forma.
Los vectores son un caso particular de matrices los cuales tienen el nmero de filas
(o columnas) igual a uno.
Las variables escalares no existen en Scilab: se considera como escalar una matriz
de 1 x 1.
Scilab fue creado con el objetivo de realizar los clculos matriciales lo ms rpido
posible. Lo cual permite operaciones de lgebra lineal con un lenguaje de alto nivel.
Muchas de las operaciones algebraicas bsicas (+,-,etc.) son efectuadas a travs de
un cdigo fuente compilado y optimizado.
Con dichos operadores de alto nivel, muchos de los algoritmos matriciales no
requieren la utilizacin de lazos (loops). De hecho, un script que calcula la misma
operacin es tpicamente de 10 a 100 veces ms lento.
 Arreglos. Dimensionamiento, construccin
Los smbolos utilizados para definir una matriz son
"[]" marcan el inicio y el final de una matriz
"," o " " separan las columnas
";" separan los valores de las filas
Existen comandos de Scilab que permiten crear matrices de un tamao especfico,
por ejemplo un determinado nmero de filas y columnas.
Los ms utilizados son zeros, ones and eye. Estos comandos toman como
argumento de entrada el nmero de filas y columnas para generar una matriz de
ceros, de unos y una matriz identidad respectivamente.
Hay distintas formas de acceder a los elementos de una matriz A:
la matriz completa, con A como sintaxis,
elemento por elemento mediante al sintaxis A(i,j),
mediante un rango de valores de los ndices mediante el operador ":
Operaciones: Si se escribe un punto "." antes de un operador, la operacin se
interpreta elemento a elemento. Por ejemplo: observar que si A=ones(2,2) y
B=ones(2,2), luego A*B=4*ones(2,2) y A.*B=2*ones(2,2).
Por ejemplo, una matriz de 2 x 3 de valores sera
-->A = [1,2,3;4,5,6]
A =1. 2. 3.
4. 5. 6.
y un vector de tres componentes: -->b = [1,2,3] o c=b o d=A(2,:)
 Estructuras de control
ALTERNATIVAS Ejemplo:
if (cond1)
if ( %f ) then
disp("Hello !")
[else if (cond2)] ] else
disp("Goodbye !")
[else] end
.
end

select var , Ejemplo:

case selec1 then i = -5;

select i
case selec2 then case 1
disp ("One")
case 2
case selecn then disp ("Two")
case 3
disp("Three")
else
else
error("Unexpected value of the parameter i")
end end
REPETITIVAS Ejemplo:

(repetir mientras) Ejemplo: k = 0;

while 1==1,
while (cond) s = 100; k = k+1;
while s > 50 if k > 100 then
end disp(s^2) break
s = s-5; end;
end end
break: se utiliza para interrumpir un lazo.
continue: permite pasar al siguiente lazo, de manera tal que las instrucciones en el cuerpo
del lazo actual no se ejecuten.
abort: se utiliza para detener la ejecucin de la iteracin actual. Muy utilizado en procesos
de depuracin de cdigo.

(conteo controlado) Ejemplo:

for var = inic: paso: fin for i = 5 : - 1 : 1

disp(i)
end
end
Salida: 5. 4. 3. 2. 1.
 Instrucciones de entrada / salida. Archivos

[fd] = mopen(file[,mode,swap])
donde file = nombre del archivo, mode = caracter, swap = escalar.
mclose([fd])
donde fd = escalar

fd especifica una referencia numrica (canal) para el archivo nombrado

(no debe estar en uso)
mode especifica el estado del archivo nombrado, puede ser:
r Abre un archivo existente (para leer)
rb Abre un archivo binario existente (para leer)
rt Abre un archivo de texto existente (para leer)
w Crea un nuevo archivo (para escribir)
wb Crea un nuevo archivo binario (para escribir)
 Instrucciones de entrada / salida. Archivos
Antes de trabajar con un archivo, se debe elegir el lugar de trabajo en la
mquina.
Ejecutando el comando pwd en la consola, nos informa el lugar donde se
grabarn los archivos con su respectiva ruta. Para cambiarlo, se selecciona en
File > Cambiar directorio actual

Ejemplo: Crear el archivo resultado.txt y escribir en el mismo los vectores s y t

s = [0:10]';
t = [0:2:20]';
fid = mopen('resultado.txt','w')
//crea el archivo resultado
mfprintf(fid,'%15.7f %15.7f\n',[s,t])
//imprime en el archivo primero la columna s y al lado la
columna t
mclose(fid)
Ejemplo: Crear el archivo resultado.txt y escribir en el mismo los vectores s y t
Salida:
0.0000000 0.0000000
2.0000000 1.0000000
4.0000000 2.0000000
6.0000000 3.0000000
8.0000000 4.0000000
10.0000000 5.0000000
12.0000000 6.0000000
14.0000000 7.0000000
16.0000000 8.0000000
18.0000000 9.0000000
20.0000000 10.0000000
Ejemplos:

largo.sce

// calcula la distancia entre el origen y el punto

x = input("Ingrese la coordenada x del punto: ")

y = input("Ingrese la coordenada y del punto: ")
disp(neuclid(x,y),"La distancia desde (0,0) al punto
seleccionado es:")

neuclid.sci

//calcula la norma Euclidea

function z = neuclid(s,t)
z = sqrt(s*s+t*t)
endfunction
camcor.sce

//calcula la coordenada del punto

r = input("Ingrese el radio del punto: ")

a = input("Ingrese el angulo del punto: ")
disp(polcar(r,a),"La coordenada cartesiana del punto
ingresado es: ")

polcar.sci

function [x,y] = polcar(r,a)

//cambia de coord polares (r,a) a cartesianas(x,y)

x = r*cos(a); //angulo en radianes

y = r*sin(a);
endfunction
 Funciones predefinidas
cos(x) devuelve el coseno(x), x esta en radianes
acos(x) devuelve arco coseno de (x) en radianes
sin(x) devuelve el seno(x), x esta en radianes
asin(x) devuelve arco seno de (x) en radianes
tan(x) devuelve la tangente de (x), x esta en radianes
atan(x) devuelve arco tangente de (x) en radianes
exp(x) devuelve el valor de ex
log (x) devuelve el logaritmo neperiano de x
log10 (x) devuelve el logaritmo base 10 de x
sqrt (x) devuelve la raz cuadrada de x (x 0)
abs (x) devuelve |x|
int (x) devuelve la parte entera de x
ceil (x) devuelve el valor entero ms cercano hacia +
floor (x) devuelve el valor entero ms cercano hacia -
[nr,nc]=size(x) devuelve el nmero de columnas y filas de una matriz (dimensin)
n=length(M) devuelve la cantidad de elementos de una lista
y=sum(x) para un arreglo x, devuelve la suma de todos sus elementos en el escalar y.
 Ejemplo: Bascara
//PURPOSE: Roots of linear and cuadratic polynomials else // Dos races complejas conjugadas
//**************************************************************************** rc1(1)=-b/den;
//No hace falta declarar las variables rc1(2)= +sqrt(-rad)/den;
// Body of BASCARA rc2(1)= -b/den;
rc2(2)= -sqrt(-rad)/den;
// Lectura de datos disp('Dos raices complejas conjugadas')
disp('Raices de los polinomios y = a x^2 + b x + c o de y = b x + c') disp(rc1(1),'real r1=')
disp(' ') disp(rc1(2),'imag r1=')
a = input('Ingrese el valor del coeficiente a: ') disp(rc2(1),'real r2=')
disp(rc2(2),'imag r2=')
b = input('Ingrese el valor del coeficiente b: ') end
c = input('Ingrese el valor del coeficiente c: ') //
// end
if (a==0) then // Polinomio lineal //
end
if (b~=0) then
r1 = -c/b;
disp(r1,'La raiz del polinomio lineal es = ')
else
disp('Recta paralela al eje x, no hay raiz')
end
else
b2 = b*b; // cuadrado del coef. b
rad = b2 -4*a*c; // radicando
den = 2*a; // denominador de Bascara
//
if (rad==0) then // Una raz real doble
r1 = -b/den;
// r2 = r1
disp(r1,'Una raiz real doble, r1 = r2 = ')
//
else if (rad>0) then // Dos races reales distintas
r1=(-b+sqrt(rad))/den;
r2=(-b-sqrt(rad))/den;
disp('Dos raices reales distintas')
disp(r1,'r1 = ')
disp(r2,'r2 = ')
//