我想将一个浮点数四舍五入到给定的精度,例如:
0.051 i want to convert it to
0.1
0.049 i want to convert it to
0.0
0.56 i want to convert it to
0.6
0.54 i want to convert it to
0.5
我无法更好地解释,但这样做的原因是将点位置(例如0.131f、0.432f)转换为网格中瓦片的位置(例如0.1f、0.4f)。
0.2 0.4 0.6 ...
然后你通过四舍五入
float round(float f)
{
return floor(f * 5 + 0.5) / 5;
// return std::round(f * 5) / 5; // C++11
}
ceil()
和floor()
函数没有精度,我猜可以通过添加自己的精度来解决这个问题,但这可能会引入误差,例如:double ceil(double v, int p)
{
v *= pow(10, p);
v = ceil(v);
v /= pow(10, p);
}
编辑 1:我在寻找Python中Numpy的解决方案,并没有意识到OP要求的是C ++哈哈,算了。
编辑 2:哈哈,看起来我甚至没有回答你最初的问题。看起来你真的想按小数四舍五入(操作与给定数字无关),而不是按精度四舍五入(操作取决于数字),其他人已经解决了这个问题。
实际上,我也在寻找这个东西,但找不到,所以我为Numpy数组编写了一个实现。看起来它实现了slashmais所述的逻辑。
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
这里还有一个C++标量版本,你也可以使用Eigen做类似上面的操作(它们有逻辑索引):(我也趁此机会练习了一些boost库哈哈):
#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;
}
输出:
0.1
0
0.6
0.5
0.1
0
1
1
1.23
1.03e+06
0.00923
一种算法:
使用floor()
和ceil()
函数。 floor
将把一个浮点数转换为下一个较小的整数,而ceil
则转换为下一个较大的整数:
floor( 4.5 ); // returns 4.0
ceil( 4.5 ); // returns 5.0
float round( float f )
{
return floor((f * 10 ) + 0.5) / 10;
}
floor( f + 0.5 )
会四舍五入到一个整数。通过先乘以10,然后将结果除以10,您可以按0.1的增量进行四舍五入。
通常你在编译时就知道所需的精度。因此,可以使用这里提供的模板化Pow函数进行以下操作:
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;
}
在这里进行了测试。
结果还显示了浮点数表示的不精确性 :)
3
3.099999905
3.140000105
3.14199996
3.141599894
3.141590118
3.141592979
3.141592741
使用double可以得到更好的结果:
template <int PRECISION>
double roundP(double f)
{
const int temp = Pow<10,PRECISION>::result;
return round(f*temp)/temp;
}
精度为20的打印结果:
3
3.1000000000000000888
3.1400000000000001243
3.1419999999999999041
3.1415999999999999481
3.1415899999999998826
3.1415929999999998579
3.1415926999999999047
我将简要优化一下之前的答案,先将输入数字转换为双精度浮点数以防止溢出。以下是一个示例函数(不太美观,但完全可行):
#include <cmath>
// round float to n decimals precision
float round_n (float num, int dec)
{
double m = (num < 0.0) ? -1.0 : 1.0; // check if input is negative
double pwr = pow(10, dec);
return float(floor((double)num * m * pwr + 0.5) / pwr) * m;
}
double round(long double number, int precision) {
int decimals = std::pow(10, precision);
return (std::round(number * decimals)) / decimals;
}
Check some examples below...
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
round(5.1234500015, 9)
returns => 5.123450002
我曾经写过一个小函数,可以将double
舍入到固定精度(例如2个小数位 - 如0.01
),而不需要包含<cmath>
:
constexpr double simplyRounded( const double value )
{
return (((((int)(value * 1000.0) % 10) >= 5) + ((int)(value * 100.0))) / 100.0);
}
...这可以被调整以给您一个小数点后1位的精度(例如0.1
),接受并返回float
,如下所示:
constexpr float simplyRounded( const float value )
{
return (((((int)(value * 1000.0f) % 10) >= 5) + ((int)(value * 100.0f))) / 100.0f);
}
由于 Mooing Duck 编辑了我的问题并删除了代码,说问题不应该包含答案(可以理解),所以我将在这里写出解决方案:
float round(float f,float prec)
{
return (float) (floor(f*(1.0f/prec) + 0.5)/(1.0f/prec));
}
0.1
这样的数字在二进制浮点数中无法精确表示。四舍五入可以在输出时进行(转换为字符串或写入文件)。 - Keith Thompson#define ROUND(n,p) round(n*pow(10,p))/pow(10,p)
- Vinícius A. Jorge