Faça um script que recebe do usuário o valor
, em que
e construa o sinal
que:
- Calcule para esses valores de x as funções:
- Para isso, crie uma função que calcula os vetores de saída passando o vetor x como entrada da função;
- Com os vetores calculados, salve os vetores
e
em um aquivo ‘. dat’ cujo o nome é passado pelo usuário.
- verifique se é necessário ou não inserir o ‘.dat’ ao final do valor passado pelo usuário.
Passo 1
O enunciado pede um script que faça o seguinte (resumindo e listando tudo o que foi dado e o que se deve entregar):
- Ler do usuário o valor
com a restrição . - Construir o vetor
definido por
- Calcular para todos os elementos de
as funções
- Implementar uma função que recebe o vetor
e retorna os vetores . - Pedir ao usuário o nome do arquivo para gravar e salvar os vetores
em um arquivo ASCII com extensão . Verificar se o usuário já passou a extensão e, se não, acrescentá-la automaticamente.]
Passo 2
Validação da entrada
. O script precisa:
- Ler o valor do usuário e verificar que é numérico.
- Verificar
. Se não, avisar/erro.
Motivo didático: sempre validar entradas em programação para evitar valores errados que façam o programa falhar ou produzir resultados inválidos.
Em MATLAB/Octave a leitura pode ser feita com a função
input. A verificação de limite é feita com abs(xmax). Exemplo de checagem:- Se
abs(xmax) > 30então abortar com mensagem de erro.
Passo 3
Construção do vetor
. Uso do operador
: do MATLAB:- Em MATLAB,
a:b:cconstrói um vetor que vai deaatéccom passob. - Para garantir os sinais corretos usamos
abs(xmax)e construímos
x = -abs(xmax):0.01:abs(xmax);
Comentário didático: o operador:cria vetores rapidamente e é vetorizado — funciona sem loops. A precisão de inclusão do extremo direito depende se o passo divide exatamente o intervalo, mas isso não é um problema prático aqui.
Passo 4
Escolha e explicação de
. Vou definir a função escolhida como
Motivo da escolha: mistura uma envoltória gaussiana
com uma oscilação
. É suave, demonstra multiplicação ponto-a-ponto em vetores e tem comportamento interessante ao longo de
.
Passo 5
Implementação da função que recebe
e devolve
.
- Requisito do enunciado: criar uma função separada.
- Assinatura sugerida (MATLAB/Octave):
function [y1,y2,y3] = compute_y(x) - Implementação vetorizada (usar operadores elementwise):
- Para potências elemento a elemento use
.^. - Para multiplicação elemento a elemento use
.*.
- Para potências elemento a elemento use
- Fórmulas em código:
y1 = x.^3 .* sin(pi*x/5);y2 = -0.8 * cos(pi*x/10) + 0.01 * x;y3 = exp(-(x.^2)/50) .* cos(pi*x/5);
Aula rápida sobre vetorização:
- Em MATLAB um vetor
xé um array; se escreversin(pi*x/5)a funçãosinaplica-se a cada elemento automaticamente porque as funções trigonométricas aceitam arrays. - Evitar
fordesnecessário: usar operações vetoriais é mais conciso e eficiente.
Passo 6
Pedir o nome do arquivo e checar/colocar a extensão
.
- Ler string do usuário com
input(...,'s'). - Verificar se os últimos 4 caracteres são
'.dat'(caso-insensitivo):- Em MATLAB:
if length(fname) >= 4 && strcmpi(fname(end-3:end),'.dat') - Se já tiver, usar como está; caso contrário concatenar
'.dat':filename = [fname '.dat'];
Motivo: evitar que o usuário passemeuarquivoe o programa salve comomeuarquivosem extensão; também não acrescentar'.dat'duas vezes.
- Em MATLAB:
Passo 7
Gravação dos vetores em arquivo
.dat.- Formato sugerido: 4 colunas (cada linha:
x y1 y2 y3). - Opção robusta: usar
fopen/fprintfpara controlar formato e compatibilidade entre MATLAB e Octave:- Abrir:
fid = fopen(filename,'w'); - Escrever um cabeçalho opcional (comentado com
#):fprintf(fid,'# x y1 y2 y3\n'); - Preparar matriz
data = [x(:) y1(:) y2(:) y3(:)];(colunas). - Escrever todas as linhas com
fprintf(fid,'%0.6f %0.6f %0.6f %0.6f\n', data.');- Nota técnica: o
data.'(transposta) é necessário porquefprintflê em coluna-major order.
- Nota técnica: o
- Fechar com
fclose(fid);
- Abrir:
- Tratamento de erro: checar se
fid == -1e tratar adequadamente (mensagem de erro).
Passo 8
Feedback ao usuário e dicas finais.
- Após salvar, informar
fprintf('Arquivo salvo em %s\n', filename);. - Observação didática: os números são salvos com 6 casas decimais no exemplo (
%0.6f). Se quiser mais precisão alterar o formato, por exemplo%0.10f. - Compatibilidade: o código apresentado funciona tanto no MATLAB atual quanto no GNU Octave (com funções básicas descritas).
Passo 9
Resumo das peças a entregar (sem tocar no código): será um script principal que:
- lê
, - gera
, - chama a função
compute_y(x), - pede o nome do arquivo, ajusta a extensão se necessário,
- salva os vetores em colunas no
.dat.
Resposta
% Arquivo: main_save_vectors.m
% Script principal: lê x_max, cria x, chama compute_y, salva x,y1,y2,y3 em .dat
% Script principal: lê x_max, cria x, chama compute_y, salva x,y1,y2,y3 em .dat
% Ler x_max do usuário e validar
xmax = input('Entre com x_{max} (|x_{max}| <= 30): ');
if isempty(xmax) || ~isnumeric(xmax)
error(‘Entrada inválida: deve ser um número.’);
end
if abs(xmax) > 30
error(‘Entrada inválida: |x_{max}| deve ser <= 30.’);
end
xmax = input('Entre com x_{max} (|x_{max}| <= 30): ');
if isempty(xmax) || ~isnumeric(xmax)
error(‘Entrada inválida: deve ser um número.’);
end
if abs(xmax) > 30
error(‘Entrada inválida: |x_{max}| deve ser <= 30.’);
end
% Construir vetor x
x = -abs(xmax):0.01:abs(xmax);
x = -abs(xmax):0.01:abs(xmax);
% Calcular y1, y2, y3 chamando a função
[y1,y2,y3] = compute_y(x);
[y1,y2,y3] = compute_y(x);
% Pedir nome do arquivo e garantir extensão .dat
fname = input(‘Nome do arquivo de saída (com ou sem .dat): ‘,‘s’);
if length(fname) >= 4 && strcmpi(fname(end-3:end),’.dat’)
filename = fname;
else
filename = [fname ‘.dat’];
end
fname = input(‘Nome do arquivo de saída (com ou sem .dat): ‘,‘s’);
if length(fname) >= 4 && strcmpi(fname(end-3:end),’.dat’)
filename = fname;
else
filename = [fname ‘.dat’];
end
% Abrir arquivo para escrita
fid = fopen(filename,‘w’);
if fid == -1
error(‘Não foi possível abrir o arquivo para escrita: %s’, filename);
end
fid = fopen(filename,‘w’);
if fid == -1
error(‘Não foi possível abrir o arquivo para escrita: %s’, filename);
end
% Escrever cabeçalho opcional e os dados: colunas x y1 y2 y3
fprintf(fid,’# x y1 y2 y3\n’);
data = [x(😃 y1(😃 y2(😃 y3(😃];
% Usar transposta porque fprintf lê coluna-major
fprintf(fid,’%0.6f %0.6f %0.6f %0.6f\n’, data.’);
fprintf(fid,’# x y1 y2 y3\n’);
data = [x(😃 y1(😃 y2(😃 y3(😃];
% Usar transposta porque fprintf lê coluna-major
fprintf(fid,’%0.6f %0.6f %0.6f %0.6f\n’, data.’);
% Fechar arquivo
fclose(fid);
fclose(fid);
fprintf(‘Dados salvos em %s\n’, filename);
% -------------------------------
% Arquivo: compute_y.m
% Função que recebe vetor x e retorna y1, y2, y3
% Arquivo: compute_y.m
% Função que recebe vetor x e retorna y1, y2, y3
function [y1,y2,y3] = compute_y(x)
% compute_y calcula os vetores y1, y2, y3 para o vetor x (vetorizado).
% Fórmulas:
% y1(x) = x.^3 .* sin(pix/5)
% y2(x) = -0.8 * cos(pix/10) + 0.01 * x
% y3(x) = exp(-(x.^2)/50) .* cos(pi*x/5) (função escolhida)
% compute_y calcula os vetores y1, y2, y3 para o vetor x (vetorizado).
% Fórmulas:
% y1(x) = x.^3 .* sin(pix/5)
% y2(x) = -0.8 * cos(pix/10) + 0.01 * x
% y3(x) = exp(-(x.^2)/50) .* cos(pi*x/5) (função escolhida)
% Garantir que x é vetor (operações vetoriais)
% Cálculos vetoriais (use .^ e .* para operações elemento-a-elemento)
y1 = x.^3 .* sin(pix/5);
y2 = -0.8 * cos(pix/10) + 0.01 * x;
y3 = exp(-(x.^2)/50) .* cos(pi*x/5);
end
% Cálculos vetoriais (use .^ e .* para operações elemento-a-elemento)
y1 = x.^3 .* sin(pix/5);
y2 = -0.8 * cos(pix/10) + 0.01 * x;
y3 = exp(-(x.^2)/50) .* cos(pi*x/5);
end