保留数字的有效位数

女爷i 2021-10-30 01:20 338阅读 0赞

###### 保留数字的有效位数 ######

***在学习过程中，有碰到过需要保留有效位数的问题，在经过一番查找资料后，完成学习，记录下学习成果***

/**
             * double
                  *  这个函数的作用
                  *  整个数字保留有效位数
                  *  保留的有效位数即n
             * @param num
             * @param n
             * @return
             */
            public double HoldNumberOfSignificantDigi(double num, int n) {
                if(num == 0) {
                    return 0;
                }
    
                //这里主要是来获取的num的位数，例如10.2 则d=2.0 -0.000345 则d=-3.0
                //d  正数表示左移，负数右移
                 double d = Math.ceil(Math.log10(num < 0 ? -num: num));
                
                //这里进行判断将数字的小数点后的第一位变为四舍五入的对象需要移动几位
                 int power = n - (int) d;
                
                 double magnitude = Math.pow(10, power);
                 long shifted = Math.round(num*magnitude);
                return shifted/magnitude;
            
            }
              /**
             * float
                  *  这个函数的作用
                  *  整个数字保留有效位数
                  *  保留的有效位数即n
             * @param num
             * @param n
             * @return
             */
            public float HoldNumberOfSignificantDigi(float num, int n) {
                if(num == 0) {
                    return 0;
                }
                //这里主要是来获取的num的位数，例如10.2 则d=2.0 -0.000345 则d=-3.0
                //d  正数表示左移，负数右移
                 double d = Math.ceil(Math.log10(num < 0 ? -num: num));
                //这里进行判断将数字的小数点后的第一位变为四舍五入的对象需要移动几位
                 int power = n - (int) d;
                 double magnitude = Math.pow(10, power);
                 long shifted = Math.round(num*magnitude);
                return (float) (shifted/magnitude);
                
            }
            /**
             * double
              * 保留小数部分的有效位数
              * 整数部分保留，只处理小数部分
             * @param num
             * @param n
             * @return
             */
            public double HoldDecimalNumberOfSignificantDigi(double num, int n) {
                //正负数标记，0为正数，1为负数
                int flag=0;
                if(num == 0) {
                    return 0;
                }
                //确定num是正数还是负数，如果是负数，将它变为正的，并且flag=1
                if(num<0) {
                    num=-num;
                    flag=1;
                }
                //向下取整，因为num一定是正的，所以就相当于保留整数部分
                double a=Math.floor(num);
                //取小数部分  可能存在问题，就是7、8个0之后还会有一些奇怪的数字
                double b=num-a;
                //取偏移量 变为0.XXXX需要移动几位
                 double d = Math.ceil(Math.log10(b));
                //计算整体偏移量，加上保留的有效位数，需要移动几位
                 int power = n - (int) d;
                 double magnitude = Math.pow(10, power);
                 long shifted = Math.round(b*magnitude);
                if(flag==1) {
                    return (a+shifted/magnitude)*-1;
                }else {
                    return a+shifted/magnitude; 
                }
            }
            /**
             * float
             * 保留小数部分的有效位数
             * 整数部分保留，只处理小数部分
             * @param num
             * @param n
             * @return
             */
            public float HoldDecimalNumberOfSignificantDigi(float num, int n) {
                //正负数标记，0为正数，1为负数
                int flag=0;
                if(num == 0) {
                    return 0;
                }
                //确定num是正数还是负数，如果是负数，将它变为正的，并且flag=1
                if(num<0) {
                    num=-num;
                    flag=1;
                }
                //向下取整，因为num一定是正的，所以就相当于保留整数部分
                double a=Math.floor(num);
                //取小数部分  可能存在问题，就是7、8个0之后还会有一些奇怪的数字
                double b=num-a;
                //取偏移量 变为0.XXXX需要移动几位
                 double d = Math.ceil(Math.log10(b));
                //计算整体偏移量，加上保留的有效位数，需要移动几位
                 int power = n - (int) d;
                 double magnitude = Math.pow(10, power);
                long shifted = Math.round(b*magnitude);
                if(flag==1) {
                    return (float) ((a+shifted/magnitude)*-1);
                }else {
                    return (float) (a+shifted/magnitude);   
                }
            }

**有想过写一个通用的方法，但是发现个人实力不够，只能这样做了**

转载于:https://www.cnblogs.com/hlwd/p/10978232.html