Runde ein Schwimmer auf einem regelmäßigen raster mit vordefinierten Punkte

Standard ceil(), floor() Funktionen nicht haben, a Präzision, ich denke, könnte das umgehen, indem Sie Ihre eigenen Präzision - das kann aber zu Fehlern - z.B.

double ceil(double v, int p)
{
  v *= pow(10, p);
  v = ceil(v);
  v /= pow(10, p);
}

Ich denke, man könnte testen, um zu sehen, ob dies zuverlässig für Sie?

EDIT 1: ich war auf der Suche nach Lösungen für numpy python und wusste gar nicht, dass der OP gefragt, für C++ haha, naja.

EDIT 2: Lol, sieht aus wie ich nicht einmal die Adresse deiner ursprünglichen Frage. Es sieht aus wie Sie wirklich wollen, um zu Runden nach dezimal (der Betrieb ist unabhängig von der angegebenen Zahl), nicht, a Präzision (der Betrieb ist abhängig von der Anzahl), und die anderen haben schon angesprochen, dass.

Ich war eigentlich auf der Suche rund um für diese zu, konnte aber etwas nicht finden, so warf ich zusammen eine Implementierung für numpy-arrays. Es sieht aus wie es implementiert die Logik, dass slashmais angegeben.

def pround(x, precision = 5):
    temp = array(x)
    ignore = (temp == 0.)
    use = logical_not(ignore)
    ex = floor(log10(abs(temp[use]))) - precision + 1
    div = 10**ex
    temp[use] = floor(temp[use] / div + 0.5) * div
    return temp

Hier ist ein C++ scalar version als gut, und wahrscheinlich könnte man etwas tun, ähnlich wie oben mit Hilfe von Eigen (Sie haben logische Indizierung): (ich nahm auch dies als eine chance, noch etwas zu üben boost haha):

#include <cmath>
#include <iostream>
#include <vector>
#include <boost/foreach.hpp>
#include <boost/function.hpp>
#include <boost/bind.hpp>

using namespace std;

double pround(double x, int precision)
{
    if (x == 0.)
        return x;
    int ex = floor(log10(abs(x))) - precision + 1;
    double div = pow(10, ex);
    return floor(x / div + 0.5) * div;
}

    template<typename T>
vector<T>& operator<<(vector<T> &x, const T &item)
{
    x.push_back(item);
    return x;
}

int main()
{
    vector<double> list;
    list << 0.051 << 0.049 << 0.56 << 0.54;
    //What the OP was wanting
    BOOST_FOREACH(double x, list)
    {
        cout << floor(x * 10 + 0.5) / 10 << "\n";
    }

    cout << "\n";

    BOOST_FOREACH(double x, list)
    {
        cout << pround(x, 0) << "\n";
    }

    cout << "\n";

    boost::function<double(double)> rounder = boost::bind(&pround, _1, 3);
    vector<double> newList;
    newList << 1.2345 << 1034324.23 << 0.0092320985;
    BOOST_FOREACH(double x, newList)
    {
        cout << rounder(x) << "\n";
    }

    return 0;
}

Ausgabe:

0.1
0
0.6
0.5

0.1
0
1
1

1.23
1.03e+06
0.00923

In der Regel wissen Sie das gewünschte Präzision bei der Kompilierung. Deshalb wird die Verwendung der Vorlagen-Pow-Funktion zur Verfügung hier, die Sie tun können:

template <int PRECISION>
float roundP(float f)
{
    const int temp = Pow<10,PRECISION>::result;
    return roundf(f*temp)/temp;
}

int main () {
    std::cout << std::setprecision(10);
    std::cout << roundP<0>(M_PI) << std::endl;
    std::cout << roundP<1>(M_PI) << std::endl;
    std::cout << roundP<2>(M_PI) << std::endl;
    std::cout << roundP<3>(M_PI) << std::endl;
    std::cout << roundP<4>(M_PI) << std::endl;
    std::cout << roundP<5>(M_PI) << std::endl;
    std::cout << roundP<6>(M_PI) << std::endl;
    std::cout << roundP<7>(M_PI) << std::endl;
}

Getestet hier.

Das Ergebnis zeigt auch, wie ungenau ist die Gleitkommadarstellung 🙂

3

3.099999905

3.140000105

3.14199996

3.141599894

3.141590118

3.141592979

3.141592741

Können Sie bessere Ergebnisse durch doppelte:

template <int PRECISION>
double roundP(double f)
{
    const int temp = Pow<10,PRECISION>::result;
    return round(f*temp)/temp;
}

Gedruckt mit Präzisions-20:

3

3.1000000000000000888

3.1400000000000001243

3.1419999999999999041

3.1415999999999999481

3.1415899999999998826

3.1415929999999998579

3.1415926999999999047

Seit Muhen Ente bearbeitet meine Frage und entfernt den code sagen, Fragen sollte nicht enthalten die Antworten (verständlich), Schreibe ich die Lösung hier:

float round(float f,float prec)
{
    return (float) (floor(f*(1.0f/prec) + 0.5)/(1.0f/prec));
}

Können Sie Runden eine Zahl auf eine gewünschte Präzision mit der folgenden Funktion

double round(long double number, int precision) {
  int decimals = std::pow(10, precision);
  return (std::round(number * decimals)) / decimals;
}

Schauen Sie sich einige Beispiele unten...

1)

round(5.252, 0)
returns => 5

2)

round(5.252, 1)
returns => 5.3

3)

round(5.252, 2)
returns => 5.25

4)

round(5.252, 3)
returns => 5.252

Diese Funktion funktioniert auch für zahlen mit 9 Präzision.

5)

round(5.1234500015, 9)
returns => 5.123450002