Ejemplo: Grafica para hacer en Mathlab/Octave GNU:

1)Problema 1_:
1)Grafique lo sgte: En GNU Octave online/Mathlab(fcil): SOL:
Su cdigo solucin es de:RPTA:
getplotlyoffline('https://cdn.plot.ly/plotly-latest.min.js')
X = linspace(0,2*pi,50)';
Y = [cos(X), 0.5*sin(X)];
stem(X,Y)
fig2plotly(gcf, 'offline', true);

1)Sol:

2)Problema 2:
2) Resuelva:Cree un programa, resuelve este problema
en Gnu Octave Online/Mathlab lo sgte:

y grafique

Problema:
Use la transformada de Fourier para hallar los componentes de
frecuencia de una seal afectada por un ruido:
SOL: RPTA:
2)Sol: En Mathlab/GNU Octave ser si: Rpta: Sol:
Primero se especifica los parmetros de una seal con una muestra de
frecuencia elegida de ello de 1 KHZ y la seal debe de tener una duracin de
1 segundo. Su cdigo en Mathlab de ello es:
Fs = 1000;
T = 1/Fs;
L = 1000;
t = (0:L-1)*T;

% Sampling frequency
% Sampling period
% Length of signal
% Time vector

Luego se crea una seal que contenga una funcin seno de 50 Hz con una amplitud
de 0.7 y a 120 HZ de funcin seno de amplitud 1.Luego su cdigo en GNU Octave ser:
S = 0.7*sin(2*pi*50*t) + sin(2*pi*120*t);
Luego se corrompe la seal con un medio-cero cuando el sonido tiene una variacin de
4.
Y su cdigo de ello en Mathlab es de :
X = S + 2*randn(size(t));
Luego se dibuja la seal ruidosa en el dominio del tiempo. Es difcil identificar los
componentes de la frecuencia simplemente mirando la seal de X(t).
Y su cdigo en Mathlab es de :
plot(1000*t(1:50),X(1:50))
title('Signal Corrupted with Zero-Mean Random Noise')
xlabel('t (milliseconds)')
ylabel('X(t)')

Grfica:

Ahora empieza a crear por medio de Mathlab la transformada de Fourier de la seal y su cdigo
en Mathlab es de:
Y = fft(X);
Luego tambin empieza a crear por la Pc usando el Mathlab los 2 lados del espectro P2.
De all dibuje por la computadora el lado ms simple del espectro P1 basado en P2 y en
base en la medida evaluada de manera pareja de la seal L.
Y

su cdigo es de:

P2 = abs(Y/L);
P1 = P2(1:L/2+1);
P1(2:end-1) = 2*P1(2:end-1);
Ahora defina el dominio de la frecuencia f y dibuje en Mathlab la amplitud de un solo
lado simple de espectro P1. Nota: Las amplitudes no estn exactamente en 0.7 y 1 ,
como se esperaba, esto debido al ruido agregado anteriormente a la seal. En
promedio seales largas producen mejores aproximaciones de frecuencia en
Mathlab/Gnu Octave.
Y su cdigo en Mathlab es de:
f = Fs*(0:(L/2))/L;

plot(f,P1)
title('Single-Sided Amplitude Spectrum of X(t)')
xlabel('f (Hz)')
ylabel('|P1(f)|')

La grafica de ello es de:

Ahora tomamos la transformada de Fourier de la seal original antes creada aqu y sin corromper
y lo llevamos ello a las amplitudes exactas de 0.7 y 1.0.
Su cdigo en GNU Octave/Mathlab es de :

Y = fft(S);
P2 = abs(Y/L);
P1 = P2(1:L/2+1);
P1(2:end-1) = 2*P1(2:end-1);
plot(f,P1)
title('Single-Sided Amplitude Spectrum of S(t)')
xlabel('f (Hz)')

ylabel('|P1(f)|')

Y para terminar todo el cdigo de este problema junto en Mathlab es de :

2)Sol:
// Autor : Fredy Albornoz Escobedo
// Se crea programa en Mathlab que me permite usar la transformada de
Fourier para hallar los //componentes de frecuencia de una seal afectada por
un ruido: Seal ruidosa : Sol: si:
// Y su cdigo en Mathlab es de:
/////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////////
// 2)SOL: Y su cdigo de Mathlab es de:
Fs = 1000;
T = 1/Fs;
L = 1000;
t = (0:L-1)*T;

% Sampling frequency
% Sampling period
% Length of signal
% Time vector

S = 0.7*sin(2*pi*50*t) + sin(2*pi*120*t);
X = S + 2*randn(size(t));
plot(1000*t(1:50),X(1:50))
title('Signal Corrupted with Zero-Mean Random Noise')
xlabel('t (milliseconds)')
ylabel('X(t)')
Y = fft(X);
P2 = abs(Y/L);
P1 = P2(1:L/2+1);
P1(2:end-1) = 2*P1(2:end-1);
f = Fs*(0:(L/2))/L;
plot(f,P1)
title('Single-Sided Amplitude Spectrum of X(t)')
xlabel('f (Hz)')
ylabel('|P1(f)|')
Y = fft(S);
P2 = abs(Y/L);
P1 = P2(1:L/2+1);
P1(2:end-1) = 2*P1(2:end-1);
plot(f,P1)
title('Single-Sided Amplitude Spectrum of S(t)')
xlabel('f (Hz)')
ylabel('|P1(f)|')

///////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////

Rpta final 2: Hecho.

3)Problema 3:
3)Sol: Resuelva: Usando el programa de Mathlab lo sgte:
Problema: Escriba un programa en Mathlab que me permita comparar las
ondas de la funcin coseno en el dominio de tiempo y en el dominio de la
frecuencia. Ondas de la funcin coseno por medio del uso de la transformada
de Fourier:
SOL:
3)Sol:Rpta:
Para resolver ello primero se especifica los parmetros de una seal al cual
se la aplica muestreo y del cual se halla su frecuencia y ello es de 1KHZ y
una seal que tiene una duracin de 1 segundo: Su cdigo en Mathlab es de:
Fs = 1000;
T = 1/Fs;
L = 1000;
t = (0:L-1)*T;

% Sampling frequency
% Sampling period
% Length of signal
% Time vector

Luego de ello se crea una matriz donde cada columna representa una onda de function coseno
con una frecuencia escalada respectivamente en cada caso. El resultado X, es de 3-by-1000
matrix. La primera columna tiene una onda de frecuencia de 50 HZ , y la segunda columna tiene
una onda de frecuencia de 150 HZ y la tercera columna tiene una onda de frecuencia de 300 HZ.
Su cdigo en Mathlab es de:
x1 = cos(2*pi*50*t);
x2 = cos(2*pi*150*t);
x3 = cos(2*pi*300*t);
X = [x1; x2; x3];

% First row wave

% Second row wave
% Third row wave

Ahora se grafica en Mathlab las primeras 100 entradas de cada columna de X en una
sola figura simple y ello en orden y para comparar sus frecuencias.
Su cdigo en Mathlab/GNU Octave es de:
for i = 1:3
subplot(3,1,i)
plot(t(1:100),X(i,1:100))
title(['Row ',num2str(i),' in the Time Domain'])
end

Grafica:

Para lograr hacer cumplir las metas del algoritmo propuesto aqu, la funcin de Fourier de Mathlab
de fft te permite conectar la entrada con una fila de zeros uno a continuacin de otro. En este
caso, complete cada columna de X con zeros esto para hacer que le medida de cada columna
sea la prxima potencia mas alta de 2 ello a partir desde la medida actual de ello. Entonces para
ello defina la nueva medida usando la funcin en Mathlab de nextpow2 funcin, su cdigo en
Mathlab ser de :
n = 2^nextpow2(L);

Especifique el argumento dim para usar la function de fft en mathlab a travs de las columnas
de X y ello aplicado para cada seal. Su cdigo es de:
dim = 2;

Ahora creamos las funciones de las transformadas de Fourier en las seales:

Y = fft(X,n,dim);

Luego de ello calculamos el lado doble del espectro de cada seal aqu analizada anteriormente y
como tambin el lado simple del espectro de dichas de igual forma que lo anterior para ambos
casos. Y su codigo es de:
P2 = abs(Y/n);
P1 = P2(:,1:n/2+1);
P1(:,2:end-1) = 2*P1(:,2:end-1);

Luego en el dominio de la frecuencia , se dibuja en Mathlab el espectro de la amplitud de un solo

lado para cada columna en una sola sencilla figura, Y su cdigo en Mathlab es de:
for i=1:3
subplot(3,1,i)
plot(0:(Fs/n):(Fs/2-Fs/n),P1(i,1:n/2))
title(['Row ',num2str(i), ' in the Frequency Domain'])
end
Grafica:

Y su cdigo completo junto de problema 3 solucin en Mathlab es de:

//Autor: Fredy Albornoz Escobedo
// Se crea programa en Mathlab que me permita comparar las ondas de la
funcin coseno en el //dominio de tiempo y en el dominio de la frecuencia.
Ondas de la funcin coseno por medio del //uso de la transformada de Fourier:
//Grupo B Epit UNAS 2016
//Solucin:

//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
Fs = 1000;

% Sampling frequency

T = 1/Fs;
L = 1000;
t = (0:L-1)*T;
x1 = cos(2*pi*50*t);
x2 = cos(2*pi*150*t);
x3 = cos(2*pi*300*t);

% Sampling period
% Length of signal
% Time vector
% First row wave
% Second row wave
% Third row wave

X = [x1; x2; x3];

for i = 1:3
subplot(3,1,i)
plot(t(1:100),X(i,1:100))
title(['Row ',num2str(i),' in the Time Domain'])
end
n = 2^nextpow2(L);
dim = 2;
Y = fft(X,n,dim);
P2 = abs(Y/n);
P1 = P2(:,1:n/2+1);
P1(:,2:end-1) = 2*P1(:,2:end-1);

for i=1:3
subplot(3,1,i)
plot(0:(Fs/n):(Fs/2-Fs/n),P1(i,1:n/2))
title(['Row ',num2str(i), ' in the Frequency Domain'])
end

////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
Rpta: 3: Resuelto.