diario-beatriz_paz

[beatriz-paz]

Diário de bordo

[beatriz-paz]

27/03/23

Hoje a aula de programação foi disponibilizada para que pudéssemos dar inicio ao projeto.

• Projeto escolhido: Analisador de preços de ações
• Grupo criado, composto por: Leonardo, Júlia e Beatriz
• Criamos o repositório no GitHub

Iniciamos no desenvolvimento do projeto, entendendo-o, e buscando dividir em pedaços para conseguimos conclui-lo.

• Nosso problema inicial, o que seria a primeira parte, era fazer a leitura do arquivo e armazenar de forma estruturada a data e o preço da ação, pensando em uma forma estratégica para usar essas informações depois. No inicio pensamos em armazenar o preço das ações em uma lista, e por conta dessa ideia adaptamos a função que "obtem_primeiro" valor da string, para obter o último, que é o preço. E após usaríamos os preços da lista para fazer o calculo do "dia anterior mais próximo cujo preço de ação seja maior que o dia presente" e armazenaríamos o resultado numa pilha de dados. Ficando dessa forma:

• Contudo, após analisarmos melhor o problema, percebemos que essa forma de ler o arquivo não é tão estratégica, e uma possibilidade melhor e mais viável seria criar um novo tipo de dado (struct) que contenha: data, preço e valor de recorrência do aumento do preço.

[beatriz-paz]

28/03/23

• Conseguimos desenvolver a parte do código que faz a leitura do arquivo e armazena na struct criada chamada 'Acoes" e guarda em uma estrutura do tipo vetor.

• Após pensei em criar um loop para desenvolver a parte do código que precisa calcular a sequencia de dias que aumentaram os valores das ações. Contudo os 2 loops pensados não deram certos. Abaixo deixo o código com as mudanças propostas, e as ideias do loop:

#include <iostream>
#include <fstream>
#include <error.h>
#include <sstream>
#include <stack>
#include <vector>

using namespace std;

struct Acoes{
    string data;
    double preco, preco_crescente, probabilidade_dias;
};

int main(int argc, char * argv[]) {

    //criando um arquivo para leitura
    ifstream arq(argv[1]);

    //verifica se conseguiu abrir o arquivo
    if (! arq.is_open()){
        perror("Ao abrir ");
        return errno;
    }

    //criando um vetor do tipo Acoes que foi criado
    vector<Acoes>info_acoes;

    //cria uma variavel linha para conseguir armazenar a linha lida do arquivo no loop
    string linha;

    //ler as linhas do arquivo, armazenando em um vetor os precos
    while (getline(arq, linha)) {

        istringstream frase(linha);
        Acoes dados_acoes;

        frase >> dados_acoes.data >> dados_acoes.preco; // ler a linha do arquivo e armazena a data e o preço na struct criada através do operador de extração ">>"
        info_acoes.push_back(dados_acoes); //adiciona ao vetor a struct
    }

    //pilha para armazenar "o dia anterior mais próximo cujo preço de ação seja maior que o dia presente."
    stack<double>dias_preco_crescente;
    dias_preco_crescente.push(0);

    // PRIMEIRA IDEIA DE LOOP

    /* while (!dias_preco_crescente.empty()){
        for (int i = 0; i < info_acoes.size() ; ++i) {
            if (dias_preco_crescente.top() <= info_acoes[i].preco){
                if (dias_preco_crescente.empty()){
                    dias_preco_crescente.push(i + 1);
                } else {
                    dias_preco_crescente.push(1 - dias_preco_crescente.top());
                }
            } else{
                dias_preco_crescente.push(info_acoes[i].preco);
            }
        }
    } */

    // SEGUNDA IDEIA DE LOOP

    for (int i = 0; i < info_acoes[i].preco; ++i) {
        while (!dias_preco_crescente.empty() && dias_preco_crescente.top() <= info_acoes[i].preco){
            dias_preco_crescente.pop();
        }
        if (dias_preco_crescente.empty()){
            dias_preco_crescente.push(i + 1);
        } else {
            dias_preco_crescente.push(1 - dias_preco_crescente.top());
        }

        dias_preco_crescente.push(i);

    }

    return 0;

}

[beatriz-paz]

29/03/23

• Durante a aula de programação tentamos desenvolver a parte da lógica do código que deve gerar o primeiro arquivo como resultado que seria os "Dias com preço menor ou igual". Porém com o auxílio do professor, percebemos a necessidade de fazer uma alteração na struct criada, ou seja, ao invés de criar uma struct que armazena dados de entrada e saída, dividimos em structs de entrada, resultado1 e resultado2. Isso para auxiliar na codificação e legibilidade do código.

Pendências:

Criar funções que ler o arquivo de entrada Deixar o código já feito mais elegante e eficiente Desenvolver a logica e programar a parte do código que gerar o resultado1 e 2

[beatriz-paz]

31/03/23

• Hoje conseguimos concluir a função do código que gera o vetor com as informações do arquivo de entrada (data e preço).
• Criamos um novo loop para calcular os dias, porém o mesmo ainda não está completo, falta finalizar a parte de armazenar os dias calculador na struct criada chamada Resultado.

Código até o momento está dessa forma:

#include <iostream>
#include <fstream>
#include <error.h>
#include <sstream>
#include <stack>
#include <vector>

using namespace std;

// tipo de dado criado para armazenar os valores do arquivo de entrada
struct CotacaoAcoes{
    string data;
    double preco;
};

struct Resultado{
    string data;
    int dias_preco_aumentou;
};

struct Contagem{
    string data;
    double probabilidade_dias = 0;
};

//função que ler os dados de entrada e armazena em um vetor do tipo "CotacaoAcoes"
vector<CotacaoAcoes>dados_entrada(ifstream * arq){
    string linha;
    vector<CotacaoAcoes>info_acoes;

    while (getline(*arq, linha)) {

        istringstream frase(linha);
        CotacaoAcoes dados_acoes;

        frase >> dados_acoes.data >> dados_acoes.preco; // ler a linha do arquivo e armazena a data e o preço na struct criada através do operador de extração ">>"
        info_acoes.push_back(dados_acoes); //adiciona ao vetor a struct "dados_acoes"
    }
    return info_acoes;
}

int main(int argc, char * argv[]) {

    //criando um arquivo para leitura
    ifstream arq(argv[1]);

    //verifica se conseguiu abrir o arquivo
    if (! arq.is_open()){
        perror("Ao abrir ");
        return errno;
    }

    // vetor que armazena os dados lidos do arquivo usando a função "dados_entrada" para tal operação
    vector<CotacaoAcoes>info_acoes = dados_entrada(&arq);

    //pilha para armazenar "o dia anterior mais próximo cujo preço de ação seja maior que o dia presente."
    stack<int>dias_preco_crescente;
    dias_preco_crescente.push(0);

    vector<Resultado>dia;

    for (int i = 0; i < info_acoes.size(); ++i) {

        dia.push_back(Resultado()); 

        while (!dias_preco_crescente.empty() && info_acoes[dias_preco_crescente.top()].preco <= info_acoes[i].preco) {
            dias_preco_crescente.pop();
        }

        int dia_com_aumento_preco = 0;

        if (dias_preco_crescente.empty()) {
            dias_preco_crescente.push(dia_com_aumento_preco = i + 1);
        } else {
            dias_preco_crescente.push(1 - dias_preco_crescente.top());
        }

        dias_preco_crescente.push(i);

        //teste
        dia[i].dias_preco_aumentou = dias_preco_crescente.top() - 1;
        dia[i].data = info_acoes[i].data;

    }

    return 0;

}

[beatriz-paz]

31/03/23

• Conseguimos criar o loop que calcula a quantidade de dias que houve um aumento do preço, ficando dessa forma inicialmente:

//pilha para armazenar "o dia anterior mais próximo cujo preço de ação seja maior que o dia presente."
    stack<int>dias_preco_crescente;
    dias_preco_crescente.push(0);

    vector<Resultado>dia;

    for (int i = 0; i < info_acoes.size(); ++i) {

        dia.push_back(Resultado());

        while (!dias_preco_crescente.empty() && info_acoes[dias_preco_crescente.top()].preco <= info_acoes[i].preco) {
            dias_preco_crescente.pop();
        }

        if (dias_preco_crescente.empty()) {
            dias_preco_crescente.push(i + 1);
            dia[i].dias_preco_aumentou = i + 1;
        } else {
            dia[i].dias_preco_aumentou = i - dias_preco_crescente.top();
            dias_preco_crescente.push(1 - dias_preco_crescente.top());
        }

        dias_preco_crescente.push(i);
        dia[i].data = info_acoes[i].data;

    }

Pendências:

• Criar a parte do código que escreve em um arquivo de saida o resultado dos dias calculados no loop feito;
• Desenvolver a segunda parte do programa que calcula "as probabilidades de duração de preço ascendente";
• Limpar o código, deixando-o mais claro e eficiente;

[beatriz-paz]

01/04/23

Hoje tentamos implementar a segunda parte do projeto que seria um loop para calcular as probabilidades de duração de preço ascendente. Contudo não conseguimos deixá-lo pronto, até o momento temos essa ideia de loop:

//vector<Contagem>probabilidade_aumento_preco;
    vector<Contagem>probabilidade_aumento_preco;

    // loop para calcular as probabilidades de duração de preço ascendente

        int contador = 0;
        for (int i = 0; i < info_acoes.size(); i++) {
            int numero = dia[i].dias_preco_aumentou;
            while (i < dia.size()) {
                numero = dia[i].dias_preco_aumentou;
                int digitoAtual = numero % 10;
                if (digitoAtual == dia[i].dias_preco_aumentou) {
                    contador++;
                }
                int num = numero /= 10;
                i++;
            }
        }

Pendências:

• Terminar o loop da segunda parte;
• Criar a parte do código que escreve em um arquivo de saida o resultado dos dias calculados no loop feito;
• Limpar o código, deixando-o mais claro e eficiente;

[beatriz-paz]

02/04/23

Hoje pela manhã tive a ideia de como montar o loop do calculo da probabilidade, passei para o código, testei e funcionou!

vector<Contagem>probabilidade_aumento_preco;

    for (int i = 0; i < dia.size(); ++i) {
        double contador = 0;
        int qtd_dia = dia[i].dias_preco_aumentou;
        for (int j = 0; j < dia.size(); ++j) {
            if (dia[j].dias_preco_aumentou == qtd_dia){
                contador++;
            }
        }
        double probabilidade = contador / dia.size();
        probabilidade_aumento_preco.push_back(Contagem());
        probabilidade_aumento_preco[i].dia = qtd_dia;
        probabilidade_aumento_preco[i].probabilidade_dias = probabilidade;
    }

• O loop acima, além de calcular a quantidade de vezes que aparece um certo digito armazenando na variável contador, ele também já faz o calculo da probabilidade e guarda a informação no vetor de probabilidade.

Após conseguir desenvolver a parte do código que escreve num arquivo de saída os resultados calculados, ficando dessa forma:

//criando o arquivo de saida "resultado" que contém o calculo da quantidade de dias que teve o aumento do preço
    ofstream arq_dias("resultado.txt");
    //valida se deu para abrir o arquivo criado
    if (not arq_dias.is_open()) {
        cerr << "Algum erro ao abrir o arquivo ..." << endl;
        return 0;
    }
    // Percorre o vetor "dia" e escreve cada elemento no arquivo resultado
    for (auto elemento : dia) {
        arq_dias << elemento.data << " "<< elemento.dias_preco_aumentou << endl;
    }

    //criando o arquivo de saida "contagem" que contém o calculo da probabilidade de dias que teve o aumento do preço
    ofstream arq_probabilidade("contagem.txt");
    //valida se deu para abrir o arquivo criado
    if (not arq_probabilidade.is_open()) {
        cerr << "Algum erro ao abrir o arquivo ..." << endl;
        return 0;
    }
    // Percorre o vetor "probabilidade_aumento_preco" e escreve cada elemento no arquivo resultado
    for (auto elemento : probabilidade_aumento_preco) {
        arq_probabilidade << elemento.dia << " "<< elemento.probabilidade_dias << endl;
    }

• Tentei criar uma função para que essa já criasse o arquivo, passando apenas o nome do mesmo como parâmetro, porém achei que não ajudou muito a otimizar linhas de código;

Pendências:

• Verificar uma forma para arredondar o calculo da probabilidade;
• Limpar o código, deixando-o mais claro e eficiente;

[beatriz-paz]

02/04/23

Código do projeto finalizado.

Versão final está já no repositório do github

• Deixamos o código mais limpo transformando loops, como o que calcula a probabilidade, em funções. Abaixo apresento todas as funções criadas das quais usamos no programa:

//função que ler os dados de entrada e armazenar em um vetor do tipo "CotacaoAcoes"
vector<CotacaoAcoes>dados_entrada(ifstream * arq){
    string linha;
    vector<CotacaoAcoes>info_acoes;

    while (getline(*arq, linha)) {

        istringstream frase(linha);
        CotacaoAcoes dados_acoes;

        frase >> dados_acoes.data >> dados_acoes.preco; // ler a linha do arquivo e armazena a data e o preço na struct criada através do operador de extração ">>"
        info_acoes.push_back(dados_acoes); //adiciona ao vetor a struct "dados_acoes"
    }
    return info_acoes;
}

// Função para calcular os dias com preço ascendente e armazenar em um vetor
vector<Resultado>dias_preco_ascendente(vector<CotacaoAcoes>&info_acoes){
    vector<Resultado>dia;
    //pilha para armazenar "o dia anterior mais próximo cujo preço de ação seja maior que o dia presente."
    stack<int>dias_preco_crescente;
    dias_preco_crescente.push(0);

    for (int i = 0; i < info_acoes.size(); ++i) {

        dia.push_back(Resultado());

        while (!dias_preco_crescente.empty() && info_acoes[dias_preco_crescente.top()].preco <= info_acoes[i].preco) {
            dias_preco_crescente.pop();
        }

        if (dias_preco_crescente.empty()) {
            dias_preco_crescente.push(i + 1);
            dia[i].dias_preco_aumentou = i + 1;
        } else {
            dia[i].dias_preco_aumentou = i - dias_preco_crescente.top();
            dias_preco_crescente.push(1 - dias_preco_crescente.top());
        }

        dias_preco_crescente.push(i);
        dia[i].data = info_acoes[i].data;
    }

    return dia;
}

// Função para calcular a probabilidade de repetição de preço ascendente e armazena o resultado em um vetor
vector<Contagem>calculo_probabilidade(vector<Resultado>&dia){
    vector<Contagem>probabilidade_aumento_preco;

    for (int i = 0; i < dia.size(); ++i) {
        double contador = 0;
        int qtd_dia = dia[i].dias_preco_aumentou;
        for (int j = 0; j < dia.size(); ++j) {
            if (dia[j].dias_preco_aumentou == qtd_dia){
                contador++;
            }
        }
        double probabilidade = contador / dia.size();
        probabilidade_aumento_preco.push_back(Contagem());
        probabilidade_aumento_preco[i].dia = qtd_dia;
        probabilidade_aumento_preco[i].probabilidade_dias = probabilidade;
    }
    return probabilidade_aumento_preco;
}

// Função para ordenar o vetor de probabilidade e remover os valores repetidos
vector<Contagem>ordena_e_remove_rep(vector<Contagem>&probabilidade_aumento_preco){
    // usando a função SORT para ordenar o vetor de probabilidade
    sort(probabilidade_aumento_preco.begin(), probabilidade_aumento_preco.end(), [](const Contagem& a, const Contagem& b) {
        return a.dia < b.dia;
    });
    // remover elementos duplicados do vetor usando a função UNIQUE
    auto it = unique(probabilidade_aumento_preco.begin(), probabilidade_aumento_preco.end(), [](const Contagem& a, const Contagem& b) {
        return a.dia == b.dia;
    });
    probabilidade_aumento_preco.erase(it, probabilidade_aumento_preco.end());

    return probabilidade_aumento_preco;
}

• Resolvemos a questão do arredondamento do valor da probabilidade calculado, criando o seguinte loop:

 // Percorre o vetor "probabilidade_aumento_preco" e escreve cada elemento no arquivo resultado
    for (auto elemento : probabilidade_aumento_preco) {
        // Arredonda o valor do elemento para 4 casas decimais

        elemento.probabilidade_dias = round(elemento.probabilidade_dias * 10000) / 10000;
        arq_probabilidade << elemento.dia << " " << fixed << setprecision(4) << elemento.probabilidade_dias << endl;
    }

• Antes de enviarmos a versão final para o repositório, testamos o programa com os arquivos disponibilizados pelo professor na apresentação do projeto, e o mesmo funcionou conforme esperado.

[beatriz-paz]

03/04/23

Pensamos que havíamos finalizado o projeto, contudo antes de enviá-lo, ao testar no computador Linux do IFSC ocorreu um erro, que basicamente significava que nosso programa estava tentando acessar um espaço de memória inacessível. Com o auxílio do professor, conseguimos resolver esse bug ajustando a seguinte linha de código: dias_preco_crescente.push(1 + i - dias_preco_crescente.top()), adicionando o "i" no calculo. Essa parte do código encontra-se dentro da função abaixo:

// Função para calcular os dias com preço ascendente e armazenar em um vetor
vector<Resultado>dias_preco_ascendente(vector<CotacaoAcoes>&info_acoes){
    vector<Resultado>dia;
    //pilha para armazenar "o dia anterior mais próximo cujo preço de ação seja maior que o dia presente."
    stack<int>dias_preco_crescente;
    dias_preco_crescente.push(0);

    for (int i = 0; i < info_acoes.size(); ++i) {

        dia.push_back(Resultado());

        while (!dias_preco_crescente.empty() && info_acoes[dias_preco_crescente.top()].preco <= info_acoes[i].preco) {
            dias_preco_crescente.pop();
        }

        if (dias_preco_crescente.empty()) {
            dias_preco_crescente.push(i + 1);
            dia[i].dias_preco_aumentou = i + 1;
        } else {
            dia[i].dias_preco_aumentou = i - dias_preco_crescente.top();
            dias_preco_crescente.push(1 + i - dias_preco_crescente.top());

        }

        dias_preco_crescente.push(i);
        dia[i].data = info_acoes[i].data;
    }

    return dia;
}

Essa correção, permitiu que o código rodasse e gerasse os dois arquivos de saída sem problema. Contudo, foi verificado que por algum motivo ainda não entendido, o arquivo que calcula a probabilidade está gerando uns numeros diferentes do arquivo de exemplo do professor, o que antes não ocorria, gerava os dois arquivos certos.

Por consequência:

• Ainda não entregamos o projeto, pois precisamos verificar uma forma de corrigir o arquivo de saída de probabilidade;
• Fazer o relatório sobre o projeto;

[beatriz-paz]

03/04/23

Relatório do projeto finalizado!

Pendência:

• verificar uma forma de corrigir o arquivo de saída gerado pelo programa;

[beatriz-paz]

04/04/23

Por falta de tempo, não conseguimos corrigir a tempo o bug do código. Então tivemos que entregar o projeto da forma como está mesmo.