Fundamentos de computación(ICM) en octave
Upcoming SlideShare
Loading in...5
×
 

Fundamentos de computación(ICM) en octave

on

  • 3,330 views

 

Statistics

Views

Total Views
3,330
Views on SlideShare
3,330
Embed Views
0

Actions

Likes
0
Downloads
61
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as OpenOffice

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Fundamentos de computación(ICM) en octave Fundamentos de computación(ICM) en octave Presentation Transcript

    • Fundamentos de Computación (ICM) con GNU Octave
        Autor: Gabriel Romero Mora
        Comunidad de Software Libre
      • Introducción a Octave y Características
      • Condicionales
      • Lazos de Repetición
      • Acumuladores y Contadores
      • Aleatorios
      • Arreglos una dimensión
      • Arreglos de dos dimensiones o Matrices
      • Caracteres y Cadenas
      • Funciones
      • Condicionales Múltiples(switch)
      • Funciones Recursivas
      • Estructuras
      • Archivos
      Contenido
    • Introducción GNU Octave es un lenguaje de alto nivel destinado al cálculo numérico, tiene un interprete(consola) que resuelve dichos cálculos numéricos, además permite la ejecución de scripts realizados por el usuario. Posee el mismo lenguaje de programación que MATLAB(lenguaje M), esto permite una alta compatibilidad entre ellos. Es un software libre (cero costo) y esta disponible en diferentes plataformas como Linux, Windows y MacOsX.
      • Características generales
      • Provee mucha funcionalidad para trabajar con matrices.
      • La sintaxis es la misma utilizada en MATLAB.
      • No pasa valores por referencia solo por valor.
      • Es un lenguaje interpretado.
      • Se pueden crear scripts.
      • Soporta gran parte de las funciones de la biblioteca estándar de C .
    • Primeros pasos en Octave
        Vamos a empezar a interactuar con el interprete o consola, realizando una simple suma:
      ans ( answer ) es una variable interna del programa que guarda el valor de una operación. Resultado de la suma 4+2
    • Variables
        Las variables nos permiten dar nombre a los valores que nos interesa guardar y poder referirnos a ellos más tarde. Las variables en Octave no tienen tipo fijo , así que es posible almacenar distintos tipos de dato en la misma variable, estas variables pueden ir cambiando de tipo y valor a lo largo de la ejecución del programa.
      Tipo escalar(numérica) Tipo vector(arreglo) Tipo cadena de texto
      • Algunas reglas importantes:
      • Los nombres de las variables deben iniciar con una letra y deben ser nombres representativos.
      • Ej: total1, contador
      • Octave diferencia los nombres de variables en mayúsculas y minúsculas. Ej: var1, Var1 y VAR1
      • Las instrucciones deben terminar en punto y coma ; .
      • Los comentarios se colocan con % o # .
      • Ej: %esto es un comentario y # esto es otro comentario
    • Entrada y salida de datos
      • Función input()
      • Se utiliza para que el programa pida valores de entrada a variables mientras se ejecuta.
      • Sintaxis :
        • Para ingresar valores tipo numéricas
        • variable_numérica = input ( 'texto' );
        • Para ingresar cadenas de texto
        • variable_cadena = input ( 'texto','s' );
      • Ejemplo:
        • numero = input ( 'Ingrese un numero: ' );
        • cad = input ( 'Ingrese un texto: ', 's' );
    • Entrada y salida de datos
      • Funciónes disp() y fprintf()
      • Muestran datos de salida por pantalla.
      • Sintaxis :
      • disp ( nombre_variable o 'texto' );
      • fprintf muestran datos de salida formateados.
      • Sintaxis:
      • fprintf ( 'texto:%s numero:%dn' ,varCad,varNum);
      %s muestra contenido de variables tipo texto, %d muestra contenido de variables tipo numéricas y n hace un salto de línea(un enter) .
    • Rangos
      • Son argumentos tipo numéricos dedicados a contar.
      • Se usan en estructuras for.
      • Se pueden crear vectores filas.
      • Sintaxis:
      • valor_inicial : salto : valor_final
      • Si no se coloca un valor salto el valor por defecto será “1”.
        Ejemplos
      Rango con salto positivo Rango con salto negativo Rango sin salto
    • Operadores Lógicos Operador Descripción x < y x es menor que y. x <= y x es menor o igual que y. x == y x es igual que y. x > y x es mayor que y. x >= y x es mayor o igual que y. x ~= y x != y x <> y x no es igual a y.
    • Operador Descripción x & y Retorna 1 si “x” y “y” son verdaderos caso contrario retorna 0. x | y Retorna 0 si “x” y “y” son falsos caso contrario retorna 1. ~x !x Retorna el valor 0 si x vale 1 o 1 si x vale 0. Operadores Booleanos “ short-circuit&quot; Similar a los anteriores con la diferencia que solo basta con analizar el valor del primer elemento ( “x” ) para saber el resultado x && y Retorna 1 si “x” y “y” son verdaderos caso contrario retorna 0. x || y Retorna 0 si “x” y “y” son falsos caso contrario retorna 1. Operadores Booleanos
      • Condicionales Son instrucciones que ejecutan otras instrucciones de código, si se cumple una condición establecida.
      if condición Instrucciones; else Instrucciones; end if condición Instrucciones; end if condición1 Instrucciones; elseif condición2 Instrucciones; else Instrucciones; end Nota: Para cualquiera de las estructuras de control los paréntesis puede omitirse y el fin de la estructura (end) puede colocarse end[nombre de la estructura] ( endif, endfor, endwhile ).
      • Ejemplos:
      a=2; if a==2 disp('a vale 2'); end num= input('Ingrese un número: '); if mod(num,2)==0 disp('El número es par'); else disp('El número es impar'); end disp() Muestra un mensaje por pantalla. Condición por verdad.
    • for índice=rango Instrucciones; end while condición Instrucciones; end do Instrucciones; until condición Estructura for Estructura while Estructura do-until Estructura que repite sus instrucciones hasta llegar al fin del rango . Estructura que repite sus instrucciones mientras la condición sea verdadera . Estructura que repite sus instrucciones hasta que la condición sea falsa .
        Lazos de Repetición
        Son estructuras que permiten repetir instrucciones de código según una condición lógica.
      • Ejemplos: Estructuras que muestra la suma de los números de 1 al 5.
      suma=0; for i=1:5 suma=suma+i; end disp(suma); suma=0; i=1; while (i<=5) suma=suma+i; i=i+1; end disp(suma); i incrementa el valor de i en 1 La expresión i=1:5 indica que: i es la variable que inicia en 1 y termina en 5 con incrementos de 1, es un rango.
    • do x=0; valor=input('Ingrese un entero positivo: ','s'); if ( ~isletter(valor)) valor=str2num(valor); else disp('Error!, Ingreso un caracter o una cadena de caracteres'); x=1; end if(valor<0) disp('Error!, Ingrese un valor positivo'); end until (valor>0 & x==0) disp('Dato valido! , Ingreso Exitoso!'); Programa que valida si el ingreso es un número, caso contrario muestra un error! y se mantiene hasta que ingrese un número.
      • Contador
      • Se suele denominar contador cuando el incremento de la variable es de uno en uno.
      • Sintaxis:
      • variable = variable + 1;
      • Acumulador :
      • Variable cuyo valor se incrementa o decrementa en un valor fijo (en cada iteración de un bucle).
      • Sintaxis:
      Forma Normal Forma Abreviada (C-style) a=a+5 a+=5 a=a-5 a-=5 a=a*5 a*=5 a=a/5 a/=5
        Contadores y Acumuladores
      • Son números obtenidos al azar, es decir, que todo número tenga la misma probabilidad de ser elegido y que la elección de uno no dependa de la elección del otro. La función rand*(n) genera números aleatorios Sintaxis: min + fix( rand* ( max - min +1 ) ) ;
        Números Aleatorios
      • Ejemplo: Genere números 5 números de 7 al 20
      for i=1:5 aleatorio= 7 +fix(rand*( 20 - 7 +1)); disp(aleatorio); end Genera un número aleatorio entre 7 y 20. Muestra cada número aleatorio generado. Estructura for que se repite 5 veces generando en cada repetición un número aleatorio entre 7 y 20 y lo va mostrando con la función disp.
      • Son una agrupación de varios elementos del mismo tipo, también se los conoce como vectores o arrays.
      Contenido del bloque n del vector. El índice de un vector es un número único que se asigna a cada bloque o casilla del vector, el cual permite acceder a la información de dicho bloque. El tamaño de un vector es el número de bloques que lo conforman. La función length(Arreglo) permite conocer ese tamaño. Tamaño del vector(length).
        Arreglos de una dimensión
      1 n . . . . . 2 3 Indices del vector
      • Creación e inicialización de un arreglo de ceros:
        arreglo=[ ]; for i=1:n
          arreglo=[arreglo,0];
        end
        for i=1:n
          arreglo(i)=0;
        end
      Forma 1 Forma 2
        arreglo=zeros(1,n);
      Forma 3 Recordar que: A través del indice i del arreglo se puede acceder al contenido de uno de los bloques, arreglo(1) accede al contenido del bloque 1 que es 0. 0 0 0 0 0 0 n ... 1 2 3 i
        arreglo
      • Ejemplo : Cree un vector de tamaño n y almacene números aleatorios del 1 al 5 en el mismo y luego muéstrelo por pantalla. Solución 1 n=input('Ingrese tamaño del vector: '); for i=1:n
          aleatorio=1+fix(rand*(5)); % genera un nº aleatorio v(i)=aleatorio; % coloca el aleatorio en vector v
        end disp(vector); % muestra por pantalla
      • Solución 2 n=input('Ingrese tamaño del vector: '); v=[ ] % definimos el vector for i=1:n
          aleatorio=1+fix(rand*(5)); % genera # aleatorio v=[v,aleatorio] ; % coloca el aleatorio en vector v
        end disp(v); % muestra por pantalla el vector v
      • Existen dos tipos de vectores: Vector Fila
      • Vector Columna
      Se agrupan los elementos de forma vertical. Se lo define como: [a1 ; a2 ; a3 ; … ; an] Se agrupan los elementos de forma horizontal. Se lo define como: [a1 , a2 , a3 , …, an] o [a1 a2 a3 … an] Ejemplo: Ejemplo: 1 2 3 4 1 2 3 4
    • Arreglo de dos dimensiones o Matrices
        Es un conjunto de variables del mismo tipo cuyo acceso a sus elementos se realiza por índices.
      Fila Columna Matriz A(3,3)=5 5 1 2 3 4 5 6 1 2 3 4 5 6
      • Ejemplo:
      • Genere una matriz de tamaño n con números aleatorios desde 0 a n^2.
      • for i=1:n
        • for j=1:n
          • matriz (i,j)=fix(rand*(n^2));
        • end
      • end
      Indices que recorren cada casilla de la matriz. 1 2 3 . . . n 1 2 3 . . . n i j
          • matriz (i,j)
      6
      • Se define una matriz con valores de la siguiente forma: M=[3, 5, 7 ; 1, 2, 8] Ejemplo:
      1era fila 2da fila Operador que genera un salto
    • Direccionamiento de vectores y matrices a partir de vectores Los elementos de una matriz a pueden direccionarse a partir de los elementos de vectores: Supongamos que tenemos el vector A=[2, 5, 4, 6, 1] y queremos obtener los 3 últimos valores que lo conforman. La solución sería: A(3:5) donde 3:5 es un rango de indices(posiciones) del vector. Ejemplo:
    • FUNCIÓN DESCRIPCIÓN eye(n) Crea una matriz identidad cuadrada de tamaño n. ones(n) ó ones(m,n) Crea una matriz de 1's. zeros(n) ó zeros(m,n) Crea una matriz de 0's. rand(n) ó rand(m,n) Crea una matriz de aleatorios entre 0 y 1. magic(n) Crea una matriz de nxn donde las filas y columnas suman lo mismo.
        Funciones que generan vectores y matrices
      • Ejemplo:
      • Definimos un vector A y aplicamos varias de las funciones que generan vectores o matrices.
      • Operaciones con vectores y matrices
        Son similares a las operaciones con escalares pero se debe considerar las reglas que rigen sobre los vectores o matrices.
      OPERACI ÒN NOMBRE A+B Suma A-B Resta A*B Multiplicación A/B División A^B o A**B Potencia AB o A*inv(B) División (por der.) A' Transpuesta A*B' o dot(A,B) Producto escalar cross(A,B) Producto vectorial A'*B Producto cartesiano
      • Funciones básicas con vectores y matrices
      FUNCIÓN DESCRIPCIÓN det(A) Retorna el determinante. sum(A) Retorna la suma de los elementos de A prod(A) Retorna el producto de los elementos de A max(A) Retorna el elemento máximo de A. min(A) Retorna el elemento mínimo de A. trace(A) Retorna suma de los elementos de la diagonal p. conj(A) Retorna la conjugada de A. inv(A) o inverse(A) Retorna la inversa e A. size(A) Retorna el # de filas y columnas de A. length(A) Retorna la dimensión máxima de A. rows(A) Retorna el # de filas del vector A. columns(A) Retorna el # de columnas de A. sort(A) Ordena de menor a mayor los elementos de A.
      • Ejemplo:
      • Definimos un vector A y aplicamos algunas de las funciones previamente vistas.
    • Caracteres y Cadenas
      • Una cadena de caracteres es un vector que contiene letras.
      • Se las define entre comillas simples o dobles.
      • Ejemplos:
      • cadena='Kokoa'
      • cadena=“Software Libre”
      • Funciones importantes con cadena de caracteres.
      FUNCIÓN DESCRIPCIÓN int2str(n) o double2str(n) Convierte un número a caracter. ischar(a) Retorna 1 si el valor de a es un caracter. isletter(a) Retorna 1 si el valor de a es una letra. findstr(cad,c) Retorna un vector con las posiciones de c en la cadena cad . strcad(cad1,cad2,...,cadn) Retorna un vector con las cadenas cad1,cad2,...,cadn concatenadas(unidas). strcmp(cad1,cad2) Retorna 1 si las cadenas son iguales. strrep(cad,x,y) Remplaza el valor de y por el valor de x en la cadena cad . toupper(cad) Convierte a mayúscula el valor de cad. tolower(cad) Convierte a minúscula el valor de cad.
      • Ejemplos:
      • Conversión de un número a carácter y comparación de caracteres.
      • Conversión a mayúsculas y minúsculas.
      Se define una variable numero=2 Se lo convierte a caracter con int2str o double2str. Se compara carácter y '2'con strcmp. Resultado indicando que los argumentos '2' y caracter son iguales. Se define una variable cad='Kokoa' y se la transforma a mayúscula. Se define una variable cad='KOKOA' y se la transforma a minúscula.
    • Funciones function variable_retornada = nombre_funcion ( lista_argumentos ) cuerpo_de_función end Las funciones y scripts son el mecanismo que ofrece Octave para simplificar la escritura de programas o la carga de datos iniciales. Se pueden escribir directamente en la línea de comandos de Octave , o en archivos externos . En ese caso los scripts y las funciones se invocan exactamente igual que cualquier otra función predefinida de Octave. La única condición es que esos archivos se encuentren en un directorio dentro del path(ruta) de Octave. Formato de una función: function [var1,var2,vector,matriz] = nombre_funcion ( lista_argumentos ) cuerpo_de_función end Se pueden retornar mas de una variable e inclusive un vector o matriz de la siguiente manera:
      • Ejemplos:
      Función que retorna el cuadrado de un número. function resultado = cuadrado (numero) resultado=numero^2; end Función que retorna el cuadrado de un número. function [suma,resta] = cuadrado (a,b) suma=a+b; resta=a-b; end Recibe como argumento una variable numero , se la eleva al cuadrado y la variable resultado guarda y retorna ese valor. Recibe como argumentos una variable a y b se aplican las operaciones indicadas entre ellas y luego se las guarda en las variables suma y resta .
    • Función que retorna una matriz M de tamaño tam llena de algún carácter. function M = DibujaCuadrado (caracter,tam) for i=1:tam for j=1:tam M(i,j)=caracter; end end end Recibe como argumentos una variable llamada caracter y tam , luego de hacer operaciones con estas variables, se retorna una matriz M.
      • Condicionales Múltiples
      Es una estructura que se utiliza para seleccionar una de entre múltiples alternativas. Son útiles para ejecutar opciones de menú. switch (opción) case 1 Instrucciones1; case 2 Instrucciones2; case 3 Instrucciones3; ... case n Instruccionesn; otherwise Instrucciones; end switch (opción) case 'caracter1' Instrucciones1; case 'caracter2' Instrucciones2; case 'carácter3' Instrucciones3; ... case 'caractern' Instruccionesn; otherwise Instrucciones; end
      • Ejemplo: dia=input('Ingrese un numero de día de la semana: '); switch (dia)
          case 1
            disp('Es Lunes');
          case 2
            disp('Es Martes');
          case 3
            disp('Es Miercoles');
          case 4
            disp('Es Jueves');
          case 5
            disp('Es Viernes');
          otherwise
            disp('Otro día');
        end
      • Ejemplo: Elabore un menú que tenga las siguientes opciones: Menú del Juego a. Jugar b. Salir
        Solución: disp('Menu del Juego'); disp('a Jugar'); disp('b Salir'); opcion=input('Ingrese una opción: '); switch (opcion)
          case 'a'
            disp('Ha iniciado el Juego');
          case 'b'
            disp('Fin del Juego');
          otherwise
            disp('Opción no reconocida');
        end
    • Funciones Recursivas
        Una función recursiva es aquella que se llama a si misma.
    • function x=calculaExponente(x,n) if n==0 y=1; elseif n==1 y=x; else y=x* calculaExponente (x, n-1 ) ; endif x=y; end
        Ejemplo: Crear una función calculaExponente(x,n) donde x es la base y n es el exponente.
      Si el exponente es 0 resultado y=1. Si el exponente es 1 el resultado y=x(base). Si el exponente es diferente de 1 y 0, se llama a si misma y el resultado será x^n. El resultado es asignado a x que es la variable que retorna la función. x n =x n-1 ● x n-2 ... ● x 0
    • Estructuras(struct)
      • Una estructura es la agrupación de datos de tipo diferente bajo un mismo nombre.
      • Estos datos se llaman miembros (members) o campos (fields).
      • Una estructura es un nuevo tipo de dato, del que luego se pueden crear muchas variables.
      • Supongamos que auto sea una estructura y sus campos sean placa, color, marca y modelo.
      • Supongamos que persona sea una estructura y sus campos sean CI, nombres, apellidos y edad, país etc.
        Estructura Persona
        Estructura Auto
      Ejemplos de estructuras placa modelo marca color
      • Creación de una estructura: nombre = struct (' campo1 ', valor1 ,' campo2 ', valor2 ,...,' campon ', valorn );
      Nombre de la estructura Nombres de los campos(variables). Valores numéricos van sin comillas simples y los valores de tipo texto van con comillas simples. Nota : Los nombres de los campos van con comillas simples. Instrucción que crea la estructura
      • Ejemplos: Defina la estructura vehículo con los siguientes datos: placa, color, marca y modelo,año. vehiculo=struct(' placa ',' ',' color ',' ',' marca ',' ',' modelo ',' ',' anio ',0);
      • Defina la estructura hospitales dado su nombre, dirección, #empleados, tratamientos.
      • hospital=struct(' nombre ',' ',' dir ',' ',' nempleado ',0,' tratamiento ',' ');
      Nota: Al crear las estructuras por lo general, los campos númericos se los inicializan en 0 y los campos de tipo caracter se inicializan con ' ' .
      • Ejemplo: Ingresar y mostrar datos de una estructura Realice un programa que registre n vehículos(placa, color, marca, modelo año) y luego los muestre.
      disp('REGISTRO DE VEHICULOS'); vehiculo=struct(' placa ',' ',' color ',' ',' marca ',' ',' modelo ',' ',' anio ',0); n=input('Ingrese número de vehículos: '); for i=1:n fprintf('Vehículo #%dn',i); vehiculo(i).placa=input('Ingrese placa : ','s'); vehiculo(i).color=input('Ingrese color: ','s'); vehiculo(i).marca=input('Ingrese marca :','s'); vehiculo(i).modelo=input('Ingrese modelo :','s'); vehiculo(i).anio=input('Ingrese año: '); end Salida por pantalla
    • disp('LISTADO DE VEHICULOS'); fprintf('PlacatColortMarcatModelotAñon'); for i=1:n placa=vehiculo(i).placa; color=vehiculo(i).color; marca=vehiculo(i).marca; modelo=vehiculo(i).modelo; anio=vehiculo(i).anio; fprintf('%st%st%st%st%dn',placa,color,marca,modelo,anio); end Se almacena los valores de los campos en la posición del índice (i). Muestra los datos formateados Salida por pantalla
    • Archivos
      • Los archivos o ficheros permiten guardar datos de variables y a su vez cargarlos:
      • Se usan dos comandos básicos save y load .
      • Save: crea un archivo y guarda valores de variables en el mismo.
      • save 'nombre_archivo' variables
      • Load: carga datos de un archivo.
      • load 'nombre_archivo' variables
      • Ejemplo de estructuras con archivos Registre n empleados(nombre, apellido, edad, salario) de una empresa en un archivo. Solución : 1.- Desde la consola creamos el archivo con datos iniciales de una estructura llamada “ empleado “ y guardarlas en dicho archivo. empleado.nombre=' ' empleado.apellido=' ' empleado.edad=0 empleado.salario=0 save 'datosEmpleados' empleado
      • Ejemplo de estructuras con archivos 2.- Creamos un programa(programa.m) donde debemos cargar dicho archivo inicializado previamente.
      disp('Registro de Empleados'); load ' datosEmpleados ' empleado ; % se carga el archivo(estructura) n=input('Ingrese numero de empleados:'); k=length( empleado )+1; % nº de registros en el archivo más 1 for i=k:(k+n-1) fprintf('Empleado %dn',i);
        • empleado(i) .nombre=input('Ingrese nombre: ','s');
        • empleado(i) .apellido=input('Ingrese apellido: ','s');
        • empleado(i) .edad=input('Ingrese edad: ');
      empleado(i) .salario=input('Ingrese salario: '); end save ' datosEmpleados ' empleado ; %guarda los datos de la estructura en el archivo
      • Análisis de la solución:
      • El programa registra los datos después del último registro. Al crear el archivo este tiene un registro en “blanco”, si el usuario desea ingresar 5 registros por primera vez el programa registrará los 5 registros a partir de la siguiente linea del archivo y si luego desea ingresar 3 más el programa empezará a registrar después de los 5 registros es decir desde la 7ma línea.
      1er registro “ blanco” 6to registro k=length(empleado)+1 k k+3-1 datosEmpleado
      • Referencias bibliográficas
      • http://www.gnu.org/software/octave/
      • http://softlibre.unizar.es/manuales/aplicaciones/octave/manual_octave.pdf
      • http://softlibre.unizar.es/manuales/aplicaciones/octave/octave.pdf
      • http://ocw.uniovi.es/file.php/31/slidesOctave.pdf
      • http://pcmap.unizar.es/softpc/OctaveManual.pdf