Calculando casas de um numero flutuante em c++ [RESOLVIDO]

dark777
(usa Debian)

Enviado em 09/12/2024 - 00:16h

Ola galera beleza?

Fiz o seguinte programa em c++:

#include <cmath>

#include <string>

#include <sstream>

#include <iomanip>

#include <iostream>



size_t countNumber(const double& number)

{

 double n = number;



 std::string numberStr = std::to_string(n);

 

 size_t pos = numberStr.find('.');

 

 if (pos != std::string::npos)

  {

   size_t count = (numberStr.length() - 1);

  }

 

 return count;

}



std::string concatNumber(const double& number)

{

 double n = number;

 

 std::string numberStr = std::to_string(n);

 

 size_t pos = numberStr.find('.');

    

 size_t count = (pos != std::string::npos) ? (numberStr.length() - 1) : (numberStr.substr(pos + 1).length());

 

 std::string result = "1.";

 

 for (size_t i = 0; i < count; ++i) result += "0";



 return result;

}



int main()

{

 double parteInteira, parteDecimal;



 const double& number = 185.153989965;

 

 size_t casasDecimais = countNumber(number);



 parteDecimal = modf(number, &parteInteira);



 //double numConcat = concatNumber(number);



 std::cout << "\nParte Inteira.: " << parteInteira

           << "\nParte Decimal.: " << parteDecimal

           << "\nNumber concat.: " << concatNumber(number)

           << "\nCasas Decimais: " << casasDecimais

           << "\nValor Calculado.: (parteDecimal / numConcat)"

           << std::endl;

}

 

O porgrama gera a saida:

Parte Inteira.: 185

Parte Decimal.: 0.15399

Number concat.: 1.000000000

Casas Decimais: 9

Valor Calculado.: (parteDecimal / numConcat)

 

O objetivo é contar a quantidade de casas decimais após o primeiro ponto, criar um numero divisor com a mesma quantidade de casas decimais, e entao dividir o numero decimal por este numero gerado, o problema é que nao estou entendendo como pegar o valor concatenado completo e dividir pela parte decimal ou seja converter a string em double sem que "std::stod" trunque a quantidade de casas do numero concatenado, como converter o numero gerado para double e realizar a divisão corretamente como segue abaixo:

Valor Calculado.: (parteDecimal / numConcat)

 

wiki.anon

alexabolada
(usa Debian)

Enviado em 09/12/2024 - 00:16h

Olá! Vamos dar uma olhada no seu código C++ e ver como podemos resolver a questão da conversão da string para double sem truncar as casas decimais.

Primeiro, seu código já está bem estruturado, mas o problema que você mencionou ocorre porque `std::stod` pode não lidar corretamente com números que têm muitas casas decimais.

Uma alternativa é usar um tipo de dado que suporte precisão maior, como `boost::multiprecision::cpp_dec_float`, se você estiver disposto a usar uma biblioteca externa. Mas se preferir não usar bibliotecas externas ou se precisar de uma solução simples, podemos fazer algumas modificações. Vamos focar em como lidar com a string da maneira correta.

Por exemplo, ao invés de criar `numConcat` como uma string, você poderia iterar sobre a parte decimal e gerar o divisor diretamente como um número de ponto flutuante. Aqui está uma maneira de fazer isso:

```cpp
#include <cmath>
#include <string>
#include <sstream>
#include <iomanip>
#include <iostream>

size_t countNumber(const double& number) {
size_t pos;
std::string numberStr = std::to_string(number);

pos = numberStr.find('.');

return (pos != std::string::npos) ? (numberStr.length() - pos - 1) : 0;
}

double createDivisor(size_t count) {
return pow(10, count);
}

int main() {

paulo1205
(usa Ubuntu)

Enviado em 10/12/2024 - 04:40h

Não sei quão (in)eficiente seria, mas eu provavelmente usaria o conhecimento sobre a quantidade de bits no número de ponto flutuante e quantos desses bits são ocupados pela parte inteira para calcular quantos dígitos disponíveis há depois da vírgula para representar o número com a maior precisão possível (por exemplo: como double tem entre 15 e 16 dígitos de precisão, um valor como 12345,678 provavelmente vai dizer que tem 5 dígitos inteiros e 11 dígitos fracionários; por outro lado um valor como 0,0625 possivelmente diria que há 0 inteiros e 18 fracionários).

// NOTA: Este código não em C++ foi testado. É apenas para dar uma ideia.



#include <math>

#include <limits>

#include <stdexcept>



#include <cstdlib>



template <typename SOME_FLOAT> void conta_digitos(SOME_FLOAT valor, size_t &digitos_inteiros, size_t &digitos_fracionarios){

	constexpr size_t TOTAL_DIGITOS=std::numeric_limits<SOME_FLOAT>::max_digits10;

	constexpr SOME_FLOAT zero(0), um(1);



	if(isnan(valor) || isinf(valor))

		throw std::range_error("valor não pode ser expresso em forma numérica");



	SOME_FLOAT valor_nao_negativo(valor<zero? -valor: valor);

	if(valor_nao_negativo>=um){

		digitos_inteiros=floor(std::log10(valor_nao_negativo));

		digitos_fracionarios=TOTAL_DIGITOS-digitos_inteiros;

	}

	if(valor_nao_negativo>zero){

		digitos_inteiros=0;

		digitos_fracionarios=TOTAL_DIGITOS-floor(std::log10(valor_nao_negativo));

	}

	else

		digitos_inteiros=digitos_fracionarios=0;

} 

... Então Jesus afirmou de novo: “(...) eu vim para que tenham vida, e a tenham plenamente.” (João 10:7-10)