TEMA 0: INTRODUCCIÓN

Conceptos básicos
- Informática: INFORmación autoMÁTICA
Tratamiento automático y racional de la información por medio de ordenadores.
- Información: conjunto de símbolos que representan hechos, objetos o ideas. Tipos:
- Datos: conjuntos de símbolos que representan una información en forma adecuada
para ser procesada.
- Instrucciones: indican al ordenador qué debe hacer y con qué datos.
- Ordenador: máquina que acepta datos de entrada, realiza operaciones aritméticas y
lógicas y obtiene datos de salida, bajo el control de un programa previamente almacenado.
Necesidad Hardware + Software (Ambos son necesarios para poder utilizar un ordenador).
- Programa: conjunto ordenado de sentencias que se dan a un ordenador indicando las
operaciones que se desea que realice.
- Tipos de sentencias:
- Instrucciones: representan una orden a ejecutar.
- Declarativas: proporcionan información sobre los datos.
Elementos de un sistema informático
- Hardware: conjunto de componentes físicos.
- Software: conjunto de programas ejecutables sobre el hardware junto con los documentos
y datos asociados a los mismos.
Hardware
- Esquema Von Neumann.
- Computadora Central:
- CPU (Procesador).
- Memoria principal.
- Periféricos.
Software
- Lenguaje de programación: lenguaje utilizado para la escritura de los programas.
- Elementos del lenguaje:
- Léxico o vocabulario: conjunto de símbolos constitutivos.
- Sintaxis o gramática: conjunto de reglas para la construcción de las sentencias
correctas.
- Semántica: conjunto de reglas que asocian significado a las construcciones
correctas del lenguaje.
- Traductor: Software que traduce programas escritos en un lenguaje de programación a
otro. Tipos:
- Compiladores: traducen globalmente un programa escrito en un determinado
lenguaje (fuente) y producen como salida el programa escrito en otro lenguaje (objeto).
- Intérpretes: traducen y ejecutan una a una las sentencias de un programa pero sin
generar un nuevo programa traducido.
Representación de la información
- Codificación en sistema binario {0, 1}
- Bit: unidad mínima de información. Representa la información correspondiente a si ha
ocurrido un suceso.
- Byte: cantidad mínima de información para representar un carácter. Se suele tomar 8 bits.
𝑛
- n bits permiten representar 2 datos diferentes.
TEMA 1: BASES DE DATOS. CONCEPTOS
Introducción
Los sistemas de bases de datos surgen a causa de los problemas que plantean los
sistemas de archivos.
Desde el punto de vista lógica (usuarios):
- Almacenan todos los datos en un solo lugar.
- Almacenan las definiciones de las relaciones entre los datos.
Desde el punto de vista físico:
- Los datos se almacenan en uno o varios discos y en uno o varios ficheros.
Acceso a datos:
- A través del sistema de gestión de bases de datos (SGBD).
- Se realiza mediante sentencias específicas.
- Una Base de Datos es un conjunto de datos almacenados entre los que existen relaciones
lógicas. Se diseña para satisfacer los requerimientos de información de una organización.
- La base de datos almacena:
- Los datos de la organización.
- Una descripción de dichos datos: metadatos.
- SGBD es una aplicación que:
- Permite a los usuarios definir, crear y mantener una BD mediante un lenguaje de
definición de datos.
- Permite insertar, actualizar, eliminar y consultar datos mediante un lenguaje de
manipulación de datos.
- Proporciona acceso controlado a la BD mediante:
- Sistema de seguridad
- Sistema de integridad
- Sistema de control de ocurrencia
- Sistemas de control de recuperación
- Diccionario de datos
Papeles en el entorno de bases de datos:
- Administrador:
- Hace el diseño físico e implementa la BD.
- Controla la seguridad y ocurrencia.
- Mantiene el sistema y las prestaciones
- Diseñadores:
- Hacen el diseño lógico de la BD.
- Programadores de Aplicaciones:
- Implementan los programas para los usuarios finales.
- Usuarios Finales:
- Clientes de la base de datos.
Ventajas de los SGBD:
- Hay menos datos redundantes.
- Se pueden evitar problemas de consistencia de datos.
- Flexibilidad en las búsquedas.
- Se puede extraer información adicional.
- Se pueden compartir.
- Se dispone de un estándar.
- Se mejora la seguridad en el acceso a la información.
 - Se facilita la concurrencia.
- Hay servicios de copia de seguridad y recuperación.
Modelos de Datos: Modelo Relacional
Un modelo de datos está formado por:
- Un conjunto de conceptos para definir la estructura de la base de datos:
- Datos.
- Relaciones entre los datos.
- Restricciones sobre datos y relaciones.
- Un conjunto de operaciones y para realizar consultas y actualizaciones de datos.
- Dependiendo de los tipos de conceptos que ofrecen para describir la estructura de la BD
los modelos de datos se clasifican en:
- Conceptuales: usan conceptos de alto nivel muy cercanos al usuario.
- Lógicos: usan conceptos que pueden ser entendidos por los usuarios finales, pero
están cerca de cómo se almacenan físicamente en el ordenador.
- Físicos: conceptos de bajo nivel que describen los detalles de cómo se almacena
la información en el ordenador. Suelen usarlos el personal informático.
- Cada SGBD soporta un modelo lógico, siendo el más común el Modelo Relacional.
- El Modelo Relacional es un modelo de datos lógico, basado en conceptos matemáticos.
- Propiedades de las relaciones:
- Cada relación tiene un nombre distinto.
- Los valores de los atributos son atómicos.
- Cada atributo tiene un nombre distinto en una relación.
- Los atributos no están ordenados.
- No hay tuplas duplicadas. (Tuplas: estructura de datos ligera que tiene un número
específico y una secuencia de valores)
- Las tuplas no están ordenadas.
- Dominio: Conjunto de valores que puede tomar un atributo.
- Claves Candidatas: Atributo o atributos que identifican de modo único las tuplas de una
relación. Características:
- Irreducibilidad.
- Unicidad.
- Clave Primaria: Clave candidata que se escoge para identificar las tuplas de una relación
de modo único.
Todas las relaciones tienen una única clave primaria asociada.
- Claves Externas o Ajenas (atributo/s que se refiere a un atributo/s de otra tabla. Los
atributos de la tabla que referencia deben ser la clave primaria en la tabla referenciada):
- Sus valores deben coincidir con los de la clave primaria de otra relación.
- Es la única forma de representar la relación entre diferentes tablas de datos.
- Valores Nulos:
- Son valores que pueden tomar los atributos.
- Significa que no sabemos qué valor tiene este campo.
- Forma parte del dominio del atributo.
- Reglas de Integridad: Restricciones que siempre se deben cumplir en una base de datos.
- Tipos principales:
- De Entidades: Ninguno de los atributos que componen la clave primaria puede ser
nulo.
- Referencial: Si en una relación hay una clave externa, sus valores deben ser
valores nulos o valores que existen en la clave primaria a la que hace referencia.
Diseño Bases de Datos
1. Descripción de la BD por parte del personal de la organización.
2. Construcción del esquema de información que se usa en la organización.
3. Descripción de alto nivel de la estructura de una BD, independientemente del SGBD que
se vaya a utilizar para manipularla.
4. Conversión del esquema conceptual en un esquema lógico.
5. Descripción de la estructura de una BD en términos de las estructuras de datos que
puede procesar un tipo de SGBD.
6. Proceso de creación del esquema físico a partir del esquema lógico.
7. Descripción de la implementación de la BD en memoria secundaria, para asegurar un
acceso eficiente a los datos.
Modelo Entidad Relación
- Es un Modelo Conceptual.
- Está formado por un conjunto de conceptos que permiten describir la realidad mediante un
conjunto de representaciones gráficas y lingüísticas.
- Existe un modelo E/R extendido que permite más expresividad que el modelo E/R inicial.
- Veremos los elementos básicos del modelo E/R y algunos del modelo E/R
extendido.
- Entidad: Cualquier concepto sobre el que se recoge información.
- Relación:
- Correspondencia o asociación entre dos o más entidades.
- Su nombre describe su función.
- Relación ternaria(1-N) o reflexiva(N-N).
- Cardinalidad o Grado de una Relación: Expresa el número de entidades a las que otra
entidad puede estar asociada en una relación (1-N)(N-N).
- Tipos:
- Relaciones 1:1. A cada ocurrencia de una entidad le corresponde una y sólo una
ocurrencia de la otra, y viceversa.
- Relaciones 1:N. A cada ocurrencia de la primera entidad le pueden corresponder
varias ocurrencias de la segunda, y a cada ocurrencia de la segunda le corresponde no más
de una ocurrencia de la primera.
- Relaciones N:N. A cada ocurrencia de la primera entidad le pueden corresponder
varias ocurrencias de la segunda, y viceversa.
- Atributo:
- Característica de interés o un hecho sobre una entidad o sobre una relación.
- Si el atributo es clave primaria, se señala rellenando el círculo, subrayando el
nombre o con un doble círculo.
- Entidad Débil:
- Es una entidad cuya existencia depende de otra entidad.
- Con sus atributos no tiene suficiente para formar clave primaria.
- Su clave primaria no suele ser suficiente para identificar los datos que representa.
- Suele ser una Relación 1:N o 1:1.
- Se representa con un rectángulo doble y con una flecha hacia la entidad fuerte de
la que depende.
- Especialización o estructuras ES-UN
- Un conjunto de entidades puede incluir subgrupos de entidades que se diferencian
de alguna forma de las otras entidades del conjunto.
- El proceso de designación de subgrupos dentro de un conjunto de entidades se
denomina especialización.
- Los atributos de la entidad raíz, también los tienen los de las entidades
especializadas.
- Además, cada entidad especializada puede tener sus propios atributos.
- La clave primaria está especificada en la entidad raíz.
- A tener en cuenta…. Eliminar las relaciones redundantes.
- A tener en cuenta…. cada relación tiene su propio significado.
Paso a Tablas (Modelos Relacional)
- Un esquema conceptual a través del diseño lógico es transformado en un esquema
lógico.
- El modelo relacional proporciona un esquema lógico que permite representar BD en
diferentes SGBD.
- La realización de este diseño lógico conlleva la ejecución de una serie de reglas.
- Entidades: Todas las entidades se convierten en tablas, con sus atributos y sus claves
primarias.
- Entidades débiles: Todas las entidades débiles se convierten en tablas, con sus atributos
y sus claves primarias.
- Se añade a la clave primaria de la entidad débil los atributos de la clave primaria de la
entidad fuerte de la que depende.
- Relaciones: Todas las relaciones se convierten en tablas, con sus atributos y sus claves
primarias en caso de que las tengan.
- Se añaden como atributos de esta tabla las claves primarias de las entidades que
relacionan.
- Claves Primarias en las Relaciones:
- Relaciones 1:1, la clave primaria será una de las claves primarias de las entidades
que relaciona.
- Relaciones 1:N, la clave primaria siempre será la correspondiente a la clave
primaria de la entidad cuya cardinalidad es la del N.
- Relaciones N:N, la clave primaria siempre será la correspondiente a la clave
primaria de la entidad cuya cardinalidad es la del N, es decir, todas.
- Especialización: Existen 3 modos de realizarlo:
- Opción 1. Se crea una relación por cada entidad. Cada entidad hija tendría la clave
primaria de la entidad raíz.
- Opción 2. Sólo se crea una relación por cada entidad hijo. Cada entidad hija tendrá
todos los atributos de la entidad padre que desaparece.
- Opción 3. Sólo se crea la relación de la entidad padre. El resto desaparece. Se
añaden los atributos de las entidades que desaparecen.
- Consejos para decidir qué opción escoger:
- Si la entidad raíz tiene un gran número de atributos, elegir la opción 1.
- Si las entidades hijas no tienen ningún atributo y no forman parte de ninguna
relación, elegir la opción 3. En este caso incluso se puede añadir un atributo que se llame
tipo en la relación de la entidad raíz.
- En el resto de los casos conviene usar la opción 2, a excepción de cuando la
entidad raíz forma parte de una relación, en cuyo caso elegir la opción 1.
- Reducción de Tablas
- Último paso para la obtención del esquema relacional.
- Asegura que las tablas que se obtienen son las mínimas necesarias.
- Mejora la eficiencia del sistema.
- La reducción de tablas implica que la información de una tabla eliminada debe ser
incluida en otra tabla. NUNCA se elimina una tabla directamente.
- Reducción de Tablas. Proceso:
1. Únicamente son susceptibles de ser eliminadas aquellas relaciones que provienen
de relaciones 1:1 y 1:N.
2. Una tabla se podrá eliminar siempre que se puedan incluir los atributos de dicha
relación en otra tabla sin alterar su sentido.
- Relaciones o Claves Ajenas.
- Una vez obtenidas las tablas de una BD, se pueden definir las relaciones entre sus
atributos.
- Recordamos que las relaciones o claves ajenas son aquellos atributos de una
relación cuyos datos proceden de la clave primaria de otra relación.

TEMA 2: TIPOS DE DATOS BÁSICO Y ESTRUCTURAS DE

CONTROL
Metodología de la programación
- El proceso de la programación es un proceso de resolución de problemas:
- Definición (¿Qué?)
- Análisis del programa.
- Desarrollo (¿Cómo?)
- Diseño (Algoritmo).
- Codificación a un lenguaje de programación (Programa).
- Pruebas: depuración, verificación y validación.
- Mantenimiento (Mejoras y correcciones)
-Mantenimiento.
Definición del problema
- Tener claro las entradas, salidas e intentar buscar relación entre ellas.
- Una buena definición es esencial para obtener una solución correcta.
Desarrollo
- Diseño: desarrollo de un algoritmo o conjunto finito de acciones para resolver un
problema.
- Codificación: expresar las acciones del algoritmo con un lenguaje de programación y así
obtenemos un programa.
- Pruebas: ejecutar el programa dándole valor a los datos de entrada para comprobar si
devuelve bien la salida.
Mantenimiento
- Necesidad de realizar correcciones a errores aparecidos cuando el software se está
utilizando.
- Necesidad de ampliar las funcionalidades del software.
- Necesidad de adaptación del software a nuevos entornos.
Características de los programas
- Legibilidad: programa fácil de leer y entender.
- Portabilidad:
- Algoritmo: fácil codificación en cualquier lenguaje.
- Programa: ejecución en cualquier sistema.
- Modificabilidad: facilidad para hacer correcciones y mejoras.
- Eficiencia: aprovechamiento de los recursos del ordenador.
- Modularidad: división en módulos con funciones bien definidas.
- Estructuración: se ha de cumplir con las reglas de la Programación Estructurada.
Estilo de programación
- Objetivo: hacer el algoritmo/programa más legible.
- Elementos de estilo:
- Uso de comentarios.
- Código autodocumentado.
- Código con formato.
- Uso de constantes.
Tipos de datos
- Tipos de datos permiten manejar la información de forma sencilla ignorando los detalles
de su representación interna.
- El tipo de dato determina:
- Conjunto de valores posibles.
- Conjunto de operaciones posibles.
Clasificación:
- Elementales o básicos: indivisibles.
- Predefinidos: Existen ya definidos en los lenguajes de programación: entero, real,
lógico, carácter.
- Definidos por el usuario: se ha de determinar el conjunto de valores y nombre de
dicho tipo.
- Estructurados (estructuras de datos) - agrupaciones lógicas de elementos:
- Según el tipo de los elementos: Homogéneas/Heterogéneas.
- Según su gestión en memoria: Estáticas/Dinámicas.
- Según acceso a los elementos individuales: por Nombre/por Posición/por Clave.
Tipo de dato entero
- Conjunto de valores: subconjunto de los número enteros centrado en 0.
- Operaciones:
- Aritméticas:
- Suma, Resta, Multiplicación.
- División entera (devuelve cociente de la división entera) (fix(x/y)).
- Módulo (devuelve el resto de la división entera) (mod(x, y)).
- Relacionales: <, >, <=, >=, ==, ~=
𝑛−1 𝑛−1
- Con n bits se pueden representar desde el - 2 hasta el 2 − 1.
- Problemas: desbordamiento (overflow).
Tipo de dato real
- Conjunto de valores: subconjunto de los números reales centrado en 0.
- Operaciones:
- Aritméticas:
- Suma, Resta, Multiplicación, División.
- Relacionales: <, >, <=, >=, ==, ~=
𝑒
- Representación: N=M*𝐵
- Problemas:
- Desbordamiento (overflow).
- Errores de redondeo.
Tipo de dato carácter
- Conjunto de valores: conjunto ordenado y finito de caracteres. Normalmente se utiliza el
conjunto de caracteres ASCII: ({‘a’, .., ‘z’, ‘A’, ..,’Z’, ‘0’, .., ‘9’, ‘¡’, ‘@’, …}).
- Operaciones:
- Operaciones de conversión a enteros y viceversa.
- Relacionales: <, >, <=, >=, ==, ~=
- Los valores se escriben entre comillas simples.
Tipo de dato lógico
- Conjunto valores: dos valores posibles {Verdad, Falso} (true 1 y fase 0)
- Operaciones:
- Relacionales: ==, ~=
- Operadores lógicos más importantes: && (Y), || (O), ~ (NO).
Estructura de datos array
- Agrupación de un número de elementos del mismo tipo.
- Es homogénea y de acceso por posición.
- Puede tener 1 o más dimensiones.
- El número de índices para acceder a uno de sus elementos coincide con la dimensión del
array.
- Se puede operar con arrays a nivel de sus elementos.
Arrays: acceso a sus elementos
- Array unidimensional (vector): <identificador> (índice)
- Array bidimensional (matriz): <identificador> (fila, columna)
Elementos de un programa
- Estructuras de control.
- Variables, constantes, valores constantes, expresiones:
- Variable:
- Identificador (nombre)
- Valor (puede ser cambiado)
- Constante:
- Identificador (nombre)
- Valor (no puede ser cambiado)
- Valor constante o literal:
- Valor (no puede ser cambiado)
- Expresión:
- Valor (resultado de evaluarla)
- Todos tienen un tipo de dato asociado. Existen lenguajes tipificados y no tipificados.
- El tipo de dato determina el conjunto de valores y el conjunto de operaciones.
- Declaración: proceso mediante el cual se define cuál va a ser el tipo de los elementos con
identificador.
- Inicialización: proceso mediante el cual se le asigna a los elementos con identificador un
valor inicial.
Elementos de un programa: Variables
- Objeto de datos que posee un valor conocido a través de un identificador.
- El valor que almacena es único pero se puede modificar por medio de las instrucciones del
programa.
- En lenguajes tipificados es necesario declararlas en el programa.
Elementos de un programa: Constantes
- Objeto de datos que posee un valor invariable conocido a través de un identificador.
- La declaración de una constante está implícita en su inicialización
Elementos de un programa: Valores Constantes
- Valores que aparecen explícitamente en el programa sin identificador.
Expresiones
- Combinaciones de variables, constantes, valores constantes, operadores, paréntesis y
llamadas a funciones.
- Su valor es el resultado de evaluarla de izquierda a derecha, teniendo en cuenta la
precedencia de operadores y paréntesis.
El tipo de una expresión es el tipo de su valor asociado.
Precedencia
- Los paréntesis tienen precedencia sobre los operadores. Se evalúan de dentro hacia
fuera.
Tipos de estructura de control
- Estructuras secuenciales: las instrucciones se ejecutan una a continuación de otra en el
orden en el que están escritas.
- Estructuras condicionales o de selección: permiten decidir qué conjuntos de
instrucciones ejecutar.
- Estructuras repetitivas o cíclicas: permiten que un conjunto de instrucciones se ejecute
varias veces.
Estructuras secuenciales: Asignación
- Permite cambiar el valor de una variable:
<identificador>=<expresión>;
- En lenguajes tipificados, el tipo de la variable tiene que ser compatible con el tipo del valor
que se le asigne.
- Se trata de una operación destructiva.
Estructuras secuenciales: Lectura/Entrada
- Permite asignar valores dados desde un dispositivo de entrada.
<identificador>=input(`texto’);
- Esta instrucción en Matlab permite mostrar un texto.
- En lenguajes tipificados, el tipo de la variable tiene que ser compatible con el tipo del valor
que se lea.
- Se trata de una operación destructiva.
- Ejemplo:
altura=input(‘Introduce la altura del rectángulo: ‘);
Estructuras secuenciales: Escritura/Salida
- Permite transferir resultados a un dispositivo de salida.
disp(expresión); disp(‘literal’);
- Ejemplos:
area=10.0;
disp (‘área’) %muestra en la pantalla área
disp (area) %muestra en la pantalla 10.0
disp (area*2) %muestra en la pantalla 20.0
% significa que a continuación hay un comentario.
Plantilla programa
%Programa Nombre
%Entradas: descripción, restricciones, ..
%Salidas: descripción
%Constantes <identificador>= valor
%Variables: <identificador>: tipo
%Instrucciones del Programa Principal
Estructuras Secuenciales: Ejemplo
Problema: Calcular el área de un rectángulo dadas las dimensiones de sus lados.
%Programa CalculoAreaRectangulo
%Entradas: el tamaño de los dos lados de un rectángulo, ambos>0
%Salidas: el área del rectángulo
%Variables: base, altura, area: REAL
base=input(‘Introduce el tamaño del primer lado: ‘);
altura=input(‘Introduce el tamaño del segundo lado: ‘);
area=base*altura;
disp (‘El área es ‘); disp (area);
Estructuras Condicionales o de Selección: Simple
- Permitir decidir entre dos caminos diferentes de ejecución (SI lógico ENTONCES B1 SI NO
B2).
if (expresión lógica)
<Bloque instrucciones 1>
else
<Bloque instrucciones 2>
end
- La parte que se ejecuta si la expresión lógica es falsa es opcional ( SI lógico ENTONCES
B1).
if (expresión lógica)
<Bloque instrucciones>
end
Problema: Mostrar el resultado de dividir dos datos dados de entrada.
%Programa División
%Entradas: el dividendo y el divisor
%Salidas: resultado en la división
%Variables: dividendo, divisor, resultado: REAL
dividendo=input(‘Introduce dividendo: ‘);
divisor=input(‘Introduce divisor: ‘);
if divisor ~=0
resultado=dividendo/divisor;
disp (‘El resultado es ‘);
disp (resultado);
else
disp (‘No se puede dividir entre 0’);
end

- Condiciones anidadas
% Mayor de tres números diferentes
if a > b
if a > c
disp('El mayor es '), disp(a);
else
disp('El mayor es '), disp(c);
end
else
if b > c
disp('El mayor es '), disp(b);
else
disp('El mayor es '), disp(c);
end
end
- Condiciones compuestas
% Mayor de tres números diferentes
if (a>b) && (a>c)
disp('El mayor es '), disp(a);
end
if (b>a) && (b>c)
disp('El mayor es '), disp(b);
end
if (c>a) && (c>b)
disp('El mayor es '), disp(c);
end
Estructuras Condicionales o de Selección: Múltiple
- Permite decidir entre varios caminos diferentes de ejecución (EN CASO DE QUE).
switch (expresión)
case <literal 1>
<Bloque 1>
case <literal 2>
<Bloque 2>
….
case {<literal n>, <literal n>,… }
<Bloque n>
otherwise
<Bloque por defecto>
end
% La parte otherwise es opcional
Problema: Dado un número del 1 al 7 mostrar con qué día de la semana se corresponde.
%Programa DiasSemana
%Entradas: la posición de un día de la semana
%Salidas: el nombre del día de la semana asociado con la posición de entrada
%Variables: digito: ENTERO
digito=input (‘Introduce el número de día de la semana: ‘);
switch (digito)
case 1
disp (‘Lunes’);
case 2
disp (‘Martes’);
….
case 7
disp (‘Domingo’);
otherwise
disp(‘Dígito no válido’);
end
Estructuras Repetitivas
- Permiten ejecutar repetidamente un conjunto de instrucciones.
- El número de ejecuciones lo determina el valor de una variable conocida como variable
control.
- Tipos:
- Ciclos contados (PARA): el número de ejecuciones se establece al construir el
ciclo.
- Ciclos condicionales (MIENTRAS): el número de ejecuciones depende de un valor
de tipo lógico.
- Las estructuras repetitivas se pueden anidar de forma que en el cuerpo de un ciclo puede
aparecer otro.
- La estructura interna debe estar completamente dentro de la estructura externa, no
pudiendo existir solapamientos.
- En ciclos anidados no se puede utilizar la misma variable de control.
Estructuras Repetitivas: Ciclo Fijo o Contado
suma1=0;
for i=1:10
suma1=suma1+1;
end
disp(suma1); %escribe 10
suma2=0;
for i=[1, 9, 4, 6]
suma2=suma2+i;
end
disp(suma2); %escribe 20
Problema: Dado un número n de nota calcular la nota media.
%Programa NotaMedia
%Entradas: el número de notas y la secuencia de valores de dichas notas
%Salidas: la nota media
%Variables: n, i: ENTERO; nota, media: REAL
media=0.0;
n=input (‘Introduce el número de notas: ‘);
for x=1:n
nota=input (‘Introduce la nota: ‘);
media=media + nota;
end
media=media/n;
disp(‘La nota media es ‘), disp(media);
Estructuras Repetitivas: Ciclo Condicional (MIENTRAS)
suma=0;
i=1; //inicialización
while (i<=10)
suma =suma+1;
i=i+1; //modificación
end
disp(suma);
Problema: Calcular la nota media de una serie de notas, se termina al pulsar -1.
%Programa NotaMedia
%Entradas: una secuencia de notas
%Salidas: la nota media
%Variables: i:ENTERO; nota, media:REAL
i=0;
media=0.0;
nota=input (‘Introduce una nota, -1 para terminar: ‘);
while (nota ~=-1)
media=media+nota;
i=i+1;
nota=input (‘Introduce una nota, -1 para terminar: ‘);
end
media=media/i;
disp(‘La nota media es ‘), disp(media);
Utilización de Arrays
- Array unidimensional (vector):
- Inicialización/Declaración:
A=[1,9,2,8,3]
- Acceso a los elementos:
<identificador>(índice)
A(3)=2
disp(a(4)) %muestra el 8
- Array bidimensional (matriz):
- Inicialización/Declaración (separar con ; para las filas):
B=[1,13,9,15,5;11,2,14,4,6;10,12,3,7,8]
- Acceso a los elementos:
<identificador>(fila,columna)
B(2,3) es 14 disp(B1,4)) B(:,4)(devuelve la columna 4) B(1,2:3)(devuelve [B(1,2)B(1,3)])
- Acceso secuencial:
B(4) es 13
- Formas de crear arrays:
- Especificando los valores manualmente: v[1,2,3]
- Utilizando otros arrays: m=[v,v] quedaría m=[1,2,3,1,2,3]
- Especificando el incremento: x=a[:h]:b, ej. x=1:2:10 queda x=[1,3,5,7,9]
- Especificando su dimensión n:linspace(a,b[,n]), ej. y=linspace(1,36,12) crea un
vector desde 1 a 36, de 12 elementos.
- length(v): función que devuelve la dimensión de un vector.
- size(M): función que devuelve las dimensiones de una matriz.
- El uso de estructuras cíclicas nos permite el acceso a cada elemento de los arrays.
- La estructura cíclica ideal para recorrer los diferentes elementos del array es el ciclo for,
dado que en la mayoría de las situaciones las dimensiones se saben a priori.
for i=1:5
A(i)=0
end
- Si queremos escribir por pantalla todos los valores de esta matriz.
for i=1:3
for j=1:5
disp (A(i,j))
end
end
Problema: Calcular la nota media de una serie de notas almacenadas en un array.
%Programa NotaMedia
%Entradas: Array con diez números reales
%Salidas: la nota media
%Variables: Notas: ARRAY(10) de REALES, media:REAL, i:ENTERO
for i=1:10
notas(i)=input(‘Introduce nota: ‘);
end
media=0.0;
for i=1:10
media=media+notas(i);
end
media=media/10;
disp(‘La nota media es ‘), disp(media);
Arrays en Matlab
- El entorno Matlab posee una gran potencialidad en el manejo de arrays. Por tanto, no
siempre es necesario trabajar elemento a elemento. Ejemplos:
- Crear un array vacío x=[] #también elimina elementos
- Operación para inicializar un array a ceros: x=zeros(tamfilas,tamcolumnas)
- Operación para inicializar un array con números aleatorios:
y=rand(tamfilas,tamcolumnas)
- Crear una matriz identidad: z=eye(tamfilas,tamcolumnas)
- Crear una matriz traspuesta: t=z’
- Operaciones para sumar, restar, multiplicar, dividir o hacer la potencia de un array con
valores escalares: w=y*12, z/pi, y.^4 (eleva cada elemento de y a 4), 4.^v (4 elevado a
cada elemento de v)
- Los arrays también pueden operar entre ellos usando cualquiera de los operadores ya
conocidos. Ejemplos:
- Suma: sum(v), sum(M) es sum(M,1), suma(M,2)
- Producto: prod(v)
- Producto escalar: dot(v,w)
- Media:mean(v)
- Valor máximo de las componentes de un vector (y es el elemento y k indica la
posición): [y,k]=max(v)
- Igual con el valor mínimo: [y,k]=min(v)
- Diagonal de la matriz: diag(M)
- Cambio de dimensiones: reshape(v,nf,nc);
TEMA 3: PROGRAMACIÓN MODULAR
Definición
- Programación modular: consiste en dividir un algoritmo en unidades de menor tamaño→
cada una realiza una tarea explícita y única.
- Cada fragmento se denomina función, módulo, subalgoritmo, subrutina o subprograma.
- Ventajas:
- Simplicidad: permite descomponer un problema en otros más simples.
- Reutilización: cada módulo se identifica mediante un nombre, lo que permite
utilizarlo siempre que se quiera.
- Generalidad: se pueden parametrizar.
- La Programación Modular consiste en dividir un problema en subproblemas más pequeños
que se resuelven con módulos.
- Un módulo o función realiza una tarea concreta y es deseable que se diseñe, implemente
y depure de manera independiente al resto del código.
- Mediante la combinación de las soluciones parciales se debe obtener la solución global.
Parámetros
- Parámetros: permiten la comunicación entre un módulo y otro.
- Pueden ser de Entrada y/o Salida:
- Entrada: valores que son proporcionados al módulo.
- Salida: son valores que se calculan en el módulo y que se devuelven al que lo ha
invocado.
- Según el comportamiento, hay módulos que:
- Devuelven la salida asociada a su nombre.
- Devuelven las salidas en parámetros.
- Tipos de parámetros:
- Reales o actuales: valores que se pasan al módulo.
- Formales: los que aparecen en la declaración del módulo y contendrán los valores
de los parámetros actuales cuando se invoca al módulo.
- Cuando se utiliza un módulo los parámetros actuales deben coincidir en número, orden y
tipo con los parámetros formales que aparecen en la declaración o diseño del módulo.
- Tipo de paso de parámetros:
- Valor o copia: se utilizan para proporcionar información a un módulo. Los cambios
realizados no son visibles fuera.
- Variable o referencia: se utilizan tanto para recibir como para transmitir valores, de
manera que los cambios que se hagan serán visibles desde fuera. Se indican de alguna
forma, por ejemplo con una palabra reservada (var) o algún símbolo (&).
Sintaxis
function parámetros-salida=nombre(parámetros-entrada)
%Descripción: qué hace la función
%Parámetros de entrad:
% identificador y descripción
%Parámetros de salida:
% identificador y descripción
%Variables (internas):
% identificador:tipo
%Instrucciones del cuerpo de la función

- Un módulo consta de:

- Una cabecera que comienza con la palabra reservada function y donde se
especifican:
- Parámetros de salida. Si hay más de uno hay que ponerlos entre [] y
separados por comas.
- Signo=
- Nombre del módulo
- Entre paréntesis los Parámetros de entrada. Si hay más de uno hay que
separarlos con comas.
- Texto de ayuda. Es opcional, aunque muy recomendable.
 - El cuerpo del módulo:
- Contiene las sentencias necesarias para calcular los valores que se van a
devolver.
- Utiliza los parámetros de entrada del módulo, así como aquellas variables
auxiliares que se precisen para realizar dichos cálculos.
- Asigna valores a los parámetros de salida (¡Obligatorio!)
Ojo: las variables que no sean parámetros son locales a la función
Nombre de un módulo
- Deben empezar por una letra.
- A continuación pueden ir más letras, dígitos o el carácter de subrayado (guión bajo).
- No puede contener ni espacios en blanco, ni vocales acentuadas, ni caracteres especiales.
- Lo correcto es denominar al archivo que contiene el módulo, con el mismo nombre del
mismo, seguido de la extensión .m.
- Un archivo puede incluir varios módulos. Sólo el primero es accesible desde el exterior
mientras que el resto de módulos del fichero son internos, es decir utilizables únicamente
por los módulos presentes en el archivo.
- Si un conjunto de módulos van a ser utilizados sólo por un módulo principal, sí que los
podemos juntar en el mismo archivo.
Primeros ejemplos
- Ejemplos con varios argumentos de entrada o salida:
function [x,y]=fejemplo(a,b,c)
%Descripción: calcula la suma y producto de tres valores
%Parámetros de entrada: a, b, c:REAL
%Parámetros de salida: x, y: REAL
x=a+b+c;
y=a*b*c;

- Un módulo puede no devolver nada y/o no tener parámetros de entrada. Ejemplo:

function info
%Descripción: muestra información sobre la precisión de la máquina
%Parámetros de entrad: Ninguno
%Parámetros de salida: Ninguno
disp (‘precisión de la máquina: ‘);
disp (eps); %Épsilon de la máquina. Ej. 2.2204e-016
disp (‘mayor numero real’);
disp(realmax); %Real más grande de la máquina. Ej: 1.7977e+308
disp (‘menor numero real’);
disp(realmin); %Real más pequeño de la máquina. Ej: 2.2251e-308
Llamada a un módulo
- Podemos llamar a un módulo desde:
- la línea de órdenes.
- dentro de otro módulo.
- Observa que los parámetros de entrada y salida no tienen por qué tener el mismo nombre
que en la definición de la función
- Escribimos todos los parámetros de entrada entre paréntesis y todos los parámetros de
salida entre corchetes, siempre en el orden correspondiente: >>[v,w]=fejemplo(a,b,c)
- Las variables de un módulo son locales, de modo que, aunque en el módulo se modifiquen
los parámetros de entrada, el valor de dichas variables queda inalterado en el entorno
principal.
- La forma de realizar la llamada sería así:
>>[z1, z2]=fejemplo(4,2,3)
z1=9
z2=24
- Mientras que si ponemos:
>>z=fejemplo (4,2,3)
z=9→sólo recuperamos el primer valor
Ámbitos de las variables
- Globales: conocidas en todos los módulos. No se recomienda su uso.
- Locales: específicas de un módulo.
Errores típicos
- Los parámetros formales de un módulo sólo están definidos durante la ejecución del
mismo. Si los usamos fuera, se producirá un error.
- Evitar redefinir módulos ya definidos.
- No se pueden pasar nombres de módulos como parámetros.
Ejemplo 1
Problema: Diseñar un módulo que calcule el área de un rectángulo.
function a=calculoArea(lado1,lado2)
%Descripción: calcula el área de un rectángulo
%Parámetros de entrada: lado1, lado2: REAL, representan la medida de los lados de un
rectángulo; lado1>0 y lado2>0.
%Parámetros de salida: a:REAL, el área del rectángulo
a=lado1*lado2;
Problema(cont.). Llamada desde el algoritmo principal.
base=input(‘Introduce el tamaño del primer lado: ‘);
altura=input(‘Introduce el tamaño del segundo lado: ‘);
area=calculoArea(base,altura);
disp(‘El área es ‘), disp(area);

TEMA 4: GESTIÓN DE ARCHIVOS

Definición
- Concepto de Archivo: Un archivo (o fichero) es la unidad lógica de almacenamiento en
un dispositivo de memoria secundaria.
- Cualquier conjunto de datos almacenado en un dispositivo de almacenamiento secundario,
independientemente de la información que represente, está agrupado en una estructura de
datos llamada archivo.
- En los sistemas operativos modernos, un archivo se estructura como una secuencia de
bytes.
Ventajas e inconvenientes del uso de archivos
- Ventajas:
- Persistencia de los datos. La memoria principal de un programa se libera tras su
terminación (es volátil). Para poder mantener la información de ejecución de un programa
hay que guardarla en archivos. Así podemos recuperar los datos en posteriores ejecuciones
 - Capacidad de almacenamiento superior. El espacio de direcciones de memoria
de un programa es limitado. Si los datos no caben en memoria principal se pueden guardar
en archivos.
- Inconvenientes:
- Lentitud de acceso a memoria secundaria. Los datos se tienen que buscar y
además se tienen que trasladar a memoria principal para poder procesarse.
Tipos de Archivos
- En función del tipo de información que contienen, los archivos se suelen clasificar en dos
categorías:
- De texto: las secuencias de bytes que lo forman sólo representan caracteres ASCII
lebigles (.txt, .m, etc.).
- Binarios: las secuencias de bytes que lo forman deben ser interpretadas según la
representación utilizada durante su almacenamiento (.exe, .jpg, etc.).
El descriptor de archivo
- El acceso a archivos se hace a través de una estructura intermedia gestionada por el
sistema operativo denominada manejador de archivo.
- Para acceder a un archivo desde un lenguaje de programación, el sistema operativo crea
un manejador de archivo y éste se asocia a una variable que será el descriptor o
identificador de archivo.
- Todo archivo tiene asociado un buffer (zona de memoria principal) para realizar las
operaciones de E/S de forma más rápida.
- La escritura no se realiza directamente sobre el dispositivo de almacenamiento, sino que
se escribe en el buffer.
- El espacio en memoria principal se reserva automáticamente cuando se realiza la apertura
del archivo y se inicializa el descriptor de archivo.
Órdenes save y load
- Al finalizar la sesión de Matlab se borran todas las variables definidas hasta ese momento.
- En ocasiones puede resultar interesante interrumpir el trabajo con Matlab y poderlo
recuperar más tarde en el mismo punto en el que se dejó.
- Mediante las órdenes save y load es posible recuperar los valores de algunas o todas las
variables definidas en una sesión.
- Guardar variables: orden save.
- Sintaxis: save [nombre_archivo][var1 var2 …][;]
- Se crea un archivo binario con la extensión .mat en el que se almacenan los valores de
var1, var2, junto con sus nombres, etc.
- Si no se especifica el nombre del archivo, por defecto se crea el archivo binario
matlab.mat
- Si no se especifica el nombre de ninguna variable, se guardan todas las variables
definidas en la sesión actual.
- Esta sintaxis es más apropiada para la línea de órdenes.
Funciones save y load
- Más general y permite que el nombre del fichero esté en una variable al igual que los
nombres de las variables.
- Sintaxis: save(nombre_archivo, var1, var2, …)[;]
nombreArch=input(‘Introduce nombre el archivo: ‘, ‘s’);
save(nombreArch)
- También se puede dar el nombre del archivo directamente como literal y el de las variables
a=6; save(‘prueba’, ‘a’)
- Para almacenar en formato texto
save(‘prueba.txt’, ‘a’, ‘-ascii’)
- Añadir nuevas variables a un fichero existente con ‘-append’
Órdenes save y load
- Recuperar variables: orden load.
- Sintaxis: load[nombre_archivo][var1 var2 …][;]
- Se cargan en la sesión actual los valores almacenados en el archivo especificado.
- Si no se especifica el nombre del archivo, por defecto se toman los datos de matlab.mat
- Esta sintaxis es más para la línea de órdenes.
- Utilizada como función, load permite parámetros de entrada y devolver los valores en la
variable elegida.
- Sintaxis: load(nombre_archivo)[;] %igual que antes
- load() %se cargan las variables y los datos de matlab.mat
- load(‘prueba.txt’) %carga los datos del fichero prueba.txt en la variable prueba
- load(‘matlab.mat’, ‘a’) %carga la variable a y su valor
- Sintaxis: variable=load(nombre_archivo)[;] %elige la variable
datos=load(‘prueba.txt’) %almacena en la variable datos los valores almacenados en
prueba.txt
Ejemplos de save y load
- Definimos en Matlab las siguientes variables V y M:
>>V=[1 2 3 4 ]
V=
1234
>>M=[V’ V’ V’]
M=
111
222
333
444
>>
- Guardar en el archivo valores.mat:
>>save valores V M;
- >>load valores asignará a las variables V y M los valores almacenados en el archivo
valores.mat
- load también permite leer vectores o matrices a partir de archivos de texto.
Otras operaciones con archivos
- El manejo de archivos desde Matlab consiste, al igual que en cualquier otro lenguaje de
programación, en sustituir los dispositivos habituales de Entrada (teclado) y Salida (monitor)
por archivos.
- Los programas leerán los datos de entrada desde un archivo, en lugar de desde el teclado,
y escribirán los resultados en otro(s) archivo(s) en lugar de hacerlo en la pantalla.
- Apertura de un archivo. Función fopen.
- Sintaxis:
- id_arch=fopen(‘nombre.dat’, ‘modo_apertura’);
- Abre el archivo nombre.dat y devuelve id_arch, que es el descriptor o identificador
del archivo.
- Si no hay ningún problema en la apertura, id_arch tomará un valor entero mayor
que 2.
- Si ocurre algún tipo de error id_arch valdrá -1.
Modos de apertura del archivo
- ‘w’. Apertura del archivo para escritura. Los datos se escriben desde el principio. Si el
archivo no existe, se crea.
- ‘w+’. Apertura del archivo para lectura y escritura. Los datos se escriben desde el
principio. Si el archivo no existe se crea.
- ‘r’. Apertura para lectura. El archivo debe existir.
- ‘r+’. Apertura del archivo para lectura y escritura. Los datos se escriben desde el
principio y el archivo debe existir.
- ‘a’. Apertura para añadir información al final del archivo. Si el archivo no existe, se crea.
- ‘a+’. Apertura para lectura y para añadir información al final del archivo. Si el archivo no
existe, se crea.
- NOTA: si se va a trabajar con un archivo binario, se le añade una b a estas cadenas: ‘wb’,
‘rb+’, etc.
- Cierre de un archivo. Función fclose.
- Sintaxis:
- estado=fclose(id_arch);
- Cierra el archivo especificado por id_arch.
- Devuelve 0 si la operación tiene éxito y -1 si no lo tiene.
- fclose(‘all’) cierra todos los archivos abiertos.
- NOTA: es importante cerrar los archivos cuando ya no se vayan a utilizar más.
- Tras ejecutar fclose ya no tiene sentido utilizar más el descriptor de archivo.
- Ejemplo
mi_archivo=fopen(‘prueba.dat’, ‘w’);
if(mi_archivo== -1)
disp (‘Error en la apertura’);
else
disp(‘Apertura correcta’);
%Instrucciones a realizar con el archivo
fclose(mi_archivo);
end
- Operaciones con archivos de texto:
- Escritura en un archivo de texto. Función fprintf:
- Escribe datos con formato en un archivo.
- Sintaxis:
- res=fprintf([id_arch], ‘tipo_formato’, expr1, expr2, …);
- Escribe en el archivo identificado por id_arch las expresiones expr1, expr2, etc, que
serán del formato especificado en tipo_formato.
- res es un entero que será el número de bytes que se han escrito.
- Si se omite id_arch se escribe en la salida estándar: pantalla.
- Valores de tipo_formato: ‘%d’ para enteros; ‘%f’, ‘%e’ o ‘%g’ para reales, ‘%c’ para
caracteres; ‘%s’ para cadenas de caracteres; ‘\n’; ‘\t’
Función que escribe un vector en un fichero. Todo en una fila
function exito= EscribeVector2(nombreFichero, v)
% FUNCION exito= EscribeVector2 (nombreFichero, v)
% DESCRIPCIÓN: Escribe en una línea de un fichero los datos de un vector separados por
espacios
% PARÁMETROS DE ENTRADA: -nombreFichero: el nombre del fichero de texto
% -v: el vector
% PARÁMETROS DE SALIDA: -exito: valor lógico indicando si se guardaron los datos
fid= fopen(nombreFichero, 'w');
if(fid~= -1)
for ind= 1:length(v)
fprintf(fid, '%f', v(ind));
if ind~= length(v)
fprintf(fid, ' ');
else
fprintf(fid, '\n');
end
end
exito= true; fclose(fid);
else
exito= false;
end
- Lectura de un archivo de texto. Función fscanf:
- Lee datos formateados en un archivo.
- Sintaxis:
- [var, leidos]=fscanf ([id_arch], ‘tipo_formato’, [tam]);
- Lee los datos del archivo id_arch, los convierte según el formato especificado en
tipo_formato y los devuelve en var.
- leidos es un ENTERO que será el número de elementos que se han leído.
- Valores de tipo_formato: los mismos que para fprintf.
- tam puede ser:
- n: lee n elementos en un vector columna.
- inf: lee hasta el final del archivo (opción por defecto).
- [nf, nc]: lee los elementos necesarios para llenar una matriz nf*nc, se
guarda por columnas. Solamente se puede poner inf en nc.