Anlisis matricial de estructuras con SCILAB

Parte 1- Introduccin
Este trabajo contiene una descripcin detallada de los principales elementos del entorno integrado de SCILAB, cuyo objetivo es dar a los estudiantes de ingeniera y de otras carreras tcnicas, que no tienen conocimientos avanzados de informtica, la posibilidad de desarrollar rpidamente aplicaciones para la solucin de problemas de mecnica de estructuras, en un lenguaje de alto nivel, con una interfaz interactiva de gran calidad, y lo que es todava mejor, utilizando software libre, continuamente actualizado.
Autor: Prof. Ing. Jos Luis Volta Grau Ctedra de Estructuras 2 y Estructuras 3 Facultad de Ingeniera-U.N.A. Octubre -2010

J.L.Volta / Anlisis matricial de estructuras con Scilab-Parte 1

1. Informtica para clculos de ingeniera

Actualmente, los programas o aplicaciones informticas para clculos de ingeniera suelen contener varios mdulos con tareas especficas, como ser: a) b) c) d) e) f) g) interfaz de usuario; edicin de datos (input); verificacin de los datos (pre-procesamiento); graficacin de datos (pre-procesamiento); procesamiento de datos; salida de resultados (output); graficacin de resultados (post-procesamiento);

Una aplicacin puede incluir todas estas tareas, o solamente algunas, y complementarse con otras aplicaciones para las tareas restantes. La interfaz de usuario puede ser la tarea que requiere ms trabajo y tiempo de desarrollo. Antes de la industrializacin del software, que fue posible con la Programacin Orientada a Objetos (POO en el lenguaje informtico), y de los actuales sistemas operativos con interfz grfica, era comn el uso de programas con una interfz de usuario muy simple, o sin interfaz alguna, usando la lnea de comandos para correr el programa, con una sintaxis como la siguiente: >nombre_del_ejecutable(archivo_de_datos) donde archivo_de_datos era un archivo de texto en caracteres ASCII que contena los datos ordenados y formateados exactamente como el programa poda interpretarlos. El programa procesaba los datos y grababa los resultados en un archivo de texto que se poda leer con cualquier editor de textos. Actualmente casi no hay aplicaciones que no tengan su interfz grfica de usuario o GUI (Grafical User Interface), que consiste en barras de mens, barras de herramientas, cuadros de dilogo, etc. El desarrollo de esta fase del programa se ha facilitado muchsimo con los lenguajes visuales (Visual Basic, Visual C, Delphi, Java-Swing, etc.) Las siguientes tareas no son menos complicadas que la primera: edicin y verificacin de datos van enlazadas, ya que los datos deben ordenarse de un modo congruente con lo que el programa espera leer en cada paso: formato, tipo, cantidad de datos, etc., y verificar que los datos sean consecuentes con los clculos a realizar con los mismos. Los datos pueden editarse en dos formas: interactivamente, o en un archivo de texto o planilla electrnica. Para programas que requieren pocos datos de entrada es ms simple editar interactivamente, usando un cuadro de dilogo por ejemplo, pero si son muchos datos (ms de un centenar, por ejemplo) es ms cmodo editar en un archivo. Graficar los datos y los resultados son, en ingeniera, la mejor forma de verificar los clculos, pero la programacin de esta tarea requiere el empleo de un lenguaje que permita programar grficos con facilidad, de lo contrario es una tarea harto difcil. El procesamiento de datos y la salida de resultados son las partes ms simples del desarrollo de la aplicacin, las que consisten en implementar los algoritmos de clculo, tarea para la cual el ingeniero est normalmente bien entrenado, en la materia tcnica especfica que es el objetivo de la aplicacin.
1

J.L.Volta / Anlisis matricial de estructuras con Scilab-Parte 1

2. Usando SCILAB en aplicaciones para ingeniera

Scilab es un Entorno Integrado de Desarrollo (EDI en el lenguaje informtico, o IDE en ingls) que es adems interactivo, es decir que puede ejecutar directamente comandos, sentencias, u rdenes escritas en una ventana de comandos y mostrar un resultado como si fuese una calculadora. Es similar a la aplicacin comercial MatLab, pero a diferencia de sta, Scilab es de cdigo abierto y de distribucin libre y gratuita. Otras aplicaciones free-software similares son: Octave (con QtOctave como EDI); Euler, FreeMat, etc., pero algunas caractersticas de Scilab, que las otras no poseen, lo hacen preferible para nuestro trabajo. Algunas de sus caractersticas principales son: - lenguaje propio, de alto nivel, con caractersticas similares a otros lenguajes como C, Pascal, Java y Fortran. La interfaz de usuario est escrita en Java, a partir de la versin 5. Muchas funciones se desarrollaron originalmente en Fortran. La sintaxis, por su parte, tiene una estructura ms parecida a Pascal que a C; - el lenguaje es funcional, no es orientado a objetos; no obstante es posible usar el propio entorno integrado para disear una interfaz de usuario, con mens y cuadros de dilogos sencillos; - puede usarse interactivamente, como una calculadora, o bien corriendo un "script" de comandos y/o funciones guardadas en un archivo de texto; esta interactividad facilita la depuracin del cdigo, mediante la prueba y el error", inspeccin de valores de variables en tiempo de corrida, etc., sin necesidad de un depurador propiamente dicho; - todas las variables son matrices dinmicas de algn tipo base (entero, real, imaginario, boolean, cadenas de caracteres, etc). El tipo se define al asignar el primer elemento de la matriz. El tamao de la matriz crece automticamente al asignar nuevos elementos (matrices dinmicas); - las funciones pueden devolver cualquier cantidad de argumentos, incluso opcionales (usando el parmetro "varargout"), comportamiento similar a los "procedures" de Pascal o "sub" (rutinas) de Basic; - tiene capacidad para graficar datos o funciones de una forma sencilla en una ventana grfica especfica; Estas caractersticas hacen de Scilab una herramienta muy valiosa para los tcnicos que deben realizar clculos matemticos repetitivos con matrices, ecuaciones diferenciales, sistemas lineales y no lineales de ecuaciones, etc. Si estos clculos repetitivos o rutinarios se programan en una aplicacin, es obvio el ahorro de tiempo y trabajo que esto significa para el profesional.

J.L.Volta / Anlisis matricial de estructuras con Scilab-Parte 1

3. Un vistazo al entorno integrado de Scilab

La versin de Scilab utilizada para este trabajo es la 5.2.2, liberada en Mayo del 2010. La aplicacin presenta una ventana principal que contiene una barra de mens, una barra de herramientas y una ventana de comandos (command window) donde se interacta con el usuario.

Estudiaremos ahora algunos comandos de la barra de mens. Advertimos de antemano que, hasta la fecha, todo en el IDE de Scilab est en Ingls o Francs, incluyendo la ayuda en lnea; no hay traduccin al Espaol, aunque hay un documento .pdf en portugus, en el sitio www.scilab.org. Comando File/Execute: carga y ejecuta un script (extensin .sce) o un archivo de funciones (extensin .sci); Comando File/Open a file: abre un archivo de texto *.sce o *.sci en el editor propio de Scilab (llamado simplemente Editor en esta versin); Comando File/Load environment: carga variables y entorno de una sesin previa, grabada con el comando File/Save environment; Comando File/Change current directory: cambia el directorio de trabajo actual; Comando Applications/Editor: abre el editor integrado; Comando ?/Scilab help: ayuda detallada de las funciones, comandos, etc.

J.L.Volta / Anlisis matricial de estructuras con Scilab-Parte 1

4. Trabajando con una calculadora matricial

Toda variable en Scilab es interpretada como una matriz de algn tipo, el cual se define al asignar el primer elemento. Para aprender la sintaxis del lenguaje de Scilab y las funciones del entorno, lo mejor es comenzar a trabajar interactivamente. El prompt --> indica que est esperando una sentencia; 4.1 Definicin implcita de matrices: a) definiendo una variable cualquiera: a diferencia de otros lenguajes, no se requiere una definicin explcita del tipo ni tamao de una variable (matriz): si escribimos: -->a=3.4 * 5.2 Scilab acepta el dato, lo evala como un nmero real y responde con un eco: a= 17.68 b) escribimos: -->a=3.4 * 5.2; no hay eco si la lnea termina con el punto y coma (;) para ver el resultado tecleamos: -->a a= 17.68 O bien, usando la funcin disp (por display): -->disp(a) 17.68 OJO: los nombres de variables deben contener letras del alfabeto ingls, nmeros y otros caracteres permitidos (no usar vocales con acentos, y evitar la letra ''); c) asignamos otros elementos a la matriz a: -->a(2,3)=-4.66 * %pi %pi es el nmero pi , constante pre-definida.

el eco despliega una matriz de 2x3 en la ventana de comandos, con a(1,1)=17.68 y a(2,3)=-14.639822, los dems elementos = 0; Scilab aument automticamente el tamao de la matriz a para dar cabida al nuevo elemento. Observacin importante: en Scilab el primer elemento de una lista, vector o matriz, tiene subndice(s) 1 y no cero como en los lenguajes de programacin C, Pascal, Java, Basic, etc. Esto es porque Scilab es una aplicacin para matemticas (los matemticos cuentan desde 1 y no desde cero, a diferencia de los profesionales informticos); d) la matriz a definida arriba es de tipo real (float o double); si asignamos: -->a(2,2)=m // se produce un error, a solo acepta nmeros; e) Scilab distingue maysculas de minsculas, por lo que A(1,1) no es lo mismo que a(1,1), es otra variable; esto lo acerca a C y lo distancia de Pascal, que no distingue maysculas de minsculas;
4

J.L.Volta / Anlisis matricial de estructuras con Scilab-Parte 1

f)

Se puede copiar la variable a en la variable b: -->b=a;

g) Para comprobar que todos los elementos de b son iguales a los de a escribimos: -->chk=(b==a) chk = TTT TTT devuelve una matriz booleana, con todos sus elementos = T (true); Scilab define 2 constantes boolean: %t para valores verdaderos y %f para valores falsos; -->%t T -->%f F Si cambiamos el valor de un elemento de la matriz b: -->b(2,2)=8.72, -->chk=(b==a) devolver F para el elemento 2,2 de la matriz chk: chk = TTT TFT 4.2 Definicin explcita de matrices: --> unavar=[ ] crea una matriz vaca, sin tipo, y lo asigna a la variable unavar

--> num=[3.4,-3.4;0.114,3.44] crea una matriz 2x2 de nmeros reales, las filas se separan con punto y coma (;), y los elementos de cada fila se separan con coma (,); --> items=[item-1,item-2,item-3] crea un vector fila de 1 fila x 3 columnas, de elementos alfanumricos o de caracteres, los cuales deben ir entre comillas simples o dobles; --> filas=[item-1;item-2;item-3] alfanumrica; crea un vector columna 3 filas x 1 columna,

--> chk=[%f,%t,%f,%t] crea un vector fila de tipo bolean (%t=true, %f=false son constantes predefinidas de Scilab. 4.3 Matrices definidas por funciones Scilab posee una extensa y variada cantidad de funciones para diversos tpicos: funciones matemticas, para manejo de archivos, para interfaz de usuario, funciones utilitarias, para optimizacin y simulacin, modelado de sistemas, para grficos, etc. En nuestro trabajo utilizaremos slo una pequea cantidad de estas funciones. Funciones que definen matrices numricas: a) -->a=rand(3,3) genera una matriz de nmeros aleatorios de 3x3
5

J.L.Volta / Anlisis matricial de estructuras con Scilab-Parte 1

b) -->m=zeros(3,3) crea una matriz m (3x3) de ceros (matriz cero); c) -->m=ones(3,3) crea una matriz m (3x3) unitaria; e) -->m=eye(3,3) eye (ojo)); crea una matriz m identidad [ I ] (3x3) (se lee como la palabra inglesa

e) --> m=emptystr(3,3) crea una matriz 3x3 de elementos alfanumricos vacos; no se debe confundir con la matriz vaca que explicamos antes. 4.3 Operaciones con matrices numricas a) -->d=b-a devolver la diferencia de las matrices (deben ser del mismo tamao, de filas y columnas); b) -->3.5 * num; todos los elementos de num se multiplican por 3.5; c) --> x=num*a; producto; num es de 2x2, a de 2x3 la operacin devuelve en x de 2x3 el

d) --> x=a*num produce un error, la multiplicacin no es conmutativa en general, el nmero de columnas del 1er factor debe ser igual al nmero de filas del 2; e) si a, b y num son las matrices definidas arriba, se comprueba la propiedad distributiva del producto: --> c=num*(a+b) --> d=num*a+num*b

se observa que c y d son iguales.

el orden de las operaciones puede introducir errores de redondeo para los ltimos dgitos, por lo que la operacin: --> chk=(num*a+num*b==num*(a+b)) puede devolver una matriz con algunos elementos %f (false), por lo que este modo de comprobacin no es aconsejable para esta operacin; f) -->e=b devuelve la transpuesta de b usando el operador comilla simple (); g) -->f=b * a devuelve el producto vectorial de b' * a; h) -->f=b *a*b devuelve el doble producto de b' * a * b; i) -->g=inv(a) devuelve en g la matriz inversa de a; j) copiar filas o columnas de una matriz: -->props(2,5)=-3.4; // asignamos -3.4 al elemento (2,5) de la matriz props; -->props(2,3)=5.99; -->unafila=props(2,:) copiamos en 'unafila' todos los elementos de la 2 fila de 'props', unafila = 0. 0. 5.99 0. - 3.4

El signo dos puntos (:) indica 'todos los elementos' de filas o columnas;
6

J.L.Volta / Anlisis matricial de estructuras con Scilab-Parte 1

-->unacol=props(:,3) copia en 'unacol' la 3 columna de 'props'; unacol = 0. 5.99 k) tamaos del vector o matriz: usamos la funcin size: -->props=zeros(4,8); creamos una matriz de ceros, de 4 filas, 8 columnas; -->[fila,col]=size(props) devuelve los tamaos de filas y columnas; -->filas=size(props,1); devuelve el tamao de filas; En esta funcin se v que Scilab admite sobrecarga de funciones, o sea que una funcin puede tener ms de una sintaxis, con parmetros diferentes.

5. Otros tipos de variables

Adems de los tipos simples ya vistos: carcter, cadenas, nmeros enteros, nmeros reales, nmeros imaginarios, booleans, y sus arreglos en matrices, Scilab define otros tipos compuestos (slo mencionamos los que pueden ser tiles para el objeto de este curso). Estas variables estructuradas se crean con una funcin apropiada. lista: es una secuencia indexada de cualesquiera objetos de Scilab, por ejemplo, se puede crear la siguiente lista, definiendo antes la matriz MC:

-->MC=[12.5,33;105,008]; -->ml=list(Tipo 1,35,Tipo 2,27,Contado,%t,Tabla,MC); -->disp(ml(3)); // devuelve el elemento 3 de la lista indexada estructura: una estructura es un tipo record (en Pascal) o 'struct' (en C), con pares de datos campo-valor, donde campo es una cadena de caracteres y valor cualquier tipo de objetos de Scilab, por ejemplo: -->ms=struct(Tipo 1,36,Tipo 2,27,Contado,%t,Tabla,MC); -->disp(ms.Contado); // Contado es el campo y devuelve el valor T -->disp(ms.Tabla); // Tabla es el campo y devuelve la matriz MC

6. Constantes includas en Scilab

Scilab define algunas constantes globales tiles para el clculo numrico: a) Constantes matemticas: %pi (nmero pi); %e (base de logaritmos naturales), %nan (not a number): si un elemento de una matriz numrica es una cadena o un boolean, se reemplaza por Nan para evitar que se levante un error;

7. Funciones tiles del GUI (Graphical User Interface)

Las siguientes funciones son tiles para el trabajo interactivo y tambin para la programacin de script:
7

J.L.Volta / Anlisis matricial de estructuras con Scilab-Parte 1

b) -->home devuelve el directorio de la cuenta del usuario actual. En Windows XP ser: C:\Documents and Settings\<cuenta del usuario>; c) -->SCIHOME devuelve el directorio donde se instal Scilab; d) -->pwd devuelve el directorio de trabajo actual, que puede cambiarse con la funcin chdir() o con el comando File/Change current directory del men File; e) -->who despliega en pantalla todos los nombres de las variables declaradas en la sesin de trabajo actual; f) -->resp=chdir(<nuevo directorio>), cambia el directorio de trabajo actual, devuelve 'T' si el cambio tuvo xito, 'F' en caso contrario; tambin puede usarse el comando de men File/Change current directory; g) -->clc borra el contenido de la ventana de comandos (limpia la ventana); h) -->get_absolute_file_path(<nombre_archivo>), devuelve la ruta completa (incluyendo el ltimo separador \ de nombres) del archivo nombre_archivo, que contiene un script que se ejecuta en Scilab,; el archivo debe estar abierto en Scilab; h) -->archivo=uigetfile(mscara, directorio inicial, ttulo del dilogo): cuadro de dilogo para seleccionar un archivo para abrir; todos los parmetros son opcionales, por lo que normalmente escribiremos simplemente archivo=uigetfile(). Pero por ejemplo, si queremos abrir el archivo miarch.dat en el directorio c:\documents and settings\estructuras-3\mis documentos\jose luis, escribimos: -->midir='c:\CursoScilab; -->arch=uigetfile(*.dat,midir,Abrir archivo de datos); La funcin devuelve el nombre completo (el path o ruta) del archivo (en este ejemplo 'c:\CursoScilab\misdatos.dat'), si se pulsa el botn 'Open' del cuadro de dilogo; si se pulsa 'Cancel' devuelve una cadena vaca;

J.L.Volta / Anlisis matricial de estructuras con Scilab-Parte 1

i) -->archivo=uiputfile(mscara, directorio inicial, ttulo del dilogo), dilogo para seleccionar un archivo para grabar datos; repitiendo el ejemplo anterior, para guardar el archivo 'misdatos.dat', contenido en la variable 'arch' que recin abrimos, escribimos: -->arch=uiputfile(*.dat,midir,Guardar archivo de datos); La funcin devuelve el nombre completo (el path) del archivo si se pulsa el botn Guardar del cuadro de dilogo; si se pulsa Cancelar devuelve una cadena vaca;

Si el archivo ya existe, la funcin despliega un mensaje adicional para asegurarse que el usuario desea reemplazar el archivo existente:

Si se pulsa 'Yes' la funcin devuelve el 'path' completo del archivo (en este ejemplo 'c:\CursoScilab\misdatos.dat'), si se pulsa 'No' devuelve una cadena vaca. OJO: las funciones anteriores no guardan nada, slo devuelven el 'path' de un archivo para leer o guardar datos. Para guardar las variables x1,x2,...xn en el archivo 'archivo' en formato binario usamos 'save': -->save(archivo,x1,x2,xn), guarda las variables x1,x2xn en el archivo archivo en formato binario; funcin simple que ahorra mucho trabajo de programacin para guardar matrices en archivos; por ejemplo: -->personal=[nombre-1; nombre-2; nombre-3]; -->edad=[25,46,33]; -->profesion=[estudiante,contador,agricultor];
9

J.L.Volta / Anlisis matricial de estructuras con Scilab-Parte 1

La sentencia: -->save(arch,personal,edad,profesion]; guarda las matrices en el archivo 'misdatos.dat', cuyo 'path' (obtenido con la funcin 'uiputfile') est contenido en la variable 'arch',; k) -->load(archivo,x1,x2,xn), recupera variables del archivo guardadas con la funcin save; antes de recuperar los valores de las variables no aseguramos de que stas no existan, eliminando las variables 'personal', 'edad' y 'profesin', con la funcin 'clear': -->clear('personal', 'edad', 'profesion'); esta funcin elimina las variables personal edad y profesion que definimos antes; alternativamente podemos borrar todos los datos de estas matrices, sin eliminarlas, escribiendo: -->personal=[] -->edad=[] -->profesion=[] luego recuperamos las matrices guardadas en el archivo 'misdatos.dat', cuyo 'path' est contenido en la variable 'arch', escribiendo: -->load(arch), luego podemos inspeccionar si se recuperaron los datos: -->personal (muestra la matriz recuperada, y as las dems); Tambin podemos recuperar una o algunas de las matrices guardadas, no todas, escribiendo por ejemplo: -->load(arch,edad) recupera la matriz edad; los nombres de las matrices se guardan con los valores, por lo que debe usarse el mismo nombre con que se guard; ntese adems que los nombres de las variables argumentos deben estar entre comillas, lo que no se requiere en la funcin 'save'; l) -->print(archivo,x1,x2,xn), imprime en un archivo de texto (formato ASCII) las variables x1, x2, etc.; para guardar las matrices que definimos antes, escribimos: -->[carpeta,nom,ext]=fileparts(arch); obtenemos las partes del archivo arch que estamos usando: carpeta: directorio actual ('c:\CursoScilab\');nom: nombre ('misdatos'); ext: su extensin ('.dat'); -->archtexto=carpeta+nom+.txt; // creamos el path del archivo de texto donde imprimiremos las variables en formato ascii: -->print(archtexto,personal,edad,profesion); Podemos leer los datos impresos en el archivo archtexto usando el editor de textos de Scilab o el notepad de Windows. Esta funcin es til para guardar los datos en formato directamente legible. m) -->disp(x1,x2,xn) muestra en la ventana de comandos los valores de las variables; nota: las variables se muestran en orden inverso (es decir comienza por xn, luego xn-1 hasta x1);
10

J.L.Volta / Anlisis matricial de estructuras con Scilab-Parte 1

n) -->mprintf(format,x1,x2,xn), muestra en la ventana de comandos los valores de las variables, con formato (equivale a la funcin printf de C), el formato sigue la sintaxis del lenguaje C; o) -->var=x_matrix(rtulos,var-inicial), cuadro de dilogo para editar matrices; por ejemplo, definimos una matriz nula de 3x4: -->matdatos=zeros(3,4) y un vector de cadenas de texto: -->titulos=[Matriz de datos (pulse OK para actulizar);var1, var2, var3, var4] -->matdatos=x_matrix(titulos,matdatos); la funcin devuelve en 'matdatos' la matriz 'matdatos' actualizada si se pulsa 'OK', si se pulsa 'Cancel' la matriz se anula (ojo con este comportamiento, que no es lo normal, ya que usualmente al cancelar una accin de edicin simplemente deberan restaurarse los valores originales de la variable)

p) Scilab incluye una macro (le llamamos as porque no responde a la declaracin de funcin que veremos ms adelante), muy til para editar matrices en formato de planilla electrnica sencilla. Se pueden escribir frmulas, operaciones, funciones, etc. en las celdas de esta planilla, pero no admite copiar y pegar, deshacer cambios, etc. -->editvar matdatos; // edita la matriz matdatos

Al usar esta funcin deber cuidarse dos detalles importantes:

11

J.L.Volta / Anlisis matricial de estructuras con Scilab-Parte 1

a diferencia de la funcin x_matrix el cuadro de editvar es 'no modal', es decir que podemos volver al 'prompt' de Scilab y realizar otros clculos sin cerrar el cuadro; ste permanecer abierto y activo hasta que se pulse el botn 'Quit' que se muestra debajo del ttulo; la funcin no actualiza automticamente la variable que se est editando; deber pulsarse el botn 'Update to Scilab' para que los datos editados se reflejen en la memoria de Scilab; Si se desea modificar el tamao de la matriz que se est editando, puede hacerlo pulsando el botn 'Resize'; tambin el ancho de las columnas puede modificarse al modo de Excel, posicionando el cursor del ratn entre dos columnas en la lnea del encabezado de columnas, y pulsando el botn derecho del mouse. q) otra funcin similar a x_matriz es x_mdialog, con la cual se pueden editar vectores y matrices numricas o de texto, por lo que estas variables deben estar en formato de cadena de texto y no en valores numricos; si se editan nmeros deber evaluarse si los datos pueden convertirse a nmeros: para ello usamos la funcin evstr, como en el siguiente ejemplo:

Al pulsar 'OK' se cierra el cuadro de dilogo y evaluamos los datos numricos recogidos: -->valvars=evstr(txtvars); si no hay errores en el formato de los nmeros, los datos numricos se guardarn en el vector/matriz 'valvars'; si hay error Scilab levantar el error; en programacin este error debe interceptarse con el bloque 'try..catch' para evitar que se aborte nuestro programa (ver ms adelante, en 'Elementos de programacin').
12

J.L.Volta / Anlisis matricial de estructuras con Scilab-Parte 1

r) -->selec=x_choose(tems,ttulo), cuadro de dilogo para seleccionar un item de una lista; por ejemplo, creamos la siguiente lista de opciones: -->items=['Opcin-1';'Opcin-2';'Opcin-3';'Opcin-4';'Opcin-5']; -->info=['Seleccione un item de la lista';'Doble-click para seleccionar']; Luego seleccionamos la opcin: -->itemsel=x_choose(items,info); muestra el cuadro siguiente:

Recordemos que el valor de itemsel no se muestra en pantalla si terminamos la sentencia con punto y coma (;), para observar el valor tecleamos: -->itemsel; el valor devuelto es el ndice del elemento seleccionado (el primer elemento es siempre el '1'). Debe observarse que para seleccionar un tem de la lista debe hacer doble-click sobre el tem, el cuadro slo tiene un botn 'Cancelar'; si se pulsa este botn, " itemsel" valdr cero. q) -->botonsel=messagebox(mensaje, titulo, cono, botones, modo) Esta funcin despliega un cuadro de dilogo con un ttulo, mostrando el mensaje, con uno o ms botones, de tipo modal o no modal. Ejemplo, definimos: -->msaje=Error en el procesamientoEl dato fff no corresponde; -->tit=Mensaje de mi programa; -->icono=error; -->botones=['Continuar,Abortar,Reiniciar]; -->modo=modal; Luego: -->botonsel=messagebox(msaje,tit,icono,botones,modo);

13

J.L.Volta / Anlisis matricial de estructuras con Scilab-Parte 1

Muestra el cuadro de mensaje y devuelve en botonsel el ndice ordinal del botn pulsado: 1=Continuar; 2=Abortar; 3=Reiniciar; -->disp(botonsel); // muestra el ndice del botn pulsado

8. Elementos de programacin
Scilab tiene todos los elementos de programacin para propsitos generales que encontramos en C, Java, Pascal, Basic, etc., con pequeas (o grandes!) diferencias en la sintaxis: - Asignacin: = - Operadores de comparacin; ==, ~=, <, >, <=, >= - Operadores booleanos: | (or), & (and), ~ (not) - bloque de decisin: ifthenelseend; - bloque iterativo: fordoend; - bloque iterativo: whiledoend; - break permite romper el bloque y salir del mismo en cualquier momento; - Bloque de seleccin: select <var> case valor1 <instrucciones> case valor2 <instrucciones> else <instrucciones> end; En Scilab los programas se codifican en archivos de texto, y pueden ser de tipo script, con extensin ".sce", o una coleccin de funciones, con extensin .sci, o inclusive un script (.sce) que adems contiene funciones. Para editar un script o un archivo de funciones usamos el editor incorporado de Scilab: desde el men Applications/Editor, o tecleando editor en la ventana de comandos. Un "script" es simplemente una secuencia de sentencias, las mismas que hemos ejecutado interactivamente, las que ahora se ejecutarn secuencialmente desde la 1 a la ltima lnea del "script". Para ejecutar un archivo "script", utilizamos el comando File/Execute de la barra de mens, o bien escribiendo la funcin exec(archivo,[modo]) en la ventana de comandos (el parmetro archivo requiere el path completo si la funcin no est previamente cargada en Scilab), el argumento modo es opcional permitiendo ejecutar el script de varias formas. Al cargar un script ste se ejecuta inmediatamente, no as las funciones, las cuales se ejecutan solamente cuando se las llaman, sea desde el mismo script, desde otra funcin, o interactivamente, tecleando su nombre en la ventana de comandos.
14

J.L.Volta / Anlisis matricial de estructuras con Scilab-Parte 1

Los archivos .sci que slo contienen funciones pueden compilarse y guardarse con extensin .bin (archivos compilados, en formato binario, usando la funcin genlib). En Scilab las funciones se declaran con la siguiente sintaxis: function [<parmetros_de_salida>]= <nombre_de_la_funcin>(<parmetros_de_ entrada>) Tanto las variables de salida como las de entrada admiten varios argumentos, incluso opcionales. El paso predeterminado de los argumentos de entrada es por valor y no por referencia, es decir la funcin crea una copia local de la variable pasada como argumento. Toda funcin debe terminar con la sentencia endfunction.

9. Alcance o visibilidad de las variables

Las variables pueden ser locales o globales. Una variable global es totalmente visible y puede ser llamada y editada desde la ventana de comandos o desde cualquier funcin definida en el entorno de Scilab. Una variable declarada (tecleada) en el entorno integrado o en un script tiene automticamente un alcance global. Las variables locales se definen dentro de una funcin. Pero dentro de una funcin, para hacer referencia a una variable global siempre deber declarrsela explcitamente usando la palabra reservada global, para evitar un conflicto con otra variable local que pueda tener el mismo nombre, la cual ocultara a la variable global porque la local tiene prioridad dentro de la funcin. 10. Funciones tiles para programacin Adems de todas las funciones ya descritas arriba, que pueden usarse dentro de un script o de una funcin, Scilab permite colocar uno o varios mens personalizados en su barra de mens, lo cual ofrece al programador una forma cmoda y simple de organizar el uso de aplicaciones complejas, que constan de varias tareas concatenadas. Mediante estos mens, tenemos por lo tanto, una interfz grfica de usuario. -->addmenu(<nombre-menu>,<lista-comandos>,<manejo-eventos>); Los argumentos que se pasarn a los parmetros de la funcin son: <nombre-men>: una cadena de texto, con el nombre del men; <lista-comandos>: un vector de cadenas de texto, con los nombres de los comandos que generarn los eventos correspondientes; <manejo-eventos>: opciones para manejar los eventos del men; la forma de este argumento es la una lista con opciones; la forma que usaremos es: list(2,<funcin-manejadora>) donde la funcin-manejadora debe estar cargada en Scilab antes de la llamada a addmenu, y debe tener un parmetro de entrada para recibir como argumento el ndice del comando seleccionado de la lista-comandos.
15

J.L.Volta / Anlisis matricial de estructuras con Scilab-Parte 1

Luego, la funcin manejadora tiene este prototipo: function mis_eventos(comando) select comando case 1 then (instrucciones o funcin manejadora del evento 1) Case 2 then (instrucciones o funcin manejadora del evento 2) ... end; // select endfunction; Ejemplo: grabar el siguiente trozo de cdigo en el archivo MisEventos.sci: (ver Apndice A) Luego, ejecutar el archivo en Scilab, esto carga en memoria las funciones declaradas en dicho archivo; Finalmente, teclear la siguiente sentencia, que pone el men Mi menu en la barra de mens de Scilab, como se muestra en la siguiente pantalla. -->addmenu(Mi menu,[Registro;Mensaje;Seleccin],list(2,MisEventos));

Si se pulsa el comando 'Registro' se muestra el siguiente cuadro de dilogo, que permite obtener datos usando un formulario (el ejemplo usa la funcin x_mdialog estudiada antes).

16

J.L.Volta / Anlisis matricial de estructuras con Scilab-Parte 1

El comando 'Mensaje' muestra un simple cuadro de mensaje con 2 botones; el comando 'Seleccin' muestra un cuadro de seleccin. En programacin, la sentencia addmenu se incluye en un script o funcin en un mdulo que es parte de la aplicacin. Slo debe llamarse una vez esta funcin, de lo contrario se cargar varias veces el men en la barra de mens. Por defecto, el men creado est habilitado para ser usado; cuando se desea inhabilitar el men o uno de sus comandos (porque el contexto de programa lo requiera), se usa la funcin unsetmenu: -->unsetmenu(men, [comando]) Men es el nombre del men, comando es opcional, y es el nombre del comando a inhabilitar, si no se especifica, se inhabilita todo el menu. Para volver a habilitar un men o comando del men, usar la funcin setmenu. Ver otros ejemplos de scripts y funciones en los apndices B y C En el apndice B el script incluye funciones, en el apndice C, el script y las funciones se ponen en archivos separados, y el script carga en Scilab (ejecuta) el archivo de funciones.

17

J.L.Volta / Anlisis matricial de estructuras con Scilab-Parte 1

APENDICE A // funcin MisEventos: dispara una accin de acuerdo con el argumento pasado a la funcin function MisEventos(cmd) select cmd case 1 then Evento_1(); case 2 then Evento_2(); case 3 then Evento_3(); end; endfunction; function Evento_1() // gestiona un cuadro de dilogo para registrar usuario registropersona=['Nombre','Apellido','Edad','Profesin']; datospersona=['','','','']; listapersonal=[]; datosleidos=x_mdialog('Ingrese sus datos personales',registropersona, datospersona); disp(datosleidos); for col=1:4 do listapersonal(1,col)=datosleidos(col); end; disp('Apellido del usuario actual es ' + listapersonal(1,2)); endfunction; function Evento_2() // muestra un mensaje botones=['OK','Cancelar']; botonsel=messagebox('Se ha seleccionado el comando nro: 2','Mis eventos','info',botones,'modal'); disp('Botn pulsado= ' + botones(botonsel)); endfunction; function Evento_3() // gestiona un cuadro de seleccin listaOpciones=['Opcin 1';'Opcion 2';'Opcion 3']; opcselec=x_choose(listaOpciones,'Doble click sobre la opcin para seleccionar','Cancelar'); if(opcselec ~= 0) then // se ha seleccionado una opcin disp('Opcin elegida= '+ string(opcselec)); else disp('Seleccin cancelada por el usuario'); end; endfunction; // fin del archivo MisEventos.sci

18

J.L.Volta / Anlisis matricial de estructuras con Scilab-Parte 1

APENDICE B // un script con funciones: editarcargas.sce // utiliza la funcin 'x_matrix' para editar una matriz de datos de cargas nodales // global PNodales; // define una matriz global con los datos de cargas nodales global ArchPN; // nombre del archivo donde se guardar la matriz // // cambiar directorio de trabajo midir=get_absolute_file_path('editarcargas.sce'); chdir(midir); // // valores iniciales de las variables PNodales=zeros(3,4); // crea la matriz, inicialmente 3x4, con valores nulos ArchPN=midir+'cargasPN.dat'; // cargasPN.dat es el nombre del archivo // // informacin inicial para el usuario clc; infoini=[' Programa: Editar Cargas Nodales'; ' '; ' Lista de comandos:'; ' nueva_hipot : para crear una matriz de cargas vaca'; ' leer_datos : para cargar los datos guardados'; ' editar_datos : para editar los datos de la matriz'; ' guardar_datos: para salvar los datos en archivo']; mprintf('%s\n',infoini); // function nueva_hipot global PNodales; PNodales=zeros(3,4); // crea la matriz, inicialmente vaca endfunction; // function leer_datos global PNodales; global ArchPN; load(ArchPN); endfunction; // function editar_datos global PNodales; info=['Editar cargas nodales'; 'Pulse OK para actualizar'; 'Nudo,___Px,___Py,___Mz']; PNodales=x_matrix(info,PNodales); endfunction; // function guardar_datos global ArchPN; save(ArchPN,PNodales); // guarda la matriz de datos en archivo endfunction;

19

J.L.Volta / Anlisis matricial de estructuras con Scilab-Parte 1

APENDICE C // archivo: selectarea.sce // este script muestra en pantalla (no en la barra de mens) un men en forma // de lista de tareas; las funciones que se llaman desde aqu se definen en // el archivo selectarea.sci, el cual se carga desde aqu en la ltima lnea // definir variables globales clear; // borra todas las variables con el mismo nombre que las de este script global midir; global listamenu; global miarchdatos nomarchdatos; global midato1 midato2 midato3 midato4; // otras variables globales necesarias aqu... // inicializar variables globales... midir=''; miarchdatos=''; midato1=zeros(3,3); midato2=zeros(2,2); midato3=zeros(2,4); midato4=zeros(1,4); // directorio del usuario midir=get_absolute_file_path('selectarea.sce'); // cambiar directorio de trabajo chdir(midir); clc; // limpia la ventana de comandos // definir la lista de comandos del men listamenu=[' Programa: Mi Programa de Ejemplo'; ' Para analizar un modelo teclee uno de las siguintes comandos:'; ' '; ' menu : muestra este men de comandos'; ' tarea1 : inicia las matrices de datos'; ' tarea2 : edita las matrices de datos'; ' tarea3 : recupera datos de una matriz'; ' tarea4 : salva los datos en archivo'; ' terminar : borra todas las variables y termina el programa']; // mprintf('\t%s\n',listamenu); // muestra la lista de tareas en pantalla exec(midir + 'selectarea.sci'); // carga en memoria la biblioteca de funciones // fin del script

// archivo: selectarea.sci biblioteca de funciones para ejecutar // acciones de comandos de un men en pantalla (no en la barra de menus) // function menu global listamenu; clc; mprintf('\t%s\n',listamenu); endfunction; // // funcin tarea1: por ejemplo, inicia las matrices de 'midato1'...'midato4' // acepta el nombre para un archivo y guarda los datos en el mismo function tarea1 global midir miarchdatos nomarchdatos global midato1 midato2 midato3 midato4; nomarchdatos=''; nomarchdatos=x_dialog(['Escriba un nombre para el archivo de datos (sin extensin)'], nomarchdatos); if(nomarchdatos ~= []) then 20

J.L.Volta / Anlisis matricial de estructuras con Scilab-Parte 1

miarchdatos=midir + nomarchdatos + '.dat'; midato1=rand(3,3); midato2=rand(2,2); midato3=rand(2,4); midato4=rand(1,4); save(miarchdatos, midato1, midato2, midato3, midato4); mprintf('%s\n','Se iniciaron la matrices de datos'); else mprintf('%s\n','No se iniciaron las matrices de datos'); end; endfunction; // // funcin tarea3: por ejemplo recupera la matriz 'midato3' del archivo // y lo edita (en este caso el nombre del archivo se obtiene mediante el // cuadro de dilogo de windows function tarea3 global midato3; miarchdatos=uigetfile(['*.dat'], midir, 'Seleccionar archivo de datos'); if(miarchdatos ~= ''); load(miarchdatos,'midato3'); midato3=x_matrix('Editando los datos de la matriz ''midato3''',midato3); else mprintf('%s\n','No se leyeron datos.'); end endfunction; // // funcin tarea2: por ejemplo seleccionar una matriz de datos para editar function tarea2 items=['Editar ''midato1'''; 'Editar ''midato2'''; 'Editar ''midato3''' 'Editar ''midato4''']; botonsel=x_choose(items,['Seleccione un item para editar'; 'Doble click sobre el item para aceptar']); select botonsel case 1 then editar1; case 2 then editar2; case 3 then editar3; case 4 then editar4; end; endfunction // // funcin editar1: edita los datos de la matriz 'midato1' function editar1 global midato1; item=['Editando mis datos ''midato1'''; 'Col1, Col2, Col3']; midato1=x_matrix(item,midato1); endfunction; // // funcin editar2: edita los datos de la matriz 'midato2' function editar2 global midato2; item=['Editando mis datos ''midato2'''; 'Col1, Col2']; midato2=x_matrix(item,midato2); endfunction; // // funcin editar3: edita los datos de la matriz 'midato3' 21

J.L.Volta / Anlisis matricial de estructuras con Scilab-Parte 1

function editar3 global midato3; item=['Editando mis datos ''midato3'''; 'Col1, Col2, Col3, Col4']; midato3=x_matrix(item,midato3); endfunction; // // funcin editar4: edita los datos de la matriz 'midato4' function editar4 global midato4; item=['Editando mis datos ''midato4'''; 'Col1, Col2, Col3, Col4']; midato4=x_matrix(item,midato4); endfunction; // // funcin tarea4: por ejemplo, salva los datos de las matrices en // formato binario y en formato texto function tarea4 global miarchdatos midato1 midato2 midato3 midato4; if(nomarchdatos == []) then miarchdatos=uiputfile(['*.dat'], midir,'Guardar los datos de la estructura'); end; if(miarchdatos ~='') then // nombre para el archivo de texto [midir,nomarch,ext]=fileparts(miarchdatos); miarchtexto=midir+nomarch+'.txt'; save(miarchdatos,midato1, midato2, midato3, midato4); // eliminar el archivo de texto existente antes de re-escribirlo if(isfile(miarchtexto)) then mdelete(miarchtexto); end; print(miarchtexto, midato4, midato3, midato2, midato1); mprintf('%s\n','Se guardaron los datos'); editor(miarchtexto); else mprintf('%s\n','No se guardaron los datos'); end; endfunction; // function terminar clearglobal(); mprintf('%s\n','Final de sesin de ''selectarea'''); endfunction;

22

J.L.Volta/AnlisismatricialdeestructurasconScilabParte1

Anexo 1 - Scilab y otros lenguajes de computacin

Objetivo de este trabajo es realizar una comparacin entre SCILAB y algunos de los lenguajes informticos que se usan corrientemente para el desarrollo de software de propsito general, concretamente en el campo de los clculos tcnicos y de ingeniera. Con este propsito hemos utilizado los entornos integrado de desarrollo (EID) free software de estos lenguajes, y nos hemos limitado a desarrollar una aplicacin al nivel "de consola", sin la construccin de complicadas interfaces grficas de usuario (GUI), ni programacin orientada a objetos (POO), ni guiada por eventos. Se pretende mostrar las ventajas que ofrece, para tcnicos e ingenieros, el uso de Scilab sobre otros lenguajes, tanto del lenguaje como del entorno integrado de trabajo, el cual es interactivo y permite ser utilizado como intefz grfica de usuario sin necesidad de construir una GUI propia. Para el efecto, se busca comparar el ahorro de tiempo codificacin que requiere un algoritmo simple de clculo de ecuaciones lineales, incluyendo la presentacin de resultados en el monitor y, finalmente, el proceso de datos en un archivo del disco. y trabajo de de un sistema los datos y grabar estos

Se han usado los siguientes lenguajes y sus EID respectivos (un objetivo adicional es usar solamente software libre, que puede bajarse gratuitamente de Internet); el sistema operativo usado es Windows-XP, pero, con excepcin de lcc, estos lenguajes son multiplataformas: 1) Lenguaje: Free Basic; compilador: fbc.exe; EID: FBEdit.exe y/o Fbide.exe; 2) Lenguaje: Free Pascal; compilador: fpc.exe; EID: propio de Free Pascal (fp.exe); 3) Lenguaje: C; compilador: lcc (para win32); EID: wedit.exe; 4) Lenguaje: Python; interpretado; EID: IDLE (de Python.org) 5) Lenguaje: Scilab; interpretado; EID: wscilex.exe (propio de Scilab); Otras aplicaciones de clculos matemticos similares a Scilab tambin se han incluido en la comparativa. Aunque en este caso simple no existen casi diferencias (los cdigos apenas se diferencian en las puntuaciones), Scilab tiene algunas funciones que las otras aplicaciones no tienen y que son tiles para crear mens, cuadros de dilogo, editor de matrices, etc. 6) 7) 8) Lenguaje: Octave; interpretado; EID: QtOctave.exe; Lenguaje: FreeMat; interpretado; EID: FreeMat.exe; Lenguaje: Euler; interpretado; EID: Euler.exe;

El problema planteado es resolver un sistema de 6 ecuaciones lineales. El proceso de resolucin utilizado en los programas 1) a 4) es el de

J.L.Volta/AnlisismatricialdeestructurasconScilabParte1

Gauss-Jordn. Las aplicaciones de clculo numrico 5) a 8) utilizan ste y otros mtodos para optimizar la solucin. mk*x=p; cuyos elementos se obtienen con las siguientes formulas:

mk(i,i)=10*i; para 0<i<7 mk(i,j)=3*fila; para 0<i<7; i+1<j<7 mk(j,i)=mk(i,j); resulta una matriz simtrica de banda p(i)=i; para 0<i<7 las matrices mk y el vector p: 0. 6. 30. 9. 0. 0. 0. 0. 9. 40. 12. 0. 0. 0. 0. 12. 50. 15. 0. 0. 0. 0. 15. 60.

Se obtienen as mk= 10. 3. 0. 0. 0. 0. p= 1. 2. 3. 4. 5. 6. 3. 20. 6. 0. 0. 0.

La solucin es el vector p= 0.0795216 0.0682613 0.0660348 0.0677099 0.0581077 0.0854731 A seguir trascribimos los diferentes cdigos mencionados. Puede observarse que las aplicaciones para clculos matemticos, Scilab, Octave, FreeMat, y Euler tienen la menor cantidad de lineas de cdigo y la sintaxis ms simple.

1. Free Basic
Free Basic compila y crea un auto-ejecutable (ecuac.exe) que se puede llamar desde la lnea de comandos en una ventana del sistema, la cual se abre desde el men Tools/Command Prompt en el editor FbEdit.
' programa ecuac.bas: solucion de un sistema lineal con Free Basic ' ' variables globales, matrices y vectores dinmicos

J.L.Volta/AnlisismatricialdeestructurasconScilabParte1

' dim shared mk() As Double dim shared p() As Double declare sub calc_raices() ' declara el procedimiento que se implementar abajo declare sub imprimirvars() ' procedimiento para imprimir las matrices ' ejecutar el programa redim mk(6,6) ' define el tamao de la matriz dinmica redim p(6) ' idem del vector p ' cls ' limpia la pantalla calc_raices ' ejecuta el clculo del sistema imprimirvars ' imprime las matrices en un archivo de texto ' fin del programa ' implementacin de la subrutina calc_raices '------------------------------------------------------------------Sub calc_raices() ' Dim fpiv As Integer, fila As Integer, col As Integer ' iniciar valores nulos de la matriz y vector For fila = 1 To 6 For col = 1 To 6 mk(fila, col) = 0 Next p(fila) = 0 Next ' asignando valores de la matriz mk For fila = 1 To 6 col = fila mk(fila, col) = 10 * fila Next For fila = 1 To 5 col = fila + 1 mk(fila, col) = 3 * fila mk(col, fila) = 3 * fila Next ' mostrar en pantalla la matriz mk print "Matriz del sistema" print For fila = 1 To 6 For col = 1 To 6 print using "########.##"; mk(fila, col); Next print Next print ' asignando valores al vector p print "Vector del sistema" print For fila = 1 To 6 p(fila)=fila ' mostrar valores de p print using "######.##"; p(fila) Next print

J.L.Volta/AnlisismatricialdeestructurasconScilabParte1

' ' resolviendo el sistema mk*x=p ' for fpiv=1 to 6 for fila=1 to 6 if(fila<>fpiv) then for col=(fpiv+1) to 6 mk(fila,col)=mk(fila,col)mk(fila,fpiv)*mk(fpiv,col)/mk(fpiv,fpiv) next p(fila)=p(fila)-mk(fila,fpiv)*p(fpiv)/mk(fpiv,fpiv) end if next ' for fila for col=(fpiv+1) to 6 mk(fpiv,col)=mk(fpiv,col)/mk(fpiv,fpiv) next ' for col p(fpiv)=p(fpiv)/mk(fpiv,fpiv) next ' for fpiv ' imprimir en pantalla los resultados print "Solucin del sistema" print for fila=1 to 6 print using "#.########"; p(fila) next ' End Sub -----------------------------------------------------------------------' imprimir variables en archivo sub imprimirvars() dim nomdir as string, nomarchdat as string dim fila as integer, col as integer nomdir=curdir nomarchdat=nomdir+"\archdatos.txt" open nomarchdat for output as #1 print #1, "Matriz reducida del sistema" print #1, for fila=1 to 6 for col=1 to 6 print #1, using "####.#####"; mk(fila,col), next print #1, next print #1, print #1,"Solucin del sistema" print #1, for fila=1 to 6 print #1, using "#.########"; p(fila) next print #1, close #1 Print Print "Las matrices se imprimieron en el archivo:" Print nomarchdat end sub

J.L.Volta/AnlisismatricialdeestructurasconScilabParte1

2. Free Pascal

El archivo se compila creando un auto-ejecutable (ecuac.exe). Este se puede correr desde el editor fp y ver los resultados en consola usando el men Debug/User Screen o pulsando Alt/F5.
program ecuac; {$APPTYPE CONSOLE} uses SysUtils,Crt, objPas; var mk: array[1..6,1..6] of double; P: array[1..6] of double; //--------------------------------------------------------------------------procedure calc_raices; var fpiv, fila, col: integer; begin // valores iniciales nulos de los elementos de las matrices for fila:=1 to 6 do begin for col:=1 to 6 do mk[fila,col]:=0; p[fila]:=0; end; // asignando valores a la matriz mk for fila:=1 to 6 do begin col:=fila; mk[fila, col]:= 10*fila; end; for fila:=1 to 5 do begin col:=fila+1; mk[fila,col]:=3*fila; mk[col, fila]:=3*fila; end; // mostrar en pantalla la matriz mk clrscr; writeln; writeln('Matriz del sistema'); writeln; for fila:=1 to 6 do begin for col:=1 to 6 do write(mk[fila,col]:10:1); writeln; end; writeln; // asignando valores al vector P y mostrando en pantalla writeln; writeln('Vector del sistema'); writeln; for fila:=1 to 6 do begin

J.L.Volta/AnlisismatricialdeestructurasconScilabParte1

P[fila]:=fila; writeln(P[fila]:10:1); end; writeln; // resolviendo K*x=P for fpiv:=1 to 6 do begin for fila:=1 to 6 do begin if (fila<>fpiv) then begin for col:=(fpiv+1) to 6 do mk[fila,col]:=mk[fila,col]mk[fila,fpiv]*mk[fpiv,col]/mk[fpiv,fpiv]; P[fila]:=P[fila]-mk[fila,fpiv]*P[fpiv]/mk[fpiv,fpiv]; end; end; for col:=(fpiv+1) to 6 do mk[fpiv,col]:=mk[fpiv,col]/mk[fpiv,fpiv]; P[fpiv]:=p[fpiv]/mk[fpiv,fpiv]; end; // imprimir en pantalla los resultados writeln; writeln('Solucin del sistema'); writeln; for fila:=1 to 6 do writeln(P[fila]:10:8); end; // //----------------------------------------------------------------------------procedure imprimirvars; var archtxt:text; fpdir, nomarch: string; fila, col: integer; // begin getdir(0,fpdir); nomarch:=fpdir+'\archdatos.txt'; assignfile(archtxt, nomarch); rewrite(archtxt); writeln(archtxt,'Matriz reducida'); writeln(archtxt); for fila:=1 to 6 do begin for col:=1 to 6 do write(archtxt,mk[fila,col]:12:8); writeln(archtxt); end; writeln(archtxt); writeln(archtxt,'Solucin del sistema'); writeln(archtxt); for fila:=1 to 6 do writeln(archtxt,P[fila]:12:8); writeln(archtxt); close(archtxt); writeln; writeln('Las matrices se imprimieron en el archivo:');

J.L.Volta/AnlisismatricialdeestructurasconScilabParte1

writeln(nomarch); end; // //--------------------------------------------------------------------------begin // resolver el sistema calc_raices; // imprimir matriz y vector imprimirvars end.

3. C (con lcc)
El archivo se compila creando un auto-ejecutable (ecuac.exe), el cual puede correrse desde el editor con el comando del men Compiler/Execute ecuac.exe lo cual abre una ventana del sistema para mostrar los resultados en consola.
/* ecuac.c: ejemplo de solucin de un sistema lineal */ #include<stdio.h> #include<tcconio.h> #include<direct.h> #include<string.h> #include<stdlib.h> double mk[6][6]; double p[6]; char *nomarch="\\archdatos.txt"; FILE *archtxt; void calc_raices(void) { int fpiv, fila, col; /* valores nulos de los elementos de las matrices */ for (fila=1; fila<=6; fila++) { for (col=1; col<=6; col++) mk[fila][col]=0; p[fila]=0; } /* asignando valores a la matriz mk */ for (fila=1; fila<=6; fila++) { col=fila; mk[fila][col]=10*fila; } for (fila=1; fila<=5; fila++) { col=fila+1; mk[fila][col]=3*fila; mk[col][fila]=3*fila; } /* mostrar en pantalla la matriz */

J.L.Volta/AnlisismatricialdeestructurasconScilabParte1

printf("%s","Matriz del sistema\n\n"); for (fila=1; fila<=6; fila++) { for (col=1; col<=6; col++) printf("%10.1f",mk[fila][col]); printf("\n"); } printf("\n"); /* asignar valores al vector p y mostrar en pantalla */ printf("%s","\nVector del sistema\n\n"); for (fila=1; fila<=6; fila++) { p[fila]=fila; printf("%10.1f\n",p[fila]); } printf("\n"); /* resolviendo el sistema mk*x=p */ for (fpiv=1; fpiv<=6; fpiv++) { for (fila=1; fila<=6; fila++) { if(fila != fpiv) { for (col=(fpiv+1); col<=6; col++) mk[fila][col]=mk[fila][col]mk[fila][fpiv]*mk[fpiv][col]/mk[fpiv][fpiv]; p[fila]=p[fila]-mk[fila][fpiv]*p[fpiv]/mk[fpiv][fpiv]; } } for (col=(fpiv+1); col<=6; col++) mk[fpiv][col]=mk[fpiv][col]/mk[fpiv][fpiv]; p[fpiv]=p[fpiv]/mk[fpiv][fpiv]; } /* imprimir en pantalla los resultados */ printf("%s","\nSolucion del sistema\n\n"); for (fila=1; fila<=6; fila++) printf("%10.8f\n",p[fila]); } //----------------------------------------------------------------------void imprimirvars(void) { int fila, col; char *pathc; pathc=getcwd(NULL,1024); strcat(pathc,nomarch); // printf("\n%s %s\n",pathc, nomarch); if((archtxt=fopen(pathc,"w"))==NULL) { printf("No se puede abrir el archivo"); exit(1); } fprintf(archtxt,"%s\n","Matriz reducida del sistema"); fprintf(archtxt,"\n"); for (fila=1; fila<=6; fila++) {

J.L.Volta/AnlisismatricialdeestructurasconScilabParte1

for(col=1; col<=6; col++) fprintf(archtxt,"%12.8f",mk[fila][col]); fprintf(archtxt,"\n"); } fprintf(archtxt,"\n"); fprintf(archtxt,"\n%s\n","Solucin del sistema"); fprintf(archtxt,"\n"); for (fila=1; fila<=6;fila++) fprintf(archtxt,"%12.8f\n",p[fila]); fprintf(archtxt,"\n"); fclose(archtxt); printf("Las matrices se imprimieron en el archivo:\n"); printf("%s",pathc); } //---------------------------------------------------------------------int main(void) { clrscr; calc_raices(); imprimirvars(); return 0; }

4. Python
El archivo ecuac.py no se compila. Se corre dentro del entorno integrado y los resultados se muestran en la ventana del editor. Tambin puede correrse desde la lnea de comandos de una ventana del sistema escribiendo python ecuac.py que muestra los resultados en la consola (se requiere agregar python.exe en el path del sistema o del usuario).
# -*- coding: cp1252 -*# programa ecuac.py: solucion de un sistema lineal usando Python # variables globales, matrices y vectores dinamicos # iniciar valores nulos de la matriz import os # mk=[0.0]*7 for fila in range(7): mk[fila]=[0.0]*7 # iniciar valores nulos del vector p=[0.0]*7 # asignando valores a los elementos de mk for fila in range(1,7): col=fila mk[fila][col]=10.0*fila for fila in range(1,6): col=fila+1 mk[fila][col]=3.0*fila mk[col][fila]=3.0*fila # mostrar la matriz mk print 'Matriz del sistema\n' for fila in range(1,7):

J.L.Volta/AnlisismatricialdeestructurasconScilabParte1

for col in range(1,7): print mk[fila][col], print # asignando valores a los elementos de p for fila in range(1,7): p[fila]=fila # mostrando p en pantalla print '\nVector del sistema\n' for fila in range(1,7): print p[fila] # resolviendo el sistema mk*x=p for fpiv in range(1,7): for fila in range(1,7): if(fila!=fpiv): for col in range(fpiv+1,7): mk[fila][col]=mk[fila][col]mk[fila][fpiv]*mk[fpiv][col]/mk[fpiv][fpiv] p[fila]=p[fila]-mk[fila][fpiv]*p[fpiv]/mk[fpiv][fpiv] for col in range(fpiv+1, 7): mk[fpiv][col]=mk[fpiv][col]/mk[fpiv][fpiv] p[fpiv]=p[fpiv]/mk[fpiv][fpiv] # mostrar en pantalla el resultado print '\nSolucin del sistema\n' for fila in range(1,7): print p[fila] # imprimir las matrices en un archivo pitondir=os.getcwd() nomarchdat=pitondir+'\\archdatos.txt' arch=open(nomarchdat,'w') arch.write('Matriz reducida del sistema\n') arch.write('\n') for fila in range(1,7): for col in range(1,7): arch.write('%10.6f' %(mk[fila][col])) arch.write('\n') arch.write('\nSolucion del sistema\n') arch.write('\n') for fila in range(1,7): arch.write('%10.6f \n' %p[fila]) arch.close() print '\nLas matrices se imprimieron en el archivo:\n' print nomarchdat # fin del script

5. Scilab
El archivo no se compila, slo se interpreta desde el EID de Scilab; los resultados se muestran en la ventana de comandos de Scilab. Puede compilarse en un archivo ecuac.bin, que no es auto-ejecutable y slo se corre dentro de Scilab.
// ecuac.sce: resuelve un sistema lineal

10

J.L.Volta/AnlisismatricialdeestructurasconScilabParte1

clc; // iniciando las matrices mk=zeros(6,6); p=zeros(6); // generando los trminos diagonales de mk for fila=1:6 do col=fila; mk(fila,col)=10*fila; end; // generando los otros trminos de mk for fila=1:5 do col=fila+1; mk(fila,col)=3*fila; mk(col,fila)=3*fila; end; // generando los valores de p for fila=1:6 do p(fila)=fila; end; // mostrando en pantalla las variables disp('Matriz del sistema:'); disp(mk); disp('Vector del sistema:'); disp(p); // resolviento el sistema p=mk\p; // mostrando el resultado disp('Solucin del sistema:'); disp(p); // guardando la solucin del sistema en un archivo de texto midir=get_absolute_file_path('ecuac.sce'); miarch=midir + 'archdatos.txt'; info='Solucin del sistema'; deletefile(miarch); // destruir el archivo anterior, si existe // grabar los nuevos datos print(miarch,p, mk, info); disp('La solucin se guard en el archivo: ' + miarch); // fin del script

6. Octave
Igual que Scilab, el archivo se interpreta dentro del entorno de Qtoctave. Alternativamente puede correrse desde la linea de comandos de una ventana del sistema con la orden octave ecuac.m (requiere que octave.exe est en el path del sistema o del usuario).
# ecuac.m: resuelve un sistema lineal clc; mk=zeros(6,6); p=zeros(6,1); # asingnado valores de la diagonal de mk for fila=1:6 col=fila; mk(fila,col)=10*fila; endfor; # asignando valores a otros terminos de mk

11

J.L.Volta/AnlisismatricialdeestructurasconScilabParte1

for fila=1:5 col=fila+1; mk(fila,col)=3*fila; mk(col,fila)=3*fila; endfor; # asingando valores a p for fila=1:6 p(fila,1)=fila; endfor; # mostrando en pantalla las variables disp('Matriz del sistema'); disp(mk); disp('Vector del sistema'); disp(p); # resolviendo el sistema p=mk\p; # mostrando el resultado disp('Solucin del sistema'); disp(p); # grabando las matrices en un archivo de texto archdat="c:\\cursoscilab\\otrosides\\qtoctave\\archdatos.txt" save("-ascii",archdat","mk","p"); # fin del script

7. FreeMat
Igual que Scilab y Octave, el archivo requiere el interprete/IDE FreeMat.exe. No se ejecuta desde la linea de comandos de una ventana del DOS.
% ecuac.m: resuelve un sistema lineal clc; mk=zeros(6,6); p=zeros(6,1); for fila=1:6 col=fila; mk(fila,col)=10*fila; end; % asignando valores a mk for fila=1:5 col=fila+1; mk(fila,col)=3*fila; mk(col,fila)=3*fila; end; % asingando valores a p for fila=1:6 p(fila,1)=fila; end; % mostrando en pantalla las variables disp('Matriz del sistema'); disp(mk); disp('Vector del sistema'); disp(p); % resolviendo el sistema p=mk\p; % mostrando el resultado disp('Solucin del sistema');

12

J.L.Volta/AnlisismatricialdeestructurasconScilabParte1

disp(p); % grabando los datos en archivo info1='Matriz del sistema'; info2='Solucin del sistema'; archdatos='c:\cursoscilab\otrosides\freemat\archdatos.txt'; archtxt=fopen(archdatos,'w'); fprintf(archtxt,'%s\n',info1); for fila=1:6 for col=1:6 fprintf(archtxt,'%10.6f',mk(fila,col)); end; fprintf(archtxt,'\n'); end; fprintf(archtxt,'%s\n',info2); for fila=1:6 fprintf(archtxt,'%10.6f\n',p(fila)); end; fclose(archtxt); disp('Las matrices se guardaron en el archivo:'); disp(archdatos); % fin del script

8. Euler
Igual que FreeMat, el archivo requiere el interprete Euler.exe. No se ejecuta desde la linea de comandos de una ventana del DOS.
// ecuac.e: resuelve un sistema lineal con Euler // limpiando la ventana de comandos function ecuac() shortformat; cls; // iniciando matriz y vector a cero mk:=zeros(6,6); p:=zeros(6,1); // asignando valores a la diagonal de la matriz mk for fila=1 to 6; col:= fila; mk[fila,col] := 10*fila; end; // asignando valores fuera de la diagonal de mk for fila=1 to 5; col:=fila+1; mk[fila,col]:=3*fila; mk[col,fila]:=3*fila; end; // asignando valores al vector p for fila=1 to 6; p[fila,1]:=fila; end; // mostrando en pantalla las variables shortformat; "Matriz del sistema" mk "Vector del sistema" p // resolviendo el sistema p:=mk\p;

13