Infinito en C
En este tutorial, discutiremos el infinito en C. Comenzaremos con la discusión sobre el infinito en general.
A continuación, discutiremos el infinito como un error de tiempo de ejecución en C y concluiremos con una discusión sobre cómo almacenar y usar el infinito en C.
que es infinito
Todos conocemos la recta numérica de nuestra escuela primaria. Esta recta numérica está representada por flechas que no tienen principio ni fin.
Sin embargo, en teoría, tenemos ambos. Los números terminan en infinito positivo ∞ (a veces escrito como +∞) y comienzan en infinito negativo -∞.
Todo número real x se encuentra entre – ∞ < x < ∞. Infinito se refiere a un número cuyo peso está más allá de cualquier límite descriptible.
Cuando decimos que tenemos números infinitos, esto significa que tenemos una cantidad interminable de números.
Todos sabemos que cuando dividimos una cosa, obtenemos pedazos o partes de la cosa real. Cuanto más pequeño sea el divisor, más piezas tenemos.
Para obtener más piezas, tenemos que dividir la cosa en piezas más pequeñas. Por tanto, si dividimos algo que tiende a cero, obtenemos infinitas piezas (piezas incontables).
Por el contrario, si dividimos cualquier número real por infinito, el resultado será cero, ya que es lo mismo que distribuir una cantidad limitada en infinitas partes; por lo tanto, cada pieza obtendrá casi cero acciones.
Infinito en la programación
Normalmente, los programadores tienen un problema típico con el infinito; cada vez que el divisor es cero (generalmente por error) en una expresión, el programa falla (terminación anormal).
La terminación anormal puede ser un problema grave para el software crítico para la vida. Los programadores nunca quieren una terminación anormal; por lo tanto, se utilizan las comprobaciones if-else o se realiza el manejo de excepciones.
Considere un código simple:
#include <stdio.h>
int main() {
printf("%d\n", 5 / 0);
printf("\nEnd of program\n");
return 0;
}
En este programa, estamos usando una división codificada de 5 con 0 para verificar el comportamiento del programa; sin embargo, puede haber un caso en el que un programador pueda usar una variable como divisor cuyo valor de alguna manera se vuelve cero. Lo hemos probado en el compilador en línea de Programiz C, y el resultado se muestra a continuación.
Floating point exception
Probamos el mismo código en otro compilador en línea y el resultado se muestra a continuación.
main.c: In function ‘main’:
main.c:3:23: warning: division by zero [-Wdiv-by-zero]
3 | printf ("%d\n", 5 / 0);
| ^
Este programa finaliza (bloqueo) en la primera declaración de print. Tenemos otra declaración de print, que no se ejecuta porque el programa ya ha sido terminado (llamada terminación anormal).
Representación del Infinito en C
En C, el infinito se representa con INF o inf. Normalmente, resulta de una división por cero o valor nulo.
Vea este código de ejemplo:
#include <math.h>
#include <stdio.h>
double divide(double d1, double d2) { return d1 / d2; }
int main() {
printf("Result: %lf\n", divide(2, 3));
printf("Result: %lf\n", divide(2, 0));
return 0;
}
Hay dos declaraciones de print en el código. Llamamos a la función con parámetros distintos de cero en la primera declaración de print, mientras que el segundo parámetro es cero en la segunda llamada de print.
Producción :
Result: 0.666667
Result: inf
La situación puede parecer similar al primer código; sin embargo, es ligeramente diferente. En el primer código, tenemos una expresión (habiendo dividido por cero) dentro de la instrucción print y, como resultado, el programa finaliza de manera anormal.
Sin embargo, este segundo programa llama a la función dividir desde la función principal(). La función dividir devuelve inf como resultado de la llamada de la función main, que lo imprime en consecuencia.
Podemos obtener los mismos resultados si almacenamos el resultado en alguna variable en la función main.
#include <math.h>
#include <stdio.h>
double divide(double d1, double d2) { return d1 / d2; }
int main() {
double result = divide(2, 0);
printf("Result: %lf\n", result);
return 0;
}
Además de obtener inf como resultado, podemos comparar el resultado con infinito. Nuestras próximas instrucciones pueden estar basadas en el valor de la expresión, y muchos casos requieren no proceder en el caso del resultado infinito.
Por lo tanto, debemos verificar el valor antes de ejecutar las siguientes instrucciones.
Para ello disponemos de una función isinf para comprobar si el resultado es infinito o no. Ver el ejemplo:
#include <math.h>
#include <stdio.h>
double divide(double x, double y) { return x / y; }
int main() {
double res = divide(7, 3);
if (!isinf(res))
printf("Result is %lf\n", res);
else
printf("The result is infinity, and further computations not possible\n");
res = divide(7, 0);
if (!isinf(res))
printf("Result is %lf\n", res);
else
printf("The result is infinity, and further computations not possible\n");
return 0;
}
Fíjese en la declaración if donde pasamos nuestro resultado a la función isinf para comparar el resultado con infinito. Si res tiene un valor infinito, salteamos la instrucción printf.
Producción :
Result is 2.33333
The result is infinity, and further computations not possible
Es evidente a partir de la salida que no podemos continuar en el caso de resultados infinitos; sin embargo, el programa no realiza ninguna terminación anormal. En cualquier caso, el programador puede guardar cualquier dato requerido, puede escribir registros, etc.
Infinito negativo en C
También tenemos infinito negativo en C. Por ejemplo, si multiplicamos infinito por un número negativo, obtendremos infinito negativo en el resultado.
Vea este código simple:
#include <math.h>
#include <stdio.h>
int main() {
double res = -1 * INFINITY;
printf("Result is %lf\n", res);
return 0;
}
La salida de este código es El resultado es -inf. Veamos otro ejemplo para entender las manipulaciones -INFINITY.
#include <math.h>
#include <stdio.h>
double divide(double x, double y) { return x / y; }
int main() {
double res = divide(7, 3);
if (!isinf(res))
printf("Result is %lf\n", res);
else
printf("The result is infinity, and further computations not possible\n");
res = divide(-7, 0);
if (res != -INFINITY)
printf("Result is %lf\n", res);
else
printf(
"The result is negative infinity, and further computations not "
"possible\n");
return 0;
}
Aquí, la segunda llamada de función a la función dividir le pide que divida un número negativo por 0, devolviendo así un valor igual a infinito negativo.
Producción :
Result is 2.33333
The result is negative infinity, and further computations not possible
En este tutorial, hemos cubierto ambos aspectos. Primero, discutimos los métodos para salvar nuestros programas de una terminación anormal en caso de resultados infinitos.
Después de eso, analizamos cómo nuestros programas pueden manipular aún más el infinito para desarrollar expresiones condicionales que involucren valores infinitos.