Aproximación utilizando gmp mpf_class.

05 Aug, 2023 Programación 0

Estoy escribiendo una Unidad de Prueba utilizando Catch2.
Quiero comprobar si dos vectores son iguales. Se ven así utilizando gmplib:

std::vector<mpf_class> result

Debido a que estoy “falsificando” el vector expected_result, obtengo el siguiente mensaje después de una prueba fallida:

unittests/test.cpp:01: ERROR:
REQUIRE( actual_result == expected_result )
with expansion:
  { 0.5, 0.166667, 0.166667, 0.166667 }
   ==
  { 0.5, 0.166667, 0.166667, 0.166667 }

Entonces estaba buscando una función que pudiera hacer una aproximación por mí.
Simplemente no tuve éxito en encontrar una solución que funcionara para mí.

Encontré algunas Funciones de Comparación pero no funcionan en mi proyecto.

EDIT:
El “ejemplo mínimo y reproducible” sería:

TEST_CASE("DemoTest") {
// simplified:
mpf_class a = 1; 
mpf_class b = 6;

mpf_class actual_result = a / b;
mpf_class expected_result = 0.16666666667;

REQUIRE(actual_result == expected_result);
}

Imagen
Este es el resultado del ejemplo mencionado.

La única diferencia en mi aplicación real es que los resultados se almacenan en vectores. Pero como solo estoy “falsificando” el resultado diciendo que es “0.1666666667” probablemente ya no se ajuste al ==. Así que necesito una función que tome una aproximación y compare el rango con una precisión de epsilon = +-0.001.

Edit:
Después de implementar la solución sugerida por @Arc, funcionó bien hasta que tuve algunos valores que no eran “exactos”.
Así que tengo un fallo con los siguientes valores:

actual   0.16666666666666666666700000000000000000000000000000
expected 0.16666666666666665741500000000000000000000000000000

Aunque mi valor “expected” se ve así:

mpf_class expected = 0.16666666666666666666700000000000000000000000000000

Volviendo a mi pregunta original, ¿hay alguna forma de comparar una aproximación del número con un epsilon de +-0.0001 o cuál sería la mejor manera de solucionar este problema?

davy.ai

August 5, 2023 at 11:02 am

Para comparar dos vectores de mpf_class, puedes utilizar el conjunto de comprobación Approx proporcionado por Catch2. Te permite especificar un valor de épsilon para la aproximación.

Aquí tienes un ejemplo de cómo utilizarlo:

TEST_CASE("MiPrueba") {
  std::vector<mpf_class> resultado_actual = calcular_resultado();
  std::vector<mpf_class> resultado_esperado = {0.5, 0.166667, 0.166667, 0.166667};

  REQUIRE_THAT(resultado_actual, Catch::Approx(resultado_esperado).epsilon(0.001));
}

En este ejemplo, el valor de épsilon se establece en 0.001, lo que significa que la diferencia entre los valores actual y esperado debe ser menor o igual a 0.001.

Si deseas comparar los valores individuales de los vectores en lugar de los vectores enteros, puedes utilizar el conjunto de comprobación Approx en combinación con el conjunto de comprobación WithinAbs. Aquí tienes un ejemplo:

TEST_CASE("MiPrueba") {
  std::vector<mpf_class> resultado_actual = calcular_resultado();
  std::vector<mpf_class> resultado_esperado = {0.5, 0.166667, 0.166667, 0.166667};

  for (int i = 0; i < resultado_actual.size(); i++) {
    REQUIRE_THAT(resultado_actual[i], Catch::WithinAbs(resultado_esperado[i], 0.001));
  }
}

En este ejemplo, el conjunto de comprobación WithinAbs se utiliza para comparar valores individuales con un valor de épsilon de 0.001.

Answer

davy.ai

August 5, 2023 at 11:02 am
Para comparar dos vectores de mpf_class, puedes utilizar el conjunto de comprobación Approx proporcionado por Catch2. Te permite especificar un valor de épsilon para la aproximación.

Aquí tienes un ejemplo de cómo utilizarlo:
```
TEST_CASE("MiPrueba") {
  std::vector<mpf_class> resultado_actual = calcular_resultado();
  std::vector<mpf_class> resultado_esperado = {0.5, 0.166667, 0.166667, 0.166667};

  REQUIRE_THAT(resultado_actual, Catch::Approx(resultado_esperado).epsilon(0.001));
}
```
En este ejemplo, el valor de épsilon se establece en 0.001, lo que significa que la diferencia entre los valores actual y esperado debe ser menor o igual a 0.001.

Si deseas comparar los valores individuales de los vectores en lugar de los vectores enteros, puedes utilizar el conjunto de comprobación Approx en combinación con el conjunto de comprobación WithinAbs. Aquí tienes un ejemplo:
```
TEST_CASE("MiPrueba") {
  std::vector<mpf_class> resultado_actual = calcular_resultado();
  std::vector<mpf_class> resultado_esperado = {0.5, 0.166667, 0.166667, 0.166667};

  for (int i = 0; i < resultado_actual.size(); i++) {
    REQUIRE_THAT(resultado_actual[i], Catch::WithinAbs(resultado_esperado[i], 0.001));
  }
}
```
En este ejemplo, el conjunto de comprobación WithinAbs se utiliza para comparar valores individuales con un valor de épsilon de 0.001.

Comments are closed.

es.davy.ai

¿Tienes una pregunta?

Aproximación utilizando gmp mpf_class.

Answer

davy.ai