Análisis matricial de estructuras-Parte 1 - ing.una.py · PDF fileJ.L.Volta /...

Este trabajo contiene una descripción detallada de los principales elementos del entorno integrado de SCILAB, cuyo objetivo es dar a los estudiantes de ingeniería y de otras carreras técnicas, que no tienen conocimientos avanzados de informática, la posibilidad de desarrol lar rápidamente aplicaciones para la solución de problemas de mecánica de estructuras, en un lenguaje de alto nivel, con una interfaz interactiva de gran calidad, y lo que es todavía mejor, utilizando software libre, continuamente actualizado.

Análisis matricial de estructuras con SCILAB

Parte 1- Introducción

Autor: Prof. Ing. José Luis Volta Grau Cátedra de Estructuras 2 y Estructuras 3 Facultad de Ingeniería-U.N.A. Octubre -2010

J.L.Volta / Análisis matricial de estructuras con Scilab-Parte 1

1

1. Informática para cálculos de ingeniería Actualmente, los programas o aplicaciones informáticas para cálculos de ingeniería suelen contener varios módulos con tareas específicas, como ser:

a) interfaz de usuario; b) edición de datos (input); c) verificación de los datos (pre-procesamiento); d) graficación de datos (pre-procesamiento); e) procesamiento de datos; f) salida de resultados (output); g) graficación de resultados (post-procesamiento);

Una aplicación 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 más trabajo y tiempo de desarrollo. Antes de la industrialización del software, que fue posible con la Programación Orientada a Objetos (POO en el lenguaje informático), y de los actuales sistemas operativos con interfáz gráfica, era común el uso de programas con una interfáz de usuario muy simple, o sin interfaz alguna, usando la línea 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 contenía los datos ordenados y formateados exactamente como el programa podía interpretarlos. El programa procesaba los datos y grababa los resultados en un archivo de texto que se podía leer con cualquier editor de textos. Actualmente casi no hay aplicaciones que no tengan su interfáz gráfica de usuario o GUI (Grafical User Interface), que consiste en barras de menús, barras de herramientas, cuadros de diálogo, etc. El desarrollo de esta fase del programa se ha facilitado muchísimo con los lenguajes “visuales” (Visual Basic, Visual C, Delphi, Java-Swing, etc.) Las siguientes tareas no son menos complicadas que la primera: edición y verificación 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 cálculos a realizar con los mismos. Los datos pueden editarse en dos formas: interactivamente, o en un archivo de texto o planilla electrónica. Para programas que requieren pocos datos de entrada es más simple editar interactivamente, usando un cuadro de diálogo por ejemplo, pero si son muchos datos (más de un centenar, por ejemplo) es más cómodo editar en un archivo. Graficar los datos y los resultados son, en ingeniería, la mejor forma de verificar los cálculos, pero la programación de esta tarea requiere el empleo de un lenguaje que permita programar gráficos con facilidad, de lo contrario es una tarea harto difícil. El procesamiento de datos y la salida de resultados son las partes más simples del desarrollo de la aplicación, las que consisten en implementar los algoritmos de cálculo, tarea para la cual el ingeniero está normalmente bien entrenado, en la materia técnica específica que es el objetivo de la aplicación.


2

2. Usando SCILAB en aplicaciones para ingeniería Scilab es un Entorno Integrado de Desarrollo (EDI en el lenguaje informático, o IDE en inglés) que es además 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 aplicación comercial MatLab, pero a diferencia de ésta, Scilab es de código abierto y de distribución libre y gratuita. Otras aplicaciones free-software similares son: Octave (con QtOctave como EDI); Euler, FreeMat, etc., pero algunas características de Scilab, que las otras no poseen, lo hacen preferible para nuestro trabajo. Algunas de sus características principales son: - lenguaje propio, de alto nivel, con características similares a otros lenguajes como C, Pascal,

Java y Fortran. La interfaz de usuario está escrita en Java, a partir de la versión 5. Muchas funciones se desarrollaron originalmente en Fortran. La sintaxis, por su parte, tiene una estructura más 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 diseñar una interfaz de usuario, con menús y cuadros de diálogos 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 depuración del código, mediante “la prueba y el error", inspección de valores de variables en tiempo de corrida, etc., sin necesidad de un depurador propiamente dicho;

- todas las variables son matrices dinámicas de algún tipo base (entero, real, imaginario,

boolean, cadenas de caracteres, etc). El tipo se define al asignar el primer elemento de la matriz. El tamaño de la matriz crece automáticamente al asignar nuevos elementos (matrices dinámicas);

- las funciones pueden devolver cualquier cantidad de argumentos, incluso opcionales (usando

el parámetro "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 gráfica

específica; Estas características hacen de Scilab una herramienta muy valiosa para los técnicos que deben realizar cálculos matemáticos repetitivos con matrices, ecuaciones diferenciales, sistemas lineales y no lineales de ecuaciones, etc. Si estos cálculos repetitivos o rutinarios se programan en una aplicación, es obvio el ahorro de tiempo y trabajo que esto significa para el profesional.


3

3. Un vistazo al entorno integrado de Scilab La versión de Scilab utilizada para este trabajo es la 5.2.2, liberada en Mayo del 2010. La aplicación presenta una ventana principal que contiene una barra de menús, una barra de herramientas y una ventana de comandos (command window) donde se interactúa con el usuario.

Estudiaremos ahora algunos comandos de la barra de menús. Advertimos de antemano que, hasta la fecha, todo en el IDE de Scilab está en Inglés o Francés, incluyendo la ayuda en línea; no hay traducción al Español, aunque hay un documento .pdf en portugués, en el sitio ‘www.scilab.org’. Comando File/Execute: carga y ejecuta un “script” (extensión “.sce”) o un archivo de funciones (extensión “.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 versión); Comando File/Load environment: carga variables y entorno de una sesión 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.


4

4. Trabajando con una calculadora matricial Toda variable en Scilab es interpretada como una matriz de algún 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 Definición implícita de matrices:

a) definiendo una variable cualquiera: a diferencia de otros lenguajes, no se requiere una definición explícita del tipo ni tamaño de una variable (matriz): si escribimos: -->a=3.4 * 5.2 Scilab acepta el dato, lo evalúa como un número real y responde con un eco:

a= 17.68

b) escribimos: -->a=3.4 * 5.2; no hay eco si la línea termina con el punto y coma (;) para ver el resultado tecleamos: -->a a= 17.68 O bien, usando la función ‘disp’ (por display): -->disp(a) 17.68 OJO: los nombres de variables deben contener letras del alfabeto inglés, números 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 número 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 demás elementos = 0; Scilab aumentó automáticamente el tamaño de la matriz ‘a’ para dar cabida al nuevo elemento. Observación importante: en Scilab el primer elemento de una lista, vector o matriz, tiene subíndice(s) 1 y no cero como en los lenguajes de programación C, Pascal, Java, Basic, etc. Esto es porque Scilab es una aplicación para matemáticas (los matemáticos cuentan desde 1 y no desde cero, a diferencia de los profesionales informáticos);

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 números;

e) Scilab distingue mayúsculas de minúsculas, 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 mayúsculas de minúsculas;


5

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 = T T T T T T 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 = T T T T F T

4.2 Definición explícita de matrices:

--> unavar=[ ] crea una matriz vacía, sin tipo, y lo asigna a la variable ‘unavar’

--> num=[3.4,-3.4;0.114,3.44] crea una matriz 2x2 de números 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 alfanuméricos o de caracteres, los cuales deben ir entre comillas simples o dobles;

--> filas=[‘item-1’;item-2’;’item-3’] crea un vector columna 3 filas x 1 columna, alfanumérica;

--> 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 tópicos: funciones matemáticas, para manejo de archivos, para interfaz de usuario, funciones utilitarias, para optimización y simulación, modelado de sistemas, para gráficos, etc. En nuestro trabajo utilizaremos sólo una pequeña cantidad de estas funciones. Funciones que definen matrices numéricas: a) -->a=rand(3,3) genera una matriz de números aleatorios de 3x3


6

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) crea una matriz “m” identidad [ I ] (3x3) (se lee como la palabra inglesa

“eye” (ojo)); e) --> m=emptystr(3,3) crea una matriz 3x3 de elementos alfanuméricos vacíos; no se

debe confundir con la matriz vacía que explicamos antes. 4.3 Operaciones con matrices numéricas

a) -->d=b-a devolverá la diferencia de las matrices (deben ser del mismo tamaño, de filas y columnas);

b) -->3.5 * num; todos los elementos de ‘num’ se multiplican por 3.5; c) --> x=num*a; ‘num’ es de 2x2, ‘a’ de 2x3 la operación devuelve en ‘x’ de 2x3 el

producto; d) --> x=a*num produce un error, la multiplicación no es conmutativa en general, el número

de columnas del 1er factor debe ser igual al número 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 dígitos, por lo que la operación:

--> chk=(num*a+num*b==num*(a+b)) puede devolver una matriz con algunos elementos %f (false), por lo que este modo de comprobación no es aconsejable para esta operación;

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;


7

-->unacol=props(:,3) copia en 'unacol' la 3ª columna de 'props';

unacol = 0. 5.99

k) tamaños del vector o matriz: usamos la función size: -->props=zeros(4,8); creamos una matriz de ceros, de 4 filas, 8 columnas; -->[fila,col]=size(props) devuelve los tamaños de filas y columnas; -->filas=size(props,1); devuelve el tamaño de filas; En esta función se vé que Scilab admite sobrecarga de funciones, o sea que una

función puede tener más de una sintaxis, con parámetros diferentes. 5. Otros tipos de variables Además de los tipos simples ya vistos: carácter, cadenas, números enteros, números reales, números imaginarios, booleans, y sus arreglos en matrices, Scilab define otros tipos compuestos (sólo mencionamos los que pueden ser útiles para el objeto de este curso). Estas variables ‘estructuradas’ se crean con una función 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 incluídas en Scilab

Scilab define algunas constantes globales útiles para el cálculo numérico:

a) Constantes matemáticas:

%pi (número pi); %e (base de logaritmos naturales), %nan (not a number): si un elemento de una matriz numérica 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 también para la programación de “script”:


8

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 función

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 sesión 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; también 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(máscara, directorio inicial, título del diálogo): cuadro de diálogo

para seleccionar un archivo para abrir; todos los parámetros 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 función devuelve el nombre completo (el “path” o ruta) del archivo (en este ejemplo 'c:\CursoScilab\misdatos.dat'), si se pulsa el botón 'Open' del cuadro de diálogo; si se pulsa 'Cancel' devuelve una cadena vacía;


9

i) -->archivo=uiputfile(máscara, directorio inicial, título del diálogo), diálogo para seleccionar un archivo para grabar datos; repitiendo el ejemplo anterior, para guardar el archivo 'misdatos.dat', contenido en la variable 'arch' que recién abrimos, escribimos: -->arch=uiputfile(‘*.dat’,midir,’Guardar archivo de datos’); La función devuelve el nombre completo (el “path”) del archivo si se pulsa el botón “Guardar” del cuadro de diálogo; si se pulsa “Cancelar” devuelve una cadena vacía;

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

Si se pulsa 'Yes' la función devuelve el 'path' completo del archivo (en este ejemplo 'c:\CursoScilab\misdatos.dat'), si se pulsa 'No' devuelve una cadena vacía. OJO: las funciones anteriores no guardan nada, sólo 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,x2…xn en el archivo “archivo” en formato binario; función simple que ahorra mucho trabajo de programación para guardar matrices en archivos; por ejemplo:

-->personal=[‘nombre-1’; ‘nombre-2’; ‘nombre-3’]; -->edad=[25,46,33]; -->profesion=[‘estudiante’,’contador’,’agricultor’];


10

La sentencia: -->save(arch,personal,edad,profesion]; guarda las matrices en el archivo 'misdatos.dat', cuyo 'path' (obtenido con la función 'uiputfile') está contenido en la variable 'arch',;

k) -->load(archivo,’x1’,’x2’,…’xn’), recupera variables del archivo guardadas con la función

“save”; antes de recuperar los valores de las variables no aseguramos de que éstas no existan, eliminando las variables 'personal', 'edad' y 'profesión', con la función 'clear': -->clear('personal', 'edad', 'profesion'); esta función 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 demás); También 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ó; nótese además que los nombres de las variables argumentos deben estar entre comillas, lo que no se requiere en la función '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 extensión ('.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 función 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);


11

n) -->mprintf(format,x1,x2,…xn), muestra en la ventana de comandos los valores de las

variables, con formato (equivale a la función “printf” de C), el formato sigue la sintaxis del lenguaje C;

o) -->var=x_matrix(rótulos,var-inicial), cuadro de diálogo 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 función 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 acción de edición simplemente deberían restaurarse los valores originales de la variable)

p) Scilab incluye una macro (le llamamos así porque no responde a la declaración de función que veremos más adelante), muy útil para editar matrices en formato de planilla electrónica sencilla. Se pueden escribir fórmulas, 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 función deberá cuidarse dos detalles importantes:


12

‐ a diferencia de la función x_matrix el cuadro de editvar es 'no modal', es decir que podemos volver al 'prompt' de Scilab y realizar otros cálculos sin cerrar el cuadro; éste permanecerá abierto y activo hasta que se pulse el botón 'Quit' que se muestra debajo del título;

‐ la función no actualiza automáticamente la variable que se está editando; deberá pulsarse el botón 'Update to Scilab' para que los datos editados se reflejen en la memoria de Scilab;

Si se desea modificar el tamaño de la matriz que se está editando, puede hacerlo pulsando el botón 'Resize'; también el ancho de las columnas puede modificarse al modo de Excel, posicionando el cursor del ratón entre dos columnas en la línea del encabezado de columnas, y pulsando el botón derecho del mouse.

q) otra función similar a x_matriz es x_mdialog, con la cual se pueden editar vectores y matrices numéricas o de texto, por lo que estas variables deben estar en formato de cadena de texto y no en valores numéricos; si se editan números deberá evaluarse si los datos pueden convertirse a números: para ello usamos la función evstr, como en el siguiente ejemplo: Al pulsar 'OK' se cierra el cuadro de diálogo y evaluamos los datos numéricos recogidos:

-->valvars=evstr(txtvars); si no hay errores en el formato de los números, los datos numéricos se guardarán en el vector/matriz 'valvars'; si hay error Scilab levantará el error; en programación este error debe interceptarse con el bloque 'try..catch' para evitar que se aborte nuestro programa (ver más adelante, en 'Elementos de programación').


13

r) -->selec=x_choose(ítems,título), cuadro de diálogo para seleccionar un item de una lista; por ejemplo, creamos la siguiente lista de opciones:

-->items=['Opción-1';'Opción-2';'Opción-3';'Opción-4';'Opción-5']; -->info=['Seleccione un item de la lista';'Doble-click para seleccionar']; Luego seleccionamos la opción: -->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 sólo tiene un botón 'Cancelar'; si se pulsa este botón, " itemsel" valdrá cero.

q) -->botonsel=messagebox(mensaje, titulo, ícono, botones, modo)

Esta función despliega un cuadro de diálogo con un “título”, mostrando el “mensaje”, con uno o más “botones”, de tipo “modal” o no modal. Ejemplo, definimos: -->msaje=’Error en el procesamiento…El 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);


14

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

8. Elementos de programación Scilab tiene todos los elementos de programación para propósitos generales que encontramos en C, Java, Pascal, Basic, etc., con pequeñas (o grandes!) diferencias en la sintaxis: - Asignación: =

- Operadores de comparación; ==, ~=, <, >, <=, >= - Operadores booleanos: | (or), & (and), ~ (not) - bloque de decisión: if…then…else…end; - bloque iterativo: for…do…end; - bloque iterativo: while…do…end; - “break” permite romper el bloque y salir del mismo en cualquier momento; - Bloque de selección:

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 extensión ".sce", o una colección de funciones, con extensión “.sci”, o inclusive un script (.sce) que además 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 ejecutarán secuencialmente desde la 1ª a la última línea del "script". Para ejecutar un archivo "script", utilizamos el comando File/Execute de la barra de menús, o bien escribiendo la función exec(archivo,[modo]) en la ventana de comandos (el parámetro archivo requiere el path completo si la función 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 función, o interactivamente, tecleando su nombre en la ventana de comandos.


15

Los archivos .sci que sólo contienen funciones pueden compilarse y guardarse con extensión .bin (archivos compilados, en formato binario, usando la función genlib). En Scilab las funciones se declaran con la siguiente sintaxis: function [<parámetros_de_salida>]= <nombre_de_la_función>(<parámetros_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 función crea una copia local de la variable pasada como argumento. Toda función 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 función definida en el entorno de Scilab. Una variable declarada (tecleada) en el entorno integrado o en un script tiene automáticamente un alcance global. Las variables locales se definen dentro de una función. Pero dentro de una función, para hacer referencia a una variable global siempre deberá declarársela explícitamente usando la palabra reservada global, para evitar un conflicto con otra variable local que pueda tener el mismo nombre, la cual ocultaría a la variable global porque la local tiene prioridad dentro de la función. 10. Funciones útiles para programación Además de todas las funciones ya descritas arriba, que pueden usarse dentro de un script o de una función, Scilab permite colocar uno o varios menús personalizados en su barra de menús, lo cual ofrece al programador una forma cómoda y simple de organizar el uso de aplicaciones complejas, que constan de varias tareas concatenadas. Mediante estos menús, tenemos por lo tanto, una interfáz gráfica de usuario. -->addmenu(<nombre-menu>,<lista-comandos>,<manejo-eventos>); Los argumentos que se pasarán a los parámetros de la función 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 generarán 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,<función-manejadora>) donde la función-manejadora debe estar cargada en Scilab antes de la llamada a ‘addmenu’, y debe tener un parámetro de entrada para recibir como argumento el índice del comando seleccionado de la ‘lista-comandos’.


16

Luego, la función manejadora tiene este prototipo: function mis_eventos(comando) select comando case 1 then (instrucciones o función manejadora del evento 1) Case 2 then (instrucciones o función manejadora del evento 2) ... end; // select endfunction; Ejemplo: grabar el siguiente trozo de código en el archivo ‘MisEventos.sci: (ver Apéndice 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 menús de Scilab, como se muestra en la siguiente pantalla. -->addmenu(‘Mi menu’,[‘Registro’;’Mensaje’;’Selección’],list(2,’MisEventos’));

Si se pulsa el comando 'Registro' se muestra el siguiente cuadro de diálogo, que permite obtener datos usando un formulario (el ejemplo usa la función x_mdialog estudiada antes).


17

El comando

'Mensaje' muestra un simple cuadro de mensaje con 2 botones; el comando 'Selección' muestra un cuadro de selección. En programación, la sentencia ‘addmenu’ se incluye en un script o función en un módulo que es parte de la aplicación. Sólo debe llamarse una vez esta función, de lo contrario se cargará varias veces el menú en la barra de menús. 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 función ‘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 función ‘setmenu’. Ver otros ejemplos de scripts y funciones en los apéndices B y C En el apéndice B el script incluye funciones, en el apéndice C, el script y las funciones se ponen en archivos separados, y el script carga en Scilab (ejecuta) el archivo de funciones.


18

APENDICE A // función MisEventos: dispara una acción de acuerdo con el argumento pasado a la función 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 diálogo para registrar usuario registropersona=['Nombre','Apellido','Edad','Profesión']; 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('Botón pulsado= ' + botones(botonsel)); endfunction; function Evento_3() // gestiona un cuadro de selección listaOpciones=['Opción 1';'Opcion 2';'Opcion 3']; opcselec=x_choose(listaOpciones,'Doble click sobre la opción para seleccionar','Cancelar'); if(opcselec ~= 0) then // se ha seleccionado una opción disp('Opción elegida= '+ string(opcselec)); else disp('Selección cancelada por el usuario'); end; endfunction; // fin del archivo MisEventos.sci


19

APENDICE B // un script con funciones: editarcargas.sce // utiliza la función '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 // // información inicial para el usuario clc; infoini=[' Programa: Editar Cargas Nodales'; ' '; ' Lista de comandos:'; ' nueva_hipot : para crear una matriz de cargas vacía'; ' 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 vacía 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;


20

APENDICE C // archivo: selectarea.sce // este script muestra en pantalla (no en la barra de menús) 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 línea // 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; // // función 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 extensión)'], nomarchdatos); if(nomarchdatos ~= []) then


21

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; // // función 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 diálogo 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; // // función 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 // // función 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; // // función 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; // // función editar3: edita los datos de la matriz 'midato3'


22

function editar3 global midato3; item=['Editando mis datos ''midato3'''; 'Col1, Col2, Col3, Col4']; midato3=x_matrix(item,midato3); endfunction; // // función 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; // // función 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 sesión de ''selectarea'''); endfunction;

J.L.Volta / Análisis matricial de estructuras con Scilab‐Parte 1

1

Anexo 1 - Scilab y otros lenguajes de computación Objetivo de este trabajo es realizar una comparación entre SCILAB y algunos de los lenguajes informáticos que se usan corrientemente para el desarrollo de software de propósito general, concretamente en el campo de los cálculos técnicos y de ingeniería. Con este propósito hemos utilizado los entornos integrado de desarrollo (EID) ‘free software’ de estos lenguajes, y nos hemos limitado a desarrollar una aplicación al nivel "de consola", sin la construcción de complicadas interfaces gráficas de usuario (GUI), ni programación orientada a objetos (POO), ni guiada por eventos. Se pretende mostrar las ventajas que ofrece, para técnicos 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 intefáz gráfica de usuario sin necesidad de construir una GUI propia. Para el efecto, se busca comparar el ahorro de tiempo y trabajo de codificación que requiere un algoritmo simple de cálculo de un sistema de ecuaciones lineales, incluyendo la presentación de los datos y resultados en el monitor y, finalmente, el proceso de grabar estos datos en un archivo del disco. 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 excepción 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 cálculos matemáticos similares a Scilab también se han incluido en la comparativa. Aunque en este caso simple no existen casi diferencias (los códigos apenas se diferencian en las puntuaciones), Scilab tiene algunas funciones que las otras aplicaciones no tienen y que son útiles para crear menús, cuadros de diálogo, editor de matrices, etc. 6) Lenguaje: Octave; interpretado; EID: QtOctave.exe; 7) Lenguaje: FreeMat; interpretado; EID: FreeMat.exe; 8) Lenguaje: Euler; interpretado; EID: Euler.exe; El problema planteado es resolver un sistema de 6 ecuaciones lineales. El proceso de resolución utilizado en los programas 1) a 4) es el de


2

Gauss-Jordán. Las aplicaciones de cálculo numérico 5) a 8) utilizan éste y otros métodos para optimizar la solución. 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 simétrica de banda p(i)=i; para 0<i<7 Se obtienen así las matrices mk y el vector p: mk= 10. 3. 0. 0. 0. 0. 3. 20. 6. 0. 0. 0. 0. 6. 30. 9. 0. 0. 0. 0. 9. 40. 12. 0. 0. 0. 0. 12. 50. 15. 0. 0. 0. 0. 15. 60. p= 1. 2. 3. 4. 5. 6. La solución es el vector p= 0.0795216 0.0682613 0.0660348 0.0677099 0.0581077 0.0854731 A seguir trascribimos los diferentes códigos mencionados. Puede observarse que las aplicaciones para cálculos matemáticos, Scilab, Octave, FreeMat, y Euler tienen la menor cantidad de lineas de código y la sintaxis más simple.

1. Free Basic Free Basic compila y crea un auto-ejecutable (ecuac.exe) que se puede llamar desde la línea 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 dinámicos


3

' 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 tamaño de la matriz dinámica redim p(6) ' idem del vector p ' cls ' limpia la pantalla calc_raices ' ejecuta el cálculo del sistema imprimirvars ' imprime las matrices en un archivo de texto ' fin del programa ' implementación 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


4

' ' 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 "Solución 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,"Solución 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


5

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


6

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('Soluci¢n 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,'Soluci¢n 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:');


7

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 soluci¢n 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 */


8

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++) {


9

for(col=1; col<=6; col++) fprintf(archtxt,"%12.8f",mk[fila][col]); fprintf(archtxt,"\n"); } fprintf(archtxt,"\n"); fprintf(archtxt,"\n%s\n","Solución 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. También puede correrse desde la línea 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):


10

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 '\nSolución 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, sólo 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 sólo se corre dentro de Scilab. // ecuac.sce: resuelve un sistema lineal


11

clc; // iniciando las matrices mk=zeros(6,6); p=zeros(6); // generando los términos diagonales de mk for fila=1:6 do col=fila; mk(fila,col)=10*fila; end; // generando los otros términos 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('Solución del sistema:'); disp(p); // guardando la solución del sistema en un archivo de texto midir=get_absolute_file_path('ecuac.sce'); miarch=midir + 'archdatos.txt'; info='Solución del sistema'; deletefile(miarch); // destruir el archivo anterior, si existe // grabar los nuevos datos print(miarch,p, mk, info); disp('La solución 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


12

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('Solución 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('Solución del sistema');


13

disp(p); % grabando los datos en archivo info1='Matriz del sistema'; info2='Solución 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;

Análisis matricial de estructuras-Parte 1 - ing.una.py · PDF fileJ.L.Volta /...

Documents

Transcript of Análisis matricial de estructuras-Parte 1 - ing.una.py · PDF fileJ.L.Volta /...