C++ Como tratar dados de um arquivo txt numa função matemática em C/C++???

Welington Silva 2002 · 5 de setembro de 2020

Olá, meus amigos. Preciso implementar um programa para executar os seguintes procedimentos:

1. Abrir o arquivo Arq01.txt e extrair seus dados. (Esse arquivo tem vários valores aleatórios .txt)

2. Utilizar os dados do arquivo na Função (1).

3. Salvar os dados gerados a partir da Função (1) no arquivo Arq02.txt.

f(x) = x cos(x) sin(x) Função (1)

Implementar também uma rotina em outra linguagem (Python) para abrir o Arq02.txt e plotar os dados.

>>>>>>>>>>O que não sei mesmo, por agora, é como vou fazer os procedimentos 1 e 2.<<<<<<<<<<<<<<

Alguém pode me ajudar?

Ansi C · 5 de setembro de 2020

"Não é a linguagem de programação que define o programador, mas sim sua lógica."

Um exemplo de como ~perde mais tempo.

Basta associar passo a passo e comandos hipotéticos para desenvolver na base da consulta. Coloque no Google: Como abrir arquivo (txt) usando C. Depois tente o mesmo para Python.

Preferencialmente consulte a documentação de referência, Python em particular tem muitos exemplares superiores de documentação.

devair1010 · 5 de setembro de 2020

@Welington Silva 2002 para abrir um arquivo seria bom saber como os dados foram gravados nele , pois você pode abrir o arquivo usando o comando fopen , e usando a função fscanf você pega o conteúdo do arquivo , e em seguida você pode trabalhar com esses dados e escreve los na tela , e na função1 você pode usar o comando fprintf para gravar no arquivo os dados depois de extrair o seno e cosseno deles , e então faça seu código sobre esse exercício e poste aqui para vermos como está e em que podemos ajudar .

Welington Silva 2002 · 5 de setembro de 2020

@Mauro Britivaldo Exatamente como estou fazendo, assisti a vários vídeos, pesquisei em vários fóruns e a ideia está se desenvolvendo... Muito obrigado!!!

adicionado 2 minutos depois

@devair1010 exatamente como estou tentando agora. Antes eu tava tentando com

arquivoE.is_open())
{
while(getline(arquivoE, linha)

Mais ou menos assim, só que isso dava ruim por conta do getline, mesmo que eu tentasse usar atoi, strtof, coisas do tipo para converter string para float e trabalhar na função 01.

Vou tentar por meio do fopen, fscanf e tal em diante... Muitíssimo obrigado !!!

arfneto · 6 de setembro de 2020

22 horas atrás, Welington Silva 2002 disse:

Exatamente como estou fazendo, assisti a vários vídeos, pesquisei em vários fóruns e a ideia está se desenvolvendo

Que tinha nos vídeos e pesquisas sobre copiar um arquivo? Como está seu programa agora?

O programa que você quer escrever é chamado genericamente de filtro: apenas lê a entra e gera uma saída com uma possível transformação, que seria o tal filtro.

No seu problema filtro está bem definido e é aquela função.Mas o enunciado não diz se a medida x está em graus ou radianos e essa é uma falha comum.

Ou você não disse, e aí seria outra falha comum

Imaginando que o valor de x venha em graus, o comum no BR, você precisa converter para radianos antes porque as funções sin() e cos() --- como todas as funções trigonométricas --- operam em radianos e não em graus. E aí tem outra pergunta: o valor de x na função será o valor convertido em radianos ou o valor que está no arquivo?

Do ponto de justa de uma função matemática é mais certo considerar o valor de x na função como o valor em radianos

Para converter de graus para radianos tem a fórmula do ensino fundamental, certo?

22 horas atrás, Welington Silva 2002 disse:

Mais ou menos assim, só que isso dava ruim por conta do getline

Não sei o que quer dizer. Mas porque não usar fluxos mesmo e usar o operador de extração popularmente conhecido por ">>"?

Você tem um livro? Tem uma tabela das funções em <string> ? Uma pesquisa minimalista em português com aquele conhecido site de busca mostra

é só o que precisa fazer.

De volta ao programa

a função:
- o programa é muito simples e escrever uma classe só com essa função seria um exagero então vamos pensar em uma função f que recebe um argumento x que é uma string
- assim é mais fácil, porque vem do arquivo assim, uma string. Para a saída pode ser double mesmo porque afinal as classes stream tem overloads para double e você pode escrever por exemplo
```
cout << " Valor do double x: " << x; // '<<' converte x para string
```
o protótipo
```
double      f(string string_x);
```
já estaria bem porque é só o que temos: vem uma string volta um double

exemplo de uma função de teste para f()

void fase2()
{
    const string valores[8]{ "0","30","45","90", "-30","-45","-90","90" };
    for (auto& x : valores)
    {
        cout << "Angulo: " << x << " graus.\tf(x) = " <<
            fixed << f(x) << endl;
    };
}

O simples, certo? pega esses 8 valores conhecidos, em graus, e chama a função. E faz a gentileza de mostrar os valores na tela ou não ia adiantar nada afinal

Eis uma saída

Angulo: 0 graus.        f(x) = 0.000000
Angulo: 30 graus.       f(x) = 0.226725
Angulo: 45 graus.       f(x) = 0.392699
Angulo: 90 graus.       f(x) = -0.000000
Angulo: -30 graus.      f(x) = 0.226725
Angulo: -45 graus.      f(x) = 0.392699
Angulo: -90 graus.      f(x) = -0.000000

Eu repeti os valores aqui porque estão aqui na minha tela e pode ajudar a conferir, mas o simples é abrir o Google Planilhas, grátis, ou o Excel 365 e digitar a fórmula numa planilha e assim pode digitar e conferir qualquer valor, certo?

porque fase2()? Se leu o nome da função pode ter ficado curioso. É porque esse era o segundo teste óbvio a fazer. O primeiro seria qual? Ler o arquivo e gerar a saída, claro. Eu preferi escrever antes sobre a função polo lance dos graus.

Citação

Vou deixar um exemplo completo ao final

Por falar no filtro, um "programa" para ler da entrada para a saída:

Estamos considerando um arquivo que só tem valores de x. Podem estar um por linha um vários numa linha talvez, mas serão apenas valores de x.
Em C++ há claro muitas maneiras de ler isso, mas o simples é usar streams e ler com ">>" e gravar com "<<". Porque não?
No entanto como é apenas um filtro e estamos usando C++ isso deve estar disponível em vários sabores, cores e tamanhos. Mas apenas com << >> e a função acima já serve, dentro de um loop, para resolver o problema
Um exemplo trivial: copiar strings da entrada para a saída. Veja fase1(), um programa de uma linha só:
```
void fase1(string arquivo_entrada, string arquivo_saida)
{
    ifstream entrada{ arquivo_entrada };
    ofstream saida{ arquivo_saida };
    ists x{ entrada };
    ists fim{};
    osts fx{ saida, "\n" };
    copy(x, fim, fx);
};
```
É só isso: copia do arquivo entrada para o arquivo saida as strings todas. Abre os arquivos, cria a saída, roda o loop, copia as strings e termina. O final vai ser dado por fim, que é o caso de ler {} --- ou seja nada --- do arquivo de entrada. Em C++ os iteradores fazem muito dessas coisas comuns de loop e filtros ficarem triviais. Entenda que as strings vão estar separadas um '\n' na saída: esse é o segundo parâmtetro de fx. Se você quisesse fazer por exemplo um sort() ou separar as palavras únicas ou sei lá o que, basta usar a mesma coisa do lado da entrada. Um iterador de entrada. E faz sentido.
Só que copy() não processa. Claro que deve ver alguma maneira de processar e aí seria só copiar o programa de uma linha para outro programa de uma linha. Processar no seu caso é apenas chamar aquela função que calcula f(x). E tem. Pelo menos duas. for_each() e transform() servem

Mas e a função como podia ser? Era uma das dúvidas afinal

Pode ser algo bem simples assim:

double      f(string string_x)
{
    const double PI = 3.1415926536;
    double x = stod(string_x, NULL);
    x = x * PI / 180.;
    return (x * sin(x) * cos(x));
};  // fx()

Podia ser mais curta mas assim é mais fácil de ler.

E como transformar cada x na entrada em f(x) na saída?

A opção "moderninha" em C++ é usar uma struct filtro porque afinal é um filtro.

Assim se pode usar outras funções e gravar em outros arquivos ou com outros delimitadores por exemplo. Tudo que a gente precisa na struct é a saída e a função, certo?

struct filtro
{
    osts saida;
    filtro(osts s) : saida(s){};
    void operator()(string string_x)
    {   const double    PI = 3.1415926536;
        double y = stod(string_x, NULL);
        double x = y * PI / 180.;
        x = x * sin(x) * cos(x);
        *saida = to_string(x);
    };
};  // filtro()

Sim, a função está dentro da struct e o iterador de saída que vai ser usado pra gravar os dados. É só o que precisa ter.

using osts = ostream_iterator<string>;

Esse using é como um typedef C para não ter que digitar toda hora esse nome gigante.
o {} é porque não tem código nenhum a mais: basta fazer saida = s para inicializar a saída e saber onde gravar os dados. E isso está lá mais compacto depois dos ':'. É o jeito comum de construir essas coisas. A struct só tem uma variável: saida.

E como fica um programa que usa um filtro desses?

void fase3(string arquivo_entrada, string arquivo_saida)
{
    ifstream entrada{ arquivo_entrada };
    ofstream saida{ arquivo_saida };
    ists x{ entrada };
    ists fim{};
    osts fx{ saida, "\n" };
    filtro f(fx);
    for_each(x, fim, f);
};

Passou de uma para duas linhas. A declaração do filtro e o for_each(). Claro que essa podia ser main()

Vou deixar um exemplo no fim e não queria escrever um programa com cada teste...

Para chamar seria algo bobinho como :

fase3("entrada.txt", "saida2.txt");

e vai criar o arquivo com os resultados.

Como funciona?

A lógica é simples: vai ler de x até fim. fim é quando não lê nada, tipo EOF ou erro. Vai ler strings. porque ists é

using ists = istream_iterator<string>;

Porque é muito chato escrever esses nomes grandes e faz o simples parecer complicado. Como ists é um iterador de string a vida segue: ele vai ler todas as strings na entrada até o fim de arquivo e passar cada uma delas para o filtro f. E o filtro f é uma variável, uma struct filtro. E faz sentido, certo?

Essa linha

    filtro f(fx);

declara f como sendo aquela struct, e fx é o parâmetro que vai ser usado para a saída. E a conta fecha: era preciso saber só o filtro --- a função de transformação --- e o arquivo de saída. Declaramos os dois. E se for preciso usar outro filtro ou outro arquivo de saída no mesmo programa sem problemas: basta declarar outros. Note que um programa sólido precisaria ter mais alguns cuidados. Isso aqui é um exemplo, escrito na hora do café. Mas acho que dá pra ver porque é mais rápido criar modelos com esse tipo de linguagem.

A linha seguinte

    for_each(x, fim, f);

faz o serviço: consome a entrada todinha passando cada string lida para f, o filtro que tem a função dentro.

Note que na entrada as strings serão aceitas uma ou mais por linha. Tanto faz entrar com

0 30 45 90 -30 -45 -90

ou

Se preciso for exigir uma só string por linha não é nada especial. Escrevi isso assim porque eu escolhi e porque é meu exemplo afinal. Eu queria só mostrar a técnica porque não vejo isso nos exemplos C-like que tem nos livros.

Mas e se for pra escrever como em C dos '80?

Não é muito mais difícil. Vai passar de duas para 7 linhas

void fase4(string arquivo_entrada, string arquivo_saida)
{
    ifstream entrada{ arquivo_entrada };
    ofstream saida{ arquivo_saida };
    string x;
    entrada >> x;
    while (!entrada.eof())
    {
        saida << to_string(f(x)) << endl;
        entrada >> x;
    };  // while()
    entrada.close();
    saida.close();
};

Usando os operadores normais de extração e inserção para streams, os tais << e >>, que são na verdade os operadores de shift redefinidos para streams. Coisas de C++ e classes stream. São chamados overload

O programa de exemplo com as 4 fases e o teste está aqui

Spoiler


#include <algorithm>
#include <fstream>
#include <functional>
#include <iostream>
#include <iterator>
#include <math.h>
#include <string>
using namespace std;
using ists = istream_iterator<string>;
using osts = ostream_iterator<string>;

struct filtro
{
    osts saida;
    filtro(osts s) : saida(s){};
    void operator()(string string_x)
    {   const double    PI = 3.1415926536;
        double y = stod(string_x, NULL);
        double x = y * PI / 180.;
        x = x * sin(x) * cos(x);
        *saida = to_string(x);
    };
};  // filtro()

double      f(string); // a propria f(x) = x*sin(x)*cos(x)

void        fase1(string,string);
void        fase2();
void        fase3(string, string);
void        fase4(string, string);

int main(int argc, char** argv)
{
    fase1("entrada.txt","saida1.txt");
    fase2();
    fase3("entrada.txt", "saida2.txt");
    fase4("entrada.txt", "saida3.txt");
    return 0;
};

void fase1(string arquivo_entrada, string arquivo_saida)
{
    ifstream entrada{ arquivo_entrada };
    ofstream saida{ arquivo_saida };
    ists x{ entrada };
    ists fim{};
    osts fx{ saida, "\n" };
    copy(x, fim, fx);
};

void fase2()
{
    const string valores[8]{ "0","30","45","90", "-30","-45","-90","90" };
    for (auto& x : valores)
    {
        cout << "Angulo: " << x << " graus.\tf(x) = " <<
            fixed << f(x) << endl;
    };
}

void fase3(string arquivo_entrada, string arquivo_saida)
{
    ifstream entrada{ arquivo_entrada };
    ofstream saida{ arquivo_saida };
    ists x{ entrada };
    ists fim{};
    osts fx{ saida, "\n" };
    filtro f(fx);
    for_each(x, fim, f);
};

void fase4(string arquivo_entrada, string arquivo_saida)
{
    ifstream entrada{ arquivo_entrada };
    ofstream saida{ arquivo_saida };
    string x;
    entrada >> x;
    while (!entrada.eof())
    {
        saida << to_string(f(x)) << endl;
        entrada >> x;
    };  // while()
    entrada.close();
    saida.close();
};

double      f(string string_x)
{
    const double PI = 3.1415926536;
    double x = stod(string_x, NULL);
    x = x * PI / 180.;
    return (x * sin(x) * cos(x));
};  // f()

// fim

Espero que ajude a entender as opções

Welington Silva 2002 · 7 de setembro de 2020

@arfneto Muito bom!!! Vou postar meu código aqui, como eu já havia feito:

Vou modularizar cm funções depois.

//TRABALHO 1 -- UNIFEI -
//WELINGTON SILVA (E.C.A)

#include <iostream> //cin cout
#include <fstream>  //ofstream, ifstream, fstream
#include <stdlib.h> //system pause
#include <math.h> //calcular função 01
using namespace std; //cout,cin


int main()
{
    ofstream grava; 
	
	// grava = variável para escrever os dados em um arquivo Arq02.txt
    // OBS.: ALTERE os diretorios abaixo para o local onde estes arquivo se encontram!!!
    grava.open("C:/Users/welin/Desktop/AEDS/PROJECTS/PROJ1 - ARQ01/Arq02.txt"); //diretorio

    int i, j; //variaveis de iteração
    int l = 0, c = 0;  //variaveis para o tamanho do vetor coluna [500][1] 
				      //dos dados a serem lidos em Ar01.txt

    ifstream readFile;     // variável para ler um arquivo .txt	
    // readFile = variável qualquer de leitura do arquivo 'Arq01.txt' que contém os valores desejados de entrada
    // OBS.: ALTERE os diretorios abaixo para o local onde estes arquivo se encontram!!!
    readFile.open("C:/Users/welin/Desktop/AEDS/PROJECTS/PROJ1 - ARQ01/Arq01.txt");
if(readFile)
{
    // Lê a primeira linha do arquivo, onde contém o número de linhas e colunas e armazena
    // estes valores nas variáveis l e c, respectivamente, coloquei 500 e 1 em Arq01 no inicio
    readFile >> l >> c;
    
    	cout << endl
         << "Initializing..." << endl               //pra ficar bonitinho
         << endl;

    float matriz[l][c];             // matriz para ler os valores do arquivo Arq01.txt
 								   // Armazena os valores contidos no arquivo Arq01.txt na matriz 'matriz'
    for (i = 0; i < l; i++)       //pegando os valores em Arq01, linha por linha do vetor coluna
    {
        for (j = 0; j < c; j++)
        {
            readFile >> matriz[i][j]; //lê cada linha e imprime (no cout abaixo) para se ter o controle do processo

            cout <<i<<" "<< j << " "<<matriz[i][j]<<endl; //somente para controle
        }
    }

  //fim de aquisição, inicio de manipulação
  
	cout << endl
         << "Tratando dados na funcao..." << endl    //mais uma vez, para ficar bonitinho
         << endl;
         
float y[l][c]; //outra matriz y[500][1] só que para gravar agr
for (i=0; i<l; i++) //iteração
{
	for (j = 0; j < c; j++)
        {
        	float x = matriz[i][j]; //x recebe o valor de cada linha lido no Arq01.txt e é usado na função
        	y[i][j] = x* cos(x)* sin(x); //função 01
        	grava << y[i][j] << endl; //"grava" recebe os valores tratados e armazena em Arq02.txt
            cout <<y[i][j]<<endl; //imprime os valores já tratados
        }
}

}

else 
{cout<<"\n\tDiretorio incorreto para leitura do arquivo Arq01.txt. Digite um diretorio valido!"<<endl<<endl<<endl;}
   
    system ("pause"); //pausa o programa
    return 0; //fim do processamento
}

adicionado 0 minutos depois

agora, Welington Silva 2002 disse:

@arfneto Muito bom!!! Vou postar meu código aqui, como eu já havia feito:

Vou modularizar cm funções depois.


//TRABALHO 1 -- UNIFEI -
//WELINGTON SILVA (E.C.A)

#include <iostream> //cin cout
#include <fstream>  //ofstream, ifstream, fstream
#include <stdlib.h> //system pause
#include <math.h> //calcular função 01
using namespace std; //cout,cin


int main()
{
    ofstream grava; 
	
	// grava = variável para escrever os dados em um arquivo Arq02.txt
    // OBS.: ALTERE os diretorios abaixo para o local onde estes arquivo se encontram!!!
    grava.open("C:/Users/welin/Desktop/AEDS/PROJECTS/PROJ1 - ARQ01/Arq02.txt"); //diretorio

    int i, j; //variaveis de iteração
    int l = 0, c = 0;  //variaveis para o tamanho do vetor coluna [500][1] 
				      //dos dados a serem lidos em Ar01.txt

    ifstream readFile;     // variável para ler um arquivo .txt	
    // readFile = variável qualquer de leitura do arquivo 'Arq01.txt' que contém os valores desejados de entrada
    // OBS.: ALTERE os diretorios abaixo para o local onde estes arquivo se encontram!!!
    readFile.open("C:/Users/welin/Desktop/AEDS/PROJECTS/PROJ1 - ARQ01/Arq01.txt");
if(readFile)
{
    // Lê a primeira linha do arquivo, onde contém o número de linhas e colunas e armazena
    // estes valores nas variáveis l e c, respectivamente, coloquei 500 e 1 em Arq01 no inicio
    readFile >> l >> c;
    
    	cout << endl
         << "Initializing..." << endl               //pra ficar bonitinho
         << endl;

    float matriz[l][c];             // matriz para ler os valores do arquivo Arq01.txt
 								   // Armazena os valores contidos no arquivo Arq01.txt na matriz 'matriz'
    for (i = 0; i < l; i++)       //pegando os valores em Arq01, linha por linha do vetor coluna
    {
        for (j = 0; j < c; j++)
        {
            readFile >> matriz[i][j]; //lê cada linha e imprime (no cout abaixo) para se ter o controle do processo

            cout <<i<<" "<< j << " "<<matriz[i][j]<<endl; //somente para controle
        }
    }

  //fim de aquisição, inicio de manipulação
  
	cout << endl
         << "Tratando dados na funcao..." << endl    //mais uma vez, para ficar bonitinho
         << endl;
         
float y[l][c]; //outra matriz y[500][1] só que para gravar agr
for (i=0; i<l; i++) //iteração
{
	for (j = 0; j < c; j++)
        {
        	float x = matriz[i][j]; //x recebe o valor de cada linha lido no Arq01.txt e é usado na função
        	y[i][j] = x* cos(x)* sin(x); //função 01
        	grava << y[i][j] << endl; //"grava" recebe os valores tratados e armazena em Arq02.txt
            cout <<y[i][j]<<endl; //imprime os valores já tratados
        }
}

}

else 
{cout<<"\n\tDiretorio incorreto para leitura do arquivo Arq01.txt. Digite um diretorio valido!"<<endl<<endl<<endl;}
   
    system ("pause"); //pausa o programa
    return 0; //fim do processamento
}

@devair1010

adicionado 2 minutos depois

Esses são os valores de Arq01.txt (o 500 1) é só para usar como matriz

500 1
-50
-49.8
-49.599
-49.399
-49.198
-48.998
-48.798
-48.597
-48.397
-48.196
-47.996
-47.796
-47.595
-47.395
-47.194
-46.994
-46.794
-46.593
-46.393
-46.192
-45.992
-45.792
-45.591
-45.391
-45.19
-44.99
-44.79
-44.589
-44.389
-44.188
-43.988
-43.788
-43.587
-43.387
-43.186
-42.986
-42.786
-42.585
-42.385
-42.184
-41.984
-41.784
-41.583
-41.383
-41.182
-40.982
-40.782
-40.581
-40.381
-40.18
-39.98
-39.78
-39.579
-39.379
-39.178
-38.978
-38.778
-38.577
-38.377
-38.176
-37.976
-37.776
-37.575
-37.375
-37.174
-36.974
-36.774
-36.573
-36.373
-36.172
-35.972
-35.772
-35.571
-35.371
-35.17
-34.97
-34.77
-34.569
-34.369
-34.168
-33.968
-33.768
-33.567
-33.367
-33.166
-32.966
-32.766
-32.565
-32.365
-32.164
-31.964
-31.764
-31.563
-31.363
-31.162
-30.962
-30.762
-30.561
-30.361
-30.16
-29.96
-29.76
-29.559
-29.359
-29.158
-28.958
-28.758
-28.557
-28.357
-28.156
-27.956
-27.756
-27.555
-27.355
-27.154
-26.954
-26.754
-26.553
-26.353
-26.152
-25.952
-25.752
-25.551
-25.351
-25.15
-24.95
-24.749
-24.549
-24.349
-24.148
-23.948
-23.747
-23.547
-23.347
-23.146
-22.946
-22.745
-22.545
-22.345
-22.144
-21.944
-21.743
-21.543
-21.343
-21.142
-20.942
-20.741
-20.541
-20.341
-20.14
-19.94
-19.739
-19.539
-19.339
-19.138
-18.938
-18.737
-18.537
-18.337
-18.136
-17.936
-17.735
-17.535
-17.335
-17.134
-16.934
-16.733
-16.533
-16.333
-16.132
-15.932
-15.731
-15.531
-15.331
-15.13
-14.93
-14.729
-14.529
-14.329
-14.128
-13.928
-13.727
-13.527
-13.327
-13.126
-12.926
-12.725
-12.525
-12.325
-12.124
-11.924
-11.723
-11.523
-11.323
-11.122
-10.922
-10.721
-10.521
-10.321
-10.12
-9.9198
-9.7194
-9.519
-9.3186
-9.1182
-8.9178
-8.7174
-8.517
-8.3166
-8.1162
-7.9158
-7.7154
-7.515
-7.3146
-7.1142
-6.9138
-6.7134
-6.513
-6.3126
-6.1122
-5.9118
-5.7114
-5.511
-5.3106
-5.1102
-4.9098
-4.7094
-4.509
-4.3086
-4.1082
-3.9078
-3.7074
-3.507
-3.3066
-3.1062
-2.9058
-2.7054
-2.505
-2.3046
-2.1042
-1.9038
-1.7034
-1.503
-1.3026
-1.1022
-0.9018
-0.7014
-0.501
-0.3006
-0.1002
0.1002
0.3006
0.501
0.7014
0.9018
1.1022
1.3026
1.503
1.7034
1.9038
2.1042
2.3046
2.505
2.7054
2.9058
3.1062
3.3066
3.507
3.7074
3.9078
4.1082
4.3086
4.509
4.7094
4.9098
5.1102
5.3106
5.511
5.7114
5.9118
6.1122
6.3126
6.513
6.7134
6.9138
7.1142
7.3146
7.515
7.7154
7.9158
8.1162
8.3166
8.517
8.7174
8.9178
9.1182
9.3186
9.519
9.7194
9.9198
10.12
10.321
10.521
10.721
10.922
11.122
11.323
11.523
11.723
11.924
12.124
12.325
12.525
12.725
12.926
13.126
13.327
13.527
13.727
13.928
14.128
14.329
14.529
14.729
14.93
15.13
15.331
15.531
15.731
15.932
16.132
16.333
16.533
16.733
16.934
17.134
17.335
17.535
17.735
17.936
18.136
18.337
18.537
18.737
18.938
19.138
19.339
19.539
19.739
19.94
20.14
20.341
20.541
20.741
20.942
21.142
21.343
21.543
21.743
21.944
22.144
22.345
22.545
22.745
22.946
23.146
23.347
23.547
23.747
23.948
24.148
24.349
24.549
24.749
24.95
25.15
25.351
25.551
25.752
25.952
26.152
26.353
26.553
26.754
26.954
27.154
27.355
27.555
27.756
27.956
28.156
28.357
28.557
28.758
28.958
29.158
29.359
29.559
29.76
29.96
30.16
30.361
30.561
30.762
30.962
31.162
31.363
31.563
31.764
31.964
32.164
32.365
32.565
32.766
32.966
33.166
33.367
33.567
33.768
33.968
34.168
34.369
34.569
34.77
34.97
35.17
35.371
35.571
35.772
35.972
36.172
36.373
36.573
36.774
36.974
37.174
37.375
37.575
37.776
37.976
38.176
38.377
38.577
38.778
38.978
39.178
39.379
39.579
39.78
39.98
40.18
40.381
40.581
40.782
40.982
41.182
41.383
41.583
41.784
41.984
42.184
42.385
42.585
42.786
42.986
43.186
43.387
43.587
43.788
43.988
44.188
44.389
44.589
44.79
44.99
45.19
45.391
45.591
45.792
45.992
46.192
46.393
46.593
46.794
46.994
47.194
47.395
47.595
47.796
47.996
48.196
48.397
48.597
48.798
48.998
49.198
49.399
49.599
49.8
50

adicionado 5 minutos depois

Para gerar o gráfico em MatLab, fiz assim:

valores_y = load('C:/Users/welin/Desktop/AEDS/PROJECTS/PROJ1 - ARQ01/Arq02.txt'); % comando para carregar valores de um arquivo
valores_x = load('C:/Users/welin/Desktop/AEDS/PROJECTS/PROJ1 - ARQ01/Arq01x.txt'); % comando para carregar valores de um arquivo

figure('Name','GRAFICO GERADO')

plot(valores_x, valores_y) % cria um gráfico contínuo
xlabel('X')
ylabel('f(x)')
title('f(x) = x cos(x) sin(x)')
grid on