Faça um script que recebe do usuário o valor x_{\text {max }}, em que \left|x_{\text {max }}\right| \leq 30 e construa o sinal x que:
x=-\left|x_{\max }\right|: 0.01:\left|x_{\max }\right| ;
  • Calcule para esses valores de x as funções:
\begin{aligned} & y_{1}(x)=x^{3} \sin \left(\frac{\pi x}{5}\right) \\\ & y_{2}(x)=-0.8 \cos \left(\frac{\pi x}{10}\right)+0.01 x \\\ & y_{3}(x)=\text { escolha alguma função!. } \end{aligned}çã

- Para isso, crie uma função que calcula os vetores de saída passando o vetor x como entrada da função; { }^{1}

  • Com os vetores calculados, salve os vetores x, y_{1}, y_{2} e y_{3} 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 x_{\text{max}} com a restrição \left|x_{\text{max}}\right|\leq 30.
  • Construir o vetor x definido por
x = -\left|x_{\max}\right|:0{,}01:\left|x_{\max}\right|.
  • Calcular para todos os elementos de x as funções
\begin{aligned} & y_{1}(x)=x^{3}\sin\!\left(\frac{\pi x}{5}\right),\\[4pt] & y_{2}(x)=-0{,}8\cos\!\left(\frac{\pi x}{10}\right)+0{,}01x,\\[4pt] & y_{3}(x)=\text{uma função à escolha (vamos definir uma abaixo).} \end{aligned}çãà
  • Implementar uma função que recebe o vetor x e retorna os vetores y_{1},y_{2},y_{3}.
  • Pedir ao usuário o nome do arquivo para gravar e salvar os vetores x,y_{1},y_{2},y_{3} em um arquivo ASCII com extensão '.dat'. Verificar se o usuário já passou a extensão e, se não, acrescentá-la automaticamente.]

Passo 2

Validação da entrada x_{\text{max}}. O script precisa:
  • Ler o valor do usuário e verificar que é numérico.
  • Verificar \left|x_{\text{max}}\right|\leq 30. 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) > 30 então abortar com mensagem de erro.

Passo 3

Construção do vetor x. Uso do operador : do MATLAB:
  • Em MATLAB, a:b:c constrói um vetor que vai de a até c com passo b.
  • 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 y_{3}. Vou definir a função escolhida como
y_{3}(x)=\exp\!\bigg(-\frac{x^{2}}{50}\bigg)\cos\!\left(\frac{\pi x}{5}\right).
Motivo da escolha: mistura uma envoltória gaussiana \exp(-x^{2}/50) com uma oscilação \cos(\pi x/5). É suave, demonstra multiplicação ponto-a-ponto em vetores e tem comportamento interessante ao longo de x.

Passo 5

Implementação da função que recebe x e devolve y_{1},y_{2},y_{3}.
  • 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 .*.
  • 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 escrever sin(pi*x/5) a função sin aplica-se a cada elemento automaticamente porque as funções trigonométricas aceitam arrays.
  • Evitar for desnecessário: usar operações vetoriais é mais conciso e eficiente.

Passo 6

Pedir o nome do arquivo e checar/colocar a extensão '.dat'.
  • 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 passe meuarquivo e o programa salve como meuarquivo sem extensão; também não acrescentar '.dat' duas vezes.

Passo 7

Gravação dos vetores em arquivo .dat.
  • Formato sugerido: 4 colunas (cada linha: x y1 y2 y3).
  • Opção robusta: usar fopen/fprintf para 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 porque fprintf lê em coluna-major order.
    • Fechar com fclose(fid);
  • Tratamento de erro: checar se fid == -1 e 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:
  • x_{\text{max}},
  • gera x,
  • 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
% 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
% Construir vetor x
x = -abs(xmax):0.01:abs(xmax);
% Calcular y1, y2, y3 chamando a função
[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
% 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
% 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.’);
% Fechar arquivo
fclose(fid);
fprintf(‘Dados salvos em %s\n’, filename);
% -------------------------------
% 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(pi
x/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(pi
x/10) + 0.01 * x;
y3 = exp(-(x.^2)/50) .* cos(pi*x/5);
end

Exercícios relacionados