[c++] afronden op 2 decimalen

[elgringo]

Ik wil een double afronden op 3 decimalen

dus 1,034 -> 1,03
en 12345 -> 12300 (of 1,23E4)

Ik heb hier wel een workaround voor maar das natuurlijk niet netjes als er een functie voor is.
Het is dus bedoeld om informatie weer te geven en dat het 1,23452345235434234123215123E20 staat leest dat niet makkelijk. 1,23E20 is veel makkelijker.

Ik heb met C++ builder RoundTo gebruikt (en SimpleRoundTo). Dit werkt maar dan zal ik eerst zooi moeten delen zodat het getal [1,10) komt te liggen dan afronden en dan weer vermenigvuldigen

[.oisyn]

Dit werkt maar dan zal ik eerst zooi moeten delen zodat het getal [1,10) komt te liggen dan afronden en dan weer vermenigvuldigen

En het is tevens ook de enige manier waarop een FPU het kan. Dus of jij nou die functie zelf intikt of je 'm uit een library haalt, de bewerking blijft hetzelfde. Ik snap je bezwaar dan ook niet helemaal.

Overigens wil je een getal volgens mij niet daadwerkelijk afronden (om 'm vervolgens op te slaan of er verder mee te rekenen), maar wil je alleen dat bij de weergave een afgeronde representatie wordt gebruikt. Meestal kun je dat dan ook regelen bij de functie die 'm naar je display stuurt of die er een functie van maakt. Er zijn zat modifiers in printf() of manipulators voor std::ostream om de weergave te krijgen zoals je wilt.

[ Voor 42% gewijzigd door .oisyn op 10-07-2006 17:51 ]

[elgringo]

.oisyn schreef op maandag 10 juli 2006 @ 17:48:
[...]
En het is tevens ook de enige manier waarop een FPU het kan. Dus of jij nou die functie zelf intikt of je 'm uit een library haalt, de bewerking blijft hetzelfde. Ik snap je bezwaar dan ook niet helemaal.

Overigens wil je een getal volgens mij niet daadwerkelijk afronden (om 'm vervolgens op te slaan of er verder mee te rekenen), maar wil je alleen dat bij de weergave een afgeronde representatie wordt gebruikt. Meestal kun je dat dan ook regelen bij de functie die 'm naar je display stuurt of die er een functie van maakt. Er zijn zat modifiers in printf() of manipulators voor std::ostream om de weergave te krijgen zoals je wilt.

Het is alleen het weergeven idd
Ik dacht dat het misschien wel slimmer kon, maar dat is dus niet het geval

[PhysicsRules]

een detail, maar wat je wil is niet het aantal decimalen, maar de significatie. Aantal decimalen is het aantal getallen achter de komma.

[MSalters]

Afronden of alleen afdrukken met 2 cijfers?
En in het geval afronden: toch niet omdat je met euro's rekent?

[.oisyn]

elgringo schreef op maandag 10 juli 2006 @ 18:15:

Het is alleen het weergeven idd
Ik dacht dat het misschien wel slimmer kon, maar dat is dus niet het geval

C++:

#include <cstdio>
#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
    float getal = 12345.f;

    printf("%.3g\n", getal);
    cout << setprecision(3) << getal << endl;
}

[martijnvanegdom]

Je doet iets aparts..

afronden op 3 decimalen:
dus 1,034 -> 1,03
en 12345 -> 12300 (of 1,23E4)

Als je 1,034 afrond op 3 decimalen krigt je 1,034
Als je 12345 afrond op 3 decimalen is 12345

Als je spreekt over drie significanten dan heb je het wel juist..
Ze code ik standaard geen C++ maar wat je kunt doen om dit probleem op te lossen..

-- In het geval het getal kleiner is dan 1000:
1) vermenig met 1000 en mik alles achter de komma weg
2) deel het door 10 en rond het af
3) deel dat door 100

-- in het geval dat het groter is dan 1000:
1) deel door 1000
2) rond het af
3) dit is je waarde in E

Ik kan hier en daar er naast zitten dus graag eventueel aanvulling

[.oisyn]

Je zit er idd naast en voor de rest is het al gezegd (significante cijfers ipv decimalen)
Waarom die deling door 10 na de vermenigvuldiging met 1000? Als je op 3 decimalen af wilt ronden dan doe je gewoon round(x * 1000) / 1000. Waarom je controleert of de waarde groter of kleiner dan 1000 is is me ook een raadsel, het geeft iig geen goede oplossing voor afronden met significante cijfers.

Voor significante cijfers zul je idd eerst je exponent moeten bepalen, dat doe je uiteraard met de log10 functie. Als je de exponent E weet kun je vervolgens delen door 10^E-n+1, afronden, en dan weer vermenigvuldigen met 10^E-n+1, waarbij n het aantal significante cijfers is. Let er bij het logaritme wel op dat de invoer niet 0 of kleiner mag zijn (bij 0 retourneer je gewoon 0, bij negatieve getallen behandel je ze gewoon als positief en maak je ze aan het eind weer negatief).

In code:

C++:

#include <math.h>

double round_significant(double v, unsigned signification)
{
    if (v == 0.0)
        return 0.0;

    bool negative = v < 0.0;
    if (negative)
        v = -v;

    double exponent = floor(log10(v));
    double factor = pow(10.0, exponent - signification + 1);

    v = round(v / factor) * factor;
    return negative ? -v : v;
}

[ Voor 19% gewijzigd door .oisyn op 10-07-2006 23:17 ]