Home / Questions / 233742
Accepted
Victor Alfonso Pérez Espino
Asked: 2020-01-30 17:06:53 +0800 CST 2020-01-30 17:06:53 +0800 CST

Approximation over and under (similar to rounding) C++

  • 772

How could it be done to approximate a number by default and by excess? Understanding that we say, we have the number 2.534823

A default approximation to 4 decimal places would be 2.5348

and for approximation by excess to 4 decimal places, it would be 2.5349

It's like rounding but for a specific decimal place, is there a way to do it in C++?

I have the following example, but it would only be to round to the nearest whole number, whether greater or less:

#include<iostream>
#include<math.h>
using namespace std;


int main(){

    float num;
    int decim;

    cout<<"\tCalcular aproximaciones por defecto y exceso"<<endl<<endl;

    cout<<"Ingrese un numero: " ;
    cin>>num;

    cout<<"Ingresa la cantidad de dedcimales a dejar: ";
    cin>>decim;

    /*
        con ceil y floor me acerca al entero,
        ceil al entero más cercano mayor
        floor al  entero más cercano menor
    */

    cout<<"Aproximación por exceso: "<<ceil(num)<<endl;

    cout<<"Aproximación por defecto: "<<floor(num)<<endl;

    /*
       la aproximación debería quedar como:
       numero ingresado = 1.432986

       para por defecto  con 4 decimales, quedaria 1.4329
       para exceso con 4 decimales quedaría 1.4323
       pero con ceil, subiría a 2
       y con floor bajaría a 1


    */

    return 0;
}

In C you could truncate a number, to a specified number of decimal places when printing it (i.e. the default approximation):

printf("%.3f", x);

EITHER

printf("%3f", x);

I don't remember which of the 2 ways, what I want to know is how the same could be done but in C++ and also obtain the approximation by excess

c++

2 Answers

  1. Best Answer

    As we already know , floating point numbers are imprecise , so doing it directly with the binary value can lead to ... curious results .

    A possible solution is to perform the approximation on the value already converted to a string , although this requires us to perform certain operations by hand :

    #include <string>
#include <iostream>
#include <sstream>

std::string upround( float value, unsigned decimals ) {
  std::stringstream buffer;

  buffer << value;

  // Cosas mias. `str( )` devuelve copias ... no vamos a estar todo el rato copiando cosas.
  std::string workCopy( buffer.str( ) );

  // Buscamos la posición del punto decimal.
  auto posOfPoint = workCopy.find( '.' );

  // Si es un número entero (sin punto), nada que hacer.
  if( posOfPoint == std::string::npos ) return workCopy;

  // Total de número a la derecha de la coma:
  auto workDecimals = workCopy.size( ) - 1 - posOfPoint;

  // Si hay menos decimales que los pedidos, nada que hacer.
  if( workDecimals < decimals ) return workCopy;

  // Recortamos la cadena.
  if( workDecimals > decimals ) workCopy.erase( workCopy.length( ) - ( workDecimals - decimals ) );

  // Trivial: el último dígito es != 9.
  if( workCopy.back( ) != '9' ) {
    ++( workCopy.back( ) );
  } else {
    // No trivial. El último dígito es un '9'. Es el caso 'chulo' :-)
    int pickup = 1;

    for( int idx = workCopy.length( ) - 1; idx >= 0; --idx ) {
      if( workCopy[idx] == '.' ) continue;
      workCopy[idx] += pickup;
      if( workCopy[idx] > '9' ) {
        workCopy[idx] = '0';
        pickup = 1;
      } else {
        pickup = 0;
        break;
      }
    }

    // Ya terminamos con la cadena.
    // Si aún nos queda 1 por sumar, hay que añadir un número al principio.
    if( pickup ) workCopy.insert ( 0, 1, '1' );
  }

  return workCopy;
}

int main( ) {
  const auto testValue = 3.1415f;
  std::cout << "Valor de prueba: " << testValue << '\n';
  std::cout << upround( testValue, 2 ) << '\n';
  std::cout << upround( testValue, 3 ) << '\n';

  const auto testValue2 = 9.9999f;
  std::cout << "Valor de prueba: " << testValue2 << '\n';
  std::cout << upround( testValue2, 3 ) << '\n';
  std::cout << upround( testValue2, 4 ) << '\n';
  return 0;
}

    I have not tested it thoroughly ; for test values ​​( 3.1415fand 9.9999f) displays the following:

    Test value: 3.1415
    3.15
    3.142
    Test value: 9.9999
    10.000
    10.0000

    Note: it is relatively easy to convert it to template< >, and, for that matter, add an extra argument to it to be able to use other separators, apart from the period ( .).

    • 4

  2. Use std::setprecision, your number with 3 decimal places would be 2.535and with 4 decimal places it would be 2.5348, this code:

    auto valor = 2.534823;

for (auto precision : {2, 3, 4, 5, 6, 7, 8, 9, 10})
    std::cout << std::setprecision(precision) << valor << '\n';

    Produces the following output:

    2.5
2.53
2.535
2.5348
2.53482
2.534823
2.534823
2.534823
2.534823

    You can see it working on Wandbox . Additionally, you can set the rounding style of floating point numbers using std::fesetround, having four rounding styles :

    • FE_DOWNWARD: Round towards negative.
    • FE_TONEAREST: Rounding to the nearest representable value.
    • FE_TOWARDZERO: Round towards zero.
    • FE_UPWARD: Round towards positive.

    With rounding down, the above program:

    std::fesetround(FE_DOWNWARD);

for (auto precision : {2, 3, 4, 5, 6, 7, 8, 9, 10})
    std::cout << std::setprecision(precision) << valor << '\n';

    It shows the following output:

    2.5
2.53
2.534
2.5348
2.53482
2.534822
2.5348229
2.53482299
2.534822999
    • 3