Operaciones con tipo doble en C

[ad_1]

¿Por favor explica cómo funciona? El programa me da el resultado correcto sólo cuando sumo números enteros, pero en mi tarea preferiría usar el tipo double.

opción de trabajo:
`

C++

for (int i = -10000; i < 10000; i++) {
    formula = s1 / (v1 + k) + s2;
    if (formula == 0) {
        break;
}
    k += 1;
}

Resultado: 3.000000
`

no funciona correctamente:
`

C++

for (int i = -10000; i < 10000; i++) {
    formula = s1 / (v1 + k) + s2;
    if (formula == 0) {
        break;
}
    k += 0.00001;
}

Resultado: 0,200000
`

Lo que he probado:

en mi programa necesito un resultado más preciso por eso no puedo usar el tipo int.

Solución 1
Solución 2

Solución 1

El primer paso es asegurarse de que las variables formula, s1, s2, v1y k son todos de tipo doble. En realidad, no es necesario que todos sean dobles, pero desea asegurarse de que el resultado (formula) es un doble y la división debe hacerse con dobles. Es casi seguro que un resultado entero dará resultados erróneos.

El segundo paso es tener cuidado con las comparaciones iguales con valores dobles, es decir, probar si formula es cero. La técnica habitual para esto es definir un valor épsilon que signifique “lo suficientemente cercano” y compararlo. Aquí hay un ejemplo :

C++

const double epsilon = 1.0E-9;

// do calculations here

double delta = fabs( formula );
if( delta < epsilon )
    break;

Esto saldrá del bucle for si formula está en el rango entre -1E-9 y +1E-9. Puede utilizar 1.0E-6 u otros valores para épsilon siempre que esté dentro de la tolerancia computacional deseada.

Solución 2

Hay varias cosas a tener en cuenta aquí. Parece que solo la variable k cambia con cada ciclo.

for (int i = -10000; i < 10000; i++) {
  formula = s1 / (v1 + k) + s2;
  if (formula == 0) {
	break;
  }
  k += 0.00001;
}

Desafortunadamente, el valor k += 0,00001 no se puede almacenar exactamente como flotante (o doble), por lo que el compilador suele utilizar el valor más cercano. Si ahora suma estos números dobles que no coinciden exactamente, el error en la suma aumenta con cada ciclo.

Ahora existen varias formas de resolver el problema.
1. En lugar de volver a sumar constantemente, es mejor multiplicar una vez por el índice de corte, lo que aumenta considerablemente la precisión.
2. En lugar de comparar dos flotantes directamente entre sí, sería mejor comprobar la diferencia, donde a menudo la diferencia no llega a ser 0, sino que debería caer por debajo de un valor especificado.

Usar double en lugar de float para una mayor precisión solo cambiaría el problema, no lo resolvería.

[ad_2]