INTELIGENCIA ARTIFICAL

TRABAJO PRACTICO N°1

Alumno: José Antonio Santillán

   INTELIGENCIA ARTIFICAL
Oscar Alejandro Rios
 1. Investigación de funciones. Para las funciones dadas a continuación, buscarlas, interpretarlas
y escribir un resumen de su actividad.

a) input() b) gtext() c) nargin() d) isvarname() e) fprintf()

f) error() g) warning() h) pause() i) break() j) switch()

a) input (): Solicita información al usuario

Sintaxis
user_entry = input (' prompt')
user_entry = input (' prompt', 's')

Descripción
La respuesta a la solicitud input puede ser cualquier expresión de MATLAB, que se evalúa utilizando las
variables en el espacio de trabajo actual.

user_entry = input('prompt') aparece prompt como un mensaje en la pantalla, espera la entrada desde el

teclado y devuelve el valor introducido user_entry.

user_entry = input('prompt', 's') devuelve la cadena ingresada como una variable de texto en lugar de como un
nombre de variable o valor numérico.

Observaciones
● Si se presiona la tecla Retorno sin ingresar nada, input devuelve una matriz vacía.
● La cadena de texto del mensaje puede contener uno o más '\n'caracteres. Los '\n'medios para pasar a
la siguiente línea. Esto permite que la cadena de mensajes abarque varias líneas. Para mostrar solo una
barra invertida, use '\\'.
● Si ingresa una expresión no válida en el indicador, MATLAB muestra el mensaje de error relevante y
luego le solicita nuevamente que ingrese la entrada.
Ejemplo
Presionar Retorno para seleccionar un valor predeterminado detectando una matriz vacía:

>> respuesta = entrada ('¿Queres más? S / N [Y]:', 's');

si está vacío (responder)
respuesta = 'Y';
final

b) gtext(): Colocación del texto con el mouse en la vista bidimensional

Sintaxis

gtext (' string')

gtext ({'cadena1', 'cadena2', 'cadena3', ...})
gtext ({'cadena1'; 'cadena2'; 'cadena3'; ...})
h = gtext (...)

Descripción
gtext muestra una cadena de texto en la ventana de la figura actual después de seleccionar una ubicación con
el mouse.

gtext('string') espera a que se presione un botón del mouse o una tecla del teclado mientras el puntero está
dentro de una ventana de figura. Al presionar un botón del mouse o cualquier tecla se coloca 'string' en la
parcela en la ubicación seleccionada.

gtext({'string1','string2','string3',...}) coloca todas las cadenas con un clic, cada una en una línea separada.
 gtext({'string1';'string2';'string3';...}) coloca una cadena por clic, en la secuencia especificada.

h = gtext(...) devuelve el identificador a un objeto de gráficos de texto que se coloca en el gráfico en la

ubicación que se seleccione.

Ejemplo
Coloca una etiqueta en el gráfico actual:
gtext (¡ 'Note esta divergencia! ')

c) nargin (): Número de argumentos de entrada de función

Sintaxis
nargin: devuelve el número de argumentos de entrada de la función dados en la llamada a la función que se
está ejecutando actualmente. Se utiliza esta sintaxis en el cuerpo de una función únicamente. Cuando se usa
un argumento bloque de validación, el valor devuelto por nargin dentro de una función es el número de
argumentos posicionales proporcionados cuando se llama a la función. 

nargin(fun)devuelve el número de argumentos de entrada que aparecen en la fun definición de la función. Si la

función incluye varargin en su definición, nargind evuelve el negativo del número de entradas. Por ejemplo, si
la función fun declara entradas a, varargin, a continuación, nargin('myFun')vuelve -3.
Si el argumento de entrada se refiere a una función que usa un arguments bloque de validación, entonces el
valor devuelto es el número de argumentos posicionales declarados en la definición de la función como un
valor no negativo.

Argumentos de entrada
Fun-Funcion
Funcion| vector de caracteres|escalar

d) isvarname(): Determina si la entrada es un nombre de variable válido

Sintaxis
tf = isvarname ('str')
isvarname str
Descripción
tf = isvarname 'str' devuelve lógico 1( true) si la cadena str es un nombre de variable MATLAB válido y
lógico 0( false) en caso contrario. Un nombre de variable válido es una cadena de caracteres de letras, dígitos y
guiones bajos, que suman no más de namelengthmax caracteres y comienzan con una letra.
isvarname str utiliza el formato de comando MATLAB.

Ejemplos
Este nombre de variable es válido:
isvarname foo
ans = 1
Este no es porque comience con un número:
isvarname 8th_column
ans = 0
 Si está construyendo cadenas de varias piezas, la construcción se coloca entre paréntesis.
d = fecha;

isvarname (['Monday_', d (1: 2)])

ans =
1
e) fprintf: Escribir datos en un archivo de texto

Sintaxis
fprintf(fileID,formatSpec,A1,...,An) aplica formatSpec a todos los elementos de arrays A1,...An en orden de
columna y escribe los datos en un archivo de texto. 
fprintf utiliza el esquema de codificación especificado en la llamada a fopen.

Ejemplos
fprintf(formatSpec,A1,...,An) da formato a los datos y muestra los resultados en la pantalla.
nbytes = fprintf(___) devuelve el número de bytes que escribe fprintf utilizando cualquiera de los argumentos
de entrada de las sintaxis anteriores.

Argumentos de entrada
fileID — Identificador de archivo
formatSpec — Formato de los campos de salida
Formato de los campos de salida, especificados mediante operadores de formato. formatSpec también puede
incluir texto normal y caracteres especiales.

Argumentos de salida
nbytes — Número de bytes escalar
Número de bytes que escribe fprintf, devueltos como escalar. Al escribir en un archivo, nbytes está
determinado por la codificación de caracteres. Al imprimir datos en la pantalla,  nbytes es el número de
caracteres que se muestra en la pantalla.
Ejemplo
Convierte explícitamente valores de precisión doble con fracciones a valores enteros.
a = [1.02 3.04 5.06];
fprintf('%d\n',round(a));
1
3
5

f) error(): lanza error y muestra mensaje

Sintaxis
error(msg) arroja un error y muestra un mensaje de error.
error(msg,A1,...,An) muestra un mensaje de error que contiene caracteres de conversión de formato, como los
que se utilizan con la función sprintf . Cada carácter de conversión de msgse convierte en uno de los
valores A1,...,An.
error(errID,___) incluye un identificador de error en la excepción. El identificador le permite distinguir errores y
controlar lo que sucede cuando MATLAB encuentra los errores. Puede incluir cualquiera de los argumentos de
entrada en las sintaxis anteriores.

Ejemplos
error(errorStruct) arroja un error al utilizar los campos en una estructura escalar.
 ejemplo
error(correction,___) proporciona una solución sugerida para la excepción. Puede incluir cualquiera de los
argumentos de entrada en las sintaxis anteriores.

Argumentos de entrada
o msg- Información sobre el vector de caracteres de error | escalar de cadena

Informa sobre el error, especificado como vector de caracteres o escalar de cadena.  Este mensaje se
muestra como mensaje de error. Para formatear el mensaje, use secuencias de escape, como \to \
n. También puede utilizar cualquier especificador de formato compatible con la sprintffunción,
como %so %d. Especifique valores para los especificadores de conversión mediante los A1,...,An
argumentos de entrada. 
o errID- Identificador del vector de caracteres de error | escalar de cadena

Identificador del error, especificado como vector de caracteres o escalar de cadena. Se utiliza el
identificador de error para ayudar a identificar la fuente del error o para controlar un subconjunto
seleccionado de los errores en su programa.
El identificador de error incluye uno o más campos de componentes y un campo mnemónico. Los campos
deben separarse con dos puntos. 
o A1,...,An- Vector de caracteres de valores | escalar de cadena | escalar numérico

Valores que reemplazan los especificadores de conversión en msg, especificados como vector de
caracteres, escalar de cadena o escalar numérico.
o errorStruct- Estructura escalar de información de informes de errores

Información de informe de errores, especificada como una estructura escalar. La estructura debe contener
al menos uno de estos campos: message, identifier, stack.
g) Warning: Mostrar mensaje de advertencia
Sintaxis
warning(msg) muestra el mensaje de advertencia y establece el estado de advertencia para
la lastwarn función. Si msg está vacío, warningr establece el estado de advertencia de lastwarn, pero no
muestra ningún texto.
warning(msg,A1,...,An) muestra un mensaje que contiene caracteres de conversión de formato, como los que
se utilizan con la función sprintf . Cada carácter de conversión de msg se convierte en uno de los
valores A1,...,An.
warning(warnID,___) adjunta un identificador de advertencia al mensaje de advertencia. Puede incluir
cualquiera de los argumentos de entrada en las sintaxis anteriores. El identificador le permite distinguir las
advertencias y controlar lo que sucede cuando MATLAB encuentra las advertencias.

Ejemplo:
warning(state) habilita, deshabilita o muestra el estado de todas las advertencias.
warning(state,warnID) actúa sobre el estado de una advertencia específica.
warning muestra el estado de todas las advertencias. Es equivalente a warning('query').
warnStruct = warning devuelve una estructura o matriz de estructuras que contiene información sobre qué
advertencias están habilitadas y deshabilitadas. warnStruct incluye un campo identificador con
una warnIDo 'all', y un campo state que indica el estado de la advertencia correspondiente.
 warning(warnStruct) configura los valores actuales de advertencia como se indica en la matriz de
estructura, warnStruct.

Agumentos de entrada
● msg- Información sobre la causa del vector de caracteres de advertencia | escalar de cadena

● warnID- Identificador del vector de caracteres de advertencia | escalar de cadena | |

● state- Indicador de control de advertencia

'on'| 'off'|'query'

● warnStruct- Estructura de configuración de advertencias | variedad de estructuras

● mode- Configuración de visualización de seguimiento de pila y verbosidad.

h) Pause(): Detener la ejecución de MATLAB temporalmente
Sintaxis
pause(n) detiene la ejecución durante unos n segundos antes de continuar. La pausa debe estar habilitada para
que esta llamada surta efecto.
Ejemplos
pause(state) habilita, deshabilita o muestra la configuración de pausa actual.

oldState = pause(state) devuelve la configuración de pausa actual y establece el estado de pausa indicado
por state. Por ejemplo, si está habilitada la pausa, oldState = pause('off')vuelve 'on' en oldStatey desactiva la
pausa.
Argumentos de entrada
● n- Número de segundos no negativos, número real

● state- Configuración de pausa 'on'| 'off'|'query'

i) Break(): Terminar la ejecución del bucle for o while, finaliza la ejecución de un bucle for o while. Las
declaraciones en el bucle después de break la declaración no se ejecutan.
En los bucles anidados, break sale solo del bucle en el que ocurre. El control pasa a la declaración que sigue
a end ese ciclo.

Sintaxis
break

j) Switch(): Ejecuta uno de varios grupos de declaraciones

Sintaxis
Interruptor switch_expression
case
casocase_expression
statementscase_expression
statements
...
 de otra manera
statements
final
Descripción
switch switch_expression, case case_expression, end evalúa una expresión y elige ejecutar uno de varios
grupos de declaraciones. Cada elección es un caso.
El switch bloque prueba cada caso hasta que una de las expresiones del caso sea verdadera.  Un caso es cierto
cuando:
● Para los números, .case_expression == switch_expression
● Para los vectores de caracteres, .strcmp(case_expression,switch_expression) == 1
● Para objetos que apoyan la función ,. La salida de la función sobrecargada debe ser un valor lógico o
convertible en un valor lógico. case_expression == switch_expressioneq
● Para una matriz de celdas case_expression, al menos uno de los elementos de la matriz de celdas
coincide switch_expression, como se definió anteriormente para números, vectores de caracteres y
objetos.
Cuando una expresión caso es cierto, MATLAB ejecuta las instrucciones correspondientes y se sale del
bloque switch.
Un evaluado switch_expressio ndebe ser un vector escalar o de caracteres. Un evaluado case_expression
debe ser un escalar, un vector de caracteres o una matriz de celdas de escalares o vectores de caracteres.
El otherwise es opcional. MATLAB ejecuta las declaraciones solo cuando ningún caso es verdadero.
● A case_expression no puede incluir operadores relacionales como <o >para compararlos
con switch_expression. Para probar la desigualdad, use if, elseif, else declaraciones.

2. Trabajo con vectores y matrices

a) Crear 3 vectores filas de 10 elementos cada uno; VEC1 de valores enteros positivos menores
que 20; VEC2 de valores enteros negativos mayores que (-20) y VEC3 con valores crecientes
entre [-1 ; 1]. Extraer los tres primeros elementos del primer vector, los tres últimos del
segundo vector y los tres elementos centrales del tercer vector y con todos ellos formar un
nuevo vector. Mostrar la secuencia de comandos aplicada en cada caso y los resultados.
LA IDEA DE ESTO EJERCICIOS ERA UTILIZAR LOS COMANDOS PARA EL MANEJO DE MATRICES
Y NO DESARROLLAR UNA FUNCION O SCRIPT.
for i=1:1
for j=1:10
VEC1(i,j)= fix (randi ([0 20],1,1));
VEC2(i,j)= fix (randi ([-20 0],1,1));
VEC3(i,j)= (rand());
end
end
k=1;
l=4;
for i=1:1
for j=1:10
if (j>0 && j<4)
VEC4(i,j)= VEC1(i,j);
elseif k<4
VEC4(i,j)= VEC2(i,11-k);
k=k+1;
end
if (j>6 && j<10)
VEC4(i,j)= VEC3(i,l);
l=l+1; end
end end
 b) Generar un vector fila de 32 posiciones cubiertas con bits. Luego, tomar grupos de 4 bits, en orden
desde la izquierda, convertirlos a decimal considerando que son números binarios sin signo, y
acomodarlos en un vector columna de 8 filas. Mostrar la secuencia de comandos aplicada en cada
caso y los resultados.

result = [dec1,dec2,dec3,dec4,dec5,dec6,dec7,dec8]'
 result 8x1

5
4
4
15
6
9
13
0
---------------------------------------------------corregido
for j=1:32
aleat= fix (randi ([0 2],1,1));
if (aleat==2)
VE(1,j)= aleat/2;
else
VE(1,j)= aleat;
end
end
p=0; i=1;
g=0; h=1;
for o=1+p:32
s=0;
for j=1:4
if( VE(o,j)==1)
switch (j)
case (1)
s=s+8;
case (2)
s=s+4;
case (3)
s=s+2;
case (4)
s=s+1;
end
end
end
p=p+4;
VE2(h,g+1)=s; End

c) Crear una matriz A4x3, con elementos aleatorios enteros en el intervalo [-64 ; 64]. Buscar la
función específica que realiza tal tarea y reordenar en orden creciente de izquierda a
derecha y de arriba hacia abajo. De la matriz A anterior, crear un vector columna con el
promedio aritmético de cada fila; y un vector fila con el promedio geométrico de cada
columna. Buscar si hay funciones específicas para ello. Mostrar la secuencia de comandos
aplicada en cada caso y los resultados.
LA MATRIZ DEBE QUEDAR ORDENADA EN FORMA CRECIENTE DE IZQUIERDA A DERECHA Y DE
ARRIBA HACIA ABAJO

------------------------------------corregido
for i=1 :4
for j=1:3
A(i,j)= fix (randi ([-64 64],1,1));
end
end
vec=[0,0,0,0,0,0,0,0,0,0,0,0];
c=1;
for i=1 :4
for j=1:3
vec(c)=A(i,j);
c=c+1;
end
 end
band=false;
while (~band)
band=true;
for i=1:11
if (vec(i)<vec(i+1))
aux= vec(i);
vec(i)=vec(i+1);
vec(i+1)= aux;
band=false;
end
end
end
c=1;
for i=1 :4
for j=1:3
B(j,i)=vec(c);
c=c+1;
end
end
i=1;
for h=1: 3
b=1;
vet1(h,1)=(B(i,b)+B(i,b+1)+B(i,b+2)+B(i,b+3))/4;
i=i+1;
end
i=1;
for h=1: 4
b=1;
vet2(1,h)=nthroot((B(b,i)+B(b+1,i)+B(b+2,i)),3);
i=i+1;
end

d) Matriz B de 20x20 de valores enteros positivos. Extraer una matriz B1(3x8) desde la posición
(5,5); matriz B2 que resulte de la eliminación de las columnas 11 a 14 y las filas 9 a 13 de A y
matriz A3 donde su primera y segunda diagonal se hayan intercambiado. Mostrar la
secuencia de comandos aplicada en cada caso y los resultados.

>> B=randi([1,400],20,20);
>> Baux=B(5:end,5:end);
>> B1=Baux([1:3],[1:8]);
>> B2=B;
>> B2(:,11:14)=[];
>> A=randi([-64,64],4,3);
>> B2=B;
 >> B2(:,11:14)=[];
>> B2=B;
>> B2(:,11:14)=[];
>> B2(9:13,:)=[];
>> A(4,:)=[];
>> A1=A;
>> DIAGONAL_CRUZADA=rot90(A1);

e) Generar una matriz de 4X5, cuya primera fila esté compuesta por los elementos del 1 al 15
con incrementos de 3. La segunda fila con los números desde el 5 al 1, la tercera fila con 5
valores desde 10 al 90 que solo sean decenas con unidades en cero y la cuarta fila con
valores primos enteros menores que 100. Todos estos requerimientos deben ser generados
con una o más funciones específicas para cada caso.
NO SE PIDE PROGRAMAR SCRIPT O FUNCIONES, CON ESCRIBIR ESTOS SIMPLES
COMANDO YA SE OBTIENE LO SOLICITADO:

LOS COMANDOS POR SEPARADO SERÍAN:

PARA LA 1º FILA: >> [1:3:15];
PARA LA 2º FILA: >> [5:-1:1];
……
PARA GENERAR LOS VALORES PRIMOS USAR EL COMANDO PRIMES(100) QUE
GENERA LOS PRIMEROS 100 NROS PRIMOS Y LUEGO EXTRAER SOLO 5 PRIMOS

--------corregido
i=1;
s=1;
w=0;
n=0;
p=5;

for i=1:4
for j=1:5
 if (i==1)
s=s+w;
A(i,j)=s;
s=s+3;
end

if (i==2)
A(i,j)=p;
p=p-1;
end
if (i==3)
cor=0;
while (cor~=1)
aleatorio= fix (randi ([10 90],1,1));
if mod(aleatorio,10)==0

A(i,j)=aleatorio;
cor=1;
end
end
end
if (i==4)
band=0;
while (band~=1)
a=0;
aleatorio2= fix (randi ([1 99],1,1));
for y=1:aleatorio2

if mod(aleatorio2,y)==0
a=a+1;
end
end
if (a==2)
A(i,j)=aleatorio2;
band=1;
end
end
end

end
end

3. Series. Generar las series que se indican:

a) Generar una serie de 33 números aleatorios enteros de 3 cifras, en el intervalo [100;200].
r = randi([100 200],1,33)
b) Generar una serie S1 en el intervalo [0 ; 2π] con un intervalo de π/3.3 (usar el operador
‘:’). Generar una serie S2 en el mismo intervalo que contenga 7 elementos (usar la
función linspace). Comparar ambas series y explicar sus diferencias.
 b) S1 = (0:pi/3.3:2.*pi)
S1 =
0 0.9520 1.9040 2.8560 3.8080 4.7600 5.7120
S2= linspace(0,2.*pi,7)
S2 =
0 1.0472 2.0944 3.1416 4.1888 5.2360 6.2832
• Las dos series tienen 7 elementos.
• Varía el incremento, en una es de pi/3.3, mientras que en la otra el incremento es de
1.0472.
c) Explicar cuál es el problema al intentar generar las siguientes series:
>> [10 : -2 : 25]<┘ >> [-5 : 11 : 9] >> [42 : 2.5 : 23]

 En el primer caso, el primer elemento es mayor que el segundo elemento y el incremento

es negativo, la serie no podrá ser desarrollada. Devuelve una matriz vacía.
 En el segundo caso la serie se genera sin inconvenientes.
• En el tercer caso, el primer valor es mayor que el segundo valor, el incremento es
negativo, no podrá ser desarrollada la serie. Devuelve una matriz vacía.
4.Funciones en la línea de comando. Detectar e indicar cuál es el problema que ocurre al
intentar escribir en Matlab las siguientes funciones, solucionarlo y escribirlas
adecuadamente:
a) >> P1 = a * x^2 + b * x + c
b) >> F(A,B,C) = 3 + 9^2 + pi
c) >> a=5; b=21; x=[4 5 6]; f1 = a*x+b*x^2
d) >> m=ones(2); n=magic(2); x=[7 8 9]; g1=m^2*x+x^*n
e) ¿para qué sirve el operador ‘.’ y el operador ‘;’?

a) >> P1 = a * x^2 + b * x + c
Undefined function or variables.
Faltan los argumentos de los argumentos a, b, c, x de la ecuación cuadrática, para que pueda resolver la
ecuación.

SOLUCION
Ejemplo

P1 = [3 -2 -4];
r = roots(P1)

b) >> F(A,B,C) = 3 + 9^2 + pi

Undefined function or variable 'A'.
No se encuentran definidas las variables A, B, C.

SOLUCION
>> [F] = suma (3,9.^2,pi)
F=
87.1416

function [F] = suma(a1,b1,c1)

A = a1;
B = b1;
C = c1;
F=A+B+C;
End

c) >> a=5; CORRECTO

b=21; CORRECTO
x=[4 5 6]; CORRECTO

f1 = a*x+b*x^2
Error using ^
Inputs must be a scalar and a square matrix.
To compute elementwise POWER, use POWER (.^) instead.
 SOLUCION
F1 = a*x+b*x.^2
el termino independiente = 0.

d) >> m=ones(2); CORRECTO

n=magic(2); CORRECTO
x=[7 8 9]; CORRECTO

g1=m^2*x+x.^n
Error: Unexpected MATLAB operator. Además las dimensiones de las matrices no cumplen para realizar una
multiplicación. Se podría eliminar un elemento de X para igualar dimensiones.

SOLUCION
X = [7 8]
Acomodando conectores en 1er termino:
g1=x*(m^2)
g1 = 30 30
Acomodando conectores en 2do termino:
g2=x^*n
Error: Unexpected MATLAB operator.
Suprimimos la potencia porque son incompatibles, y dejamos la multiplicacion.
g2 = x*n
g2 =
39 37
g3 = x*(m^2) + x*n
g3 =
69 67

e) ¿para qué sirve el operador ‘.’ y el operador ‘;’?

Nombre: punto
Usos:
Separador decimal. Operaciones elemento por elemento
Acceso a campos de estructura
Especificador de método o propiedad de objeto
Descripción: este carácter de punto separa las partes integral y fraccional de un número, como 3.1415. Los
operadores de MATLAB que contienen un punto siempre actúan elemento por elemento. El carácter de
punto también le permite acceder a los campos de una estructura, además de a las propiedades y los
métodos de un objeto.
Ejemplos
Separador decimal:
102.5543
Operaciones elemento por elemento:
A.*B
A.^2
Acceso a campos de estructura:
 myStruct.f1
Especificador de propiedad de objeto:
myObj.PropertyName

Nombre: punto y coma

Usos:
Representar el final de una fila
Suprimir la salida de una línea de código
Descripción: utilice puntos y comas para separar las filas en un comando de creación de un arreglo o para
suprimir la representación de la salida de una línea de código.
Ejemplos
Separe filas para crear un arreglo:
A = [12,13; 14,15]
Suprima la salida del código:
Y = max(A);
Separe varios comandos en una única línea (se suprime la salida):
A = 12.5; B = 42.7, C = 1.25;
B=
42.7000
5. Cambio de escala (reescalado).
a) Considerando la gráfica adjunta, escribir sus ecuaciones. Con
ellas, generar una secuencia de 40 puntos para cada eje.
Reescalar la secuencia de ordenadas (y) al intervalo (0,1). Graficar
las secuencias (original y reescalada) sobre el mismo sistema de
ejes.
Y 2−Y 1 4−0
1ER SEGMENTO M = = = 4/3
X 2−X 1 3−0
4
Y= X
3

2DO SEGMENTO DEL 2DO EJE

Y 2−Y 1 4−0
M= = = -4
X 2−X 1 0−1
Y -0 = -4(X-1)
Y = -4X +4

Y 2−Y 1 4−0
O= = = -4 Y = -4(X-4)
X 2−X 1 3−4
 Y = -4X+16
>> x = linspace(0,3,40);
>> y = 4/3*x;
>> plot(x,y)
>> hold on
>> x1=linspace(3,4,40);
>> y1 =-4*x1+16;
>> plot(x1,y1);

>> ymin=0;
>> ymax=1;
>> [Y2,PS]=mapminmax(y, ymin, ymax);
>> plot(x,Y2)
>> [Y1,PS]=mapminmax(y1, ymin, ymax);
>> plot(x1,Y1)

b) La ecuación siguiente representa a una función wavelet Morlet. Graficarla en el intervalo (-10,10)
con un mínimo de 100 puntos.

ψ(x)= cos( 3.x).e 2

−x

2
REESCALAR LA SECUENCIA (SÓLO DE ORDENADAS) AL INTERVALO (-1,1), VOLVER A CALCULAR LA FUNCIÓN Y
GRAFICAR CONJUNTAMENTE CON LA FUNCIÓN ORIGINAL.

>> lb = -10;
>> ub = 10;
>> n = 100;
>> [psi, xval] = morlet (lb, ub, n);
>> plot(xval,psi)
>> grid on
>> title('Morlet Wavelet')
>> hold on
>> ymin = -1;
>> ymax = 1;
 >> [YPS1,PS]=mapminmax(psi, ymin, ymax);
>> plot(xval,YPS1)
NO ES NECESARIO EL USO DE LA FUNCIÓN MORLET YA QUE ENUNCIADO NOS DÁ LA ECUACIÓN, ASÍ QUE SE DEBÍA
USAR ESA ECUACION:
>> X=linspace(-10,10,100);
>> Y= cos(3*X).*exp(1).^(-(X.^2./2));

a. Graficamos la función wavelet Morlet utilizando el siguiente comando

>> x1= linspace(-10,10,100);
>> e = exp(1);
>> Y1 = cos(3.*x1).*e.^((-x1.^2)./2);
>> plot(x1, Y1);
 Reescalamos la función con el siguiente comando:
>> [Y2,PS]=mapminmax(Y1, 0, 1);

Graficamos ambas funciones con el siguiente comando:

>> plot(x1, Y1, x1, Y2,'--')

6. Ruido. Sobre la secuencia temporal generada por la ecuación:

y = 10 * sin(2*t) + 5

a) Obtener 50 puntos para t perteneciente a [0,120º]. Verificar en qué unidades trabaja

sin().Agregar, a la secuencia, ruido blanco con una amplitud máxima de pico a pico del
10% de la sinusoide de base (quitando la componente de continua → 5).
b) Graficar la señal sin ruido en rojo y superponer la señal con ruido en azul.
c) Calcular para ambas secuencias, la media (µ) y la desviación estándar (σ).
Orientación: La ventana de graficas contiene el menú (click derecho sobre la curva), para
modificar la mayoría de los parámetros.

>> t=linspace(0,2/3*pi,50);
>> y = 10 * sin(2*t) + 5 ;
>> y1 = 2 * sin(t) ;
>> plot(t,y)
>> hold on
>> plot(t,y1)
 INCOMPLETO.
PARA AGREGAR RUIDO SE GENERA UNA SECUENCIA ALEATORIA CON AMPLITUD 2, YA
QUE LA SEÑAL EN EL EJE VERTICAL VA DESDE 15 (PICO MÁS ALTO) A -5 (PICO MÁS
BAJO) O SEA ES IGUAL A 20 UNIDADES (ESTO SE PUEDE VISUALIZAR SI SE DIBUJA LA
CURVA COMPLETA, ES DECIR ENTRE 0 Y 2Π). A ESTE VALOR DE 20 SACAMOS EL 10% QUE
ES IGUAL A 2, ENTONCES LA SECUENCIA ALEATORIA A GENERAR TENDRÁ AMPLITUD
DE 2 UNIDADES O SEA LOS NROS ALEATORIOS GENERADOS ESTARÁN ENTRE -1 Y 1.
FINALMENTE, ESTA SECUENCIA ALEATORIA SE AGREGA (SUMA) A LA SECUENCIA DE
DATOS INICIAL.

>> t=linspace(0,2/3*pi,50);
>> y = 10 * sin(2*t) + 5 ;
>> cant=size(t,2)
>> t1=-1+(1+1)*rand(1,cant)
>> r=y+t1
>>plot(t,y,'b',t1,r,'r')
>> grid on
>> title('Señal con ruido y sin ruido')
>> legend('Señal sin ruido','Señal con ruido')
.

Media de y
>> m=mean(y)
m = 8.4206

Desviación estándar de y
>> s=std(y)
s = 5.8026

Media de r
>> m=mean (r)
m = 8.4004

Desviacion estándar de r
>> s=std(r)
s = 5.8953
7. Scripts.
a) Escribir un script que dibuje un pulso como el de la
figura. Los puntos (a, b, c, d) deben ser solicitados al
usuario. Los flancos deben verse verticales
REHACER.
EN ESTE EJERCICIO SE SOLICITA PROGRAMAR UN SCRIPT, EN DONDE EL USUARIO DEBE
INGRESAR LOS VALORES DE a, b, c y d
a=input('Ingrese el punto a: ');
a = input ('Ingrese el valor de a : ');
b = input ('Ingrese el valor de b : ');
c = input ('Ingrese el valor de c : ');
d = input ('Ingrese el valor de d : ');

if (a<b)
if (b<c)
if (c<d)
y = [0 1 0 0];
x = [a b c d];
stairs (x,y);
else
disp (' El valor de c es mayor que d' );
end
else
disp (' El valor de b es mayor que c' );
end
else
disp (' El valor de a es mayor que b' );
end

b) Escribir un script que genere una matriz identidad de 10×10. Luego, el script debe
rellenar la matríz con valores aleatorios enteros del intervalo [2 ; 9], excepto en las celdas
donde están los ‘1’. Orientación: revisar las funciones eye() y randi().

INCOMPLETO. REHACER PROGRAMANDO UN SCRIPT.

RECORRER LA MATRIZ DE 10X10 Y EN DONDE LAS POSICIONES SEAN DISTINTAS (YA QUE LAS
POSICIONES DE LA DIAGONAL PRINCIPAL LAS POSICIONES SON IGUALES) ASIGNARLE UN VALOR
ENTRE 2 Y 9 GENERADO ALEATORIAMENTE
PARTE DEL CÓDIGO SERÍA:
if ( i != j )
matriz(i,j)=randi([2,9]);

matriz = eye(10);
for i=1 : 10
for j =1 : 10
if (i~=j)

matriz (i,j)= randi([-2 9]);

end

end
end
disp (matriz)

c) Escribir un script para ejecutar en forma automática el problema 3.a) anterior. La

cantidad de números de la serie debe ser introducida por el usuario (función input), lo
mismo que la cantidad de cifras de los números y el intervalo de la serie.
n = input ('Ingrese la cantidad de valores a generar: ');

Prob. 3.a) Generar una serie de 33 números aleatorios enteros de 3 cifras, en el intervalo [100;200].
n1 = input ('Ingrese la cantidad de cifras que desea que tenga
los valores a generar: ');
n2 = input ('Ingrese un valor de inicio del rango de valores :
');
n3 = input ('Ingrese un valor final del rango de valores: ');
c=0;
i=1;
while (n~=c)
num = randi([n2 n3]);
contador= 1;
control= 10;
while control <= num
contador = contador +1;
control = control * 10;
numerog= num;
end

if (num<0)
num = abs(num);
while control <= num
contador = contador +1;
control = control * 10;
numerog= -1*num;
end
end

if (contador == n1)
c=c+1;
r(i,c)=numerog;
end

end
disp (r)
8. Script 2. Dada la siguiente matriz booleana, COMPARAR Y LA CARDINALIDAD
diseñar un script que:
a. Genere 15 matrices booleanas, del
mismo tamaño, conteniendo cada una
15 “unos” dispuestos en forma
aleatoria.

ENTRE LA UNIÓN DE LAS 2 MATRICES.

matriz = zeros (10);

posiciones = randperm ( 100,15);
contador = 15;
x=1;
while contador > 0
x1= randi ([0 , 1],1,1);
if x1==1
matriz(posiciones (x))=x1;
contador= contador -1 ;
x= x+1;
end
end

Matriz muestra

matriz0 = zeros (10);

posiciones =[ 17 25 26 28 34 39 43 50
53 60 62 70 73 84 95 ]
contador = 15;
x=1;
while contador > 0
x1= randi ([0 , 1],1,1);
if x1==1
matriz0(posiciones (x))=x1;
contador= contador -1 ;
x= x+1;
end
end

b. Compare las 15 matrices con la matriz de

muestra e identifique las matrices de
mayor y menor similitud.

INCOMPLETO
LA COMPARACION DE MATRICES SE
DEBE HACER MEDIANTE EL INDICE
DE JACCARD QUE SE CALCULA
MEDIANTE EL COCIENTE ENTRE LA
CARDINALIDAD DE LA INTESECCION
ENTRE LAS 2 MATRICES A
Se presentan las 15 matrices
matriz4
Matriz 1
0 0 0 0 0 0 0 0 0 0
0 0 0 0 1 0 0 1 0 0
1 0 0 0 0 1 0 0 0 0
0 1 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 1 0 0 0 1
0 0 0 0 0 0 1 0 0 1
0 0 0 0 0 0 0 1 0 0
0 0 0 0 0 0 0 0 0 1
1 0 0 1 0 1 0 0 0 1
0 0 1 0 0 0 0 1 0 0
1 0 0 0 0 0 0 0 0 0
1 0 0 0 0 0 0 0 0 0
0 0 0 0 1 1 0 0 0 0
0 0 0 1 0 1 1 0 0 0
0 0 0 0 1 0 0 0 0 0
0 0 0 0 0 0 1 1 0 0
0 1 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 1 0
matriz5
Matriz 2

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

Matriz 3 matriz6

0 0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0
1 1 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 1 0 0
0 0 0 0 0 0 1 0 1 0 0 0 0 1 0 0 0 0 1 0
0 0 0 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 0
0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0
0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0
0 0 0 1 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0
0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0
matriz7 matriz11

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

matriz8 matriz12
0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0
0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0
1 0 0 0 0 0 1 1 0 0 0 1 0 1 0 0 0 0 0 1
0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 1 0
0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0
0 1 0 0 0 0 0 0 1 0 0 1 0 0 0 1 1 0 1 0
0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0
0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0
1 0 1 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0

matriz9 matriz13

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

matriz10 matriz14
1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 1 1 0
0 0 0 0 0 1 0 0 0 0 0 1 1 1 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 1 0 1 0 1 0 0 1 0 0 0 0 0 1 0 0 0 0 0
0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1
0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 1 0 1
0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 1 0
1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0
 matriz15
 indiceJaccard= sum (matriz10 & matriz0) /sum(matriz10 | matriz0)

0 0 0 0 0 0 0 0 1 0 indiceJaccard = 0.1176
0 0 0 0 0 0 0 0 0 0
 indiceJaccard= sum (matriz11 & matriz0) /sum(matriz11 | matriz0)
0 1 0 0 0 1 1 0 0 0
0 0 0 0 0 0 0 0 0 0 indiceJaccard = 0.1235
1 0 0 0 0 0 1 0 0 0
 indiceJaccard= sum (matriz12 & matriz0) /sum(matriz12 | matriz0)
0 1 0 0 1 0 0 0 0 1
0 0 0 0 0 0 0 0 0 0 indiceJaccard = 0.0095
0 0 0 0 0 0 1 0 0 1
 indiceJaccard= sum (matriz13 & matriz0) /sum(matriz13 | matriz0)
0 0 0 1 1 0 1 0 0 0
0 0 0 0 0 0 0 1 0 0 indiceJaccard = 0.0323

 indiceJaccard= sum (matriz14 & matriz0) /sum(matriz14 | matriz0)

 indiceJaccard= sum (matriz & matriz0)
/sum(matriz | matriz0) indiceJaccard = 0.0316

indiceJaccard = 0.0532  indiceJaccard= sum (matriz15 & matriz0) /sum(matriz15 | matriz0)

indiceJaccard = 0.1688

 indiceJaccard= sum (matriz2 & matriz0)

/sum(matriz2 | matriz0)

indiceJaccard = 0.0426

 indiceJaccard= sum (matriz3 & matriz0)

/sum(matriz3 | matriz0)

indiceJaccard = 0.1379

 indiceJaccard= sum (matriz4 & matriz0)

/sum(matriz4 | matriz0)

indiceJaccard = 0.1000

 indiceJaccard= sum (matriz5 & matriz0)

/sum(matriz5 | matriz0)

indiceJaccard = 0.0941

 indiceJaccard= sum (matriz6 & matriz0) /sum(matriz6 | matriz0)

indiceJaccard = 0.0543

 indiceJaccard= sum (matriz7 & matriz0) /sum(matriz7 | matriz0)

indiceJaccard = 0.0198

 indiceJaccard= sum (matriz8 & matriz0) /sum(matriz8 | matriz0)

indiceJaccard = 0.1538

 indiceJaccard= sum (matriz9 & matriz0) /sum(matriz9 | matriz0)

indiceJaccard = 0.0714
c. Por cada comparación realizada
genere un índice de similitud (IS C
ffi) entre 0 y 1 (un valor 1 significa
que las matrices son iguales).
Orientación: investigar el índice de
Jaccard.

 Indice de la matriz original con la 1° matriz

similarity = jaccard (matriz0,matriz)

similarity = 0.0714

 Indice de la matriz original con la 2° matriz

similarity = jaccard (matriz0,matriz2)

similarity = 0.0714

 Indice de la matriz original con la 3° matriz

similarity = jaccard (matriz0,matriz3)

similarity = 0.1111

 Indice de la matriz original con la 4° matriz

similarity = jaccard (matriz0,matriz4)

similarity = 0.1538

 Indice de la matriz original con la 5° matriz

similarity = jaccard (matriz0,matriz5)

similarity = 0.1111

 Indice de la matriz original con la 6° matriz

similarity = jaccard (matriz0,matriz6)

similarity = 0.0714

 Indice de la matriz original con la 7° matriz

similarity = jaccard (matriz0,matriz7)

similarity = 0.0345

 Indice de la matriz original con la 8° matriz

similarity = jaccard (matriz0,matriz8)

similarity = 0.1538
  Indice de la matriz original con la 9° matriz
similarity = jaccard (matriz0,matriz9)

similarity = 0.0714

 Indice de la matriz original con la 10° matriz

similarity = jaccard (matriz0,matriz10)

similarity = 0.1111

 Indice de la matriz original con la 11° matriz

similarity = jaccard (matriz0,matriz11)

similarity = 0.1111

 Indice de la matriz original con la 12° matriz

similarity = jaccard (matriz0,matriz12)

similarity = 0.0345

 Indice de la matriz original con la 13° matriz

similarity = jaccard (matriz0,matriz13)

similarity = 0.0345

 Indice de la matriz original con la 14° matriz

similarity = jaccard (matriz0,matriz14)

similarity = 0.0345
 Indice de la matriz original con la 15° matriz
similarity = jaccard (matriz0,matriz15)

similarity = 0.2000

EL RESULTADO QUE DEBE ARROJAR EL SCRIPT ES QUE MATRIZ ES SIMILAR A AL PATRON

DADO.

QUE MATRIZ ES SIMILAR AL PATRON DADO?

9. Función. Identificar qué hace la función que sigue. Previamente deben ser encontrados
y corregidos dos errores en el código.
function p = diagonal(matriz,valor)
FilCol [M N] =size(matriz);//
DEVUELVE UN VECTOR FILA CUYOS
ELEMENTOS CONTIENEN LA LONGITUD DE
LA DIMENSION DE LA MATRIZ.

if [(valor==0)&&(valor~=1)]||[(valor~=0)&&(valor==1)]
disp('valor correcto);
end
else
error('El 2do parámetro debe ser 0 o 1');
end

if FilCol(1)M ~= N FilCol(2)
 Errores:
● Cuando se compara los valores if i=j, debe ir dos veces el signo igual, para indicar que es una
comparación y no una asignación.
● Falta un end para determinar que la función termina.

La función pone en ceros la diagonal principal de la matriz si elige el valor 0 y pone unos en la diagonal
principal de la matriz si se elige el valor 1.

Primero verifica que los valores ingresados sean 0 o 1. Si no son los valores manda un mensaje de error.
En caso de ser correcto el valor ingresado, se procede a verificar que la matriz es cuadrada, si no lo es manda
un mensaje de error, en caso contrario la función recorre la matriz comparando los subíndices y si los mismos
son iguales pone el valor de esa posición en 1 o 0.

10. Función 2. Escribir una función con las siguientes características:

a.Debe generar una matriz MG (dimensión 10x10) de números enteros aleatorios en el
rango [-10 , +10].
b. Debe encontrar todas las ocurrencia de una submatriz mc 2x2, dada por el usuario como
argumento de la función, dentro de la matriz MG.
c.La función devolverá la o las posiciones en un vector de nx2 (fila y columna) de todas las
ocurrencias de mc. En caso contrario generará un mensaje de error indicando que no hay
ocurrencias de mc.
d. La función debe verificar que la matriz ingresada sea de 2x2 y que sus valores estén en el
rango indicado para A. Caso contrario, se emitirá un mensaje de error.
clc
clear all
MAT=randi([-10 10],10,10);
correcto=0;
while correcto~=1
clc
z=input ('Ingrese la dimension de la Fila de la Matriz ');
y=input ('Ingrese la dimension de la Columna de la Matriz ');
if (( z==2) && (y==2))
correcto=1;
else
 w=input ('ERROR LAS DIMENSIONES DE LA MATRIZ DEBEN SER DE 2x2
');
end
end
variable=0;
mensaje =1;
while mensaje~=3;
for i=1:z
for j=1:y
variable=input ('ingrese los valores de la matriz ');

if ((variable>-10)&&(variable <10))
mc(i,j)= variable;

else
mensaje=2;
break;
end
end

end

if (mensaje ==2)
clc
men=input ('ERROR los valores que ingresan deben estar en
rango [-10 10] ');
clc
mensaje=0;

else
mensaje=3;
end

end
REHACER.
EL SCRIPT SOLO CONSIDERA QUE LA SUBMATRIZ SE REPITE UNA SOLA VEZ. EN
LA CONSIGNA SE SOLICITA ENCONTRAR TODAS LAS OCURRENCIAS. SOLO
FALTARÍA AGREGAR UN BUCLE QUE INCLUYA TODO

MG= randi([-10,10],10,10);
correcto=0;
while correcto~=1
clc
z=input ('Ingrese la dimension de la Fila de la Matriz ');
y=input ('Ingrese la dimension de la Columna de la Matriz ');
if (( z==2) && (y==2))
disp (MG)
for i=1:1:2
for j=1:1:2
cadena = strcat('ingrese elemento (', num2str(i),',',
num2str(j), ') de la matriz : ');
ingreso = input (cadena);
MAT2(i,j)=ingreso;
end
end
correcto= 1;
else
 w=input ('ERROR LAS DIMENSIONES DE LA MATRIZ DEBEN SER DE 2x2 INGRESE
NUEVAMENTE ');
end
end

disp (MAT2)
if isempty(submatrices(MG, MAT2))
disp ('LA MATRIZ INGRESADA POR EL USUARIO NO APARECE EN MG')
end

function s = submatrices( A,B )

%busca submatriz
szA = size(A) ; % tamaño de la matriz MG
szB = size(B) ; % tamaño de la matriz MAT2
szS = szA - szB + 1 ;
tf = false(szA) ;
for r = 1:szS(1)
for c = 1:szS(2)
tf(r,c) = isequal(A(r:r+szB(1)-1,c:c+szB(2)-1),B) ;
end
end
[fila,colu] = find(tf);
s= [fila colu];
if ~isempty(s)
strcat('LA SUBMATRIZ COMIENZA EN LAS COORDENADAS (FILA=',
num2str(fila),', COLUMNA=', num2str(colu), ') ')
end
end