Resultado "curioso" al elevar el numero 5 al cuadrado y al cubo con "pow", en C++

Question

C++

#include <math.h>
#include <iostream>
#include <stdlib.h>
#include <stdio.h>
    
using namespace std;
    
int main()
{
    int cubo = 0;
    cubo = pow(5, 3);
    cout << "POW a traves de la variable 'cubo': " << cubo << endl; // me devuelve 124 (mal)
    cout << "POW directamente a consola: " << pow(5, 3); // me devuelve 125 (bien)    
    return 0;
}

Solo lo he detectado, de momento, con el 5, tanto al cuadrado como al cubo. En el primer caso, al cuadrado, me devuelve 24 por variable (mal), y 25 directo a consola (bien)

He seguido trasteando con este "problema", y he ideado un código para detectar qué numero elevado a qué potencia da un resultado diferente, si es pasado por variable o si sale directamente a consola.
Me explico después del código:

C++

#include <math.h>
#include <iostream>
#include <stdlib.h>
#include <stdio.h>

using namespace std;

int main()
{
    int resultado_variable = 0;
    int cantidad = 0;
    float potencia = 0;
    cout << "\nEscribe la cantidad de numeros a elevar a partir del 1: ";
    cin >> cantidad;
    cout << "Escribe la potencia a elevar: ";
    cin >> potencia;
    for (int i = 1; i <= cantidad; i++)
    {
        resultado_variable = pow(i, potencia);
        if (resultado_variable != pow(i, potencia))
        {
            cout << "\n" << i << "^" << potencia << endl;
            cout << "POW a traves de la variable: " << resultado_variable << endl;
            cout << "POW directamente a consola: " << pow(i, potencia) << endl;
        }
    }
    cout << "\n";
    return 0;
}

Tanto si la variable como el iterador del bucle FOR se declaran como float hasta donde he probado, el código no detecta diferencias, lo cual sería una solución satisfactoria para evitar este fenómeno, y efectuar un cálculo de cierta precisión.
Pero si la variable o el iterador se declaran como entero int, es entonces cuando aparecen resultados muy curiosos. Esto es, números iguales en pantalla que el código detecta como diferentes.
Efectivamente, no me cuadra lo del redondeo, ya que más bien parece que ante un resultado como 24,99999999..., que redondeando seguiría siendo 25, C++ no tiene en cuenta los decimales y se queda con el entero, en este caso 24.
Cosa lógica, creo yo, al declarar la variable como int.
Pero no termino de entender porqué eso mismo le afecta al iterador del bucle.

Answer 1

Las cabeceras <math.h>, <stdlib.h> y <stdio.h> son de c y no deben usarse en c++.

Existe una versión adaptada a C++ de cada una de esas cabeceras, son respectivamente <cmath>, <cstdlib> y <cstdio>, debes usar esas y no las de C para compilar código C++.

No sólo eso, también debes evitar incluir cabeceras que no usas, tu corto código no usa nada de lo que proporciona <stdlib.h> ni <stdio.h>. Dicho esto, vamos a ver las diferencias entre <math.h> y <cmath>.

---

<math.h>

Dado que C no permite la sobrecarga de funciones, existen tres versiones de la función para tres dobletes de parámetros y una macro para simular sobrecarga de funciones:

• double pow(double, double).
• float powf(float, float).
• long double powl(long double, long double).
• #define pow(base, exponent).

Dado que en C no existen los espacios de nombres, todas las funciones están en el espacio de nombres global.

<cmath>

Igual que en la cabecera C, existen las mismas tres versiones de la función, junto a una versión con exponente entero y una versión plantilla que cubre todas las combinaciones de argumentos aritméticos no cubertas por las versiones no plantilla:

• double pow(double, double).
• float powf(float,float).
• long double powl(long double, long double).
• double pow(double, int).
• float pow(float, int).
• long double pow(long double, int).
• tipo_promovido pow(tipo_aritmetico_1, tipo_aritmetico_2).

Todas estas funciones están en el espacio de nombres std.

---

Ahora que sabemos las diferencias entre ambas cabeceras, veamos que ha pasado:

1. Se ha incluido la cabecera de C <math.h>.
2. No existe versión de pow con parámetros enteros, así que se ejecuta la macro.
   1. Has llamado a la macro pow con parámetros enteros (int).
   2. Su funcionamiento es el siguiente: si cualquiera de los argumentos es de tipo int se llama pow convirtiendo los argumentos y el resultado a double.
3. Guardas el resultado double en un entero, perdiendo la parte decimal.
4. Imprimes el valor redondeado a la baja (pues perdió la parte decimal).

El error del redondeo no se da al imprimir directamente pues no guardas el resultado temporal en una variable entera, pero eso es dependiente de cómo el compilador y el sistema tengan configurados el tipo de redondeo.

Answer 2

Lo más normal es que sea un error por redondeos. No guardes un float en un int o perderás toda la parte decimal.

Por alguna razón el programa te estará devolviendo un resultado similar a 24.999999999999... al imprimir ese resultado el sistema lo redondea automáticamente a 25, pero si lo conviertes a entero, como los decimales se truncan, el resultado obtenido es 24

Para obtener más información sobre el tema puedes leer las respuestas de esta otra pregunta

¿Por qué mis programas no pueden hacer cálculos aritméticos correctamente?

Answer 3

Un error de redondeo en una operación tan simple como 5 elevado a 2 es chocante. Podrías pensar que pow() implementará esa operación multiplicando 5 por 5, en cuyo caso debería dar 25. Y aún si el 5 se está representando en coma flotante no hay forma de explicar errores de redondeo en la operación 5*5, ya que tanto 5.0 como 25.0 son representables de forma exacta en el estándar IEEE-754 (tanto el de precisión simple float, como el de precisión doble double).

Entonces ¿qué está pasando aquí?

Lo que ocurre es que pow(a, b) admite ambos parámetros de tipo float o double, para permitirte operaciones como elevar 5 a números fraccionarios. Por ejemplo 5 elevado a 0.5 sería la raíz cuadrada.

Para poder elevar a a b siendo b un número real arbitrario, la forma más sencilla de lograrlo es utilizar logaritmos. Es decir, se multiplica el logaritmo de a por b, y después se deshace el logaritmo. En definitiva: exp(log(a)*b).

Esto sí que puede explicar errores de redondeo. De hecho, mira el siguiente experimento que he realizado con python:

>>> 5.0 * 5.0 
25.0                         # No hay errores de redondeo aqui
>>> from math import log, exp
>>> exp(log(5.0)*2.0)
24.999999999999996            # Ajá!
>>> int(exp(2.0*log(5.0)))
24                            # Ajajáaaa!

Así que ya sabemos por qué te sale 24 si lo metes en una variable de tipo int. En cuanto a por qué sale 25.0 en vez de 24.999999999999996 cuando imprimes directamente el resultado de pow() se debe a que, a diferencia del REPL de python, C++ intenta dar una representación "amigable" de los números flotantes, redondeándolos a un numero razonable de decimales, en vez de mostrar hasta el último decimal. De hecho python también lo hace si usas el equivalente al "printf":

>>> print("%f" % exp(2.0*log(5.0)))
25.000000

Answer 4

       //HOLA!   
   ///soy nuevo y estoy aprendiendo a programar.
     ///Hice a mi parecer así:

 #include<iostream>
 using namespace std;

int Potencia(int ,int );
int Potencia(int x,int n){
int pot;
if(n==1){
    pot=x; 
 }else{
      pot=x*Potencia(x,n-1);
 }
return pot;
}
int main(){
int base;
int exponente;

cout<<"Digite la base:"<<" ";
    cin>>base;
cout<<"\nDigite el exponente:"<<" " ;
    cin>>exponente;
    cout<<"\nLa potencia es:"<<" "<<Potencia(base,exponente)<<endl; 
    return 0;
 }