Instituto Tecnológico de Tuxtla Gutiérrez · antecesores, a él se le atribuye las ... Es el corazón o cerebro de la computadora. Controla las operaciones de todo el equipo y consta

_______________________________________________________________________________ Apuntes de MatLab elaborados por: M.C. Roberto Carlos García Gómez 1

Instituto Tecnológico de Tuxtla Gutiérrez Departamento de Metal-Mecánica.

Curso de formación profesional.

“Programacion y Graficación con MatLab”

por: MC. Roberto Carlos García Gómez.

Tuxtla Gutiérrez, Chiapas. Octubre de 2004

Instituto Tecnológico de Tuxtla Gutiérrez

_______________________________________________________________________________ Apuntes de MatLab elaborados por: M.C. Roberto Carlos García Gómez ii

Indice. Contenido. Página

1. Introducción a la programación.......................................................................................................... 1.1 Componentes de una computadora .................................................................................................... 1.2 Lenguajes de programación................................................................................................................ 1.3 Características de MatLab. ................................................................................................................. 1.3.1 Antecedentes................................................................................................................................ 1.3.2 Características.............................................................................................................................. 1.3.3 Áreas de aplicación...................................................................................................................... 1.3.4 Funciones de aplicación especificas........................................................................................... 1.4 Identificadores..................................................................................................................................... 1.4.1 Identificación constantes............................................................................................................. 1.4.2 Identificadores variables.............................................................................................................. 1.4.3 Identificadores reservados........................................................................................................... 1.5 Tipos de datos...................................................................................................................................... 1.6 Operadores aritméticos....................................................................................................................... 1.6.1 Expresiones aritméticas............................................................................................................... 1.6.2 Niveles de prioridad en operadores............................................................................................ 1.7 Funciones matemáticas elementales.................................................................................................. 1.8 Ayuda en línea. .................................................................................................................................... 2. Conceptos de diagramación lógica..................................................................................................... 2.1 Diagramas de flujo.............................................................................................................................. 2.2 Estructura básica de un programa en matlab. ................................................................................... 2.3 Ejecución de programas básicos......................................................................................................... 3. Control de flujo.................................................................................................................................... 3.1 Operadores relacionales y lógicos...................................................................................................... 3.2 Estructura de selección simple (if)..................................................................................................... 3.3 Estructura de selección múltiple (switch).......................................................................................... 3.3.1 Estructuras anidadas. ................................................................................................................... 3.4 Procesos iterativos............................................................................................................................... 3.5 Sentencia while.................................................................................................................................... 3.6 Sentencia break.................................................................................................................................... 3.7 Sentencia continue............................................................................................................................... 3.8 Sentencia try...catch...end ................................................................................................................... 4. Vectores y matrices (arreglos)........................................................................................................... 4.1 Introducción......................................................................................................................................... 4.2 Formas de construcción. ..................................................................................................................... 4.2.1 Vectores. (arreglos unidimensionales)....................................................................................... 4.2.2 Matrices. (arreglos bidimensionales).......................................................................................... 4.2.3 Matriz vacía a[ ]. Borrado de filas o columnas.......................................................................... 4.2.4 Definición de vectores y matrices a partir de un fichero........................................................... 4.3 Operaciones aritméticas con vectores y matrices.............................................................................. 4.4 Funciones para vectores y matrices.................................................................................................... 4.5 Cadenas de caracteres......................................................................................................................... 4.6 Resumen de funciones para manejar vectores y matrices................................................................. 4.6.1 Funciones matriciales elementales. ............................................................................................ 4.6.2 Funciones matriciales especiales................................................................................................ 4.6.3 Funciones de factorización y/o descomposición matricial........................................................ 4.6.4 Cálculo del rango, normas y condición numérica...................................................................... 5. Funciones y archivos........................................................................................................................... 5.1 Definición de funciones...................................................................................................................... 5.2 Funciones con número variable de argumentos................................................................................


_______________________________________________________________________________ Apuntes de MatLab elaborados por: M.C. Roberto Carlos García Gómez iii

5.3 Sub-funciones...................................................................................................................................... 6. Graficación. ......................................................................................................................................... 6.1 Introducción......................................................................................................................................... 6.2 Funciones gráficas 2d elementales..................................................................................................... 6.2.1Función plot........................................................................................................................................ 6.2.2 Estilos de línea y marcadores en la función plot............................................................................. 6.2.3 Añadir líneas a un gráfico ya existente............................................................................................ 6.2.4 Comando subplot............................................................................................................................... 6.2.5 Control de los ejes............................................................................................................................. 6.2.6 Función line()..................................................................................................................................... 6.2.7 Control de ventanas gráficas: función figure................................................................................... 6.3 Otras funciones gráficas 2 -d............................................................................................................... 6.3.1 Función fplot................................................................................................................................ 6.3.2 Función fill para polígonos.......................................................................................................... 6.3.3 Entrada de puntos con el ratón.................................................................................................... 6.3.4 Preparación de películas o "movies". ......................................................................................... 6.3.5 Ventanas gráficas de matlab........................................................................................................ 6.4 Gráficos tridimensionales................................................................................................................... 6.4.1 Tipos de funciones gráficas tridimensionales............................................................................ 6.4.2 Dibujo de líneas: función plot..................................................................................................... 6.4.3 Dibujo de mallados: funciones meshgrid, mesh y surf.............................................................. 6.4.4 Dibujo de líneas de contorno: funciones contour y contour..................................................... 6.4.5 Mapas de colores......................................................................................................................... 6.4.6 Imágenes y gráficos en pseudocolor. Función caxi................................................................... 6.4.7 Dibujo de superficies faceteadas................................................................................................. 6.4.8 Otras formas de las funciones mesh y surf................................................................................. 6.4.9 Formas paramétricas de las funciones mesh, surf y pcolor....................................................... 6.5 Otras funciones gráficas 3d ............................................................................................................... 7. Códigos de los problemas propuestos...................................................................................................

_______________________________________________________________________________ Apuntes de MatLab elaborados por: M.C. Roberto Carlos García Gómez iii


_______________________________________________________________________________ Apuntes elaborados por: M. en C. Roberto Carlos García Gómez 1

UNIDAD I. INTRODUCCIÓN A

LA PROGRAMACIÓN. 1.1 COMPONENTES DE LAS COMPUTADORAS. Desde tiempos inmemoriales, el hombre a tenido la necesidad de realizar operaciones aritméticas cada vez con mayor rapidez y comodidad. El ábaco, fue el primer invento que logró este propósito (3000 a.c.).

o No fue sino hasta mediados del siglo XVII, cuando el matemático francés, Pascal inventó la primera calculadora mecánica que le permitió sumar y restar. Posteriormente en 1694 Leibnitz, científico alemán construyó otro modelo que le permitió sumar, restar, multiplicar y dividir.

o En 1835, en Inglaterra, Charles

Babbage también construyó un equipo que mejoró en mucho a sus antecesores, a él se le atribuye las bases que ahora poseen las computadoras actuales, como veremos más adelante.

o El primer americano que construyó

una computadora fue el doctor Hans Hollerith, que realizó el censo de los EEUU de 1890, en menos de 4 años. Su máquina leía tarjetas perforadas.

o La primera computadora digital fue construida en 1939 por IBM, la cual se llamó MARK I, utilizaba interruptores mecánicos. En la universidad de Pensilvania se construyó la ENIAC, con bulbos.

o La primera computadora comercial

fue la UNIVAC I, en 1951 construida con bulbos y podía ejecutar alrededor de 1000 operaciones por segundo siendo su campo de aplicación científico y militar.

o Se considera a ésta última y las que le siguieron (construidas con bulbos) como computadoras de la primera generación.

o En 1959 se construye la primera

computadora con transistores, desplazando a los bulbos, dando lugar al nacimiento de la segunda generación.

o En 1965 aparecieron las

computadoras construidas con circuitos integrados (CI o IC), de la tercera generación.

o La cuarta generación (que existen

hoy en día), apareció en 1970, las cuales estaban construidas con CHIP's o microprocesadores.

Desde el punto de vista histórico, la computadora electrónica es un desarrollo de los años cincuenta. No obstante, es el resultado de varios siglos de trabajo, hasta que la madurez técnica de la ingeniería y las necesidades sociales la han hecho posible. La computadora es capaz de desarrollar actividades que, de hacerlas el hombre, demandarían el uso de capacidades que no posee.



En la figura No.1 se muestra a bloques los componentes de las computadoras actuales. A los DISPOSITIVOS también se les conoce como UNIDADES. A estos componentes (excepto la UCP) también se les conoce como PERIFERICOS.

Unidad de entrada. Es un equipo que nos permite introducir información hacia el interior de la máquina (UCP). Ejemplos: Teclado, Lápiz óptico, Mouse (Ratón), Diskette, Scanner, Joystick (Palancas de juego), Cámara de video, Sintetizadores de voz, etc. Unidad de salida. Es un equipo que nos permiten enviar información hacia el exterior de la máquina (UCP). Ejemplos: Monitor, Bocinas, Plotter (trazador gráfico), Impresoras, Modems, Cañón de proyecciones, Unidades de diskette, Cintas. Unidad Central de Proceso ( UCP o CPU ). Es el corazón o cerebro de la computadora. Controla las operaciones de todo el equipo y consta a su vez, de varios componentes, como se muestra en la Fig.2.

Figura 2. Componentes de la UCP.

Unidad de aritmética y lógica. La unidad de aritmética y lógica ( UAL o ALU ) se encarga de realizar operaciones aritméticas (suma, resta, multiplicación, división, etc.), de comparación (mayor que, menor que, igual a, etc. ) y operaciones lógicas ( y , o , etc.)

Aritmética Comparación Lógica Por ejemplo: 4 + 2 4>2 2=2 y 3>4 3 * 4 3=3 2<1 o 4<5

Las operaciones aritméticas arrojan resultados numéricos, sin embargo, las operaciones de comparación y lógicas arrojan resultados de verdadero o falso solamente. Unidad de control. UC o CU, realiza el control y sincronismo de la ejecución de las instrucciones que le envía la memoria central o principal. Se encarga de que los procesos se lleven en el orden indicado y evita la colisión de los datos y por consecuencia pérdida de los mismos. Es como el sistema nervioso central en la computadora. Memoria central o principal. De los componentes que conforman la UCP, la memoria principal es con la que siempre interactuamos, por lo cual, merece una mayor atención de nuestra parte. Definamos qué es memoria: " Es algo que permite guardar información". Ahora bien, ese "algo" puede ser natural o inventado por el hombre. Por ejemplo: Madera, Piedra, Pizarrón, Casette, Disco, etc. A las memorias se les puede clasificar además por la forma en que operan, de la siguiente manera: RAM, ROM, PROM, EPROM.

Figura 1. Componentes a bloques de las computadoras.



o RAM. (Random Access Memory) (Memoria de acceso aleatorio) es la que el usuario puede utilizar libremente, es volátil o transitoria, ya que cuando se le quita la energía que lo alimenta, la información desaparece.

o ROM. (Read Only Memory) (Memoria

de sólo lectura), en este tipo de memoria la información contenida no puede alterarse; está prefijada y solamente podemos leerla.

o ROM. (ROM programable). Es una

memoria ROM que se puede grabar información solamente una vez y se convierte en ROM.

o EPROM. (ROM programable-

borrable) Es como una RAM, la única diferencia es que la información contenida en ella no se pierde aunque falte la energía que lo alimenta.

En la memoria principal de la computadora es donde se almacena toda la información proveniente del exterior, también, se almacenan los resultados de procesos internos y, así también, la información que se envía al exterior. La computadora no podría funcionar sin esta memoria, la cual es de tipo RAM, lo que significa que la información contenida en ella se pierde en caso de falla eléctrica. Memoria auxiliar o secundaria. Son dispositivos de memoria tipo EPROM, lo que significa que podemos guardar de modo permane nte cualquier información en

ellos. Auxilian a la memoria RAM, ya que la información contenida en ella se pierde en caso de falla eléctrica. Ejemplos: Disco flexible (floppye o diskette), Disco duro, CDROM (compac disk), Cintas, Discos ópticos. CUANTIFICACIÓN DE LA MEMORIA. La unidad de medida de memoria en las computadoras es el byte. Por cada caracter que usted desee almacenar en la memoria (Principal o secundaria) de la computadora requiere de un Byte. Si desea almacenar la palabra "curso" requerirá de 5 bytes. Sin embargo, esta unidad es pequeña cuando deseamos agrupar miles de letras. Se utilizan otros términos: 1 Kilobyte equivale a 1024 bytes (1Kb). 1 Megabyte equivale a 1024 Kilobytes (1Mb). 1 Gigabyte equivale a 1024 Megabytes (1Gb)

Las capacidades de almacenamiento más comunes son: Memoria principal: 32Mb, 64Mb, 128Mb, .... Disco flexible (floppye o diskette): 3 1/2" Alta densidad 1.44Mb Disco duro: 20 Gb, 40 Gb, ...... CDROM (compac disk): Hasta 650 Mb Cintas : 125 Mb, 250 Mb ..... 1.2 LENGUAJES DE PROGRAMACIÓN.

A. Lenguajes de Bajo y Alto Nivel En efecto, lo único que entienden y pueden manipular la Unidad de Control y la Unidad Aritmética son dígitos binarios o sea series de ceros y unos (paso o no paso de

corriente eléctrica). Así, mientras el hombre usa un "lenguaje natural" (idioma) muy rico en significados, la máquina usa un sistema en que existiría un sólo "significado": la diferencia entre 0 y 1 (o sea un bit de información).



¿Cómo lograr más? Simplemente concibiendo un nuevo lenguaje constituído de "bloques" de dígitos binarios (llamados "bytes" ). Este es el primer paso o "primer nivel" en la construcción de lenguajes de computación. 1º Nivel Se dice que el código binario es de "bajo nivel" o "primer nivel" (porque al usar pocos signos logra muy dificilmente expresar cosas complicadas), mientras un lenguaje humano es de "muy alto nivel" (con una cantidad mayor de signos y con reglas combinatorias logra expresar con facilidad cosas muy complicadas). Todo el esfuerzo, entonces, para facilitar la comunicación del hombre con el computador, ha de centrarse en el desarrollo de lenguajes de mayor nivel. El fabricante de un procesador fija los bloques de bits que llevarán a la CPU (unidad central de procesos) a reconocer y realizar diferentes operaciones. Este el el "código de máquina", primer lenguaje que la máquina puede interpretar y transformar en acciones. Pero es evidentemente muy difícil de usar para un ser humano. Supongamos que quiera hacer imprimir y para el lo deba decir "10011101 11100010": ¿cómo recordar órdenes de este tipo y no equivocarse al escribirlas? Practicamente nadie trabaja hoy a este nivel, excepto los diseñadores de "chips" procesadores. Del mismo modo que es posible pasar de un sistema binario a un sistema decimal (más comprensible y más desarrollado en términos de signos legibles) es posible asociar a los bloques de bits no solo valores decimales sino también otros signos. Esto lleva a un segundo nivel de expresión.

Hemos de recordar que el teclado equivale a un conjunto de interruptores: cada tecla que pulsamos equivale a cerrar brevemente uno de éstos, es decir produciendo un bit de información (no teclear = 0, teclear =1). Pero dado que hay muchas teclas, hay que identificar cada una, por lo cual pulsar una tecla significa activar un circuito que generará un "bloque" binario (byte) específico que identifica esa tecla. A cada tecla está asociado un código decimal y un código hexadecimal. El hexadecimal (16 caracteres: de 0 a 9 y de la A a la F) es el que sirve de intermediario a la máquina, para traducir nuestro código natural (alfanumérico) al código binario. Algunos ejemplos de equivalentes decimales y hexadecimales del teclado son los siguientes:

Tecla Valor Decimal

Valor Hexadecimal

1 49 31 2 50 32 9 57 39 a 97 61 b 98 62 j 106 6ª z 122 7ª ! 33 21 ? 63 3F = 61 3D

Encontrarás otros ejemplos en el "juego", que te servirán para realizar la evaluación del capítulo. Esto permite no sólo reconocer los signos del teclado y reproducirlos (como en un procesador de palabras), sino también atribuir a cada tecla otra función y hacer -por ejemplo- que transmita una orden a la CPU. Así, podríamos ordenar la impresión con un simple "?", o -como es común hoy en los Macintosh- apretando



simultáneamente una tecla de "comando" y la letra "P". 2º Nivel La creación de un lenguaje más comprensible por el hombre consiste por lo tanto en establecer la equivalencia de bloques binarios con signos de nuestro lenguaje habitual. Para permitir la programación (secuencia de comandos), se usan pequeños conjuntos de signos ("palabras") de fácil memorización, con las cuales se redactan programas, por ejemplo "ADC" significará "sumar con reserva" (en inglés: "ADd with Carry"). Este tipo de lenguaje se llama "ensamblador" o "Assembler" (Vea más adelante la "Descripción" de Lenguajes). La máquina misma hará la tarea de traducirlo en código binario, para seguir las instrucciones, gracias a otro programa cuya función es traducir la expresión humana en "lenguaje de máquina" (binario). Es programa se llama "compilador". (Vea la 3a Parte sobre "Hardsoftware"). Aunque el Assembler es un inmenso progreso en relación al código binario, su desventaja reside en que permanece estrechamente ligado a los bloques binarios que reconoce la CPU (es decir al "hardware"). Para facilitar más la tarea, se han inventado lenguajes de "alto nivel", es decir más cercanos al modo de expresar del hombre que de operación de la máquina. Los primeros y más comunes son los llamados de "tercera generación", más fáciles de manejar y más independientes de las características técnicas de los procesadores. Ahora, hasta un aficionado puede llegar a redactar un programa, sin tener que preocuparse por el código binario o de ensamble: si un programa traductor podía resolver la transformación de bloques de signos en bloques binarios, era cosa de extender las habilidades del traductor para

"enseñar" a la máquina cómo "entender" un lenguaje más complejo y agregar mecanismos automáticos de manejo de la memoria para poder utilizar lenguajes aún más comprensibles. 3º Nivel El avance en el desarrollo de "compiladores" e "intérpretes" (los dos tipos de programas traductores) ha sido por lo tanto fundamental en el desarrollo de los lenguajes de "3º generación" cuyas ventajas además de la facilidad de aprendizaje y lectura/escritura son las facilidades de corrección, transformación y conversión de un lenguaje a otro. Los más antiguos son el FORTRAN (para aplicaciones matemáticas y científicas) y el COBOL (para aplicaciones de administración y contabilidad). Con los micro-computadores nació el BASIC ("para principiantes"). Mucha importancia tiene el PASCAL, especialmente en la docencia. (Más detalles luego, en la "Descripción" de los lenguajes). Generadores de aplicaciones o 4º Nivel Posteriormente, usando estos lenguajes, se han redactado programas destinados a facilitar un número variado de operaciones en campos de aplicación específicos como simulación de fenómenos físicos, manipulación de datos estadísticos, etc. Los más avanzados y flexibles de estos programas son las planillas electrónicas u hojas de cálculo y los programas de administración de archivos o bases de datos (Vea el capítulo "Aplicaciones"). Dados que tales aplicaciones no "hacen nada" sin que el usuario defina ciertas estructuras y ciertas operaciones, pueden ser consideradas como "generadores" de aplicaciones, aunque este nombre se



reserva habitualmente para niveles más avanzados en que los usuarios pueden generar sistemas muy diferentes unos de otros, con "herramientas" que se parecen a lenguajes de programación. Estas herramientas conforman los lenguajes de cuarto nivel que son por esencia "programas para crear programas" con una finalidad específica, como el "CASE" destinado a facilitar el trabajo de los analistas de sistemas. B. Estructura de un Lenguaje Todo lenguaje, para permitir la programación, ha de contener diversos tipos de instrucciones: Instrucciones simples: de entrada: para buscar y recoger datos en la memoria central o auxiliar, o bien obtenerla por interacción con el usuario (p.ej. mensaje en el monitor de video que debe ser contestado en el teclado), de salida: datos expuestos en el monitor de video o impresos, o transmitidos en una red, de asignación: asignar un valor a una variable, sea directamente (p.ej. Variable1 = 15) sea por cálculo (p.ej. Var3 = Var1 + Var2). Instrucciones compuestas: de secuencia: por principio el orden dado a las instrucciones determina el orden en que se ejecuten, salvo instrucciones especiales de "salto" como las previstas en instrucciones de alternación o iteración. Toda instrucción compuesta debe tener una ENTRADA y una SALIDA. Puede siempre reemplazarse una instrucción simple por una compuesta manteniéndose el principio de secuencialidad de las instrucciones. de alternación: escoger entre dos alternativas en función del cumplimiento de una condición (p.ej. if X > 15 then ... else ...:

si X es mayor que 15 haga esto, sino este otro) de iteración: ejecutar repetidamente un grupo de instrucciones mientras se cumpla una condición (p.ej. para contar de 1 hasta 10: N=1, while N < 10 repeat {N = N+1, print N}. O sea mientras N sea inferior a 10, agregue 1 al valor anterior de N). En este ejemplo, se introduce un concepto muy importante en el desarrollo y uso de lenguajes de programación: la recursividad, factible por el hecho de que lo que se manipula es siempre un valor colocado en alguna celda de memoria. Así, si bien la matemática no puede aceptar una ecuación como N=N+1, aquí estamos ante una instrucción (no una ecuación) que significa "tomar el valor que está en una celda llamada N, sumarle 1 y volver a colocar el nuevo valor en la celda llamada N. Ésta es una "instrucción de asignación". Algunos lenguajes (el Algol y sus descendientes como Pascal y "C", y también Lisp y Prolog en que este procedimiento constituye la esencia del lenguaje) van aún más lejos y permiten una recursividad consistente en la posibilidad de que una instrucción compuesta ordene la ejecución de sí misma. El siguiente podría ser una breve ejemplo: Para imprimir una lista con una instrucción recursiva, basta tener en cuenta que una lista se compone de una cabeza (primer elemento) y una cola (el resto). Obviamente la cola es también una lista, por lo cual se le puede aplicar el procedimiento consistente en separar su cabeza de su cola, y así sucesivamente, hasta encontrar una cola vacía. Por lo tanto, se puede ordenar algo así: imprimir lista = imprimir cabeza lista = cola [borra de la lista la cabeza ya impresa] si lista no es vacía, imprimir lista [orden de recursión] sino: fín.



C.- Programación estructurada Como explicado a propósito de las "Instrucciones", todo programa se compone de una secuencia de instrucciones que pueden ser simples o compuestas. La presencia de instrucciones que deban repetirse muchas veces no sólo se expresa en las iteraciones, donde dicha repetición es inmediata. Existen muchos casos en que la repetición no es un flujo contínuo sino dependiente de otras operaciones o condiciones que son muy variables. Es el caso por ejemplo de las instrucciones para leer o grabar datos en un disco. La programación estructurada, que es una forma de redacción de programas (obligatoria u optativa, según el lenguaje escogido), se hace cargo de este requisito facilitando la constitución de "paquetes" de instrucciones (llamados "sub-rutinas" o "procedimientos"), los que pueden escribirse una sola vez y ser "llamados" (utilizados) las veces que se requiera. Además, pone énfasis en la conveniencia de facilitar la lectura de los programas haciendo más visible la dependencia jerárquica de las instrucciones compuestas mediante "indentación", es decir modificando el ancho del margen izquierdo para cada grupo de instrucciones.

LENGUAJES DE PROGRAMACIÓN Segunda Parte: Descripción de algunos Lenguajes de Programación

ADA Assembler Algol Basic C Cobol Fortran Html Hypertalk Java Lisp Logo Modula Pascal PL/1 Prolog ADA Es un lenguaje estructurado parecido al PASCAL, destinado a controlar mecanismos en "tiempo real" (o sea una velocidad compatible con las necesidades reales), pero de gran complejidad. Admite una programación "orientada a objetos" y un sistema de alta modularidad de tipo hipertexto. Fue elaborado a pedido del Departamento de Defensa de los Estados Unidos y establecido como norma para todos los fabricantes que participaban en el programa de la Iniciativa de Defensa Estratégica (IDE, también llamado "Guerra de las Galaxias"). Assembler (Ensamblador) Como señalado a propósito del "Primer Nivel" de los lenguajes, el Assembler es directamente dependiente de los circuitos electrónicos de los procesadores (que constituyen el núcleo de los computadores), por lo cual escribir en Ensamblador sigue siendo una tarea muy compleja, a lo cual hay que sumar que el código varía de un



procesador a otro aunque existe ya un jerga común para ciertas operaciones como las aritméticas y lógicas, por ejemplo: ADD para sumar (sin reserva) ADC para sumar con reserva ("add with carry") M para multiplicar ORA para el "o" lógico ("or and") EOR para el "o" exclusivo (o bien... o bien...) Las instrucciones de este tipo deben ir seguidas sea de dos valores (dos números a sumar o multiplicar por ejemplo) o del nombre de una variable. Cuando se ejecute el programa, el valor de una variable nombrada deberá provenir de una operación anterior que haya terminado por una instrucción del tipo "almacenar el resultado del operación en la variable X", haya extraído el valor de la variable de una determinada celda de memoria, o haya efectuado una interacción con el usuario, por ejemplo escribir en pantalla "Escriba el valor de X". (Estas son "instrucciones de asignación"). El Assembler contiene además un conjunto mínimo de instrucciones de alternación e iteración indispensables para que un programa pueda funcionar como tal. (Vea "Construcción" sobre instrucciones que han de contener todo lenguaje de programación). ALGOL El ALGOL ("ALGOrithmic Lenguage") es el primer lenguaje que fue creado por un comité internacional. En 1960 se reunieron representantes de varios países europeos y de Estados Unidos para crear un lenguaje destinado a "describir procesos" mediante instrucciones de control (iteraciones y alternaciones) de nivel más elevado que las

existentes en las versiones existentes de su predecesor, el FORTRAN. Permite escribir programas de resolución de problemas en forma limpia y clara, de fácil lectura. Aunque poco "transportable" (no permite con facilidad que un programa escrito para un tipo de computador funcione en otro), es de gran importancia conceptual por cuanto introdujo la "programación estructurada", lo cual influyó en muchos lenguajes creados posteriormente. En 1968 se implementó una nueva versión multi-propósito especialmente orientada a la tercera generación de computadores que empezaban a copar el mercado. (A diferencia de la primera versión, ésta resultó muy compleja y, por ello, tuvo poco éxito). EJEMPLO: REAL PROCEDURE exp(x); VALUE x; REAL x; BEGIN REAL sum, term, n; sum:= 1; term:= 1; n:= 0; FOR n:= n+1 WHILE abs (term) > 0.001 DO BEGIN term:= x * term / n; sum:= sum + term END; exp:= sum END. BASIC El BASIC ("Beginner's All-purpose Symbolic Instruction Code")nació con los microcomputadores, como un lenguaje simplificado y multi-propósito destinado a los usuarios no-especialistas. Permite resolver problemas numéricos o comerciales así como crear y mantener archivos, realizar gráficos lineales, etc. Es por esencia un lenguaje interpretado y no-estructurado. Sin embargo, existen algunos compiladores, pero no es común recurrir a ellos. Y también es factible redactar los programas en forma estructurada. EJEMPLO



10 INPUT A 20 INPUT B 30 C = A+ B 40 IF C > 100 THEN 90 50 PRINT "Suma = "; C 60 PRINT 70 PRINT "Desea seguir? "; : GET R$ 80 IF R$ = "S" THEN 10 90 PRINT "Resultado superior a 100!" 100 END "C" - "C++" El lenguaje "C" es bastante reciente y está especialmente orientado hacia el desarrollo de software de sistemas operativos y utilitarios que anteriormente se escribían en Assembler. Se usa hoy como base para crear el software que funciona con el sistema operativo "UNIX", logrando un alto grado de portabilidad, es decir de independencia respecto de los procesadores (con lo cual es fácil lograr que un mismo programa pueda ser ejecutado en diferentes modelos de computadores). El "C++" es un lenguaje desarrollado a partir del "C" pero con una estructura "orientada a objetos", lo cual facilita un mejor manejo de datos. (Ver "HyperTalk" sobre la orientación a objetos). Ejemplo. #include int main () { printf ("Esta es una línea de texto.\n"); printf ("Y esta es otra "); printf ("línea de texto.\n\n"); printf ("Esta es una tercera línea.\n"); return 0; }

COBOL EL COBOL ("COmmon Business-Oriented Language") es uno de los primeros lenguajes de programación creados. Fue desarrollado en 1960 por CODASYL (Conference on Data Systems Languages), un comité en que participaron fabricantes y

usarios, a pedido de la Marina de los Estados Unidos. Es uno de los pocos lenguajes reconocidos como norma internacional (americana por el ANSI -American National Standards Institute- y europea por el ISO -International Organization for Standardization-). Está orientado -como su nombre indica- a aplicaciones comerciales, por lo cual sus instrucciones están especialmente diseñadas para facilitar la entrada y salida de datos (impresión de tablas, etc.). Se pretendió que se pareciera lo más posible a un lenguaje natural, por lo cual requiere mucho más escritura que otros lenguajes. Esto facilita la lectura posterior pero resulta aburrido para los redactores. Debe iniciarse con secciones donde se declaran todas las variables y los periféricos que se van a usar, cosas que muchos lenguajes posteriores ya no requieren. EJEMPLO IDENTIFICATION DIVISION. PROGRAM-ID. SUMA. ENVIRONMENT DIVISION. INPUT-OUTPUT SECTION. FILE-CONTROL. SELECT ENTRADA ASSIGN TO INPUT. SELECT SALIDA ASSIGN TO OUTPUT. DATA DIVISION. FILE SECTION. FD ENTRADA LABEL RECORD IS OMITTED. 01 VENTA. 02 VALOR PICTURE 9999V99. 03 FILLER PICTURE X(44). FD SALIDA LABEL RECORD IS OMITTED. 01 RESULTADOS PICTURE X(132). WORKING STORAGE SECTION. ... PROCEDURE DIVISION. ...

FORTRAN El FORTRAN ("FORmula TRANslator") ha sido desarrollado entre los años 1954 y 1957, siendo el primer lenguaje usado ampliamente en la solución de problemas



numéricos y el más común hasta 1970. Sigue siendo de primera importancia en aplicaciones científicas por cuanto se adapta muy bien a la forma tradicional de escribir fórmulas matemáticas. Al contrario, no se presta con facilidad al manejo de archivos y produccción de tablas de resultados. Existen numerosas versiones y perfeccionamientos posteriores. (La versión de 1966 fue instuída como estándar por el Instituto Americano de Estandarización, reemplazándola por el FORTRAN 77 en la década siguiente EJEMPLO INTEGER A, B, C 10 READ (5,1010) A, B 1010 FORMAT (I4,I4) C = A - B IF (C. EQ. 0) GO TO 20 WRITE (6,1020) C 1020 FORMAT (I4) GO TO 10 20 STOP END

HYPERTALK "HyperTalk" es el lenguaje desarrollado por Dan Winkler para Bill Atkinson, el creador del "HyperCard" para Apple-Macintosh. Está orientado a la creación de aplicaciones conforme al sistema de "hiperarchivos" (sistemas de fichas interrelacionadas donde se facilita el "navegar" de un archivo a otro). HyperTalk es un buen ejemplo de lenguaje orientado a objetos. Este tipo de lenguaje combina la lógica declarativa con los algoritmos (Vea "PROLOG"). Un programa ya no es una secuencia de instrucciones sino un conjunto de objetos agrupados en conjuntos, definidos mediante atributos y a los cuales pueden asociarse instrucciones. Así, en HyperCard, existen archivos ("stacks" o "pilas") que agrupan fichas

("cards"), y cada una de éstas contiene campos de datos y botones. Todos son "objetos" que -si bien mantienen entre sí una relación jerárquica- tienen asociados paquetes de instrucciones ("scripts") independientes unos de otros. Cada objeto pertenece a un conjunto (como fichas o botones) que tiene "atributos" propios comunes a todos sus miembros, y cada atributo tendrá un valor común o específico para cada caso. Para dar o buscar dicho valor intervienen "facetas" que son instrucciones (procedimientos) asociadas. HTML El HTML o HyperText Marking Language es el lenguaje que se utiliza para crear páginas interactivas -como la presente- en World Wide Web. El HTML se basa en los mismos principios que el HyperTalk, permitiendo definir segmentos (de texto o ilustraciones) que remiten a otros, facilitando una "navegación" por múltiples vías, a gusto del usuario. Así es como el botón "Home" tiene asociadas las instrucciones que indican al procesador que busque la primera ficha o página del archivo llamado "Home" o "index" en el archivo del computador que presta el servicio de conexión (servidor). Y si se hace un clic en una palabra subrayada, se pasa a ver otra sección del mismo documento o algún otro documento (otro "objeto"). JAVA JAVA es un lenguaje de programación basado en el C++ (con cambios en la



sintaxis y nuevas restricciones de codificación). Permite agregar animaciones y puntos sensibles en páginas de texto. Aunque se lo pretende presentar como "EL" lenguaje destinado a desarrollos para World Wide Web, es mucho mas complejo que el HTML e incluso que otros lenguajes utilizables por los browsers de Web. LISP LISP ("LIst Processing Language") es un lenguaje computacional bastante diferente de los demás. Es un lenguaje funcional, es decir que acumula informaciones e instrucciones bajo la apariencia de fórmulas (como en álgebra). Estas informaciones toman la forma de listas (de ahí su nombre), que son memorizadas y comparadas para efectuar luego operaciones que consisten en "evaluar las fórmulas". El conjunto de funciones constituye el programa en cuanto la evaluación de una función llama a otra y así sucesivamente (en forma eminentemente recursiva). El control de la ejecución depende del intérprete (que busca la secuencia y la traduce en lenguaje máquina), mientras depende del programador la forma en que las funciones se llaman entre sí. El objetivo de este tipo de lenguaje es asemejarse a una forma humana de conservación de información (la de las descripciones) y permitir la construcción de programas que se enriquezcan o ajusten en función del uso (simulando aprendizaje). Así, LISP es el primer lenguaje creado con el fín de ser una herramienta para el desarrollo de la inteligencia artificial. EJEMPLO ? (de append (L1 L2) (if (null L1) L2

(cons (cor L1) (append (cdr L1) L2))))

LOGO Creado por Seymour Papert, padre de la "computación educativa", el LOGO está destinado a la enseñanza de la programación a los niños, desde temprana edad. Por ello es sobretodo conocido por su capacidad gráfica y su "tortuga", que es el puntero con el cual se realizan los dibujos. Es altamento modular y deja gran libertad al usuario para definir procedimientos desde muy simples hasta muy complejos, en forma jerárquica, permitiendo incluso el control de periféricos mecánicos (operación de pequeños robots). Aunque bastante poderoso (se han escrito procesadores de palabras en LOGO), practicamente no es utilizado fuera de la escuela básica. EJEMPLO Comandos para dibujar un cuadrado de 20 pixels (puntos) por lado: BAJAR_PLUMA. ADELANTE 20. ROTACION 90. ADELANTE 20. ROTACION 90. ADELANTE 20. ROTACION 90. ADELANTE 20. LEVANTAR_PLUMA. Lo que conforma el cuadrado puede simplificarse como: HACER 4 (ADELANTE 20. ROTACION 90). y ser utilizado repetidamente definiendo el comando "Cuadrado": >CUADRADO: HACER 4 (ADELANTE 20. ROTACION 90). Esta definición se puede generalizar reemplazando la longitud por una variable (El programa pide automáticamente en pantalla el valor de una variable si lo desconoce): >CUADRADO: HACER 4 (ADELANTE LADO. ROTACION 90). (Las órdenes para bajar y levantar la "pluma" -que permiten dejar o no dejar rastro al mover la "tortuga" - pueden introducirse o no en la definición, a voluntad).



"PASCAL" Del nombre del filosófico y matemático francés, PASCAL es un lenguaje inicialmente diseñado para la docencia introductoria de la programación (a ni vel superior). Surgió alrededor de 1970, en gran parte como reacción simplificadora después de la creación de los muy complejos PL/1 y ALGOL68 para los nuevos computadores de tercera generación. Muy inspirado en la primera versión oficial de ALGOL (60), es un lenguaje muy estructurado y con alta modularidad. Tuvo por ello -y por su simplicidad- mucha aceptación al punto de ser utilizado para crear importantes aplicaciones e incluso compiladores y sistemas operativos (antes desarrollados en Assembler). EJEMPLO PROGRAM CALCULATOR; VAR A, B: INTEGER; OPERATION; CHAR; BEGIN REPEAT READLN (A, OPERATION, B); IF OPERATION = '+' THEN WRITELN (A + B) ELSE IF OPERATION = '-' THEN WRITELN (A - B) ELSE IF OPERATION = '*' THEN WRITELN ( A* B) ELSE IF OPERATION = '/' THEN WRITELN (A / B) UNTIL FALSE END.

PL/1 EL "PL/1" es un lenguaje multi-propósito creado por IBM y SHARE, especialmente a raíz del paso de la segunda a la tercera generación de computadores, cuando se preveía la creciente difusión de estas máquinas y su posible uso en una gama

creciente de actividades. Pretendía ampliar las posibilidades del FORTRAN fusionando conceptos provenientes del COBOL y el ALGOL. La gran cantidad de instrucciones, tipos de datos y casos especiales que contempla lo hacen difícil de aprender y dominar, razón de su poca difusión. EJEMPLO TRAPZ: PROCEDURE OPTIONS (MAIN); DECLARE (J,K) FIXED DECIMAL (2), AREA FIXED DECIMAL (8,6); PUT SKIP EDIT ('AREA BAJO LA CURVA') (X(9),A); PUT SKIP; DO K=4 TO 10; AREA=0.5/K; DO J=1 TO K-1; AREA=AREA+((J/K)**2)/K); END; PUT SKIP EDIT ('PARA DELTA X=1/',K,AREA) (X(2),A,F(2),X(6),F(9,6); END; END; PROLOG Los primeros años de la décado del 70 son conocidos como un período de "crisis del software", en que se descubrió que la creación de buenos programas involucraba costos mayores que los del hardware que los ejecuta. También se hacía patente una creciente necesidad de procesar "conocimientos" (algo mucho más amplio y complejo que los datos cuantitativos o meras "secuencias de caracteres" a los cuales se reducen muchos lenguajes de programación). Esta crisis llevó a investigar numerosas alternativas, entre las cuales nuevos lenguajes no basados en instrucciones algorítmicas o procedimientos. Si el hombre "procesa" más información por inferencia lógica que por cálculo, ¿no podría la máquina hacer lo mismo? PROLOG ("PROgramación en LOGica") es una respuesta a esta crisis, producto del avance de la lógica moderna (de tipo



funcional). Lo crearon A. Colmenauer y Ph. Roussel, con la colaboración de R. Kowalski, simultáneamente en la Universidad de Aix-Marseille (Francia) y Edimburgo (Gran Bretaña). Se basa en el cálculo de predicados de primer orden y en el principio de resolución de Robinson. En vez de ser algorítmico ("procedural" en inglés, término sin traducción), es decir concebido como un conjunto de instrucciones que la máquina debe ejecutar en forma secuencial, es "declarativo", es decir basado en definiciones (de "hechos" o "reglas", como se explica más abajo). EJEMPLO Si sabemos que una línea aérea une París con Río con el vuelo 36 y otra une Río con Santiago con el vuelo 71, concluimos sin dificultad alguna que es posible viajar de París a Santiago con una escala en Río. En lógica funcional, los datos básicos ("hechos" en terminología PROLOG) podrían escribirse: une(Paris,Rio,Vuelo36). une(Rio,Santiago,Vuelo71). Vemos que la relación ("une") es la misma y que hay un término común en la lista de argumentos (lo que hay entre

paréntesis). Solo falta explicitar una regla idéntica a la que se usa para extraer una conclusión a partir de dos premisas en un silogismo: camino(Paris,Santiago) <- une(Paris, x, n), une(x, Santiago, m).

o sea "Hay un camino entre París y Santiago si algún vuelo (n) une París con una ciudad 'x' y (&) otro vuelo (m) une esta ciudad 'x' con Santiago. Un "programa" en PROLOG se conforma con estos dos tipos de expresiones (llamadas "cláusulas"): "hechos" y "reglas". Una cláusula con forma de hecho y seguida de un '?' constituye la forma habitual de consultar la información. Si no contiene ninguna variable, el programa verifica si existe una "copia" en la lista de hechos y contesta por sí o no. Si contiene una o más variables busca cuales se ajustan a la descripción o pueden ser deducidas mediante las reglas y señala el valor correcto de las diferentes variables (o bien "No" si no hay respuesta posible).

1.3 CARACTERÍSTICAS DE MATLAB.

1.3.1 Antecedentes. MATLAB es un entorno de calculo técnico de altas prestaciones para calculo numérico y visualización. Integra:

o Análisis numérico o Calculo matricial o Procesamiento de señales o Gráficos

en un entorno fácil de usar, donde los problemas y las soluciones son expresados como se escriben matemáticamente, sin la programación tradicional. El nombre MATLAB proviene de LABORATORIO DE MATRICES.

MATLAB fue escrito originalmente

para proporcionar un acceso sencillo al software matricial desarrollado por los proyectos LINPACK y EISPACK, que juntos representan lo mas avanzado en programas de calculo matricial. MATLAB es un sistema interactivo cuyo elemento básico de datos es una matriz que no requiere dimensionamiento. Esto permite resolver muchos problemas numéricos en una fracción del tiempo que llevar a hacerlo en lenguajes como C, BASIC o FORTRAN . MATLAB ha evolucionado en los últimos años a partir de la colaboración de muchos usuarios. Estas son muy importantes para la



mayoría de los usuarios de MATLAB y son conjuntos de funciones MATLAB que extienden el entorno MATLAB para resolver clases particulares de problemas como:

o Procesamiento de señales o Diseño de sistemas de control o Simulación de sistemas dinámicos o Identicación de sistemas o Redes neuronales y otros.

Probablemente la característica mas importante de MATLAB es su capacidad de crecimiento. Esto permite convertir al usuario en un autor contribuyente, creando sus propias aplicaciones. En resumen, las prestaciones mas importantes de MATLAB son:

o Escritura del programa en lenguaje matemático.

o Implementación de las matrices como elemento básico del lenguaje, lo que permite una gran reducción del código, al no necesitar implementar el calculo matricial.

o Implementación de aritmética compleja.

o Un gran contenido de ordenes especificas, agrupadas en TOOLBOXES.

o Posibilidad de ampliar y adaptar el lenguaje, mediante ficheros de script y funciones .M.

Historia de MATLAB Cleve Moler escribió el MATLAB original en FORTRAN, durante varios años. Los algoritmos matriciales subyacentes fueron proporcionados por los muchos integrantes de los proyectos LINPACK y EISPACK.. El MATLAB actual fue escrito en C por The Mathworks . La primera version fue escrita por:

o Steve Bangert, que escribió el interprete parser

o Steve Kleiman que implemento los gráficos

o John Little y Cleve Moler que escribieron las rutinas de análisis, la

o guía de usuario y la mayoría de los ficheros M.

o Desde la primera versión muchas otras personas han contribuido al desarrollo de MATLAB.

Documentación de MATLAB. La documentación de MATLAB incluye ayuda en línea y manuales impresos:

o MATLAB HUSERAS UIDE: Contiene aspectos específicos de la plataforma acerca de su uso y un tutorial con las funcionalidades básicas de MATLAB.

o MATLAB REFERENTE UIDE: Compendio alfabético de todas los comandos de MATLAB.

o EXTERNA INTERNASE UIDE: Describe los interfaces externos de MATLAB, incluyendo la importación y exportación de datos, librerías FORTRAN y C para linkado dinámico, lectura y escritura de ficheros y llamada a MATLAB como motor de calculo.

o INSTALLATION UIDE: Describe como instalar MATLAB.

o ONLINE HELP: La ayuda en línea del programa y las demos proporcionan información acerca de los comandos de MATLAB y muestran algunas de sus características.

o AYUDA EN INTERNET: En Internet se puede encontrar una gran variedad de sitios con información abundante sobre MATLAB. Desde el web de la propia casa MATHWORKS, hasta FAQS (Preguntas mas frecuentes), tutoriales, ayudas, foros, etc...

1.3.2 Características.



o Trabaja con memoria dinámica, por

lo que no es necesario declarar las variables que se van a usar.

o Es de aplicación específica. Con este lenguaje se pueden desarrollar programas (aplicaciones) Matemáticas, de Ingeniería, Educativas, etc.

o Es de nivel medio. Por que tiene la accesibilidad de un lenguaje de alto nivel y puede tener acceso a los recursos de la computadora como los lenguajes de bajo nivel (como el ensamblador que es el lenguaje propio de la computadora).

o Permite casi cualquier combinación de datos en operaciones. Esto es, que en una operación de suma pueden mezclarse operadores relacionales, lógicos, aritméticos con datos tipo caracter, enteros, y flotantes.

o Distingue entre mayúsculas y minúsculas.

o La comilla ' es la que, en un teclado estándar (se encuentra en la tecla de la interrogación).

1.3.3 Áreas de aplicación. En entornos universitarios se ha convertido en la herramienta de enseñanza estándar para cursos de introducción en álgebra lineal aplicada, así como cursos avanzados en otras áreas. En la industria, MATLAB se utiliza para investigación y para resolver problemas prácticos de ingeniera y matemáticas, con un gran énfasis en aplicaciones de control y procesamiento de señales. MATLAB también proporciona una serie de soluciones especificas que denominamos TOOLBOXES. 1.3.4 Funciones de aplicación específica (Tolboxes).

MATLAB proporciona 20 categorías de funciones. Algunas de las funciones de MATLAB están implementadas en el interprete, mientras que otras están escritas en forma de fichero M. Los ficheros M están organizados en 20 directorios, cada uno conteniendo los ficheros asociados con esa categoría. El comando help muestra la siguiente tabla de categorías:

o color : Funciones de control de color y modelo de iluminación.

o datafun : Análisis de datos y transformada de Fourier.

o demos : Demostraciones y ejemplos. o elfun : Funciones matemáticas

elementales. o elmat : Matrices elementales y

manipulación de matrices. o funfun : Funciones de funciones

(métodos numéricos no lineales). o general : Comandos de propósito

general. o graphics: Funciones graficas de

propósito general. o iofun : Funciones de E/S de ficheros

de bajo nivel. o lang : Construcciones de lenguaje y

depuración. o matfun : Funciones matriciales

(álgebra lineal numérica). o ops : Operadores y caracteres

especiales. o plotxy : Gráficos bidimensionales. o plotyxyz: Gráficos tridimensionales. o polyfun : Funciones polinomiales y de

interpolación. o sparfun : Funciones de matrices

dispersas (sparse). o specfun : Funciones matemáticas

especializadas. o specmat : Matrices especializadas. o sounds : Funciones de

procesamiento de sonidos. o strfun : Funciones de cadenas de

caracteres. 1.4 Identificadores.



Es un espacio de la memoria principal (RAM) de la computadora a la cual se le debe asignar un nombre para que esta pueda almacenar datos en ella y sepa a donde dirigirse cuando estos le sean requeridos.

Tabla.1 Identificadores en la memoria RAM. lado1

float 2.5

lado2 float 3.0

area float 7.5

Existen dos tipos de identificadores:

o Dados por el compilador, conocidos como palabras reservadas. Ejemplos: for y while.

o Creados por el usuario. Ejemplos: lado1, lado2, area.

En conclusión, los Identificadores son nombres que da el usuario o el compilador a cualquier parte de un programa, tales como los nombres de las variables, nombres de funciones y de los archivos.

1.4.1 Identificadores constantes. Es común que se confunda lo que es una constante con un identificador constante, por que a los identificadores constantes se les llama simplemente constantes. Es importante entender claramente las diferencias. Las constantes son todos los tipos de datos que pueden ser procesados por el compilador y que se explicarán ampliamente en el tema 1.5.

Tipos de constantes Ejemplos de Constantes (datos)

Números con decimales (float):

1.3, 3.5, 8.9 . . . . . .

Números enteros (int): 2, 3, 10, 2090 . . . . . Texto (string), entre comillas: “Hola”, “Tecnológico” . . . .

. . Letras (char), entre apóstrofos:

‘a’, ‘z’ , ‘A’,’M’ . . . . . .

Los identificadores constantes son asignaciones de constantes a identificadores. Esta asignación se hace una sola vez y su contenido no puede ser alterado posteriormente. Se pueden declarar de dos formas:

(a)

(b)

#include <stdio.h> const float PI=3.14159; main() { float radio=5.0,area; area=PI*radio*radio; printf("%f",area); }

#include <stdio.h> #define PI 3.14159 main() { float radio=5.0,area; area=PI*radio*radio; printf("%f",area); }

Se recomienda que los identificadores constantes sean declarados en mayúsculas, en estos ejemplos solamente PI ha sido declarado como identificador constante (o simplemente constante).

1.4.2. Identificadores Variables. Los identificadores variables o simplemente variables son asignaciones de constantes o resultado de fórmulas a identificadores. El valor asignado puede ser alterado posteriormente, perdiendo el dato anterior. Se deben declarar después de una llave de apertura. Se recomienda que los identificadores variables sean declarados en minúsculas, vea el programa anterior donde radio y area son declarados como variables.

1.4.3. Identificadores reservados. Caracteres especiales

Son los que se definen a continuación: a) [] : Los corchetes se utilizan para

componer vectores y matrices. [ 4 7 9] es un vector fila de tres elementos separados por blancos. [4; 7;9] es un vector de tres columnas. El punto y coma termina cada fila. Se permite el uso de vectores y matrices como elementos de un vector o matriz. Por ejemplo: [A B ; C] siempre que el numero de filas de A y B sean



iguales y C tenga el mismo numero de columnas que numero de columnas de A mas numero de columnas de B. A=[] crea una matriz vacía. También se pueden utilizar en el lado izquierdo de una asignación.

b) () : Los paréntesis se utilizan para indicar precedencia en expresiones aritméticas. También se utilizan para encerrar los índices de vectores y matrices. Si el índice es menor que 1 o mayor que la dimensión, ocurre un error.

c) = : Utilizado en sentencias de asignación.

d) ': Traspuesta de la matriz. X' es la traspuesta conjugada. X.' es la traspuesta no conjugada.

e) .: Punto decimal. Indicador de operaciones elemento a elemento.

f) ...: Tres puntos o mas al final de una línea indican que esta continuara en la línea de debajo.

g) ,: Se utiliza para separar índices de la matriz y argumentos de las funciones. También se utiliza para separar sentencias en líneas multisentencia. Si se reemplaza la coma por el punto y coma, se evita que se impriman.

h) ;: Dentro de corchetes finaliza una línea. Después de una expresión o sentencia suprime la impresión de la misma, o la separa de otra.

i) %: Denota un comentario. Indica el fin lógico de una línea. Cualquier otro texto posterior se ignora.

j) !: Indica que el resto de la línea de entrada es un comando del sistema operativo.

k) : :Se utiliza para crear vectores, como índice de matrices y para iteraciones.

1.4.3. Reglas para crear identificadores.

Los identificadores creados por el usuario

deben respetar las siguientes reglas: o Un identificador puede ser una

secuencia de letras y números. o Debe comenzar con una letra. o El carácter para subrayar “_" es

permitido. o Caracteres en mayúsculas y en

minúsculas son considerados diferentes. suma es diferente de Suma, y estos a su vez, diferentes de SUMA.

o No debe haber espacios entre caracteres.

o No se permiten letras acentuadas o la ñ.

o Se sugieren 15 caracteres máximo (máximo 8 en nombres de archivos).

o No utilizar palabras reservadas.

A continuación se muestran algunos identificadores correctos e incorrectos:

Correctos Incorrectos

contador 1_nombre

pago_total variable-3

nombre_alumno pago$total

Bandera_tipo ultimo nombre

_variable23 996

C45_nomina 1999_fin 1.5 TIPOS DE REPRESENTACIÓN DE

DATOS. Respecto a los formatos numéricos con que MATLAB muestra los resultados (recuérdese que siempre calcula con la máxima precisión), se pueden activar las mismas posibilidades por medio de comandos tecleados en la línea de comandos de MATLAB. Los más importantes de estos comandos son los siguientes:

o format short coma fija con 4 decimales (defecto) o format long coma fija con 15 decimales o format hex cifras hexadecimales o format bank números con dos cifras decimales o format short e notación científica con 4 decimales o format short g notación científica o decimal,

dependiendo del valor o format long e notación científica con 15 decimales o format long e notación científica o decimal, dependiendo

del valor o format loose introduce algunas líneas en blanco en la

salida (defecto) o format compact elimina las líneas en blanco citadas

(opción recomendada)



o format rat expresa los números racionales como cocientes de enteros

MATLAB aplica un factor de escala general a las matrices cuando los elementos más grandes o más pequeños son superiores o inferiores respectivamente a una determinada cantidad (103 y 10-3). Hay que añadir que MATLAB trata de mantener el formato de los números que han sido definidos como enteros (sin punto decimal). Si se elige la opción format rat el programa trata de expresar los números racionales como cocientes de enteros. El usuario puede controlar el número de decimales con que aparece en pantalla el valor de las variables, sin olvidar que ello no está relacionado con la precisión con la que se hacen los cálculos, sino con el aspecto con que éstos se muestran: >>1/3 ans = 0.3333 >>format long >>1/3 ans = 0.33333333333333 >>format % Vuelve al formato estándar que es el de 4 cifras decimales 1.6 OPERADORES ARITMÉTICOS. MATLAB tiene dos tipos diferentes de operadores aritméticos:

o Operadores matriciales: Gobernados por las reglas de álgebra lineal

o Operadores vectoriales: Se llevan a cabo elemento a elemento.

El punto precediendo al signo del operador distingue a las operaciones vectoriales de las operaciones matriciales. Puesto que las operaciones de suma y resta vectorial y matricial coinciden no se utiliza los pares ".+"ni ".-". Los operadores matriciales de MATLAB son los siguientes:

+ adición o suma – sustracción o resta * multiplicación ' traspuesta ^ potenciación \ división-izquierda / división-derecha .* producto elemento a elemento ./ y .\ división elemento a elemento .^ elevar a una potencia elemento a elemento

Operaciones elementales Adición-sustracción: Suma o resta dos vectores o matrices A y B. Ambas deben tener la misma dimensión, salvo que uno sea un escalar. Se puede añadir o sustraer un escalar a una matriz de cualquier dimensión. Operaciones matriciales Multiplicación matricial: A*B es el producto algebraico de las matrices A y B. El numero de _las de A debe ser igual al numero de columnas de B, a menos que uno de ellos sea un escalar. Se puede multiplicar un escalar por una matriz de cualquier dimensión. Multiplicación vectorial: A.*B es el producto elemento a elemento de los vectores A y B. Ambos deben tener la misma dimensión, a menos que uno de ellos sea un escalar. División matricial izquierda 1. Si A es una matriz cuadrada A\B=inv(A)*B, solo que se calcula de diferente forma. 2. Si A es una matriz n x n y B es un vector columna con n componentes o una matriz con varias columnas de n componentes, A\B es la solución de AX=B, calculado por eliminación gausiana. 3. Si A es una matriz m x n y B es un vector columna con m componentes, o una matriz con varias columnas de m componentes, A\B es la solución por mínimos cuadrados del sistema de ecuaciones AX=B. EL rango efectivo de A, k, se determina por la descomposición QR con pivote. Se calcula una solución X que tenga como mucho k componentes distintas de cero por columna. Si k<n, esta no es normalmente la misma solución que pinv(A)*B, que es la solución por mínimos cuadrados con la norma del residuo mínima, |AX-B\|.



División vectorial izquierda: A.\B es la matriz cuyos elementos son B(i,j)/A(i,j). A y B deben tener la misma dimensión, a menos que uno sea un escalar. División matricial derecha: B/A es lo mismo que B*inv(A). Mas precisamente B/A=(A'\B')'. División vectorial derecha: A./B es la matriz cuyos elementos son A(i,j)/B(i,j). Traspuesta matricial: Es la traspuesta algebraica de A. Para matrices complejas, esto implica la traspuesta conjugada compleja. Traspuesta vectorial: Es la traspuesta vectorial de A. Para matrices complejas esto no implica conjugación. Potenciación Potencia matricial X^p es la matriz X a la potencia de p si p es un escalar. 1. Si p es un entero, el calculo se lleva a cabo por multiplicaciones repetidas. 2. Si el entero es negativo, primero se invierte X. 3. Para otros valores de p, es necesario calcular los autovalores y autovectores, de tal forma que si [V,D]=eig(X), entonces X^p=V*D.^p/V. 4. Si x es un escalar y P una matriz, x^P es x elevado a la matriz P utilizando autovalores y autovectores. 5. X^P donde ambos son matrices es un error. Potencia vectorial A.^B es la matriz cuyos elementos son A(i,j)^B(i,j). A y B deben tener las mismas dimensiones, a menos que uno sea un escalar. 1.6.1 Expresiones aritméticas. Una variable es un nombre que se da a una entidad numérica, que puede ser una matriz, un vector o un escalar. El valor de esa variable, e incluso el tipo de entidad numérica que representa, puede cambiar a lo largo de una sesión de MATLAB o a lo largo de la ejecución de un programa. La forma más normal de cambiar el valor de una variable es colocándola a la izquierda del operador de asignación (=).

Una expresión de MATLAB puede tener las dos formas siguientes: primero, asignando su resultado a una variable, variable = expresión y segundo evaluando simplemente el resultado del siguiente modo, expresión 1.6.2. Nivel de prioridad en operadores. Las operaciones se evalúan por orden de prioridad: primero las potencias, después las multiplicaciones y divisiones y, finalmente, las sumas y restas. Las operaciones de igual prioridad se evalúan de izquierda a derecha: >>2/4*3 ans = 1.5000 >>2/(4*3) ans = 0.1667 1.7 FUNCIONES MATEMÁTICAS ELEMENTALES.

Estas funciones, que comprenden las funciones matemáticas trascendentales y otras funciones básicas, actúan sobre cada elemento de la matriz como si se tratase de un escalar. Se aplican de la misma forma a escalares, vectores y matrices. Algunas de las funciones de este grupo son las siguientes:

sin(x): seno cos(x): coseno tan(x): tangente asin(x): arco seno acos(x): arco coseno atan(x): arco tangente (devuelve un ángulo entre -p/2 y +p/2) atan2(x): arco tangente (devuelve un ángulo entre -p y +p); se le pasan 2 argumentos, proporcionales al seno y al coseno sinh(x): seno hiperbólico cosh(x): coseno hiperbólico tanh(x): tangente hiperbólica asinh(x): arco seno hiperbólico acosh(x): arco coseno hiperbólico atanh(x): arco tangente hiperbólica log(x): logaritmo natural log10(x): logaritmo decimal exp(x): función exponencial sqrt(x): raíz cuadrada



sign(x): devuelve -1 si <0, 0 si =0 y 1 si >0. Aplicada a un número complejo, devuelve un vector unitario en la misma dirección rem(x,y): resto de la división (2 argumentos que no tienen que ser enteros) mod(x,y): similar a rem (Ver diferencias con el Help) round(x): redondeo hacia el entero más próximo fix(x): redondea hacia el entero más próximo a 0 floor(x): valor entero más próximo hacia -¥ ceil(x): valor entero más próximo hacia +¥ gcd(x): máximo común divisor lcm(x) mínimo común múltiplo real(x): partes reales imag(x): partes imaginarias abs(x): valores absolutos angle(x): ángulos de fase

Funciones que actúan sobre vectores Las siguientes funciones actúan sobre vectores (no sobre matrices ni sobre escalares)

• [xm,im]=max(x) máximo elemento de un vector. Devuelve el valor máximo xm y la posición que ocupa im

• min(x) mínimo elemento de un vector. Devuelve el valor mínimo y la posición que ocupa

• sum(x) suma de los elementos de un vector • cumsum(x) devuelve el vector suma

acumulativa de los elementos de un vector (cada elemento del resultado es una suma de elementos del original)

• mean(x) valor medio de los elementos de un vector

• std(x) desviación típica • prod(x) producto de los elementos de un

vector • cumprod(x) devuelve el vector producto

acumulativo de los elementos de un vector • [y,i]=sort(x) ordenación de menor a mayor

de los elementos de un vector x. Devuelve el vector ordenado y, y un vector i con las posiciones iniciales en x de los elementos en el vector ordenado y.

Por ejemplo, la función coseno, >>cos(pi) % pi es una variable con valor predeterminado 3.14159... ans = -1 o la función exponencial

>>exp(1) % Función exponencial evaluada en 1, es decir, el número e ans = 2.7183 Además de la variable pi , MATLAB tiene otras variables con valor predeterminado; éste se pierde si se les asigna otro valor distinto. Por ejemplo: >>eps % Épsilon de la máquina. Obsérvese que MATLAB trabaja en doble precisión ans = 2.2204e-016 pero... >>eps=7 eps = 7 Otro ejemplo de función matemática: la raíz cuadrada; como puede verse, trabajar con complejos no da ningún tipo de problema. La unidad imaginaria se representa en MATLAB como i o j, variables con dicho valor como predeterminado:

>>sqrt(-4)

ans = 0+ 2.0000i

1.8 AYUDA EN LÍNEA. La ayuda de MATLAB es bastante útil; para acceder a la misma basta teclear help. Es recomendable usarlo para obtener una información más precisa sobre la sintaxis y diversas posiblidades de uso de los comandos. Para conocer las variables que se han usado hasta el momento:

>>who

Your variables are: ans eps x y

o, si se quiere más información (obsérvese que todas las variables son arrays):



>>whos

Name Size Bytes Class ans 1x1 8 double array eps 1x1 8 double array x 1x1 8 double array y 1x1 8 double array

Grand total is 4 elements using 32 bytes

Para deshacerse de una variable

>>clear y

>>who

Your variables are:

ans eps x



UNIDAD II “Conceptos de

Diagramación lógica”

2.1 DIAGRAMAS DE FLUJO. Primeramente definamos algunos conceptos básicos. Programa. Serie de pasos que se van siguiendo

en un orden preestablecido para lograr un objetivo. Ejemplos: Programa de la fiesta de XV años, Programa de honores a la bandera, Recetas de cocina, etc.

Algoritmo. Es el término que se utiliza en

computación para representar a los programas que se pueden procesar por computadora.

Los algoritmos se pueden representar de varias maneras, las dos formas más comunes y que se trabajan en estos apuntes son: a) Pseudocódigos. Algoritmos descritos con palabras. Vea los ejemplos cuando definimos programa. b) Diagramas de flujo. Algoritmos representados por medio de figuras estandarizadas. De momento, solamente trabajaremos con programas secuenciales, por lo que las palabras clave para los Pseudocódigos y las gráficas que se utilizarán (en los diagramas de flujo), son los que a continuación se muestran. a) Pseudocódigos:

INICIO Se utiliza para el indicar el inicio del algoritmo.

FIN Se utiliza para el indicar el fin del algoritmo.

PREGUNTAR Se utiliza para pedir datos y guardarlos en la(s) variable(s) que se indica(n) después.

HACER

Se utiliza para indicar procesos, que se mencionan después de esta palabra, tales como asignaciones de valores a variables.

MOSTRAR

Se utiliza para indicar que el texto (si se escribe entre comillas) o el contenido de una variable (si se escribe sin comillas) deberá imprimirse en la pantalla. El texto o la variable se escribe después de esta palabra.

Pasos: 1,2,3,…..

Se utilizan para indicar el flujo de los procesos.

b) Diagramas de Flujo:

Se utiliza para indicar inicio y fin de un proceso.

Se utiliza para pedir datos y guardarlos en la(s) variable(s) que se indica(n) dentro de la figura.

Se utiliza para indicar procesos, que se colocan dentro del rectángulo, tales como asignaciones de valores a variables,

Se utiliza para indicar que el texto (si se escribe entre comillas) o el contenido de una variable (si se escribe sin comillas) deberá imprimirse en la pantalla. El texto o la variable se escribe dentro de la figura.

Las flechas se utilizan para indicar el flujo de los procesos

Considere las siguientes reglas básicas en la construcción de diagramas de flujo:

• Solamente debe utilizar las figuras indicadas y de un tamaño adecuado.

• No debe codificar instrucciones del lenguaje dentro de las figuras.

• Debe dibujar de arriba hacia abajo y de izquierda a derecha.

• No se olvide de las puntas de flecha. • Debe indicarse lo que se quiere hacer,

no como se va a hacer. • Utilice nombres apropiados dentro de las

figuras, que indiquen claramente lo que contienen.

Elabore los siguientes algoritmos (Pseudo código y Diagrama de flujo). Coméntelo con su asesor.



- Fiesta de Quince años. - Honores a la bandera. - Proceso para trasladarse de la casa

a la escuela. - Actividades a realizar en el día.

Prog2-1.- Determinar el área de un cuadrado. Es importante conocer la fórmula que permitirá determinar el área de un cuadrado: Área = Lado2, o bien, Area = Lado * Lado. Para que la computadora o cualquier persona pueda darnos el área, requiere que le proporcionemos el valor de cualquiera de los lados (valen lo mismo). Una vez que ya conocemos el valor del lado, entonces, ya podemos determinar el área aplicando la fórmula anterior.

Pseudo código Diagrama de flujo

1.- INICIO 2.- PREGUNTAR el valor del LADO 3.- HACER AREA=LADO*LADO 4.- MOSTRAR AREA 5.- FIN

Prog2-2.- Determinar el área de un rectángulo. Es importante conocer la fórmula que permitirá determinar el área del rectángulo: Área = Lado1 * Lado2. Para que la computadora o cualquier persona pueda darnos el área, requiere que le proporcionemos los valores de ambos lados. Una vez que ya los conocemos, entonces, podremos determinar el área aplicando la fórmula anterior.

Pseudocódigo Diagrama de flujo

1.- INICIO 2.- PREGUNTAR el valor del LADO1 3.- PREGUNTAR el valor del LADO2 4.- HACER AREA=LADO1*LADO2 5.- MOSTRAR AREA 6.- FIN

Observación: En el Algoritmo, en una línea o figura se pueden pedir dos o más datos al mismo tiempo. Prog2-3.- Determinar el área de un círculo. Es importante conocer la fórmula que permitirá determinar el área del círculo: Área = PI * Radio2, también, Area = PI * Radio * Radio, también, Area = 3.14159 * Radio * Radio. Para que la computadora o cualquier persona pueda darnos el área, requiere que le proporcionemos el valor del Radio, PI no es necesario pedirlo por que es un valor constante y nunca cambia (PI=3.14159). Una vez que ya tenemos el valor del radio, entonces, podremos determinar el área aplicando la fórmula anterior.

Pseudocódigo Diagrama de

flujo 1.- INICIO 2.- PREGUNTAR el valor del RADIO 3.- HACER AREA= PI*RADIO*RADIO 4.- MOSTRAR AREA 5.- FIN



Prog2-4.- Elabore un Algoritmo que convierta Kilómetros a Milímetros. Es importante conocer la fórmula que permitirá realizar la conversión. mm= Kms*1,000,000. Para que la computadora o cualquier persona pueda realizar la converesión, requiere que le proporcionemos el valor de los Kilometros a convertir. Con este valor, podremos determinar la cantidad de milímetros aplicando la fórmula anterior (1 km = 1000 metros y 1 metro=1000 mm, por lo tanto 1 kilometro contiene 1,000,000 mm).

Pseudocódigo Diagrama de flujo

1.- INICIO 2.- PREGUNTAR Kms 3.- HACER mm= Kms*1,000,000 4.- MOSTRAR mm 5.- FIN

Prog2-5.- Elabore un Algoritmo que convierta Millas a Kilómetros. 1 Milla = 1.609 Kilómetros. En este caso se conocen las Millas y se desea convertir a kilómetros, por lo tanto, despejamos de la fórmula y nos queda: Kms = Millas*1.609.

Pseudocódigo Diagrama de flujo 1.- INICIO 2.- PREGUNTAR Millas 3.- HACER Kms= Millas*1.609 4.- MOSTRAR Kms 5.- FIN

Antes de terminar este tema es importante comentar lo siguiente:

a) Los Diagramas de flujo y los Pseudo códigos tiene el mismo objetivo, solamente se presentan de forma diferente. Observe que para cada línea de pseudocódigo corresponde una figura del diagrama de flujo y que además sirven para lo mismo.

b) Los Diagramas de flujo son más fáciles

de interpretar, pero consumen demasiado espacio, a medida que el programa crece.

c) Es importante practicar ambos métodos.

d) Más adelante, cuando se programe en la

computadora, deberán primero realizar los algoritmos con esta metodología.

e) Recuerde que para construir algoritmos (cuando

se es principiante) es necesario respetar siempre los siguientes pasos para asegurar su aprendizaje.

I. Entender el problema que se desea

analizar. Es como si le pidieran su opinión sobre el cancer y no sabe de ello, por lo tanto, no podrá externar opinión alguna. Si ya sabe de lo que le hablan continúe, en caso contrario busque suficiente información del tema.

II. Identifique qué datos necesita conocer y

qué fórmula(s) requiere. Escríbalas.

III. Construya su algoritmo y pida que alguien lo revise.

2.2 ESTRUCTURA BÁSICA DE UN PROGRAMA EN MatLab. El proceso de trasladar un algoritmo a un lenguaje de programación se conoce con el nombre de CODIFICACIÓN. Cada lenguaje impone ciertas restricciones sobre las condiciones en que se puede



codificar. Sin embargo el proceso de creación del algoritmo es el mismo para cualquier lenguaje. Es momento de codificar nuestro primer programa. Prog 2-1.

Diagrama de flujo Codificación

% Area de un cuadrado % Autor: rcgg

Lado = input(‘Dame el valor del lado’); area = Lado*Lado;

fprintf(‘El área es:%8.3f ‘ , area);

Parece complicado, pero observe que a cada figura del diagrama de flujo le corresponde una instrucción del compilador , como se indica. Antes de hacerse más preguntas, se describe a continuación por que se requieren y para que sirven cada una de las instrucciones vistas en este programa. puntos y coma “;”, comentarios “%”, signo igual

”=”, fprintf, input. Para describir cada una de estas instrucciones, utilizaremos el ejemplo Prog 1 como referencia. ; Puntos y coma.

• Indican que la instrucción terminó. • Evitan que se genere el eco de asignación. • Se pueden escribir dos o más instrucciones en

una sola línea (máximo 255 caracteres escritos por línea). Por ejemplo: area=lado*lado; perimetro=4*lado; . . . . .

% Comentarios. • Se utilizan para agregar comentarios dentro del

mismo programa y hacer más entendibles los procesos. Estos comentarios no son impresos en pantalla.

• Es conveniente documentar el programa, ya que si otra persona intenta entenderlo tendrá que

revisar el programa completo antes de comenzar a decifrarlo y muchas veces es mejor hacerlo de nuevo. Inclusive, el mismo autor después de cierto tiempo puede olvidarse.

= Signo igual. Símbolo de asignación. • Se utiliza para asignar valores a variables. Por

ejemplo, area=lado*lado; Esta instrucción indica que el producto de lado*lado sea asignado a la variable area.

Otros ejemplos: pi=3.14159; area=lado*lado; perimetro=4*lado; fprintf Instrucción que permite imprimir comentarios o contenidos de variables en la pantalla (monitor). input Instrucción que permite solicitar datos al usuario a través del teclado. 2.3 EJECUCIÓN DE PROGRAMAS BÁSICOS. MatLab, incluye un programa donde se puede escribir el algoritmo ya codificado. (Se supone, por el momento, que el alumno ya cuenta con el paquete y puede ejecutarlo). Cuando entramos al editor ( File à New à M-File ), el editor nos presenta la siguiente pantalla:

La primera vez que aparece esta pantalla, el cursor se encuentra en la parte superior izquierda, donde podrá comenzar a teclear su programa.

% Area de un cuadrado % Autor: rcgg Lado = input(‘Dame el valor del lado: ’); area = Lado*Lado; fprintf(‘El área del cuadrado es: %8.3f ‘ , area); _

Recuerde:



• Teclee su programa normalmente, si se equivoca puede regresar utilizando las flechas.

• Si el cursor ya no baja entonces utilice la tecla <ENTER>.

• La tecla <Retroceso> o <BackSpace> borra el carácter a la izquierda del cursor.

• Si algún carácter no aparece en su teclado utilice Alt + Código

Antes de ejecutar por primera vez su programa, debe indicar al Mat-Lab, en donde quedarán sus programas, para esto deberá crear una carpeta (desde el explorador de windows). Supondremos que ha creado un directorio llamado: c:\misprogs Deberá indicarle a MatLab que busque sus programas en ese directorio agregando, por única ocasión, la siguiente instrucción (desde el indicador MatLab): >> p = path; >> path( p , ’c:\misprogs’); A partir de este momento, cualquier programa que elabore y guarde en dicho directorio, no tendrá problemas en su ejecución, ya que MatLab lo buscará automáticamente en c:\misprogs. Guarde su programa, por ejemplo, con el nombre de Areacuad (MatLab le pone automáticamente la extensión .m), haciendo click en el ícono del diskette o bien el el menú File à Save.

Para ejecutar su programa ubíquese en el indicar de MatLab y teclee el nombre que le dio.

>> Areacuad <ENTER> MatLab comenzará la ejecución de su programa línea por línea hasta terminar; conteste cuando le pida el valor del lado y observe que le mostrará el resultado.

Si su programa presenta errores, revise, corrija y vuelva a realizar el mismo proceso. No hay límites para repetir este proceso. Mejoremos ahora la presentación de este programa corrigiendo el fprintf:

fprintf(‘El área del cuadrado es: %8.3f\n ‘ , area);

El \n en el fprintf provoca que el cursor baje inmediatamente al siguiente renglón. El %8.3f en el fprintf provoca que el valor del área se imprima con ocho enteros y tres decimales.

De aquí en adelante solamente presentaremos la esencia misma del programa que permita resolver el problema en cuestión sin entrar a mejorar su presentación por que consumiría demasiado espacio y puede resultar confuso su entendimiento.

Prog2-6.- Elabore un programa que calcule la velocidad conociendo la distancia y el tiempo de un móvil. d=v*t.

Prog2-7.- Elabore un programa que convierta

centímetros a milímetros. cm = centímetros mm = milímetros



Prog2-8.- Elabore un programa que calcule el área de un triángulo rectángulo. b = base h = altura

Prog2-9.- Elabore un programa que convierta grados a radianes. gra = grados rad = radianes Prog2-10.- Elabore un programa que en base al apotema y el lado, determine el área de un pentágono. l = lado a = apotema Prog2-11.- Elabore un programa que convierta dólares en pesos mexicanos. dl = dólares val = valor del dólar ps = pesos mexicanos

Prog2-12.- Determine la superficie lateral de un cilindro. S = 2 π r h. r = radio h = altura s = superficie Prog2-13.- Elabore un programa que convierta metros a kilómetros, millas, centímetros, pulgadas y milímetros. m = metros km = kilómetros mi = millas cm = centímetros in = pulgadas mm = milímetros



Prog2-14.- Conociendo la potencia y resistencia, determine el valor de la corriente(I). Pot = I² R. pot = potencia, res = resistencia (R), cor = corriente (I)



Unidad III. Control de Flujo

3.1 Operadores relacionales y lógicos.

Operación Operador Igual a ==

Diferente de ~= Menor que < Mayor que >

Menor o igual que <= Mayor o igual que >=

Tabla 3.1.1. Operadores relacionales. Los operadores relacionales son usados para comparar dos datos y determinar condiciones de verdad (TRUE), en cuyo caso el resultado es 1 (uno), o falsedad (FALSE) devolviendo 0 (cero).

Operación Resultado Operación Resultado 3>2 1 ‘a’<’b’ 1

2==2 1 300<’z’ 0 3<2 0 65==’A’ 1

1<=2 1 2>5 0 2~=2 0 1<0 0 5>=4 1 0>-1 1

Tabla 3.1.2. Ejemplos de operaciones relacionales (comparación).

Operación Operador And & Or | Not ~

Tabla 3.1.3. Operadores lógicos. Los operadores lógicos permiten evaluar dos o más operaciones relacionales al mismo tiempo y determinar condiciones de verdad (TRUE), en cuyo caso el resultado es 1 (uno), o falsedad (FALSE) devolviendo 0 (cero), como en las operaciones relacionales. El comportamiento de estos operadores está basado en tablas de verdad que se muestran a continuación.

A B A & B A | B ~! A ~! ( A & B ) 0 0 0 0 1 1 0 1 0 1 1 1

1 0 0 1 0 1 1 1 1 1 0 0

Tabla 3.1.4. Tablas de verdad de los operadores lógicos. Los operadores & y | unen dos (o más) operaciones de comparación, el ~ solamente trabaja con una operación de comparación negando el resultado de esta que puede ser una expresión larga si se encierra entre paréntesis como se muestra en los ejemplos: Operación Resultado Operación Resultado (3>2) & (2==2) 1 (‘a’<’b’) &

(300<’z)’ 0

~ ( (3>2)&(2==2) )

0 ~ ( 300< ’z’ ) 1

(3<2) | (1<=1) 1 (65==’A’) | (2>5)

1

( ~ (1<=2 ) ) & (2>=4)

0 ~ ( 2>5 ) 1

~ ( 2~=2 ) 1 (1<0) | (0>-1) 1 ~( ( ~ (1<=2 ) )

& (2>=4) ) 1 ~( (65==’A’) |

(2>5) ) 0

Tabla 2.1.5. Ejemplos de operaciones relacionales (comparación).

>> resul= 2 * ( (65==’A’) | (2>5) ) resul= 2

>> resul= ~ ( (~(1<=2 ) ) & (2>=4) ) resul= 1

Desde un inicio se comento que los programas en MatLab se generada bajo la idea de una programacion estructurada, es por eso que la codificación se simplifica. Una razón principal para lo anterior, es su modularidad de un lenguaje de programación estructurada. La modularidad significa que los programas se pueden realizar por etapas y esto se logra en gran medida por las tres estructuras de control básicas: Secuencias, Selección e Iteración. 3.2 Estructura de selección simple (if). Una condición simple, evalúa una condición (expresión condicional o lógica) y ejecuta instrucción(es) si la condición se cumple o no. Existen dos formas: (a)

(b)

Figura 3.1 Casos del la estructura condicional simple if



Observaciones:

• La estructura tiene una sola entrada y una sola salida.

• El flujo es de arriba hacia abajo y no regresa.

Caso (a) Solamente existen instrucciones si el resultado es verdadero.

if condición instrucción1; instrucción2; .

. instrucción n; end

Ejemplos:

>> a=0; b=1; >> if a < b fprintf(‘\nVerdadero\n‘); end Verdadero >>

>> a=1; >> if a ==1 fprintf(‘\nVerdadero\n‘); end Verdadero >>

Prog3-1.- Elabore un programa que solicite tres números al usuario y los muestre ordenados de mayor a menor.

Caso (b) Existen instrucciones si el resultado es verdadero o si es falso.

if condición instrucción1; instrucción2;

. instrucción n; else instrucción1; instrucción2; . instrucción n; end

También es posible evaluar el valor almacenado en una variable para una condición de Verdadero o Falso, en este caso cualquier valor diferente de cero es considerado como verdadero y cero como falso, por ejemplo: >> a=3; >> if a fprintf(‘Verdadero’); else fprintf(‘Falso’); end >> Este programa imprime: Verdadero

>> a=0; >> if a fprintf(‘Verdadero’); else fprintf(‘Falso’); end >> Este programa imprime: Falso

>>a=3; >>if (a==2)&(a>0) fprintf(‘Verdadero’); else fprintf(‘Falso’); end >> Este programa imprime: Falso

>>a=1; >>if (a==2)|(a>0) fprintf(‘Verdadero’); else fprintf(‘Falso’); end >> Este programa imprime: Verdadero

Prog3-2.- Elabore un programa que solicite dos números al usuario e imprima el mayor de ellos.



Prog3-3.-Solicitar al usuario un número y devolver la raíz cuadrada del mismo.

observación: MatLab trabaja con números imaginarios. Prog3-4.- Determinar si un alumno aprueba o reprueba un curso, sabiendo que aprobará si su promedio de tres calificaciones es mayor o igual a 7; reprueba en caso contrario. Prog3-5.- En un almacén se hace un 20% de descuento a los clientes cuya compra supere los $ 1000. ¿Cuál será la cantidad de dinero que pagará una persona por su compra?

3.3 ESTRUCTURA DE SELECCIÓN MÚLTIPLE (switch). Cuando en un problema a resolver, se tiene que hacer una pregunta sobre el valor de una variable, y dado el valor de esta, solamente se va realizar una de entre varias acciones posibles, estamos tratando entonces un problema de opción múltiple.

Esta estructura sustituye a varios if, pero en algunos casos es mas claro utilizar esta forma, la variable a evaluar puede ser del tipo entero, flotante, carácter o cadena. La forma de codificarlo es el siguiente:

Switch variable case constante1 (variable1), proceso(s); case constante2 (variable2), proceso(s); case constante3 (variable3), proceso(s); case constante4 (variable4), proceso(s); . . . otherwise, proceso(s); end Cuando un caso coincide, la ejecución del programa comienza en ese punto y continúa hasta encontrar la palabra case que es cuando se sale del switch. o cuando el fin del switch (end) es alcanzado. Observe que:

• Después de la palabra case existe un espacio antes de poner la constante.

• Cada caso debe contener el valor de una constante entera, flotante, constante de carácter o expresión, también se aceptan variables que contengan dichos valores.

• Cuando ningún caso coincida, el caso de la etiqueta "otherwise" se ejecuta. El caso por



omisión (otherwise) es opcional y no tiene una constante asociada.

• Cada caso dentro del switch debe ser único y puede ser definido como una constante o como una variable.

Prog3-6.- Elabore un programa que diga a que mes corresponde un número entero entre 1 y 12 dado por el usuario.

Prog3-7.- Elabore un programa que convierta un número comprendido entre 1 y 10, en número romano.

Prog3-8.- Elabore un programa que convierta un número comprendido entre 1 y 10, en letras, es decir, si el usuario da el 1, debe aparecer “uno”, si da el 2 debe aparecer “dos” y así sucesivamente.

Prog3-9.- Elabore un programa que muestre un menú de tres opciones para calcular el área de un rectángulo, de un cuadrado y de un círculo.

3.3.1 ESTRUCTURAS ANIDADAS. El anidamiento de estructuras no es mas que la posibilidad de incluir dentro de un if otro if, un switch dentro de un if, un if dentro del caso de un switch, etc. En términos generales MatLab, permite el anidamiento de estructuras, siempre y cuando cumplan con los requisitos descritos para cada una, es decir una sola entrada y una sola salida. Por otro lado el anidamiento lo determina la forma en que damos solución a un problema específico. Prog3-10.- Elabore un programa que determine si un número dado por el usuario es Año bisiesto. Un año bisiesto es aquel que es divisible entre 4, siempre y si es divisible entre 100 que sea divisible entre 400. Por ejemplo, los años 4, 400, 96, 104, 200 son años bisiestos y los años 100, 7, 15, 1997, 300 no lo son. Prog3-11.- Calcular la utilidad que un trabajador recibe en el reparto anual de utilidades si éste se le asigna como un porcentaje de su salario mensual que depende de su antigüedad en la empresa de acuerdo con la siguiente tabla:

TIEMPO UTILIDAD Menos de 1 año 5% del salario 1 año o más y menos de 2 años 7% del salario 2 años o más y menos de 5 años 10% del salario 5 años o más y menos de 10 años 15% del salario 10 años o más 20% del salario



3.4 PROCESOS ITERATIVOS Definición. Los bucles permiten repetir las mismas o análogas operaciones sobre datos distintos. Mientras que en C/C++/Java el "cuerpo" de estas sentencias se determinaba mediante llaves {...}, en MATLAB se utiliza la palabra end con análoga finalidad. Existen también algunas otras diferencias de sintaxis. La Figura XX muestra dos posibles formas de bucle, con el control situado al principio o al final del mismo. Si el control está situado al comienzo del bucle es posible que las sentencias no se ejecuten ninguna vez, por no haberse cumplido la condición cuando se llega al bucle por primera vez. Sin embargo, si la condición está al final del bucle las sentencias se ejecutarán por lo menos una vez, aunque la condición no se cumpla. Muchos lenguajes de programación disponen de bucles con control al principio (for y while en C/C++/Java) y al final (do … while en C/C++/Java). En MATLAB no hay bucles con control al final del bucle, es decir, no existe la construcción análoga a do ... while.

Figura 3.2 Bucles de control al principio y final 3.4 Sentencia for

La sentencia for repite un conjunto de sentencias un número predeterminado de veces. La sentencia for de MATLAB es muy diferente y no tiene la generalidad de la sentencia for de C/C++/Java. La siguiente construcción ejecuta sentencias con valores de i de 1 a n, variando de uno en uno. for i=1:n sentencias end En el siguiente ejemplo se presenta el caso más general para la variable del bucle (valor_inicial: incremento: valor_final); el bucle se ejecuta por primera vez con i=n, y luego i se va reduciendo de 0.2 en 0.2 hasta que llega a ser menor que 1, en cuyo caso el bucle se termina: for i=n:-0.2:1 sentencias end En el siguiente ejemplo se presenta una estructura correspondiente a dos bucles anidados. La variable j es la que varía más rápidamente (por cada valor de i, j toma todos sus posibles valores): for i=1:m for j=1:n sentencias end end Una última forma de interés del bucle for es la siguiente (A es una matriz): for i=A sentencias end en la que la variable i es un vector que va tomando en cada iteración el valor de una de las columnas de A. Prob. 3-12 Realiza un programa que te pida los valores de las constantes para resolver un sistema de ecuaciones lineales de tres incógnitas y resolverlo. 3.5 Sentencia while La estructura del bucle while es muy similar a la de C/C++/Java. Su sintaxis es la siguiente: while condicion sentencias



end donde condicion puede ser una expresión vectorial o matricial. Las sentencias se siguen ejecutando mientras haya elementos distintos de cero en condicion, es decir, mientras haya algún o algunos elementos true. El bucle se termina cuando todos los elementos de condicion son false (es decir, cero). Prob. 3-13 Realiza un programa que te de los números de la secuencia de Fibonacci, hasta un valor limite dado por el usuario. 3.6 Sentencia break Al igual que en C/C++/Java, la sentencia break hace que se termine la ejecución del bucle más interno de los que comprenden a dicha sentencia. 3.7 Sentencia continue La sentencia continue hace que se pase inmediatamente a la siguiente iteración del bucle for o while, saltando todas las sentencias que hay entre el continue y el fin del bucle en la iteración actual. 3.8 Sentencia try...catch...end La construcción try...catch...end permite gestionar los errores que se pueden producir en tiempo de ejecución. Su forma es la siguiente: try sentencias1 catch sentencias2 end En el caso de que durante la ejecución del bloque sentencias1 se produzca un error, el control de la ejecución se transfiere al bloque sentencias2. Si la ejecución transcurriera normalmente, sentencias2 no se ejecutaría nunca. MATLAB dispone de una función lasterr que devuelve una cadena de caracteres con el mensaje correspondiente al último error que se ha producido. En la forma lasterr(’’) pone a cero este contador de errores, y hace que la función lasterr devuelva la matriz vacía [] hasta que se produzca un nuevo error.



UNIDAD IV. VECTORES Y

MATRICES (ARREGLOS).

4.1 INTRODUCCIÓN. Aquí es necesario una breve reseña sobre los vectores y las matrices. Explicar qué es cada uno de ellos. Suma y Resta de Matrices: Si A= (aIJ) y B= (bIJ) son matrices de m x n, entonces A ± B es una matriz de m x n. Ejemplo. Considere las siguientes matrices A y B.

SUMA:

RESTA:

NOTA: La suma de matrices esta definida son si las dos son del mismo tamaño, es decir, ambas matrices deben tener la misma cantidad de renglones y columnas. Multiplicación y División de Matrices: Con el siguiente ejemplo explico el proceso de multiplicación y división omitiéndome todo el rollo de teoría.

Multiplicación:

Donde: C11 = <a11 a12 a13> . <b11 b21 b31> = a11b11 + a12b21 + a13b31 C12 = <a11 a12 a13> . <b12 b22 b32> = a11b12 + a12b22 + a13b32

C13 = <a11 a12 a13> . <b13 b23 b33> = a11b13 + a12b23 + a13b33 Y así sucesivamente con c12, c22, c32, c13, c23, c33.

División Donde: C11 = <a11 a12 a13> . <b11 b21 b31> = a11/b11 + a12/b21 + a13/b31 C12 = <a11 a12 a13> . <b12 b22 b32> = a11/b12 + a12/b22 + a13/b32 C13 = <a11 a12 a13> . <b13 b23 b33> = a11/b13 + a12/b23



+ a13/b33 Y así sucesivamente con c12, c22, c32, c13, c23, c33. Potenciación: Si tenemos un vector A= [2 5 6] Elevándolo al cuadrado A2 obtenemos el siguiente vector= [4 25 36]

TABLA de funciones de las operaciones antes mencionadas para su utilización en MATLAB

Operación

Forma Algebraica

En MATLAB

Suma a+b A + B Resta a-b A – B

Multiplicación a x b A.*B División a/b A./B

Exponenciacion an A.^n

4.2 FORMAS DE CONSTRUCCIÓN.

Los datos de los vectores y matrices se almacenan en arreglos (de una, dos, o más dimensiones), siendo el arreglo un conjunto de n elementos del mismo tipo y que se identifican con el mismo nombre pero que se hace referencia a cada uno de ellos a través de un índice que indica su posición en la memoria. 4.2.1 Vectores. (Arreglos unidimensionales). Un arreglo unidimensional es un conjunto de n datos del mismo tipo (float, carácter, etc.) que tienen un mismo nombre. El formato para la declaración de un arreglo unidimensional (vector) en matlab tiene varias formas: a) Asignando valores a los elementos del

vector cuando se crea la variable en forma de renglón. Los datos se separan con espacios en blanco.

nombre_variable=[dato1 dato2 dato3 ........ daton]; Ejemplo:

>> a = [7 3 4]; à Se crea un vector llamado a de tres elementos. a1=7, a2=3, a3=4.

b) Asignando valores a los elementos del

vector cuando se crea la variable en forma de columna.

nombre_variable=[dato1 ; dato2 ; dato3 ; ........; daton];

Ejemplo: >> b = [ 5 ; 9 ; -1 ]; à Se crea un vector llamado

b de tres elementos. b1=5, b2=9, b3= -1.

Nota: Los dos ejemplos anteriores parecen idénticos, sin embargo, tienen propiedades matemáticas diferentes, como se verá posteriormente.

Las definición anteriores asignan el nombre de la variable a y b como arreglos de tres elementos cada uno y cada dato se puede accesar usando la siguiente sintaxis:

Los arreglos en matlab comienzan con el elemento [1].

La necesidad de utilizar un arreglo se hace evidente cuando es necesario utilizar muchas variables que son del mismo tipo. Imaginemos utilizar un programa que solicite 100 datos al usuario, de la forma anterior (variables comunes) es necesario crear 100 nombres de variables diferentes, utilizando arreglos es necesario crear solamente una variable con 100 elementos, no es necesario crear las 100 variables.

La otra necesidad es utilizar estos arreglos para las operaciones matriciales donde se utilizan vectores.

Nota: En matlab no es necesario declarar la cantidad de elementos que se requieren en un arreglo, conforme se necesiten matlab va creando el espacio para los nuevos datos automáticamente. 4.2.2 Matrices. (Arreglos bidimensionales). Definición: es un conjunto de números dispuestos

en una retícula rectangular de filas y columnas. El formato general para la declaración de un arreglo

bidimensional (matriz) es:

[ ]

=

=

3

2

1

321

bb

b

b

aaaa

r

r



mxn 4x3

nombre_variable [renglón1dato1

renglón1dato2 renglón1dato3 ........ renglón1daton;

renglón2dato1 renglón2dato2 renglón2dato3 ........ renglón2daton ;

renglónmdato1 renglónmdato2 renglónmdato3 ........ renglónmdaton ];

Veamos la declaración de una matriz: a=[4 3 5;3 4 8;9 10 –1;-4 0 2];

La definición anterior asigna el nombre de la variable a como un arreglo de doce datos, distribuidos en cuatro renglones y tres columnas.

[ a ]

a(1,1) a(1,2) a(1,3)

a(2,1) a(2,2) a(2,3)

a(3,1) a(3,2) a(3,3)

a(4,1) a(4,2) a(4,3)

Cada dato se puede acceder usando la siguiente sintaxis: a(renglónm, columnan) Las matrices (arreglos de dos dimensiones) nos sirven para las operaciones matemáticas donde las soluciones requieren tratamiento matricial. Recordemos que existe una aritmética de matrices que nos permiten resolver problemas con estas herramientas. Las operaciones más comunes sobre matrices son: intercambio de renglones, intercambio de columnas, inversa de una matriz, transpuesta, determinantes, suma de matrices, multiplicación de matrices, etc.

Definitivamente el uso de matrices requiere de ciclos for (o while) anidados. Prog4-1.- Elabore un programa en matlab que pida el número de renglones (m) y el número de columnas (n) de una matriz. Posteriormente solicite uno a uno los elementos del mismo.

4.2.3 MATRIZ VACÍA A[ ]. BORRADO DE FILAS O COLUMNAS Para MATLAB una matriz definida sin ningún elemento entre los corchetes es una matriz que existe, pero que está vacía, o lo que es lo mismo que tiene dimensión cero. Considérense los siguientes ejemplos de aplicación de las matrices vacías: >> A=magic(3) A = 8 1 6 3 5 7 4 9 2 >> B=[] B = [] >> exist(B) ans = [] >> isempty(B) ans = 1 >> A(:,3)=[] A = 8 1 3 5 4 9 Las funciones exist() e isempty() permiten chequear si una variable existe y si está vacía. En el último ejemplo se ha eliminado la 3ª columna de A asignándole la matriz vacía. 4.2.4 DEFINICIÓN DE VECTORES Y MATRICES A PARTIR DE UN FICHERO MATLAB acepta como entrada un fichero nombre.m (siempre con extensión .m) que contiene instrucciones y/o funciones. Dicho fichero se llama desde la línea de comandos tecleando simplemente su nombre, sin la extensión. A su vez, un fichero *.m puede llamar a otros ficheros *.m, e incluso puede llamarse a sí mismo (funciones recursivas). Las variables definidas dentro de un fichero de comandos *.m que se ejecuta desde la línea de comandos son variables del espacio de trabajo base, esto es, pueden ser accedidas desde fuera de dicho fichero; no sucede lo mismo si el fichero *.m corresponde a una función. Si un fichero de comandos se llama desde una función, las variables que se crean pertenecen al espacio de trabajo de dicha función.



Como ejemplo se puede crear un fichero llamado unidad.m que construya una matriz unidad de tamaño 3x3 llamada U33 en un directorio llamado g:\matlab. Este fichero deberá contener la línea siguiente: U33=eye(3) Desde MATLAB llámese al comando unidad y obsérvese el resultado. Entre otras razones, es muy importante utilizar ficheros de comandos para poder utilizar el Debugger y para evitar teclear muchas veces los mismos datos, sentencias o expresiones. 4.3 OPERACIONES ARITMÉTICAS CON VECTORES Y MATRICES. **Recordemos que un vector es una matriz con una sola línea o columna ProgE4-1.- Programa que suma la matriz A con la B y devuelve el valor en la matriz C 'este programa efectúa la suma de las matrices A y B'; 'NOTA: 1.-recuerda la suma de matrices esta definida si las dos son del mismo tamaño'; a=input ('escribe la matriz A: '); b=input ('escribe la matriz B: '); c=a+b Nota: para la resta solo cambia: c = a-b. Los dos vectores deben tener el mismo tamaño. ProgE4-2.- Programa que multiplica la matriz A con la B y devuelve el valor en la matriz C este programa efectua el producto de las matrices A y B'; 'NOTA: 1. en la multiplicacion las matrices pueden ser de m x n'; a=input ('escribe la matriz A: '); b=input ('escribe la matriz B: '); c=a.*b *****para la división solo cambia c=a./b ProgE4-3.- Programa simple que eleva al cuadrado a la matriz A

este programa eleva al cuadrado a la matriz A'; a=input ('escribe la matriz A: '); c=a.^2 Prog4-2.- Elabore un programa en MatLab que sume dos matrices (A y B) de m*n elementos y genere una matriz C. El número de renglones(m) y columnas(n) lo decide el usuario.

Prog4-3.- Elabore un programa que multiplique dos matrices [A]m*n y [B]n*o elementos y genere una matriz [C] resultante de m*o elementos. El número de renglones (m) y columnas (n,o) lo decide el usuario. Prog4-4.- Elabore un programa que eleve a la potencia “ x “ una matriz m x n y genere una matriz [C] resultante. El número de renglones (m) y columnas (n,o) lo decide el usuario. 4.4 Funciones para vectores y matrices. Operador de Transponer: La transpuesta de una matriz A se denota con A’ y representa una nueva matriz en la que las filas de A se an convertido en las columnas de A’ Ejemplo: a=[1,5,2;5,4,7] a' =

>>w=[4 5 6]; %El operador ' es el de trasposición (en realidad trasposición y conjugación): >>w' ans = 4 5 6 Función Zeros:



La función zeros genera una matriz que contiene solo ceros. Si el argumento de la funcion es un escalar, como en zeros(6), la funcion generara una matriz cuadrada usando el argumento como numero de filas y numero de columnas. Si la funcion tiene dos argumentos escalares, como en zeros(m,n), generara una matriz con m filas y n columnas Ejemplo: zeros(3)

0 0 0 0 0 0 0 0 0

Función ones La función ones genera una matriz que solo contine unos, es similar que la funcion zeros . Ejemplo ones(3,2)

1 1 1 1 1 1

Función eyes En MatLab, las matrices de identidad pueden generarse usando la funcion eye. (los argumentos de eye son similares a los de las funciones zeros y ones) Matriz de identidad ( I ): es una matriz con unos en la diagonal principal y ceros en las demas posiciones Ejemplo: eye(3)

1 0 0 0 1 0 0 0 1

Matriz Inversa: La inversa de una matriz cuadrada A es la matriz A-1 para la cual los productos de las matrices A A-1 y A-1A son iguales a la matriz identidad Ejemplo: utilizando una matriz de 2 x 2

A=

A A-1 =

I

A A-1 = -

Ó

AI =A-1

= A-1-

Si desea conocer el proceso matemático para encontrar el inverso de una matriz A-1 , puede apoyarse con cualquier libro de álgebra lineal. En Matlab es muy simple encontrar el inverso de una matriz y a continuación se explica. Una matriz no tiene inversa si es del tipo: mal acondicionada o singular Función rank(A) o rango Si el rango de una matriz es igual al numero de filas que tiene, la matriz no es singular por tanto si existe su inversa Función inv (A) calcula la inversa de una matriz A-1 Prog4-5.- Las siguientes instrucciones determinan el rango de una matriz A y luego calculan la inversa A-1, o bien indica que no existe la inversa de esa matriz. Determinantes: es un escalar calculado a partir de los elementos de una matriz cuadrada. Ejemplo: en una matriz de 3 x 3 el determinante es:

Función det Matlab calcula el determinante usando la función antes mencionada det(A) calcula el determinante de la matriz cuadrada A Prog.4-6- Calcule el determinante de una matriz m x n. El número de renglones (m) y columnas (n,o) lo decide el usuario. 4.5 Cadenas de caracteres. Una cadena de caracteres (string) es un arreglo



unidimensional con datos tipo char. Nos permite almacenar texto, como nombre de cosas, personas, etc. A continuación veamos la declaración de una cadena de caracteres: nom=’Roberto’;

La definición anterior asigna el nombre de la variable nom como un arreglo de siete caracteres. Cada caracter puede ser accesado usando la siguiente sintaxis:

nom

nom(1) nom(2) nom(3) nom(4) nom(5) nom(6) nom(7)

Los espacios en blanco también cuentan como un carácter si se incluyen en el texto.

Prog4-7.- Elabore un programa que solicite el nombre del usuario, después imprima su nombre pero cada caracter en un renglón, es decir, su nombre se debe leer en forma vertical. En este ejemplo la instrucción length(nom), devuelve la cantidad de caracteres tecleados por el usuario, es decir, la cantidad de elementos reservados para la variable nom. El fprintf lleva un %c para indicar que lo que se va a imprimir es un carácter. Si coloca %i le estará indicando a matlab que el formato en el que quiere ver el dato nom(t) es en formato entero, por lo tanto, lo que se vería serian los códigos ASCII de cada uno de los caracteres tecleados. Observe que un arreglo de caracteres no se pide igual que una variable común. En este caso la instrucción input lleva ‘s’, para indicar que se trata de una cadena (string) de caracteres lo que se le va a pedir al usuario.

Prog4-8.- Elabore un programa que solicite el nombre del usuario, después imprima su nombre pero invertido.

En este programa primero se imprime el último carácter tecleado, después el penúltimo y así sucesivamente hasta llegar a imprimir el primer carácter que es el elemento 0 del arreglo de caracteres. Prog4-9.- Elabore un programa que solicite el nombre de n personas, 100 máximo. Después imprima los nombres

Nota: Observe que para pedir varios nombres, declaramos un arreglo bidimensional. Sin embargo, no utilizamos el índice de las columnas en el input y en el fprintf. Prog4-10.- Elabore un programa que solicite los nombres y las calificaciones de matemáticas, física y química de un grupo de n alumnos. Después imprima en forma de tabla la lista de calificaciones y en cada renglón el promedio de cada alumno indicando si aprueba o reprueba (mayor o igual a 70 aprueba, en caso contrario reprueba. Al final imprima el número de aprobados, reprobados y promedio general obtenido por el grupo. Para definir un vector fila, basta introducir sus coordenadas entre corchetes:

>>v=[1 2 3] % Vector de 3 coordenadas

v= 1 2 3

Si queremos declarar un vector de coordenadas equiespaciadas entre dos dadas, por ejemplo, que la primera valga 0, la última 20 y la distancia entre coordenadas sea 2, basta poner:

>>vect1=0:2:20

vect1 = 0 2 4 6 8 10 12 14 16 18 20

Equivalentemente, si lo que conocemos del vector es que la primera coordenada vale 0, la última 20 y que tiene 11 en total, escribiremos:

>>vect2=linspace(0,20,11)



vect2 = 0 2 4 6 8 10 12 14 16 18 20

A las coordenadas de un vector se accede sin más que escribir el nombre del vector y, entre paréntesis, su índice: >>vect2(3) ans = 4 y se pueden extraer subvectores, por ejemplo: >>vect2(2:5) ans= 2 4 6 8 o, >>vect1(:) ans= 0 2 4 6 8 10 12 14 16 18 20 Las matrices se escriben como los vectores, pero separando las filas mediante un punto y coma; así una matriz 3x3: >>M=[1 2 3;4 5 6;7 8 9] M = 1 2 3 4 5 6 7 8 9 >>M' % Su traspuesta (su adjunta) ans = 1 4 7 2 5 8 3 6 9 >>mat=[v;w;0 0 1] % También es una matriz 3x3 mat = 1 2 3 4 5 6 0 0 1 A los elementos de una matriz se accede sin más que escribir el nombre de la matriz y, entre paréntesis, los respectivos índices: >>mat(1,3) % Elemento en la primera fila y tercera columna de la matriz mat ans = 3

También se puede acceder a un fila o columna completas, >>mat(:,2) % Segunda columna de mat ans = 2 5 0 >>mat(2,:) % Su segunda fila ans = 4 5 6

acceder a la matriz como si fuera una columna,

>>M(2:7) % Los elementos segundo a séptimo de la matriz como columna ans = 4 7 2 5 8 3

o acceder a cualquiera de sus submatrices

>>mat(2:3,[1 3]) % Submatriz formada por los elementos que están en "todas" las filas que hay entre la segunda y la tercera y en las columnas primera y tercera

ans =

4 6 0 1

Existen algunas matrices definidas previamente; por ejemplo, la matriz identidad,

>>eye(5) % eye se pronuncia en inglés como I

ans = 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1

la matriz nula,

>>zeros(3)

ans =



0 0 0 0 0 0 0 0 0

o la matriz cuyos elementos valen todos 1:

>>ones(4) ans = 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 Se puede conocer el tamaño de una matriz y la longitud de un vector: >>size(mat) % Dimensiones de la matriz mat (número de filas y de columnas) ans = 3 3 >>size(v) ans = 1 3 >>length(v) % Longitud del vector (número de coordenadas) ans = 3 Existen comandos que permiten crear de forma sencilla matrices. Por ejemplo: >>diag(v) % Matriz diagonal cuya diagonal es el vector v ans = 1 0 0 0 2 0 0 0 3 >>diag(diag(M)) % Matriz diagonal con la diagonal de M. La sentencia diag(M) da % el vector formado por la diagonal de la matriz M ans = 1 0 0 0 5 0 0 0 9 >>diag(ones(1,4),1)+diag(ones(1,4),-1) % Matriz tridiagonal 5x5 con 0 en la diagonal % principal y 1 en la sub y superdiagonal ans = 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 >>tril(M) % Matriz formada por la parte triangular inferior de M. ans = 1 0 0

4 5 0 7 8 9 >>triu(M) % Matriz formada por la parte triangular superior de M. ans = 1 2 3 0 5 6 0 0 9 Las funciones matemáticas elementales están definidas de forma que se pueden aplicar sobre arrays. El resultado es el array formado por la aplicación de la función a cada elemento del array. Así: >>log(v) ans = 0 0.6931 1.0986 >>p=(0:0.1:1)*pi % Vector definido como el producto de un vector por un escalar p = Columns 1 through 7 0 0.3142 0.6283 0.9425 1.2566 1.5708 1.8850 Columns 8 through 11 2.1991 2.5133 2.8274 3.1416 >>x=sin(p) x = Columns 1 through 7 0 0.3090 0.5878 0.8090 0.9511 1.0000 0.9511 Columns 8 through 11 0.8090 0.5878 0.3090 0.0000 Las operaciones habituales entre arrays (suma, resta y producto escalar de vectores; suma, resta, producto y potencia de matrices) se representan con los operadores habituales: >>v,w % Recordamos los valores de v y w v = 1 2 3 w = 4 5 6 >>z=v*w' % Producto escalar (producto de matrices 1x3 por 3x1) z = 32 >>Z=w'*v % Producto de matrices 3x1 por 1x3 = Matriz 3x3 Z = 4 8 12 5 10 15 6 12 18 >>v*w % Los vectores v y w no se pueden multiplicar

??? Error using ==> * Inner matrix dimensions must agree.



>>mat % Recordamos el valor de la matriz mat mat = 1 2 3 4 5 6 0 0 1 >>mat̂ 2 % Matriz mat elevada al cuadrado ans = 9 12 18 24 33 48 0 0 1 También pueden efectuarse multiplicaciones, divisiones y potencias de arrays, entendiéndolas como elemento a elemento (como, de hecho, se realizan la suma y la resta). El operador utilizado para ellas es el habitual precedido por un punto; es decir: >>v.*w % Vector formado por los productos de las respectivas coordenadas: % ans(i)=v(i)*w(i) ans = 4 10 18 >>w./v % Vector formado por el cociente de cada coordenada de w entre la % coordenada correspondiente de v: ans(i)=w(i)/v(i) ans = 4.0000 2.5000 2.0000 >>mat.^2 % Matriz cuyos elementos son los de mat elevados % al cuadrado: ans(i,j)=mat(i,j)^2 ans = 1 4 9 16 25 36 0 0 1 Finalmente, pueden calcularse determinantes: >>det(mat) ans = -3 4.6 Resumen de funciones para manejar vectores y matrices. Las siguientes funciones exigen que el/los argumento/s sean matrices. En este grupo aparecen algunas de las funciones más útiles y potentes de MATLAB. Se clasificarán en varios subgrupos: 4.6.1 funciones matriciales elementales:

• B = A' calcula la traspuesta (conjugada) de la matriz A

• B = A.' calcula la traspuesta (sin conjugar) de la matriz A

• v = poly(A) devuelve un vector v con los coeficientes del polinomio característico de la matriz cuadrada A

• t = trace(A) devuelve la traza t (suma de los elementos de la diagonal) de una matriz cuadrada A

• [m,n] = size(A) devuelve el número de filas m y de columnas n de una matriz rectangular A

• n = size(A) devuelve el tamaño de una matriz cuadrada A

• nf = size(A,1) devuelve el número de filas de A

• nc = size(A,2) devuelve el número de columnas de A

4.6.2 funciones matriciales especiales Las funciones exp(), sqrt() y log() se aplican elemento a elemento a las matrices y/o vectores que se les pasan como argumentos. Existen otras funciones similares que tienen también sentido cuando se aplican a una matriz como una única entidad. Estas funciones son las siguientes (se distinguen porque llevan una "m" adicional en el nombre):

• expm(A) si A=XDX', expm(A) = X*diag(exp(diag(D)))*X'

• sqrtm(A) devuelve una matriz que multiplicada por sí misma da la matriz A

• logm() es la función recíproca de expm(A) Aunque no pertenece a esta familia de funciones, se puede considerar que el operador potencia (^) está emparentado con ellas. Así, es posible decir que: A^n está definida si A es cuadrada y n un número real. Si n es entero, el resultado se calcula por multiplicaciones sucesivas. Si n es real, el resultado se calcula como: A^n=X*D.^n*X' siendo [X,D]=eig(A) 4.6.3 funciones de factorización y/o descomposición matricial A su vez este grupo de funciones se puede subdividir en 4 subgrupos: a) Funciones basadas en la factorización triangular (eliminación de Gauss): [L,U] = lu(A) descomposición de Crout (A = LU) de una matriz. La matriz L es una permutación de una matriz triangular inferior (dicha permutación es consecuencia del pivotamiento por columnas utilizado en la factorización)

• B = inv(A) calcula la inversa de A. Equivale a B=inv(U)*inv(L)



• d = det(A) devuelve el determinante d de la matriz cuadrada A. Equivale a d=det(L)*det(U)

• E = rref(A) reducción a forma de escalón (mediante la eliminación de Gauss con pivotamiento por columnas) de una matriz rectangular A

• [E,xc] = rref(A) reducción a forma de escalón con un vector xc que da información sobre una posible base del espacio de columnas de A

• U = chol(A) descomposición de Cholesky de matriz simétrica y positivo-definida. Sólo se utiliza la diagonal y la parte triangular superior de A. El resultado es una matriz triangular superior tal que A = U'*U

• c = rcond(A) devuelve una estimación del recíproco de la condición numérica de la matriz A basada en la norma sub-1. Si el resultado es próximo a 1 la matriz A está bien condicionada; si es próximo a 0 no lo está.

b) Funciones basadas en el cálculo de valores y vectores propios:

• [X,D] = eig(A) valores propios (diagonal de D) y vectores propios (columnas de X) de una matriz cuadrada A. Con frecuencia el resultado es complejo (si A no es simétrica)

• [X,D] = eig(A,B) valores propios (diagonal de D) y vectores propios (columnas de X) de dos matrices cuadradas A y B (Ax = lBx). Los vectores propios están normalizados de modo que X'*B*X=I. Cuando A es simétrica y B es simétrica y definida-positiva se puede utilizar [X,D] = eig(A,B,'chol').

c) Funciones basadas en la descomposición QR:

• [Q,R] = qr() descomposición QR de una matriz rectangular. Se utiliza para sistemas con más ecuaciones que incógnitas.

• B = null(A) devuelve una base ortonormal del subespacio nulo (kernel, o conjunto de vectores x tales que Ax = 0) de la matriz rectangular A

• Q = orth(A) las columnas de Q son una base ortonormal del espacio de columnas de A. El número de columnas de Q es el rango de A

d) Funciones basadas en la descomposición de valor singular

• [U,D,V] = svd(A) descomposición de valor singular de una matriz rectangular (A=U*D*V'). U y V son matrices ortonormales. D es diagonal y contiene los valores singulares

• B = pinv(A) calcula la pseudo-inversa de una matriz rectangular A

• r = rank(A) calcula el rango r de una matriz rectangular A

• nor = norm(A) calcula la norma sub-2 de una matriz (el mayor valor singular)

• nor = norm(A,2) lo mismo que la anterior • c = cond(A) condición numérica sub-2 de la

matriz A. Es el cociente entre el máximo y el mínimo valor singular. La condición numérica da una idea de los errores que se obtienen al resolver un sistema de ecuaciones lineales con dicha matriz: su logaritmo indica el número de cifras significativas que se pierden.

4.6.4 Cálculo del rango, normas y condición numérica Existen varias formas de realizar estos cálculos, con distintos niveles de esfuerzo de cálculo y de precisión en el resultado. El rango se calcula implícitamente (sin que el usuario lo pida) al ejecutar las funciones rref(A), orth(A), null(A) y pinv(A). Con rref(A) el rango se calcula como el número de filas diferentes de cero; con orth(A) y null(A) –basadas ambas en la descomposición QR– el rango es el número de columnas del resultado (o n menos el número de columnas del resultado). Con pinv(A) se utiliza la descomposición de valor singular, que es el método más fiable y más caro en tiempo de cpu. La función rank(A) está basada en pinv(A). Normas de matrices:

• norm(A) norma sub-2, es decir, máximo valor singular de A, max(svd(A)).

• normest(A) calcula una estimación o aproximación de la norma sub-2. Útil para matrices grandes en las que norm(A) necesita demasiado tiempo norm(A,2) lo mismo que norm(A)

• norm(A,1) norma sub-1 de A, máxima suma de valores absolutos por columnas, es decir: max(sum(abs((A))))

• norm(A,inf) norma sub-¥ de A, máxima suma de valores absolutos por filas, es decir: max(sum(abs((A'))))

Normas de vectores:

• norm(x,p) norma sub-p, es decir sum(abs(x)^p)^(1/p) .



• norm(x) norma euclídea; equivale al módulo o norm(x,2).

• norm(x,inf) norma sub-¥, es decir max(abs(x)).

• norm(x,1) norma sub-1, es decir sum(abs(x)).

Cuando alguno de los operadores relacionales vistos previamente (<, >, <=, >=, == y ~=) actúa entre dos matrices (vectores) del mismo tamaño, el resultado es otra matriz (vector) de ese mismo tamaño conteniendo unos y ceros, según los resultados de cada comparación entre elementos hayan sido true o false, respectivamente. Por ejemplo, supóngase que se define una matriz magic A de tamaño 3x3 y a continuación se forma una matriz binaria M basada en la condición de que los elementos de A sean mayores que 4 (MATLAB convierte este cuatro en una matriz de cuatros de modo automático). Obsérvese con atención el resultado: >> A=magic(3) A = 8 1 6 3 5 7 4 9 2 >> M=A>4 M = 1 0 1 0 1 1 0 1 0 De ordinario, las matrices "binarias" que se obtienen de la aplicación de los operadores relacionales no se almacenan en memoria ni se asignan a variables, sino que se procesan sobre la marcha. MATLAB dispone de varias funciones para ello. Recuérdese que cualquier valor distinto de cero equivale a true, mientras que un valor cero equivale a false. Algunas de estas funciones son:

• any(x) función vectorial; chequea si alguno de los elementos del vector x cumple una determinada condición (en este caso ser distinto de cero). Devuelve un uno ó un cero

• any(A) se aplica por separado a cada columna de la matriz A. El resultado es un vector de unos y ceros

• all(x) función vectorial; chequea si todos los elementos del vector x cumplen una condición. Devuelve un uno ó un cero

• all(A) se aplica por separado a cada columna de la matriz A. El resultado es un vector de unos y ceros

• find(x) busca índices correspondientes a elementos de vectores que cumplen una determinada condición. El resultado es un vector con los índices de los elementos que cumplen la condición

• find(A) cuando esta función se aplica a una matriz la considera como un vector con una columna detrás de otra, de la 1ª a la última.

ejemplos de utilización de estas funciones. >> A=magic(3) A = 8 1 6 3 5 7 4 9 2 >> m=find(A>4) m = 1 5 6 7 8 Ahora se van a sustituir los elementos que cumplen la condición anterior por valores de 10. Obsérvese cómo se hace y qué resultado se obtiene: >> A(m)=10*ones(size(m)) A = 10 1 10 3 10 10 4 10 2 donde ha sido necesario convertir el 10 en un vector del mismo tamaño que m. Para chequear si hay algún elemento de un determinado valor –por ejemplo 3– puede hacerse lo siguiente: >> any(A==3) ans = 1 0 0 >> any(ans) ans = 1 mientras que para comprobar que todos los elementos de A son mayores que cero: >> all(all(A)) ans = 1 En este caso no ha hecho falta utilizar el operador relacional porque cualquier elemento distinto de cero equivale a true. La función isequal(A, B) devuelve uno si las matrices son idénticas y cero si no lo son. Las siguientes funciones pueden actuar sobre vectores y matrices, y sirven para chequear ciertas condiciones:



• exist(var) comprueba si la variable var existe • isnan() chequea si hay valores NaN,

devolviendo una matriz de unos y ceros • isinf() chequea si hay valores Inf,

devolviendo una matriz de unos y ceros • isfinite() chequea si los valores son finitos • isempty() chequea si un vector o matriz está

vacío • ischar() chequea si una variable es una

cadena de caracteres (string) • isglobal() chequea si una variable es global • issparse() chequea si una matriz es dispersa

(sparse, es decir, con un gran número de elementos cero)

A continuación se presentan algunos ejemplos de uso de estas funciones en combinación con otras vistas previamente. Se define un vector x con un NaN, que se elimina en la forma: >> x=[1 2 3 4 0/0 6] Warning: Divide by zero x = 1 2 3 4 NaN 6 >> i=find(isnan(x)) i = 5 >> x=x(find(~isnan(x))) x = 1 2 3 4 6 Otras posibles formas de eliminarlo serían las siguientes: >> x=x(~isnan(x)) >> x(isnan(x))=[] La siguiente sentencia elimina las filas de una matriz que contienen algún NaN: >> A(any(isnan(A)'), :)=[]





UNIDAD V. FUNCIONES Y ARCHIVOS.

5.1 DEFINICIÓN DE FUNCIONES La primera línea de un fichero llamado name.m que define una función tiene la forma: function [lista de valores de retorno] = name(lista de argumentos) donde name es el nombre de la función. Entre corchetes y separados por comas van los valores de retorno (siempre que haya más de uno), y entre paréntesis también separados por comas los argumentos. Puede haber funciones sin valor de retorno y también sin argumentos. Recuérdese que los argumentos son los datos de la función y los valores de retorno sus resultados. Si no hay valores de retorno se omiten los corchetes y el signo igual (=); si sólo hay un valor de retorno no hace falta poner corchetes. Tampoco hace falta poner paréntesis si no hay argumentos. Una diferencia importante con C/C++/Java es que en MATLAB una función no modifica nunca los argumentos que recibe. Los resultados de una función de MATLAB se obtienen siempre a través de los valores de retorno, que pueden ser múltiples y matriciales. Tanto el número de argumentos como el de valores de retorno no tienen que

ser fijos, dependiendo de cómo el usuario llama a la función14. Las variables definidas dentro de una función son variables locales, en el sentido de que son inaccesibles desde otras partes del programa y en el de que no interfieren con variables del mismo nombre definidas en otras funciones o partes del programa. Se puede decir que pertenecen al propio espacio de trabajo de la función y no son vistas desde otros espacios de trabajo. Para que la función tenga acceso a variables que no han sido pasadas como argumentos es necesario declarar dichas variables como variables globales, tanto en el programa principal como en las distintas funciones que deben acceder a su valor. Es frecuente utilizar el convenio de usar para las variables globales nombres largos (más de 5 letras) y con mayúsculas. Por razones de eficiencia, los argumentos que recibe una función de MATLAB no se copian a variables locales si no son modificados por dicha función (en términos de C/C++ se diría que se pasan por referencia). Esto tiene importantes consecuencias en términos de eficiencia y ahorro de tiempo de cálculo. Sin embargo, si dentro de la función se realizan modificaciones sobre los argumentos recibidos, antes se sacan copias de dichos argumentos a variables locales y se modifican las copias (diríase que en este caso los argumentos se pasan por valor). Dentro de la función, los valores de retorno deben ser calculados en algún momento (no hay sentencia return, como en C/C++/Java). De todas formas, no hace falta calcular siempre todos los posibles valores de retorno de la función, sino sólo los que el usuario espera obtener en la sentencia de llamada a la función. En cualquier función existen dos variables definidas de modo automático, llamadas



nargin y nargout, que representan respectivamente el número de argumentos y el número de valores de retorno con los que la función ha sido llamada. Dentro de la función, estas variables pueden ser utilizadas como el programador desee. Es un concepto distinto del de funciones sobrecargadas (funciones distintas con el mismo nombre y distintos argumentos), utilizadas en C/C++/Java. En MATLAB una misma función puede ser llamada con más o menos argumentos y valores de retorno. También en C/C++ es posible tener un número variable de argumentos, aunque no de valores de retorno. La ejecución de una función termina cuando se llega a su última sentencia ejecutable. Si se quiere forzar el que una función termine de ejecutarse se puede utilizar la sentencia return, que devuelve inmediatamente el control al entorno de llamada. SENTENCIA RETURN De ordinario las funciones devuelven el control después de que se ejecute la última de sus sentencias. La sentencia return, incluida dentro del código de una función, hace que se devuelva inmediatamente el control al programa que realizó la llamada. 5.2 FUNCIONES CON NÚMERO VARIABLE DE ARGUMENTOS Desde la versión 5.0, MATLAB dispone de una nueva forma de pasar a una función un número variable de argumentos por medio de la variable varargin, que es un vector de celdas que contienen tantos elementos como sean necesarios para poder recoger en dichos elementos todos los argumentos que se hayan pasado en la llamada. No es necesario que varargin sea el único argumento, pero sí debe ser el último, pues recoge todos los argumentos a partir de una

determinada posición. Recuérdese que a los elementos de un cell array se accede utilizando llaves {}, en lugar de paréntesis (). De forma análoga, una función puede tener un número indeterminado de valores de retorno utilizando varargout, que es también un cell array que agrupa los últimos valores de retorno de la función. Puede haber otros valores de retorno, pero varargout debe ser el último. El cell array varargout se debe crear dentro de la función y hay que dar valor a sus elementos antes de salir de la función. Recuérdese también que las variables nargin y nargout indican el número de argumentos y de valores de retorno con que ha sido llamada la función. A continuación se presenta un ejemplo sencillo: obsérvese el código de la siguiente función atan3: function varargout=atan3(varargin) if nargin==1 rad = atan(varargin{1}); elseif nargin==2 rad = atan2(varargin{1},varargin{2}); else disp('Error: más de dos argumentos') return end varargout{1}=rad; if nargout>1 varargout{2}=rad*180/pi; end MATLAB (y muchos otros lenguajes de programación) dispone de dos funciones, llamadas atan y atan2, para calcular el arco cuya tangente tiene un determinado valor. El resultado de dichas funciones está expresado en radianes. La función atan recibe un único argumento, con lo cual el arco que devuelve está comprendido entre –p/2 y +p/2 (entre –90º y 90º), porque por ejemplo un arco de 45º es indistinguible de otro de –135, si sólo se conoce la tangente. La función atan2 recibe dos argumentos,



uno proporcional al seno del ángulo y otro al coseno. En este caso ya se pueden distinguir los ángulos en los cuatro cuadrantes, entre –p y p (entre –180º y 180º). La función atan3 definida anteriormente puede recibir uno o dos argumentos: si recibe uno llama a atan y si recibe dos llama a atan2 (si recibe más da un mensaje de error). Además, atan3 puede devolver uno o dos valores de retorno. Por ejemplo, si el usuario la llama en la forma: >> a = atan3(1); devuelve un valor de retorno que es el ángulo en radianes, pero si se llama en la forma: >> [a, b] = atan3(1,-1); devuelve dos valores de retorno, uno con el ángulo en radianes y otro en grados. Obsérvese cómo la función atan3 utiliza los vectores de celdas varargin y varargout, así como el número actual de argumentos nargin con los que ha sido llamada. HELP PARA LAS FUNCIONES DE USUARIO También las funciones creadas por el usuario pueden tener su help, análogo al que tienen las propias funciones de MATLAB. Esto se consigue de la siguiente forma: las primeras líneas de comentarios de cada fichero de función son muy importantes, pues permiten construir un help sobre esa función. En otras palabras, cuando se teclea en la ventana de comandos de MATLAB: >> help mi_func el programa responde escribiendo las primeras líneas del fichero mi_func.m que

comienzan por el carácter (%), es decir, que son comentarios. De estas líneas, tiene una importancia particular la primera línea de comentarios (llamada en ocasiones línea H1). En ella hay que intentar poner la información más relevante sobre esa función. La razón es que existe una función, llamada lookfor que busca una determinada palabra en cada primera línea de comentario de todas las funciones *.m. HELP DE DIRECTORIOS MATLAB permite que los usuarios creen una ayuda general para todas las funciones que están en un determinado directorio. Para ello se debe crear en dicho directorio un fichero llamado contents.m. A continuación se muestra un fichero típico contents.m correspondiente al directorio toolbox\local de MATLAB: % Preferences. % % Saved preferences files. % startup - User startup M-file. % finish - User finish M-file. % matlabrc - Master startup M-file. % pathdef - Search path defaults. % docopt - Web browser defaults. % printopt - Printer defaults. % % Preference commands. % cedit - Set command line editor keys. % terminal - Set graphics terminal type. % % Configuration information. % hostid - MATLAB server host identification number. % license - License number. % version - MATLAB version number. % Utilities. % userpath - User environment path. % Copyright (c) 1984-98 by The MathWorks, Inc.



% $Revision: 1.10 $ $Date: 1998/05/28 19:55:36 $ Compruébese que la información anterior es exactamente la que se imprime con el comando >> help local Si el fichero contents.m no existe, se listan las primeras líneas de comentarios (líneas H1) de todas las funciones que haya en ese directorio. Para que el Help de directorios funcione correctamente hace falta que ese directorio esté en el search path de MATLAB o que sea el directorio actual. 5.3 SUB-FUNCIONES Tradicionalmente MATLAB obligaba a crear un fichero *.m diferente por cada función. El nombre de la función debía coincidir con el nombre del fichero. A partir de la versión 5.0 se introdujeron las sub-funciones, que son funciones adicionales definidas en un mismo fichero *.m, con nombres diferentes del nombre del fichero (y del nombre de la función principal) y que las sub-funciones sólo pueden ser llamadas por las funciones contenidas en ese fichero, resultando “invisibles” para otras funciones externas. A continuación se muestra un ejemplo contenido en un fichero llamado mi_fun.m: function y=mi_fun(a,b) y=subfun1(a,b); function x=subfun1(y,z) x=subfun2(y,z); function x=subfun2(y,z) x=y+z+2; FUNCIONES PRIVADAS Las funciones privadas (private) son funciones que no se pueden llamar desde cualquier otra función, aunque se encuentren en el path o en el directorio actual. Sólo ciertas funciones están

autorizadas a utilizarlas. Las funciones privadas se definen en sub-directorios que se llaman private y sólo pueden ser llamadas por funciones definidas en el directorio padre del sub-directorio private. En la búsqueda de nombres que hace MATLAB cuando encuentra un nombre en una expresión, las funciones privadas se buscan inmediatamente después de las sub-funciones, y antes que las funciones de tipo general. FUNCIONES *.P Las funciones *.p son funciones *.m pre-compiladas con la función pcode. Por defecto el resultado del comando pcode func.m es un fichero func.p en el directorio actual (el fichero func.m puede estar en cualquier directorio del search path). El comando pcode -inplace func.m crea el fichero func.p en el mismo directorio donde encuentra el fichero func.m. Pueden pasarse varios ficheros *.m al comando pcode de una sola vez. Los ficheros *.p se ejecutan algo más rápidamente que los *.m y permiten ocultar el código de los ficheros ASCII correspondientes a las funciones *.m de MATLAB. VARIABLES PERSISTENTES Las variables persistentes son variables locales de las funciones (pertenecen al espacio de trabajo de la función y sólo son visibles en dicho espacio de trabajo), que conservan su valor entre distintas llamadas a la función. Por defecto, las variables locales de una función se crean y destruyen cada vez que se ejecuta la función. Las variables persistentes se pueden definir en funciones, pero no en ficheros de comandos. Es habitual utilizar para ellas letras mayúsculas. Las variables se declaran como persistentes utilizando la



palabra persistent seguida de los nombres separados por blancos, como por ejemplo: >> persistent VELOCIDAD TIEMPO Las variables persistent se inicializan a la matriz vacía [] y permanecen en memoria hasta que se hace clear de la función o cuando se modifica el fichero-M. Para evitar que un fichero-M se modifique se puede utilizar el comando mlock file.m, que impide la modificación del fichero. El comando munlock desbloquea el fichero mientras que la función mislocked permite saber si está bloqueado o no. VARIABLES GLOBALES Las variables globales son visibles en todas las funciones (y en el espacio de trabajo base o general) que las declaran como tales. Dichas variables de declaran precedidas por la palabra global y separadas por blancos, en la forma: global VARIABLE1 VARIABLE2 Como ya se ha apuntado, estas variables sólo son visibles en los espacios de trabajo de las funciones que las declaran como tales (y en el propio espacio de trabajo base, si también ahí han sido declaradas como globales). Ya se ha dicho también que se suele recurrir al criterio de utilizar nombres largos y con mayúsculas, para distinguirlas fácilmente de las demás variables. Referencias de función (function handles) Las referencias de función (function handles) constituyen un nuevo mecanismo pera referirse a un nombre de función, introducido en MATLAB 6.0. En versiones anteriores la única forma de referirse a una función era por medio del nombre. Téngase

en cuenta que MATLAB, al igual que otros lenguajes de programación como C/C++ y Java, admite funciones sobrecargadas (overloaded functions), esto es, funciones diferentes que tienen el mismo nombre pero se diferencian entre sí por el número y tipo de los argumentos. Cuando un programa llama a una función sobrecargada, MATLAB analiza los tipos de los argumentos incluidos en la llamada y llama a la función que mejor se adapta a esos tipos de argumentos. Las referencias de función permiten al programador un mayor control sobre la función que es efectivamente llamada y tienen algunas otras ventajas que se verán en este apartado y en sus sub-apartados. El principal uso de las referencias de función (como de los nombres de función en versiones anteriores) es el pasar a una función el nombre de otra función, junto con sus argumentos, para que la pueda ejecutar. A estas funciones que ejecutan otras funciones que se les pasan como argumentos se les llama funciones de función. Por ejemplo, MATLAB dispone de una función llamada quad que calcula la integral definida de una función entre unos límites dados. La función quad es genérica, esto es calcula, mediante métodos numéricos, integrales definidas de una amplia variedad de funciones, pero para que pueda calcular dicha integral hay que proporcionarle la función a integrar. Por ejemplo, para calcular la integral entre 0 y p de la función seno(x) se puede utilizar la sentencia: >> area=quad('sin',0,pi) area = 2.0000 La función quad ejecuta la función sin por medio de la función feval, que tiene la siguiente forma general: feval(funcname, arg1, arg2, arg3, ...)



donde funcname es una cadena de caracteres con el nombre de la función a evaluar, y arg1, arg2, arg3, ... son los argumentos que se le pasan a feval para que se los pueda pasar a funcname. A partir de la versión 6.0 de MATLAB ya no se pasa, a las funciones de función, el nombre de la función como en el ejemplo anterior, sino una referencia de función o function handle. De todas formas, para mantener la compatibilidad con los programas desarrollados en versiones anteriores, se sigue admitiendo que se pase a feval el nombre de la función, pero este mecanismo ya no se soportará en versiones posteriores. En MATLAB 6 la forma correcta de ejecutar el ejemplo anterior sería (se explicará con más detalle a continuación): fh=@sin; area=quad(fh,0,pi); donde la variable fh es una referencia de función, que es un nuevo tipo de dato de MATLAB, con todas las posibilidades y limitaciones que esto supone. CREACIÓN DE REFERENCIAS DE FUNCIÓN Ya se ha comentado que las referencias de función son un nuevo tipo de datos de MATLAB 6. Una referencia de función se puede crear de dos formas diferentes: 1. Mediante el operador @ ("at" o "arroba") La referencia a la función se crea precediendo el nombre de la función por el operador @. El resultado puede asignarse a una variable o pasarse como argumento a una función. Ejemplos: fh = @sin; area = quad(@sin, 0, pi);

2. Mediante la función str2func La función str2func recibe como argumento una cadena de caracteres conteniendo el nombre de una función y devuelve como valor de retorno la referencia de función. Una de las ventajas de esta función es que puede realizar la conversión de un vector de celdas con los nombres en un vector de referencias de función. Ejemplos: >> fh = str2func('sin'); >> str2func({'sin','cos','tan'}) ans = @sin @cos @tan Una característica común e importante de ambos métodos es que se aplican solamente al nombre de la función, y no al nombre de la función precedido o cualificado por su path. Además los nombres de función deben tener menos de 31 caracteres. EVALUACIÓN DE FUNCIONES MEDIANTE REFERENCIAS La principal aplicación de las referencias de función es pasar información de funciones a otras funciones para que aquéllas puedan ser ejecutadas por éstas. Para evaluar una referencia de función MATLAB utiliza la función feval, que se llama de la forma siguiente: [r1, r2, r3, ...] = feval(fh, arg1, arg2, arg3, ...) donde fh es una referencia de función y r1, r2, r3, ... y arg1, arg2, arg3, ... son respectivamente los valores de retorno y los argumentos de la función cuya referencia es fh. Sobre la función feval hay que hacer dos observaciones: 1. La referencia de función fh debe ser un escalar. En otras palabras, no es posible



evaluar un array de referencias de función con una sola llamada a feval. 2. La función fh que se ejecuta en el momento de la llamada a feval depende de la situación en el momento en que se creó la referencia de función, y no de la situación en el momento de la llamada a feval. Por ejemplo, si después de crear la referencia fh se cambia de directorio la función correspondiente, en el momento de la ejecución no será posible encontrarla; si después de crear fh se crea una nueva función con el mismo nombre, esta función no podrá nunca ser ejecutada por medio de la referencia creada previamente. El siguiente ejemplo muestra cómo se puede ejecutar una sub-función desde otra función definida en un fichero *.m diferente. Recuérdese que, en principio, las sub-funciones sólo son accesibles desde otras funciones definidas en el mismo fichero *.m. Supóngase que se crea un fichero llamado pruebafh.m que contiene las siguientes líneas (se define una función principal pruebafh que se llama como el fichero y una sub-función subf): % fichero pruebafh.m function mifh=pruebafh mifh=@subf; function A=subf(B, C) A=B+C; Obsérvese que la función principal pruebafh devuelve una referencia a la sub-función subf. En principio sólo pruebafh tiene acceso a subf y gracias a ese acceso puede crear la referencia mifh. Sin embargo, una vez que la referencia a subf ha sido creada y devuelta como valor de retorno, cualquier función con acceso a pruebafh podrá también acceder a la sub-función subf. El siguiente programa principal, definido en un fichero pruebafhMain.m, puede acceder a la subfunción gracias a la referencia de

función (si se intenta acceder directamente se obtiene un error). % fichero pruebafhMain.m fh=pruebafh A=rand(3); B=eye(3)*10; C=feval(fh,A,B) % D=subf(A,B) % ERROR disp('Ya he terminado') Este ejemplo sencillo es bastante significativo respecto a los beneficios que se pueden obtener de las referencias de función. INFORMACIÓN CONTENIDA POR UNA REFERENCIA DE FUNCIÓN. FUNCIONES SOBRECARGADAS Una referencia de función puede contener información de varias funciones, en concreto de todas aquellas funciones que fueran "visibles" en el momento en el que dicha referencia fue creada. Recuérdese que funciones visibles, además de las funciones intrínsecas de MATLAB (built-in functions) son las funciones que están definidas en el directorio actual y en los directorios definidos en el path de MATLAB. La función functions permite obtener toda la información disponible de una referencia de función. Obsérvese la estructura salida del siguiente ejemplo (el campo methods es a su vez una estructura que puede mostrarse por separado): >> info=functions(@disp) info = function: 'disp' type: 'overloaded' file: 'MATLAB built-in function' methods: [1x1 struct] >> info.methods ans =



inline: 'c:\matlabr12\toolbox\matlab\funfun\@inline\disp' serial: 'c:\matlabr12\toolbox\matlab\iofun\@serial\disp' En este caso concreto se ha considerado la función disp, que permite mostrar los elementos de vectores y matrices. El valor de retorno de la función functions es una estructura con los cuatro campos siguientes: function cadena de caracteres con el nombre de la función a la que corresponde la referencia type Cadena de caracteres con uno de los siguientes valores: 'simple', 'subfunction', 'private', 'constructor' y 'overloaded'. file Cadena de caracteres que contiene el nombre del fichero *.m en el que está definida la función o bien el texto 'MATLAB built-in function'. methods Estructura que contiene los paths de los ficheros *.m en los que están definidas las funciones sobrecargadas que se corresponden con esta referencia. El argumento de la función functions debe ser una referencia de función escalar (no puede ser un array de referencias de función). Los distintos valores del campo type tienen los siguientes significados: simple Funciones intrínsecas no sobrecargadas. overloaded Funciones sobrecargadas. Son las únicas que tienen campo methods. constructor Constructores relacionados con clases y objetos. subfunction Funciones definidas en un fichero *.m de otra función. private Funciones privadas (definidas en un subdirectorio private). Las funciones sobrecargadas (overloaded) tienen un interés especial, pues son las únicas que tienen el campo

methods y las que pueden dar origen a más dificultades o problemas. De modo análogo a otros lenguajes de programación como C/C++ y Java, las funciones sobrecargadas de MATLAB son funciones que tienen el mismo nombre, pero distintos tipos de argumentos y distinto código (en otras palabras, funciones diferentes que sólo coinciden en el nombre). Las funciones default son las que no tienen argumentos especializados. Otras funciones esperan recibir un argumento de un tipo más concreto. Salvo que haya una función especializada cuyos argumentos coincidan con los tipos de la llamada, MATLAB utilizará la función default.



UNIDAD VI. GRAFICACIÓN. 6.1 Introducción.

A estas alturas, después de ver cómo funciona este programa, a nadie le puede resultar extraño que los gráficos 2-D de MATLAB estén fundamentalmente orientados a la representación gráfica de vectores (y matrices). En el caso más sencillo los argumentos básicos de la función plot van a ser vectores. Cuando una matriz aparezca como argumento, se considerará como un conjunto de vectores columna (en algunos casos también de vectores fila).

MATLAB utiliza un tipo especial de ventanas para realizar las operaciones gráficas. Ciertos comandos abren una ventana nueva y otros dibujan sobre la ventana activa, bien sustituyendo lo que hubiera en ella, bien añadiendo nuevos elementos gráficos a un dibujo anterior. Todo esto se verá con más detalle en las siguientes secciones. 6.2 Funciones gráficas 2D elementales

MATLAB dispone de cuatro funciones básicas para crear gráficos 2-D. Estas funciones se diferencian principalmente por el tipo de escala que utilizan en los ejes de abscisas y de ordenadas. Estas cuatro funciones son las siguientes:

• plot() crea un gráfico a partir de vectores y/o columnas de matrices, con escalas lineales sobre ambos ejes

• loglog() ídem con escala logarítmica en ambos ejes

• semilogx() ídem con escala lineal en el eje de ordenadas y logarítmica en el eje de abscisas

• semilogy() ídem con escala lineal en el eje de abscisas y logarítmica en el eje de ordenadas

En lo sucesivo se hará referencia casi

exclusiva a la primera de estas funciones (plot). Las demás se pueden utilizar de un modo similar.

Existen además otras funciones orientadas a añadir títulos al gráfico, a cada uno de los ejes, a dibujar una cuadrícula auxiliar, a introducir texto, etc. Estas funciones son las siguientes:

• title('título') añade un título al dibujo • xlabel('tal') añade una etiqueta al eje

de abscisas. Con xlabel off desaparece

• ylabel('cual') añade una etiqueta al eje de ordenadas. Con ylabel off desaparece

• text(x,y,'texto') introduce 'texto' en el lugar especificado por las coordenadas x e y. Si x e y son vectores, el texto se repite por cada par de elementos. Si texto es también un vector de cadenas de texto de la misma dimensión, cada elemento se escribe en las coordenadas correspondientes

• gtext('texto') introduce texto con ayuda del ratón: el cursor cambia de forma y se espera un clic para introducir el texto en esa posición

• legend() define rótulos para las distintas líneas o ejes utilizados en la figura. Para más detalle, consultar el Help

• grid activa la inclusión de una cuadrícula en el dibujo. Con grid off desaparece la cuadrícula



Borrar texto (u otros elementos gráficos) es un poco más complicado; de hecho, hay que preverlo de antemano. Para poder hacerlo hay que recuperar previamente el valor de retorno del comando con el cual se ha creado. Después hay que llamar a la función delete con ese valor como argumento. Considérese el siguiente ejemplo: >> v = text(1,.0,'seno') v = 76.0001 >> delete(v) Los dos grupos de funciones anteriores no actúan de la misma forma. Así, la función plot dibuja una nueva figura en la ventana activa (en todo momento MATLAB tiene una ventana activa de entre todos las ventanas gráficas abiertas), o abre una nueva figura si no hay ninguna abierta, sustituyendo cualquier cosa que hubiera dibujada anteriormente en esa ventana. Para verlo, se comenzará creando un par de vectores x e y con los que trabajar: >> x=[-10:0.2:10]; y=sin(x); Ahora se deben ejecutar los comandos siguientes (se comienza cerrando la ventana activa, para que al crear la nueva ventana aparezca en primer plano): >> close % se cierra la ventana gráfica activa anterior >> grid % se crea una ventana con una cuadrícula >> plot(x,y) % se dibuja la función seno borrando la cuadrícula Se puede observar la diferencia con la secuencia que sigue: >> close >> plot(x,y) % se crea una ventana y se dibuja la función seno

>> grid % se añade la cuadrícula sin borrar la función seno

En el primer caso MATLAB ha creado la cuadrícula en una ventana nueva y luego la ha borrado al ejecutar la función plot. En el segundo caso, primero ha dibujado la función y luego ha añadido la cuadrícula. Esto es así porque hay funciones como plot que por defecto crean una nueva figura, y otras funciones como grid que se aplican a la ventana activa modificándola, y sólo crean una ventana nueva cuando no existe ninguna ya creada. Más adelante se verá que con la función hold pueden añadirse gráficos a una figura ya existente respetando su contenido. 6.2.1 FUNCIÓN PLOT

Esta es la función clave de todos los gráficos 2-D en MATLAB. Ya se ha dicho que el elemento básico de los gráficos bidimensionales es el vector. Se utilizan también cadenas de 1, 2 ó 3 caracteres para indicar colores y tipos de línea. La función plot(), en sus diversas variantes, no hace otra cosa que dibujar vectores. Un ejemplo muy sencillo de esta función, en el que se le pasa un único vector como argumento, es el siguiente: >> x=[1 3 2 4 5 3] x = 1 3 2 4 5 3 >> plot(x) El resultado de este comando es que se abre una ventana mostrando el gráfico de la Figura 6.1.

Por defecto, los distintos puntos del gráfico se unen con una línea continua.

Fig. 6.1 Gráfico del vector x=[1 3 2 4 5 3].



También por defecto, el color que se utiliza para la primera línea es el azul.

Cuando a la función plot() se le pasa un único vector –real– como argumento, dicha función dibuja en ordenadas el valor de los n elementos del vector frente a los índices 1, 2, ... n del mismo en abscisas. Más adelante se verá que si el vector es complejo, el funcionamiento es bastante diferente.

En la pantalla de su ordenador se habrá visto que MATLAB utiliza por defecto color blanco para el fondo de la pantalla y otros colores más oscuros para los ejes y las gráficas.

Una segunda forma de utilizar la función plot() es con dos vectores como argumentos. En este caso los elementos del segundo vector se representan en ordenadas frente a los valores del primero, que se representan en abscisas. Véase por ejemplo cómo se puede dibujar un cuadrilátero de esta forma (obsérvese que para dibujar un polígono cerrado el último punto debe coincidir con el primero): >> x=[1 6 5 2 1]; y=[1 0 4 3 1]; >> plot(x,y)

La función plot() permite también dibujar múltiples curvas introduciendo varias parejas de vectores como argumentos. En este caso, cada uno de los segundos vectores se dibujan en ordenadas como función de los valores del primer vector de la pareja, que se representan en abscisas. Si el usuario no decide otra cosa, para las sucesivas líneas se utilizan colores que son permutaciones cíclicas del azul, verde, rojo, cyan, magenta, amarillo y negro. Obsérvese bien cómo se dibujan el seno y el coseno en el siguiente ejemplo: >> x=0:pi/25:6*pi; >> y=sin(x); z=cos(x); >> plot(x,y,x,z)

Ahora se va a ver lo que pasa con los vectores complejos. Si se pasan a plot() varios vectores complejos como argumentos, MATLAB simplemente representa las partes reales y desprecia las partes imaginarias. Sin embargo, un único argumento complejo hace que se represente la parte real en abscisas, frente a la parte imaginaria en ordenadas. Véase el siguiente ejemplo. Para generar un vector complejo se utilizará el resultado del cálculo de valores propios de una matriz formada aleatoriamente: >> plot(eig(rand(20,20)),'+') donde se ha hecho uso de elementos que se verán en la siguiente sección, respecto a dibujar con distintos tipos de “markers” (en este caso con signos +), en vez de con línea continua, que es la opción por defecto. En el comando anterior, el segundo argumento es un carácter que indica el tipo de marker elegido. El comando anterior es equivalente a: >> z=eig(rand(20,20)); >> plot(real(z),imag(z),'+') Como ya se ha dicho, si se incluye más de un vector complejo como argumento, se ignoran las partes imaginarias. Si se quiere dibujar varios vectores complejos, hay que separar explícitamente las partes reales e imaginarias de cada vector, como se acaba de hacer en el último ejemplo.

El comando plot puede utilizarse también con matrices como argumentos. Véanse algunos ejemplos sencillos:

• plot(A) dibuja una línea por cada columna de A en ordenadas, frente al índice de los elementos en abscisas

• plot(x,A) dibuja las columnas (o filas) de A en ordenadas frente al vector x en abscisas. Las dimensiones de A y



x deben ser coherentes: si la matriz A es cuadrada se dibujan las columnas, pero si no lo es y la dimensión de las filas coincide con la de x, se dibujan las filas

• plot(A,x) análogo al anterior, pero dibujando las columnas (o filas) de A en abscisas, frente al valor de x en ordenadas

• plot(A,B) dibuja las columnas de B en ordenadas frente a las columnas de A en abscisas, dos a dos. Las dimensiones deben coincidir

• plot(A,B,C,D) análogo al anterior para cada par de matrices. Las dimensiones de cada par deben coincidir, aunque pueden ser diferentes de las dimensiones de los demás pares

Se puede obtener una excelente y breve descripción de la función plot() con el comando help plot o helpwin plot. La descripción que se acaba de presentar se completará en la siguiente sección, en donde se verá cómo elegir los colores y los tipos de línea. 6.2.2 ESTILOS DE LÍNEA Y MARCADORES EN LA FUNCIÓN PLOT

En la sección anterior se ha visto cómo la tarea fundamental de la función plot() era dibujar los valores de un vector en ordenadas, frente a los valores de otro vector en abscisas. En el caso general esto exige que se pasen como argumentos un par de vectores. En realidad, el conjunto básico de argumentos de esta función es una tripleta formada por dos vectores y una cadena de 1, 2 ó 3 caracteres que indica el color y el tipo de línea o de marker. En la tabla siguiente se pueden observar las distintas posibilidades.

Símbolo para Color y yellow m magenta c cyan r red g green b blue w white k black Símbolo para Marcadores (markers) . puntos o círculos x marcas en x + marcas en + * marcas en * s marcas cuadradas (square) d marcas en diamante (diamond) ̂ triángulo apuntando arriba

v triángulo apuntando abajo Símbolo para Estilo de línea > triángulo apuntando a la dcha - líneas continuas < triángulo apuntando a la izda : líneas a puntos p estrella de 5 puntas -. líneas a barra-punto h estrella se seis puntas -- líneas a trazos

Cuando hay que dibujar varias líneas, por defecto se van cogiendo sucesivamente los colores de la tabla comenzando por el azul, hacia arriba, y cuando se terminan se vuelve a empezar otra vez por el azul. Si el fondo es blanco, este color no se utiliza para las líneas.



6.2.3 AÑADIR LÍNEAS A UN GRÁFICO YA EXISTENTE

Existe la posibilidad de añadir líneas

a un gráfico ya existente, sin destruirlo o sin abrir una nueva ventana. Se utilizan para ello los comandos hold on y hold off. El primero de ellos hace que los gráficos sucesivos respeten los que ya se han dibujado en la figura (es posible que haya que modificar la escala de los ejes); el comando hold off deshace el efecto de hold on. El siguiente ejemplo muestra cómo se añaden las gráficas de x2 y x3 a la gráfica de x previamente creada (cada una con un tipo de línea diferente): >> plot(x) >> hold on >> plot(x2,'--') >> plot(x3,'-.') >> hold off 6.2.4 COMANDO SUBPLOT

Una ventana gráfica se puede dividir en m particiones horizontales y n verticales, con objeto de representar múltiples gráficos en ella. Cada una de estas subventanas tiene sus propios ejes, aunque otras propiedades son comunes a toda la figura. La forma general de este comando es: subplot(m,n,i) donde m y n son el número de subdivisiones en filas y columnas, e i es la subdivisión que se convierte en activa. Las subdivisiones se numeran consecutivamente empezando por las de la primera fila, siguiendo por las de la segunda, etc. Por ejemplo, la siguiente secuencia de comandos genera cuatro gráficos en la misma ventana: >> y=sin(x); z=cos(x); w=exp(-x*.1).*y; v=y.*z; >> subplot(2,2,1), plot(x,y) >> subplot(2,2,2), plot(x,z) >> subplot(2,2,3), plot(x,w)

>> subplot(2,2,4), plot(x,v)

Se puede practicar con este ejemplo añadiendo títulos a cada subplot, así como rótulos para los ejes. Se puede intentar también cambiar los tipos de línea. Para volver a la opción por defecto basta teclear el comando: >> subplot(1,1,1)

6.2.5 CONTROL DE LOS EJES

También en este punto MATLAB tiene sus opciones por defecto, que en algunas ocasiones puede interesar cambiar. El comando básico es el comando axis. Por defecto, MATLAB ajusta la escala de cada uno de los ejes de modo que varíe entre el mínimo y el máximo valor de los vectores a representar. Este es el llamado modo "auto", o modo automático. Para definir de modo explícito los valores máximo y mínimo según cada eje, se utiliza el comando: axis([xmin, xmax, ymin, ymax]) mientras que : axis('auto') devuelve el escalado de los ejes al valor por defecto o automático. Otros posibles usos de este comando son los siguientes:

• v=axis devuelve un vector v con los valores [xmin, xmax, ymin, ymax]

• axis(axis) mantiene los ejes en sus actuales valores, de cara a posibles nuevas gráficas añadidas con hold on

• axis('ij') utiliza ejes de pantalla, con el origen en la esquina superior izda. y el eje j en dirección vertical descendente

• axis('xy') utiliza ejes cartesianos normales, con el origen en la esquina



inferior izda. y el eje y vertical ascendente

• axis('equal') el escalado es igual en ambos ejes

• axis('square') la ventana será cuadrada

• axis('image') la ventana tendrá las proporciones de la imagen que se desea representar en ella (por ejemplo la de una imagen bitmap que se desee importar) y el escalado de los ejes será coherente con dicha imagen

• axis('normal') elimina las restricciones introducidas por 'equal' y 'square'

• axis('off') elimina las etiquetas, los números y los ejes

• axis('on') restituye las etiquetas, los números y los ejes

6.2.6 FUNCIÓN LINE()

La función line() permite dibujar una o más líneas que unen los puntos cuyas coordenadas se pasan como argumentos. Permite además especificar el color, grosor, tipo de trazo, marcador, etc. Es una función de más bajo nivel que la función plot(), pero ofrece una mayor flexibilidad. En su versión más básica, para dibujar un segmento de color verde entre dos puntos, esta función se llamaría de la siguiente manera: line([xini, xend]', [yini, yend]', 'color', 'g') Se puede también dibujar dos líneas a la vez utilizando la forma: line([xini1 xini2; xend1 xend2], ([yini1 yini2; yend1 yend2]);

Finalmente, si cada columna de la matriz X contiene la coordenada x inicial y final de un punto, y lo mismo las columnas de la matriz Y con las coordenadas y, la

siguiente sentencia dibuja tantas líneas como columnas tengan las matrices X e Y: line([X], [Y]); Se pueden controlar las características de la línea por medio de pares parámetro/valor, como por ejemplo: line(x,y,'Color','r','LineWidth',4,'MarkerSize',12,'LineStyle','—','Marker','*') 6.2.7 Control de ventanas gráficas: Función figure

Si se llama a la función figure sin argumentos, se crea una nueva ventana gráfica con el número consecutivo que le corresponda. El valor de retorno es dicho número.

Por otra parte, el comando figure(n) hace que la ventana n pase a ser la ventana o figura activa. Si dicha ventana no existe, se crea una nueva ventana con el número consecutivo que le corresponda (que se puede obtener como valor de retorno del comando). La función close cierra la figura activa, mientras que close(n) cierra la ventana o figura número n.

El comando clf elimina el contenido de la figura activa, es decir, la deja abierta pero vacía. La función gcf devuelve el número de la figura activa en ese momento. Para practicar un poco con todo lo que se acaba de explicar, ejecútense las siguientes instrucciones de MATLAB, observando con cuidado los efectos de cada una de ellas en la ventana activa. El comando figure(gcf) (get current figure) permite hacer visible la ventana de gráficos desde la ventana de comandos. >> x=[-4*pi:pi/20:4*pi]; >> plot(x,sin(x),'r',x,cos(x),'g') >> title('Función seno(x) -en rojo- y función coseno(x) -en verde-')



>> xlabel('ángulo en radianes'), figure(gcf) >> ylabel('valor de la función trigonométrica'), figure(gcf) >> axis([-12,12,-1.5,1.5]), figure(gcf) >> axis('equal'), figure(gcf) >> axis('normal'), figure(gcf) >> axis('square'), figure(gcf) >> axis('off'), figure(gcf) >> axis('on'), figure(gcf) >> axis('on'), grid, figure(gcf) 6.3 Otras funciones gráficas 2-D

Existen otras funciones gráficas bidimensionales orientadas a generar otro tipo de gráficos distintos de los que produce la función plot() y sus análogas. Algunas de estas funciones son las siguientes (para más información sobre cada una de ellas en particular, utilizar help nombre_función):

• bar() crea diagramas de barras • barh() diagramas de barras

horizontales • bar3() diagramas de barras con

aspecto 3-D • bar3h() diagramas de barras

horizontales con aspecto 3-D • pie() gráficos con forma de “tarta” • pie3() gráficos con forma de “tarta” y

aspecto 3-D • area() similar plot(), pero rellenando

en ordenadas de 0 a y • stairs() función análoga a bar() sin

líneas internas • errorbar() representa sobre una

gráfica –mediante barras– valores de errores

• compass() dibuja los elementos de un vector complejo como un conjunto de vectores partiendo de un origen común

• feather() dibuja los elementos de un vector complejo como un conjunto de vectores partiendo de orígenes

uniformemente espaciados sobre el eje de abscisas

• hist() dibuja histogramas de un vector

• rose() histograma de ángulos (en radianes)

• quiver() dibujo de campos vectoriales como conjunto de vectores

A modo de ejemplo, genérese un vector de valores aleatorios entre 0 y 10, y ejecútense los siguientes comandos: >> x=[rand(1,100)*10]; >> plot(x) >> bar(x) >> stairs(x) >> hist(x) >> hist(x,20) >> alfa=(rand(1,20)-0.5)*2*pi; >> rose(alfa) 6.3.1 FUNCIÓN FPLOT

La función plot vista anteriormente dibuja vectores. Si se quiere dibujar una función, antes de ser pasada a plot debe ser convertida en un vector de valores. Esto tiene algunos inconvenientes, por ejemplo, el que "a priori" es difícil predecir en que zonas la función varía más rápidamente y habría por ello que reducir el espaciado entre los valores en el eje de abscisas. La función fplot admite como argumento un nombre de función o un nombre de fichero *.m en el cual esté definida una función de usuario. La función puede ser escalar (un único resultado por cada valor de x) o vectorial. La forma general de esta función es la siguiente: fplot('funcion', limites, 'cadena', tol) donde: 'funcion' representa el nombre de la función o del fichero *.m entre apóstrofos (pasado como cadena de caracteres),



limites es un vector de 2 ó 4 elementos, cuyos valores son [xmin,xmax] o [xmin,xmax,ymin,ymax], 'cadena' tiene el mismo significado que en plot y permite controlar el color, los markers y el tipo de línea. tol es la tolerancia de error relativo. El valor por defecto es 2e-03. El máximo número de valores en x es (1/tol)+1 Esta función puede utilizarse también en la forma: [x,y]=fplot('funcion', limites, 'cadena', tol) y en este caso se devuelven los vectores x e y, pero no se dibuja nada. El gráfico puede obtenerse con un comando posterior por medio de la función plot. Véase un ejemplo de utilización de esta función. Se comienza creando un fichero llamado mifunc.m en el directorio G:\matlab que contenga las líneas siguientes: function y = mifunc(x) y(:,1)=200*sin(x)./x; y(:,2)=x.^2; y a continuación se ejecuta el comando: >> fplot('mifunc(x)', [-20 20], 'g') Obsérvese que la función mifunc devuelve una matriz con dos columnas, que constituyen las dos gráficas dibujadas. En este caso se ha utilizado para ellas el color verde. 6.3.2 FUNCIÓN FILL PARA POLÍGONOS

Ésta es una función especial para dibujar polígonos planos, rellenándolos de un determinado color. La forma general es la siguiente: >> fill(x,y,c)

que dibuja un polígono definido por los vectores x e y, rellenándolo con el color especificado por c. Si es necesario, el polígono se cierra uniendo el último vértice con el primero. Respecto al color:

• Si c es un carácter de color ('r','g','b','c','m','y','w','k'), o un vector de valores [r g b], el polígono se rellena de modo uniforme con el color especificado.

• Si c es un vector de la misma dimensión que x e y, sus elementos se trasforman de acuerdo con un mapa de colores determinado, y el llenado del polígono –no uniforme en este caso– se obtiene interpolando entre los colores de los vértices. Sobre este tema de los colores, se volverá más adelante con un cierto detenimiento.

Este comando puede utilizarse también con matrices: >> fill(A,B,C) donde A y B son matrices del mismo tamaño. En este caso se dibuja un polígono por cada par de columnas de dichas matrices. C puede ser un vector fila de colores uniformes para cada polígono, o una matriz del mismo tamaño que las anteriores para obtener colores de relleno por interpolación. Si una de las dos, o A o B, son un vector en vez de una matriz, se supone que ese vector se repite tantas veces como sea necesario para dibujar tantos polígonos como columnas tiene la matriz. Considérese un ejemplo sencillo de esta función: >> x=[1 5 4 2]; y=[1 0 4 3]; >> fill(x,y,'r') >> colormap(gray), fill(x,y,[1 0.5 0.8 0.7])



6.3.3 Entrada de puntos con el ratón

Se realiza mediante la función ginput, que permite introducir las coordenadas del punto sobre el que está el cursor, al clicar (o al pulsar una tecla). Algunas formas de utilizar esta función son las siguientes:

• [x,y] = ginput lee un número indefinido de puntos –cada vez que se clica o se pulsa una tecla cualquiera– hasta que se termina pulsando la tecla intro

• [x,y] = ginput(n) lee las coordenadas de n puntos

• [x,y,bot] = ginput igual que el anterior, pero devuelve también un vector de enteros bot con el código ASCII de la tecla pulsada o el número del botón del ratón (1, 2, ...) con el que se ha clicado.

Como ejemplo de utilización de este comando, ejecútense las instrucciones siguientes en la ventana de comandos de MATLAB para introducir un cuadrilátero arbitrario y dibujarlo de dos formas: >> clf, [x,y]=ginput(4); >> figure(gcf), plot(x,y,'w'), pause(5), fill(x,y,'r') donde se ha introducido el comando pause(5) que espera 5 segundos antes de pasar a ejecutar el siguiente comando. Este comando admite como argumento un tiempo con precisión de centésimas de segundo. 6.3.4 Preparación de películas o "movies"

Para preparar pequeñas películas o movies se pueden utilizar las funciones

movie, moviein y getframe. Una película se compone de varias imágenes, denominadas frames. La función getframe devuelve un vector columna con la información necesaria para reproducir la imagen que se acaba de representar en la figura o ventana gráfica activa, por ejemplo con la función plot. El tamaño de este vector columna depende del tamaño de la ventana, pero no de la complejidad del dibujo. La función moviein(n) reserva memoria para almacenar n frames. La siguiente lista de comandos crearía una película de 17 imágenes o frames, que se almacenarán como las columnas de la matriz M: M = moviein(17); x=[-2*pi:0.1:2*pi]'; for j=1:17 y=sin(x+j*pi/8); plot(x,y); M(:,j) = getframe; end Una vez creada la película se puede representar el número de veces que se desee con el comando movie. Por ejemplo, para representar 10 veces la película anterior, a 15 imágenes por segundo, habría que ejecutar el comando siguiente (los dos últimos parámetros son opcionales): movie(M,10,15) Los comandos moviein, getframe y movie tienen posibilidades adicionales para las que puede consultarse el Help correspondiente. Hay que señalar que en MATLAB no es lo mismo un movie que una animación. Una animación es simplemente una ventana gráfica que va cambiando como consecuencia de los comandos que se van ejecutando. Un movie es una animación grabada o almacenada en memoria previamente.



6.3.5 Las ventanas gráficas de MATLAB

Anteriormente han aparecido en varias ocasiones las ventanas gráficas de MATLAB. Quizás sea el momento de hacer una breve recapitulación sobre sus posibilidades, que se han vuelto a mejorar en la versión 6. La Figura 6.2 muestra los menús y las barras de herramientas de las ventanas gráficas de MATLAB 6.

Fig. 6. 2 Menús y barras de herramientas de las ventanas gráficas de MATLAB.

En el menú Edit, además de los

comandos referentes a la copia de figuras, aparecen los comandos Figure Properties, Axes Properties y Current Object Properties, que abren paso a los correspondientes editores de propiedades. Los dos primeros se muestran en las figuras siguientes.

Fig. 6. 3 Editor de propiedades de Figure.

Fig. 6. 4 Editor de propiedades de Axes.

El menú Edit ofrece también las opciones estándar de Windows, permitiendo copiar, cortar y pegar los elementos seleccionados de la figura si está activada la opción Plot Edit ( ).

El menú View permite hacer visibles u ocultar las barras de herramientas Window Toolbar y Camera Toolbar. Por defecto sólo aparece la primera de ellas. Estas barras de herramientas disponen de numerosas opciones para trabajar con ventanas conteniendo gráficos 2-D y 3-D. La mejor forma de aprender es probar y acudir al Help cuando hay algo que no se entiende.

En menú Insert permite añadir elementos a la figura activa, por ejemplo rótulos, etiquetas, líneas, texto, etc. Por su parte, el menú Tools permite realizar desde menú algunas de las operaciones también disponibles en las barras de herramientas. Finalmente, el menú Help permite acceder a la ayuda concreta que hace referencia a las ventanas gráficas. 6.4 GRÁFICOS TRIDIMENSIONALES

Quizás sea ésta una de las características de MATLAB que más admiración despierta entre los usuarios no técnicos (cualquier alumno de ingeniería sabe que hay ciertas operaciones algebraicas como la descomposición de valor singular, sin ir más lejos– que tienen dificultades muy superiores, aunque "luzcan" menos). 6.4.1 Tipos de funciones gráficas tridimensionales

MATLAB tiene posibilidades de realizar varios tipos de gráficos 3D. Para darse una idea de ello, lo mejor es verlo en la pantalla cuanto antes, aunque haya que dejar las explicaciones detalladas para un poco más adelante.



La primera forma de gráfico 3D es la función plot3, que es el análogo tridimensional de la función plot. Esta función dibuja puntos cuyas coordenadas están contenidas en 3 vectores, bien uniéndolos mediante una línea continua (defecto), bien mediante markers. Asegúrese de que no hay ninguna ventana gráfica abierta y ejecute el siguiente comando que dibuja una línea espiral: >> fi=[0:pi/20:6*pi]; plot3(cos(fi),sin(fi),fi,'g') Ahora se verá cómo se representa una función de dos variables. Para ello se va a definir una función de este tipo en un fichero llamado test3d.m. La fórmula será la siguiente: El fichero test3d.m debe contener las líneas siguientes: function z=test3d(x,y) z = 3*(1-x).^2.*exp(-(x.^2) - (y+1).^2) ... - 10*(x/5 - x.^3 - y.^5).*exp(-x.^2-y.^2) ... - 1/3*exp(-(x+1).^2 - y.^2); Ahora, ejecútese la siguiente lista de comandos (directamente, o mejor creando un fichero test3dFC.m que los contenga): >> x=[-3:0.4:3]; y=x; >> close >> subplot(2,2,1) >> figure(gcf),fi=[0:pi/20:6*pi]; >> plot3(cos(fi),sin(fi),fi,'r') >> [X,Y]=meshgrid(x,y); >> Z=test3d(X,Y); >> subplot(2,2,2) >> figure(gcf), mesh(Z) >> subplot(2,2,3) >> figure(gcf), surf(Z) >> subplot(2,2,4)

>> figure(gcf), contour3(Z,16)

En la figura resultante (Figura 6.5) aparece una buena muestra de algunas de las posibilidades gráficas tridimensionales de MATLAB. En las próximas secciones se encontrará la explicación de qué se ha hecho y cómo se ha hecho. 6.4.2 DIBUJO DE LÍNEAS: FUNCIÓN PLOT3

La función plot3 es análoga a su homóloga bidimensional plot. Su forma más sencilla es la siguiente: >> plot3(x,y,z) que dibuja una línea que une los puntos (x(1), y(1), z(1)), (x(2), y(2), z(2)), etc. y la proyecta sobre un plano para poderla representar en la pantalla. Al igual que en el caso plano, se puede incluir una cadena de 1, 2 ó 3 caracteres para determinar el color, los markers, y el tipo de línea: >> plot3(x,y,z,s) También se pueden utilizar tres matrices X, Y y Z del mismo tamaño: >> plot3(X,Y,Z) en cuyo caso se dibujan tantas líneas como columnas tienen estas 3 matrices, cada una de las cuales está definida por las 3 columnas homólogas de dichas matrices. A continuación se va a realizar un ejemplo sencillo consistente en dibujar un cubo. Para ello se creará un fichero llamado cubo.m que contenga las aristas correspondientes, definidas mediante los vértices del cubo como una línea poligonal continua (obsérvese que algunas aristas se

Fig. 6. 5 Gráficos 3D realizados con MATLAB



dibujan dos veces). El fichero cubo.m define una matriz A cuyas columnas son las coordenadas de los vértices, y cuyas filas son las coordenadas x, y y z de los mismos: A=[0 1 1 0 0 0 1 0 1 1 0 0 1 1 1 1 0 0 0 0 1 1 0 0 0 0 0 1 1 0 0 0 1 1 1 1 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 1 1 0]; Ahora basta ejecutar los comandos siguientes (el trasponer los vectores en este caso es opcional): >> cubo; >> plot3(A(1,:)',A(2,:)',A(3,:)') 6.4.3 DIBUJO DE MALLADOS: FUNCIONES MESHGRID, MESH Y SURF

Ahora se verá con detalle cómo se puede dibujar una función de dos variables (z=f(x,y)) sobre un dominio rectangular. Se verá que también se pueden dibujar los elementos de una matriz como función de los dos índices.

Sean x e y dos vectores que contienen las coordenadas en una y otra dirección de la retícula (grid) sobre la que se va a dibujar la función. Después hay que crear dos matrices X (cuyas filas son copias de x) e Y (cuyas columnas son copias de y). Estas matrices se crean con la función meshgrid. Estas matrices representan respectivamente las coordenadas x e y de todos los puntos de la retícula. La matriz de valores Z se calcula a partir de las matrices de coordenadas X e Y. Finalmente hay que dibujar esta matriz Z con la función mesh, cuyos elementos son función elemento a elemento de los elementos de X e Y. Véase como ejemplo el dibujo de la función sen(r)/r (siendo r=sqrt(x2+y2); para evitar dividir por 0 se suma al denominador el número pequeño

eps). Para distinguirla de la función test3d anterior se utilizará u y v en lugar de x e y. Créese un fichero llamado sombrero.m que contenga las siguientes líneas: close all u=-8:0.5:8; v=u; [U,V]=meshgrid(u,v); R=sqrt(U.^2+V.^2)+eps; W=sin(R)./R; mesh(W) Ejecutando este fichero se obtiene el gráfico mostrado en la Figura 6.6.

Se habrá podido comprobar que la función mesh dibuja en perspectiva una función en base a una retícula de líneas de colores, rodeando cuadriláteros del color de fondo, con eliminación de líneas ocultas. Más adelante se verá cómo controlar estos colores que aparecen. Baste decir por ahora que el color depende del valor z de la función. Ejecútese ahora el comando: >> surf(W) y obsérvese la diferencia en la Figura 6.7. En vez de líneas aparece ahora una superficie faceteada, también con eliminación de líneas ocultas. El color de las

Figura 6.6. Figura 3D de la función “sombrero”

Figura 6.7. Función “sombrero” con facetas



facetas depende también del valor de la función.

Como un segundo ejemplo, se va a volver a dibujar la función picos (la correspondiente al fichero test3d.m visto previamente). Créese ahora el fichero picos.m con las siguientes sentencias: x=[-3:0.2:3]; y=x; [X,Y]=meshgrid(x,y); Z=test3d(X,Y); figure(gcf), mesh(Z), pause(5), surf(Z) Es necesario poner la instrucción pause –que espera 5 segundos– para que se puedan ver las dos formas de representar la función Z (si no, sólo se vería la segunda). Una vez creado este fichero, tecléese picos en la línea de comandos y obsérvese el resultado. Más adelante se verá también cómo controlar el punto de vista en estos gráficos en perspectiva. 6.4.4 DIBUJO DE LÍNEAS DE CONTORNO: FUNCIONES CONTOUR Y CONTOUR3 Una forma distinta de representar funciones tridimensionales es por medio de isolíneas o curvas de nivel. A continuación se verá cómo se puede utilizar estas representaciones con las matrices de datos Z y W que se han calculado previamente: >> contour(Z,20) >> contour3(Z,20) >> contour(W,20) >> contour3(W,20) donde "20" representa el número de líneas de nivel. Si no se pone se utiliza un número por defecto. Otras posibles formas de estas funciones son las siguientes:

contour(Z, val) siendo val un vector de valores para las isolíneas a dibujar

• contour(u,v,W,20) se utilizan u y v para dar valores a los ejes de coordenadas

• contour(Z,20,'r--') se puede especificar el tipo de línea como en la función plot

• contourf(Z, val) análoga a contour(), pero rellenando el espacio entre líneas

Utilización del color en gráficos 3-D En los dibujos realizados hasta ahora, se ha visto que el resultado adoptaba determinados colores, pero todavía no se ha explicado de dónde han salido. Ahora se verá qué sistema utiliza MATLAB para determinar los colores.

6.4.5 MAPAS DE COLORES Un mapa de colores se define como una matriz de tres columnas, cada una de las cuales contiene un valor entre 0 y 1, que representa la intensidad de uno de los colores fundamentales: R (red o rojo), G (green o verde) y B (blue o azul). La longitud por defecto de los mapas de colores de MATLAB es 64, es decir, cada mapa de color contiene 64 colores. Algunos mapas de colores están predefinidos en MATLAB. Buscando colormap en Help Desk se obtiene –entre otra información– la lista de los siguientes mapas de colores: autumn varies smoothly from red, through orange, to yellow. bone is a grayscale colormap with a higher value for the blue

component. Colorcube contains as many regularly spaced colors in RGB

colorspace as possible, while attempting to provide more steps of gray, pure red, pure green, and pure blue.

cool consists of colors that are shades of cyan and magenta. copper varies smoothly from black to bright copper. flag consists of the colors red, white, blue, and black. gray returns a linear grayscale colormap. hot varies smoothly from black, through shades of red, orange,

and yellow, to white.



hsv varies the hue component of the hue-saturation-value color model. The colors begin with red, pass through yellow, green, cyan, blue, magenta, and return to red.

jet ranges from blue to red, and passes through the colors cyan, yellow, and orange. It is a variation of the hsv colormap.

lines colormap of colors specified by the Axes ColorOrder property and a shade of gray.

pink contains pastel shades of pink. prism repeats the six colors red, orange, yellow, green, blue, and

violet. spring consists of colors that are shades of magenta and yellow. summer consists of colors that are shades of green and yellow. white is an all white monochrome colormap. winter consists of colors that are shades of blue and green.

El colormap por defecto es jet. Para visualizar estos mapas de colores se pueden utilizar los comandos: >> colormap(hot) >> pcolor([1:65;1:65]') donde la función pcolor permite visualizar por medio de colores la magnitud de los elementos de una matriz (en realidad representa colores de “celdas”, para lo que necesita que la matriz tenga una fila y columna más de las necesarias; ésa es la razón de que en el ejemplo anterior a la función pcolor se le pasen 65 filas y 2 columnas). Si se desea imprimir una figura en una impresora láser en blanco y negro, puede utilizarse el mapa de color gray. En el siguiente apartado se explica con más detalle el dibujo en "pseudocolor" (pcolor, abreviadamente). El comando colormap actúa sobre la figura activa, cambiando sus colores. Si no hay ninguna figura activa, sustituye al mapa de color anterior para las siguientes figuras que se vayan a dibujar. 6.4.6 IMÁGENES Y GRÁFICOS EN PSEUDOCOLOR. FUNCIÓN CAXIS

Cuando se desea dibujar una figura con un determinado mapa de colores se establece una correspondencia (o un

mapping) entre los valores de la función y los colores del mapa de colores. Esto hace que los valores pequeños se dibujen con los colores bajos del mapa, mientras que los valores grandes se dibujan con los colores altos. La función pcolor es -en cierta forma- equivalente a la función surf con el punto de vista situado perpendicularmente al dibujo. Un ejemplo interesante de uso de la función pcolor es el siguiente: se genera una matriz A de tamaño 100x100 con valores aleatorios entre 0 y 1. La función pcolor(A) dibuja en color los elementos de la matriz A, mientras que la función pcolor(inv(A)) dibuja los colores correspondientes a los elementos de la matriz inversa. Se puede observar que los colores de la matriz inversa son mucho más uniformes que los de la matriz original. Los comandos son los siguientes: >> A=rand(100,100); colormap(hot); pcolor(A); pause(5), pcolor(inv(A)); donde el comando pause(5) simplemente introduce un pausa de 5 seg en la ejecución. Al ejecutar todos los comandos en la misma línea es necesario poner pause pues si no dibuja directamente la inversa sin pasar por la matriz inicial. Si todavía se conservan las matrices Z y W que se han definido previamente, se pueden hacer algunas pruebas cambiando el mapa de colores. La función caxis permite ajustar manualmente la escala de colores. Su forma general es: caxis([cmin, cmax]) donde cmin y cmax son los valores numéricos a los que se desea ajustar el mínimo y el máximo valor de la escala de colores.



6.4.7 DIBUJO DE SUPERFICIES FACETEADAS

La función surf tiene diversas posibilidades referentes a la forma en que son representadas las facetas o polígonos coloreados. Las tres posibilidades son las siguientes: shading flat determina sombreado con color constante para cada polígono. Este sombreado se llama plano o flat. shading interp establece que el sombreado se calculará por interpolación de colores entre los vértices de cada faceta. Se llama también sombreado de Gouraud shading faceted consiste en sombreado constante con líneas negras superpuestas. Esta es la opción por defecto Edite el fichero picos.m de forma que aparezcan menos facetas y más grandes. Se puede probar con ese fichero, eliminando la función mesh, los distintos tipos de sombreado o shading que se acaban de citar. Para obtener el efecto deseado, basta poner la sentencia shading a continuación de la sentencia surf. 6.4.8 OTRAS FORMAS DE LAS FUNCIONES MESH Y SURF

Por defecto, las funciones mesh y surf atribuyen color a los bordes y facetas en función de los valores de la función, es decir en función de los valores de la matriz Z. Ésta no es sin embargo la única posibilidad. En las siguientes funciones, las dos matrices argumento Z y C tienen el mismo tamaño: mesh(Z,C) surf(Z,C) En las figuras resultantes, mientras se dibujan los valores de Z, los colores se obtienen de C. Un caso típico es aquél en el que se quiere que los colores dependan de la curvatura de la superficie (y no de su valor). MATLAB dispone de la función del2,

que aproxima la curvatura por diferencias finitas con el promedio de los 4 elementos contiguos, resultando así una matriz proporcional a la curvatura. Obsérvese el efecto de esta forma de la función surf en el siguiente ejemplo (si todavía se tiene la matriz Z formada a partir de test3d, utilícese. Si no se conserva, vuélvase a calcular): >> C=del2(Z); >> close, surf(Z,C) 6.4.9 FORMAS PARAMÉTRICAS DE LAS FUNCIONES MESH, SURF Y PCOLOR Existen unas formas más generales de las funciones mesh, surf y pcolor. Son las siguientes (se presentan principalmente con la funciones mesh y surf). La función: mesh(x,y,Z,C) dibuja una superficie cuyos puntos tienen como coordenadas (x(j), y(i), Z(i,j)) y como color C(i,j). Obsérvese que x varía con el índice de columnas e y con el de filas. Análogamente, la función: mesh(X,Y,Z,C) dibuja una superficie cuyos puntos tienen como coordenadas (X(i,j), Y(i,j), Z(i,j)) y como color C(i,j). Las cuatro matrices deben ser del mismo tamaño. Si todavía están disponibles las matrices calculadas con el fichero picos.m, ejecútese el siguiente comando y obsérvese que se obtiene el mismo resultado que anteriormente: >> close, surf(X,Y,Z), pause(5), mesh(X,Y,Z) ¿Cuál es la ventaja de estas nuevas formas de las funciones ya conocidas? La principal es que admiten más variedad en la forma de representar la cuadrícula en el plano (x-



y). La primera forma admite vectores x e y con puntos desigualmente espaciados, y la segunda admite conjuntos de puntos muy generales, incluso los provenientes de coordenadas cilíndricas y esféricas.

6.5 OTRAS FUNCIONES GRÁFICAS 3D Las siguientes funciones se derivan directamente de las anteriores, pero añaden algún pequeño detalle y/o funcionalidad:

• surfc combinación de surf, y contour en z=0

• meshz mesh con plano de referencia en el valor mínimo y una especie de “cortina” en los bordes del dominio de la función

• surfl para controlar la iluminación determinando la posición e intensidad de un foco de luz.

• light crea un foco de luz en los ejes actuales capaz de actuar sobre superficies 3-D. Se le deben pasar como argumentos el color, el estilo (luz local o en el infinito) y la posición. Son muy importantes las propiedades de los objetos iluminados patch y surface (AmbientStrength, DiffuseStrength, SpecularColorReflectance, SpecularExponent, SpecularStrength, VertexNormals, EdgeLighting, y FaceLighting), y de los ejes (AmbientLightColor). Se pueden probar estas funciones con los datos de que se dispone. Utilícese el help para ello.

ELEMENTOS GENERALES: EJES, PUNTOS DE VISTA, LÍNEAS OCULTAS, ...

Las funciones surf y mesh dibujan funciones tridimensionales en perspectiva. La localización del punto de vista o dirección de observación se puede hacer

mediante la función view, que tiene la siguiente forma: view(azimut, elev) donde azimut es el ángulo de rotación de un plano horizontal, medido sobre el eje z a partir del eje x en sentido antihorario, y elev es el ángulo de elevación respecto al plano (x-y). Ambos ángulos se miden en grados, y pueden tomar valores positivos y negativos (sus valores por defecto son -37.5 y 30). También se puede definir la dirección del punto de vista mediante las tres coordenadas cartesianas de un vector (sólo se tiene en cuenta la dirección): view([xd,yd,zd]) En los gráficos tridimensionales existen funciones para controlar los ejes, por ejemplo: axis([xmin,xmax,ymin,ymax,zmin,zmax]) También se pueden utilizar las funciones siguientes: xlabel, ylabel, zlabel, axis('auto'), axis(axis), etc. Las funciones mesh y surf disponen de un algoritmo de eliminación de líneas ocultas (los polígonos o facetas, no dejan ver las líneas que están detrás). El comando hidden activa y desactiva la eliminación de líneas ocultas. En el dibujo de funciones tridimensionales, a veces también son útiles los NaNs. Cuando una parte de los elementos de la matriz de valores Z son NaNs, esa parte de la superficie no se dibuja, permitiendo ver el resto de la superficie.



Unidad 7. Códigos de los problemas propuestos. Unidad 2. Prog2-6.- dis = input(‘Dame el valor de la distancia: ’); tiem = input(‘Dame el valor del tiempo: ’); vel = dis/tiem; fprintf(‘La velocidad es: %8.3f\n ‘ , vel); Prog2-7.- cm = input(‘Dame los centímetros: ’); mm = cm*10; fprintf(‘Los milímetros son: %3.3f \n ‘ , mm); Prog2-8.- b = input(‘Dame la base: ’); h = input(‘Dame la altura: ’); area = b*h/2; fprintf(‘El área es: %3.3f\n ‘ , area); Prog2-9.- gra = input(‘Dame los grados: ’); rad = gra*pi/180; fprintf(‘Los radianes son: %3.3f\n ‘ , rad); Prog2-10.- l = input(‘Dame el valor del lado: ’); a = input(‘Dame el valor del apotema: ’); area = 5*l*a; fprintf(‘El área es: %3.3f\n ‘ , area); Prog2-11.- dl = input(‘Dame los dólares a convertir: ’); val = input(‘Dame el valor de conversión: ’); ps = dl*val; fprintf(‘En pesos mexicanos es: %3.3f\n ‘ , ps);

Prog2-12.- r = input(‘Dame el valor del radio: ’); h = input(‘Dame el valor de la altura: ’); s = 2*pi*r*h; fprintf(‘La superficie lateral es: %3.3f\n ‘ , s);

Prog2-13.- m = input(‘Dame los metros a convertir: ’); km = m/1000; mi = m/1609.3; cm = m*100; in = m/0.0254; mm = m*1000; fprintf(‘Equivale a: %3.3f km\n ‘ , km); fprintf(‘Equivale a: %3.3f mi\n ‘ , mi); fprintf(‘Equivale a: %3.3f cm\n ‘ , cm); fprintf(‘Equivale a: %3.3f pulg\n ‘ , in); fprintf(‘Equivale a: %3.3f mm\n ‘ , mm); Prog3-1

a = input(‘Dame el primer valor’); b = input(‘Dame el segundo valor’); c = input(‘Dame el tercer valor’); if a < b x = a; a = b; b = x; end if a < c x = a; a = c; c = x; end if b < c x = b; b = c; c = x; end fprintf(‘ %3.3f %3.3f %3.3f ‘, a, b, c);

Prog3-2 a = input(‘Dame el primer valor’); b = input(‘Dame el segundo valor’); if a>b fprintf(‘El mayor es %3.3f \n’,a); else fprintf(‘El mayor es %3.3f \n’,b); end



Prog3-3 x = input(‘Dame el valor para sacar la raiz’); if x<0 fprintf(‘La raiz es: %3.3f i\n’, sqrt(-x) ); else fprintf(‘La raiz es: %3.3f \n’, sqrt(x) ); end Prog3-4 c1 = calificación 1 c2 = calificación 2 c3 = calificación 3 c1 = input(‘Dame la primer calificación’); c2 = input(‘Dame la segunda calificación’); c3 = input(‘Dame la tercera calificación’); p= (c1+c2+c3)/3; if p>7 fprintf(‘Aprobado’); else fprintf(‘Reprobado’); end Prog3-5 com = compra desc = descuento com = input(‘Dame el valor de la compra’); if com>1000 desc=0.2; else desc=0.0; end pago=com-com*desc fprintf(‘Debe pagar: %3.3f’,pago); Prog3-6.- m=input('dame un numero entre 1 y 12'); switch m case 1, fprintf('enero\n'); case 2, fprintf('febrero\n'); case 3, fprintf('marzo\n'); case 4, fprintf('abril\n'); case 5, fprintf('mayo\n'); case 6, fprintf('junio\n'); case 7, fprintf('julio\n'); case 8, fprintf('agosto\n'); case 9, fprintf('septiembre\n'); case 10, fprintf('octubre\n'); case 11, fprintf('noviembre\n'); case 12, fprintf('diciembre\n'); otherwise, fprintf('Error \n'); end

Prog3-7. num=input('dame un número entre 1 y 10'); switch num case 1, fprintf('I \n'); case 2, fprintf('II \n'); case 3, fprintf('III \n'); case 4, fprintf('IV \n'); case 5, fprintf('V \n'); case 6, fprintf('VI \n'); case 7, fprintf('VII \n'); case 8, fprintf('VIII \n'); case 9, fprintf('IX \n'); case 10, fprintf('X \n'); otherwise, fprintf('Número inválido\n'); end Prog3-8. num=input('dame un número entre 1 y 10'); switch num case 1, fprintf('uno \n'); case 2, fprintf('dos \n'); case 3, fprintf('tres \n'); case 4, fprintf('cuatro \n'); case 5, fprintf('cinco \n'); case 6, fprintf('seis \n'); case 7, fprintf('siete \n'); case 8, fprintf('ocho \n'); case 9, fprintf('nueve \n'); case 10, fprintf('diez \n'); otherwise, fprintf('Número inválido\n'); end Prog3-9 fprintf('\n1.- Area de un rectángulo\n'); fprintf('2.- Area de un cuadrado\n'); fprintf('3.- Area de un círculo\'); opcion=input('\nOpción deseada: '); switch opcion case 1, h=input('\ndame la altura: '); b=input('dame la base: '); a = b * h; fprintf('\nEl area es: %3.3f\n',a); case 2, l=input('\ndame el valor del lado: '); a = l * l; fprintf('\nEl area es: %3.3f\n',a); case 3, r=input('\ndame el valor del radio: '); a = pi * r ^2; fprintf('\nEl area es: %3.3f\n',a); otherwise, fprintf('\nNúmero inválido\n'); end



Prog3-10 aa=input('dame un numero: '); if aa/4==ceil(aa/4) if aa/100==ceil(aa/100) if aa/400==ceil(aa/400) fprintf('Si es bisiesto\n'); else fprintf('No es bisiesto\n'); end else fprintf('Si es bisiesto\n'); end else fprintf('No es bisiesto\n'); end Prog3-11 s = sueldo t = tiempo s = input('dame el sueldo: '); t = input('dame el tiempo laborado en años: '); if t < 1 u = s * 0.05; else if t < 2 u = s * 0.07; else if t< 5 u = s * 0.1; else if t < 10 u = s * 0.15; else u = s * 0.2; end end end end fprintf('utilidad: %3.3f\n',u); Prog3-12 clc;clear; for I=1:3 for K=1:4 if K<4 fprintf('\n Dame el valor del elemento A(%2i,%2i)= ',I,K); A(I,K)=input(''); else fprintf('\n Dame el valor de la constante de la ecuacion %2i, B(%2i,%2i)= ',I,I,K); B(I,1)=input(''); end

end end x=A\B; fprintf('\n El resultado es X= '); x Prog3-13 clc;clear; x1=0;x2=1;iter=1; lim=input('Dame el limite para desarrollar la serie de Fibonacci, Limite --> '); while (x1+x2)<=lim x3=x1+x2; fprintf('\n Los valores de la serie para la iteracion %3i es de %3i,%3i --> %3i',iter,x1,x2,x3); x1=x2;x2=x3; end Prog4-1 m=input(‘Dame el valor de m: ‘); n=input(‘Dame el valor de n: ‘); clear A; for k=1:1:m for l=1:1:n fprintf('Dame el valor de a(%1.0f,%1.0f)= ',k,l); A(k,l)=input(' '); end end Prog4-2.- clc fprintf('este programa permite sumar dos matrices de [m x n]\n\n'); fprintf('matriz A\n'); m=input('Dame el valor de las filas ( m ):'); n=input('Dame el valor de las columnas ( n ):'); clear A; for k=1:1:m for l=1:1:n fprintf('Dame el valor de a(%1.0f,%1.0f)= ',k,l); A(k,l)= input (' '); end end fprintf('\nmatriz B\n'); clear B; for k=1:1:m for l=1:1:n fprintf('Dame el valor de a(%1.0f,%1.0f)= ',k,l); B(k,l)= input (' '); end



end fprintf('\n'); disp(A); disp(B); c=A+B; isp(c); Prog4-3.- clc fprintf('este programa permite multiplicar dos matrices de [m x n] \n\n'); fprintf('matriz A\n'); m=input('Dame el valor de las filas ( m ): '); n=input('Dame el valor de las columnas ( n ): '); clear A; for k=1:1:m for l=1:1:n fprintf('Dame el valor de a(%1.0f,%1.0f)= ',k,l); A(k,l)= input (' '); end end fprintf('\nmatriz B\n'); m=input('Dame el valor de las filas ( m ): '); n=input('Dame el valor de las columnas ( n ): '); clear B; for k=1:1:m for l=1:1:n fprintf('Dame el valor de a(%1.0f,%1.0f)= ',k,l); B(k,l)= input (' '); end end ' ' disp(A); disp(B); c=A.*B; disp(c); Prog4-4.- clc fprintf('este programa permite elevar a la poencia " X " una matriz de [m x n]\n\n'); fprintf('matriz A\n'); m=input('Dame el valor de las filas ( m ):'); n=input('Dame el valor de las columnas ( n ):'); x=input('Dame la potencia que deseas elevar a la Matriz (x):'); fprintf('\n'); clear A; for k=1:1:m for l=1:1:n fprintf('Dame el valor de a(%1.0f,%1.0f)= ',k,l); A(k,l)= input (' '); end end

fprintf('\n'); disp(A); c=A.^x; disp(c); Prog4-5.- clc fprintf('este programa calcula la inversa de una matriz [m x n]\n\n'); fprintf('matriz A\n'); m=input('Dame el valor de las filas ( m ):'); n=input('Dame el valor de las columnas ( n ):'); fprintf('\n'); clear A; for k=1:1:m for l=1:1:n fprintf('Dame el valor de a(%1.0f,%1.0f)= ',k,l); A(k,l)= input (' '); end end fprintf('\n'); disp(A); if rank(A) == m fprintf('la inversa de la matriz: \n'); inv(A) else fprintf('La matriz no tiene inversa. \n'); end Prog.4-6- clc fprintf('este programa calcula el determinante de una matriz cuadrada \n\n'); fprintf('matriz A\n'); m=input('Dame el valor de las filas ( m ):'); n=input('Dame el valor de las columnas ( n ):'); if m == n fprintf('\n'); clear A; for k=1:1:m for l=1:1:n fprintf('Dame el valor de a(%1.0f,%1.0f)= ',k,l); A(k,l)= input (' '); end end fprintf('\n'); disp(A); fprintf('El determinante de la matriz es: \n'); det(A) else



fprintf('\n\nLa matriz no es cuadrada. \n'); end Prog4-7.- nom=input(‘Deme su nombre: ‘,’s’); for t=1:1:length(nom) fprintf('%c \n',nom(t)) end Prog4-8.- nom=input(‘Deme su nombre: ‘,’s’); for t=length(nom):-1:1 fprintf('%c ',nom(t)) end fprintf(‘\n’)

Prog4-9.- Elabore un programa que solicite el nombre de n personas, 100 máximo. Después imprima los nombres. Ojo hay que hacer este programa



Documents

Instituto Tecnológico de Tuxtla Gutiérrez · antecesores, a él se le atribuye las ... Es el corazón o cerebro de la computadora. Controla las operaciones de todo el equipo y consta