继续求教关于取整算法的问题。
上次发贴，由于时间关系，把贴结了，问题还没解决，另外不想用字符串的问题解决，所以继续求教，问题解决，马上结贴：
max,min两个数
1.max要求向上取整，min 要求向下取整，
2.max，min要求是以0.5，5，00，，结尾
如：max =123 向上取整 125
min =17 向下取整 15
如果是小数 max =0.7 取整1.0，
min =0.2向下取整0.0
另外算法对精度的要求很高，误差要求在1/1000。以所求教下大家，看看大家有没有好一点的建议。
我个人通过取模的形式来实现的，误差太多，行不通!
[解决办法]
你举的例子好像误差就超过1/1000了吧?
[解决办法]
对了max = 12.3想上取===多少？12.5?or15?
[解决办法]
牛顿迭代罗,先找一个粗的上界或者下界,然后看看能不能根据约束逼近吧,偶这样想的,至于小数嘛,我想还是要转成整数来处理的
[解决办法]
BigDecimal 类应该可以解决你的需求。
好好研究下吧。
[解决办法]
说实在的，我每天都来看一下，希望能有高手给个完美的答案
[解决办法]
个人认为，用字符串处理是最好的，否则难以保证精度
不用字符串的话，可以试一下如下的代码（精度上可能存在问题）
double x=3.3333333;
double tmp=x;
int i=1;
// 小数位转成整数
while(tmp!=Math.floor(tmp)){
i=i*10;
// 如果使用tmp=tmp*10的方式则会出现精度问题
tmp=x*i;
}
int div=((int)tmp)/10;
// 取最后一位数字
int mod=((int)tmp)%10;
double max=div*10;
double min=div*10;
if(mod <5){
// x=0.3
// max=0.5
// min=0.0
max+=5;
}else if(mod==5){
// x=0.5
// max=0.5
// min=0.5
max+=5;
min=max;
}else{
// x=0.7
// max=1.0
// min=0.5
max+=10;
min+=5;
}
max=max/i;
min=min/i;
System.out.println( "max = "+max);
System.out.println( "min = "+min);
[解决办法]
跟不上题目的话题。。不知道您们在讨论什么。。。
[解决办法]
private static void testNum(){
String max = "234.4 ";
String min = "123.1 ";
double powerN = 1;
if(max.indexOf( ". ") != -1){
int len = max.length() - max.indexOf( ". ") - 1;
powerN = Math.pow(10,len);
}
String rtnMax = " " + getRtn(Double.parseDouble(max) * powerN, true) / powerN;
max = max.indexOf( ". ") != -1 ? rtnMax : rtnMax.substring(0,rtnMax.indexOf( ". "));
powerN = 1;
if(min.indexOf( ". ") != -1){
int len = min.length() - min.indexOf( ". ") - 1;
powerN = Math.pow(10,len);
}
String rtnMin = " " + getRtn(Double.parseDouble(min) * powerN, false) / powerN;
min = min.indexOf( ". ") != -1 ? rtnMin : rtnMin.substring(0,rtnMin.indexOf( ". "));
System.out.println(max + " : " + min);
}
private static double getRtn(double number,boolean flgUpDown){
if(number%5 == 0) return number;
if(flgUpDown) number = number + 5 - number%5;
if(!flgUpDown) number = number - number%5;
return number;
}
[解决办法]
这里高手可真多啊
[解决办法]
可能我理解的不对,觉得很简单啊, 我做的一个算法,大家看看
这样理解对不对?
package AlgorithmTry;
/*
* 先分别做一个把一位小数向上取整和向下取整的函数，
* 然后把需要取整的数乘一个10的N次方调整到一位小数，
* 取整完在调回去
*/
public class Truncer {
public static int presicy=10000; //精度
public static double upTrunc(double src) //向上取整
{
if(!Truncer.scalable(src))
{
return src;
}
long l=Double.valueOf(src).longValue();
double ret;
double db=src-l;
if(db> 0.5)
{
ret = l+1.0;
}
else if(db <0.5)
{
ret = l+0.5;
}
else
{
ret = src;
}
return ret;
}
public static double downTrunc(double src) //向下取整
{
if(!Truncer.scalable(src))
{
return src;
}
long l=Double.valueOf(src).longValue();
double ret;
double db=src-l;
if(db> 0.5)
{
ret = l+0.5;
}
else if(db <0.5)
{
ret = l;
}
else
{
ret = src;
}
return ret;
}
//判断输入的数精度是否比要求的低，低的则不需要取整
public static boolean scalable(double src)
{
boolean bret=true;
int totalcnt=1;
while(Truncer.presicy/10*totalcnt> 0)
{
totalcnt++;
}
for(int i=1; i <=totalcnt;i++)
{
if(Double.valueOf(src*10*i).intValue()/(i*10.0)==src)
{
bret=false;
break;
}
}
return bret;
}
public static void main(String args[])
{
double sampledb=15725.0114124;
int scale=Truncer.presicy;
System.out.println(Truncer.upTrunc(sampledb*scale)/scale);
System.out.println(Truncer.downTrunc(sampledb*scale)/scale);
}
}
[解决办法]
继续关注。。哈哈
[解决办法]
package net.hjc.test;
/**
* @author 棉花糖
* @version 1.0, 2007/02/10
*/
public class Format
{
public static int min (int $n)
{
return Format.cArrToInt(Format.intToFC($n, true));
}
public static double min (double $n)
{
return Format.cArrToDouble(Format.doubleToFC($n, true));
}
public static int max (int $n)
{
char[] t = Format.intToFC($n, false);
return Format.cArrToInt(t) + ((t[t.length-1] == '0 ') ? 10 : 0);
}
public static double max (double $n)
{
int nInt = (int)$n;
if ($n > nInt + 0.5) return ++nInt;
char[] t = Format.doubleToFC($n, false);
int l = t.length;
int i = 0;
while (t[i++] != '. ');
return Format.cArrToDouble(t) + ((t[l-1] == '0 ') ? Math.pow(.1, l-i-1) : 0);
}
private static char[] intToFC (int $n, boolean $b)
{
char[] t = Integer.toString($n).toCharArray();
Format.tmp(t, t.length, $b);
return t;
}
private static char[] doubleToFC (double $n, boolean $b)
{
char[] t = Double.toString($n).toCharArray();
Format.tmp(t, t.length, $b);
return t;
}
private static int cArrToInt (char[] $c)
{
return Integer.parseInt((String.valueOf($c)));
}
private static double cArrToDouble (char[] $c)
{
return Double.parseDouble((String.valueOf($c)));
}
private static void tmp (char[] $t, int l, boolean $b)
{
if ($t[l-1] < '5 ') $t[l-1] = ($b) ? '0 ' : '5 ';
else if ($t[l-1] > '5 ') $t[l-1] = ($b) ? '5 ' : '0 ';
}
}
