精华内容
下载资源
问答
  • # 定义函数修约小数位数,按舍六入五成双的原则 def Little (x,y): # x 是要修约的数,y 是要保留的小数位数。假设是-0.32561,3 ABS_x = abs(x) # 取x的绝对值0.32561 x1 = int(ABS_x*10**y) # 提取需要保留的...
    # 定义函数修约小数位数,按四舍六入五成双的原则
    def Little (x,y):                       # x是要修约的数,y是要保留的小数位数。
        ABS_x = abs(x)                      # 取x的绝对值
        str_x = str(ABS_x)                  # 字符串x的绝对值
        len_x = len(str_x)                  # 计算x字符串的长度
        Point_x = str_x.find('.')             # 寻找x字符串中的小数点
    
        if Point_x == -1:                     # 如果要修约的数是整数,格式化输出,自动补零
            Result = '%' + '.' + str(y) + 'f'
            print(x, '修约有效数字为:', Result % x)
    
        else:                                      # 如果要修约的数是浮点数
            Index_point = str_x.index('.')         # 找到小数点所在的引索位置
            x1 = int(ABS_x * 10 ** y)              # 整数化输出x绝对值*10的y次方
            bb = len_x - (Index_point+1) - (y+1)
            # 用于判断x的小数位数是否与需要保留的小数位数一致,避免二进制计算问题
            # 如:print(10.05*100-int(10.05*10)*10)   输出结果为: 5.000000000000114,而不是 5
            if bb == 0:
                x2 = int(ABS_x*10**(y+1)) - x1*10
            else:
                x2 = ABS_x*10**(y+1) - x1*10         # 提取需要修约的数字,判断四舍六入五成双
    
            if x2 < 5:
                Num = x1
            if x2 > 5:
                Num = x1 + 1
            if x2 == 5:
                if x1 % 2 == 0:
                    Num = x1
                else:
                    Num = x1 + 1
            ABS_Result = Num/10**y
    
            Result ='%'+'.'+str(y)+'f'   #格式化输出自动补零
            if x>=0:
                print(x, '修约有效数字为:', Result % ABS_Result)
            else:
                print(x, '修约有效数字为:', Result % -ABS_Result)
    
    
    # 定义函数,修约数值的有效数字
    def Significant (w,v):
        # w是要修约的数字,v是需要保留的有效数字个数
        abs_w = abs(w)
        str_w = str(abs_w)
        len_w = len(str_w)                    # 计算x字符串的长度
        Point_w = str_w.find('.')             # 寻找x字符串中的小数点
    
        if Point_w == -1:                     # 如果要修约的数是整数,格式化输出,自动补零
            Result = '%' + '.' + str(v-len_w) + 'f'
            print(w, '修约有效数字为:', Result % w)
    
        else:
            if abs_w >= 1:                      # 如果要修约的数是大于1的浮点数
                index_point = str_w.index('.')  # 确定小数点所在位置
                v = v - index_point             # 确定要取的小数位数
                Little(w,v)                     # 按四舍六入五成双的原则修约
    
            if abs_w < 1:                       # 如果要修约的数是小于1的浮点数,判断小数点后面有多少个零
                len_w = len(str_w)
                n = len_w - 2                   # 计算要修约的数字的小数位数
                w1 = int(abs_w*10**n)           # 把小数变整数
                len_w1 = len(str(w1))           # 计算不为零的数的长度
                v = v + (n - len_w1)            # 反推前面有多少个零,然后确定实际要取的小数位数
                Little(w,v)
    
    
    Significant(-10,3)         # 输出  -10.0
    Significant(-10.05,3)      # 输出  -10.0
    Significant(-0.550,1)      # 输出  -0.6
    Significant(0.0055,1)      # 输出  0.006
    
    
    展开全文
  • 一、数值修约: 口诀:舍六入五考虑,五后非零则进一,五后皆零看奇偶,奇进偶舍不连续。 1.15保留一小数:1.15=1.2(五后非零 看五前面是奇数还是偶数,1是奇数,所以进1=1.2) 1.1501保留一小数:1....

    一、数值修约:

    口诀:四舍六入五考虑,五后非零则进一,五后皆零看奇偶,奇进偶舍不连续。

    1.15保留一位小数:1.15=1.2(五后非零 看五前面是奇数还是偶数,1是奇数,所以进1位=1.2)

    1.1501保留一位小数:1.1501=1.2(五后01非零,所以进一位=1.2)

    1.123保留一位小数:1.123=1.1(四舍六入,所以不进,直接舍弃=1.1)

    二、0.5修约:数值乘以2,修约,修约值除以2。

    21.639进行0.5修约,修约“个”位数=60.25*2=120.5,120.5=120,120/2=60.0

    42.542进行0.5修约,修约“个”位数=42.542*2=85.084,85.084=86,86/2=43.0


    三、0.2修约:数值乘以5,修约,修约值除以5。

    830进行0.2修约,修约“百”位数=830*5=4150,4150=420,420/5=840

    930进行0.2修约,修约“百”位数=930*5=4650,4650=4600,4600/5=920

    四、有效数字运算规则:从左边第一个非0数起,到末位数止,所有的数字都是有个数的有效数字。

    0.0109 前面0.0不是有效数字,后面109是有效数字。

    5.25749按4位有效数字修约:5.25749=5.257

    5.25750按4位有效数字修约:5.25750=5.258(5后是零看5前面是奇数还是偶数,5前面是7,7为奇数,所以进一位。)

    5.25850按4位有效数字修约:5.25850=5.258(5后是零看5前面是奇数还是偶数,5前面是8,8为偶数,所以舍弃。)

    3.109*10^5(3.109乘以10的5次方)10的5次方不是有效数字

    五、有效数字运算规则

    加减运算:以小数点后位数最少的数据为依据。

    四个数值12.80、3.25、2.153、0.0284相加,计算结果:小数点后2位最少,所以进行修约(2.153=2.15、0.0284=0.03)至小数点后两位。
    12.80+3.25+2.15+0.03=18.23

    60.4+2.02+0.222+0.0467=(修约:60.4,2.02=2.0,0.222=0.2,0.467=0)60.4+2.0+0.2+0=62.6

    乘除运算:以有效数字位数最少的为标准。

    三个数值0.0121*30.63*2.05782相乘,计算结果:有效数字位数3位,所以进行修约(30.63=30.6 ,2.05782=2.06),结果保留3位有效数字。
    0.0121*30.6*2.06=0.7627356=0.763

    5.29*0.9259=(修约:5.29,0.9259=0.926)5.29*0.926=4.89854=4.90

    乘方可开方:原数有几位有效位数,计算结果就保留几位。若还参加运算,则应多保留一位。

    常数:π和e及某些倍数或分数可视无线有效。计算过程中可根据需要确定有效位数。

    六、检测摩擦系数的检测值34 43 57 53 24 32:

    平均值:(34+43+57+53+24+32)/6=40.5

    中位数:57 53 43 34 32 24=(43+34)/2=60(偶数中间两数平均值);57 53 43 32 24=43(奇数直接取中值)

    极差:57 53 43 34 32 24=57-24=33 (最大-最小)

    标准差:SQRT((34-40.5)^2+(43-40.5)^2+(57-40.5)^2+(53-40.5)^2+(24-40.5)^2+(32-40.5)^2)=28.66 ((每一个值-平均值)平方+.../n-1)开根号

    变异系数:28.66/40.5*100=70.76(标准差/平均值)*100

    展开全文
  • C# ... /// 数据修约 -- 舍六入5成双,至少保留一位有效位 /// 数值0.00512,保留2位,修约为0.01 /// </summary> /// <param name="modifyValue">原始数据</param>...

     C#

         /// <summary>
            /// 数据修约 -- 四舍六入5成双,至少保留一位有效位
            /// 数值0.00512,保留2位,修约为0.01
            /// </summary>
            /// <param name="modifyValue">原始数据</param>
            /// <param name="degit">保留位数</param>
            /// <returns></returns>
            public static string CalcValue(decimal modifyValue, int? degit)
            {
                decimal calValue = 0;
                int degitNotNull = degit ?? 2;
    
                calValue = Math.Round(modifyValue, degitNotNull);
    
                //按此修约为0则至少保留1位有效位数
                if (calValue == 0 && modifyValue != 0)
                {
                    return modifyValue.ToString("G1");
                }
                else
                {
                    return calValue.ToString("F" + degitNotNull);
                }
            }

     

         /// <summary>
            /// 数据修约 -- 四舍六入5成双,至少保留一位有效位
            /// 数值0.00512,保留2位,修约为0.005
            /// </summary>
            /// <param name="modifyValue">原始数据</param>
            /// <param name="degit">保留位数</param>
            /// <returns></returns>
            public static string CalcValue2(decimal modifyValue, int? degit)
            {
                decimal calValue = 0;
                int degitNotNull = degit ?? 2;
    
                if (Math.Abs(modifyValue) >= 1)
                {
                    calValue = Math.Round(modifyValue, degitNotNull);
                }
    
                //按此修约为0则至少保留1位有效位数
                if (calValue == 0 && modifyValue != 0)
                {
                    string value = modifyValue.ToString();
                    //从小数点后
                    value = value.Substring(value.IndexOf(".") + 1);
                    for (int i = 0; i < value.Length; i++)
                    {
                        if ((i + 1) < degitNotNull)
                        {
                            calValue = Math.Round(modifyValue, degitNotNull);
                        }
                        else
                        {
                            calValue = Math.Round(modifyValue, (i + 1));
                        }
                    }
                    return calValue.ToString();
                }
                else
                {
                    return calValue.ToString("F" + degitNotNull);
                }
            }
    
            

     

    SQL Server:

    ROUND函数为四舍五入

    /*四舍六入五成双*/
    if object_id('fnRound') is not null 
    
      drop function fnRound 
    
      GO 
    
      create function fnRound(@num float,@i int) 
    
      returns varchar(20) 
    
      as 
    
      begin 
    
          declare @str varchar(20)     /*转换成字符类型*/ 
    
          declare @str2 varchar(20)    /*小数位数后面的字符串*/ 
    
          declare @str3 varchar(2)     /*小数位数字符串*/ 
    
          set @str = convert(varchar,@num) 
    
          if (charindex('.',reverse(@str)) <= 0) 
    
          begin 
    
          if @i > 0 
    
       begin 
    
       set @str = @str + '.' 
    
       while @i > 0 
    
        begin 
    
        set @str  = @str + '0' 
    
        set @i = @i - 1 
    
        end 
    
       end 
    
       return @str 
    
       end 
    
          set @str2 = reverse(substring(reverse(@str),1,charindex('.',reverse(@str)) - 1 - @i)) 
    
          set @str3 = substring(@str,charindex('.',@str) + 1,@i) 
    
          if @str2%5 = 0 and @str3%2 = 0   /*如果符合"五成双"*/ 
    
              set @str = substring(@str,1,charindex('.',@str) + @i) 
    
          else    /*否则四舍五入*/ 
    
              set @str = convert(varchar,round(@num,@i)) 
    
          RETURN @str 
    
      end 
    
      GO

     

    转载于:https://www.cnblogs.com/elves/p/10829767.html

    展开全文
  • /// 小数位修约 -- 舍六入5成双,至少保留一位有效位(舍六入五成双) /// 数值0.00512,保留2位,修约为0.005;0.00025修约保留3位,修约后0.0002; /// </summary> /// <param name="modifyValue">...

    实现代码: 

    /// <summary>
    /// 小数位修约 -- 四舍六入5成双,至少保留一位有效位(四舍六入五成双)
    /// 数值0.00512,保留2位,修约为0.005;0.00025修约保留3位,修约后0.0002;
    /// </summary>
    /// <param name="modifyValue">修约值</param>
    /// <param name="degit">保留位数</param>
    /// <returns></returns>
    public static string CalcValue(decimal modifyValue, int? degit){
        decimal calValue = 0;
        int degitNotNull = degit ?? 2;
        if (Math.Abs(modifyValue) >= 1){
            calValue = Math.Round(modifyValue, degitNotNull);
        }
        //按此修约为0则至少保留1位有效位数
        if (calValue == 0 && modifyValue != 0){
            string value = modifyValue.ToString();
            //从小数点后
            value = value.Substring(value.IndexOf(".") + 1);
            for (int i = 0; i < value.Length; i++){
                bool zero = value.Substring(i, 1) == "0" ? true : false;
                if (!zero){
                    if ((i + 1) < degitNotNull){
                        calValue = Math.Round(modifyValue, degitNotNull);
                    }
                    else{
                        calValue = Math.Round(modifyValue, (i + 1));
                    }
                    break;
                }
            }
            return calValue.ToString();
        }
        else{
            return calValue.ToString("F" + degitNotNull);
        }
    }

     

    展开全文
  • 数字修约规则

    2009-06-05 16:28:00
    现在被广泛使用的数字修约规则主要有四舍五入规则和四舍六入五...例如:将数字2.1875精确保留到千分位(小数点后第三位),因小数点后第四位数字为5,按照此规则应向前一位进一,所以结果为2.188。同理,将下列数字...
  • 舍六入五凑偶”的修约规则进行修约

    千次阅读 多人点赞 2020-06-16 23:51:26
    在物理实验中,处理数据时常常需要对结果按照“舍六入五凑偶”的修约规则进行修约。在本题中,我们需要对一个精度为5以内的数按照上述规则保留两小数。 例如: 9.8249=9.82 (小数点后第三<5,因此舍去...
  • 在实际的生产制造统计中,会有精度丢失的情况. 倘若按照 我们平常所用的 舍五入,(1234舍掉, 56789 进位) 这样会使整体数据偏大...例如保留3位有效数字: 1.235 => 1.235 1.2354=>1.235 (0.0004舍掉) ...
  • 首先来一个JAVASCRIPT 版本 ...--2//############################################################3//修约函数dData要修约的数,dPrecision修约间隔,4//###################################...
  • 检测分析结果的数据处理与修约有效数字 一个数的有效数字包括该数中所有的肯定数字再加上最后一可疑的数字具体来说有效数字就是实际上能测到的数字例如用万分之一天平秤量最多可精确到0.1mg称得的质量如以克为...
  • 检测分析结果的数据处理与修约有效数字 一个数的有效数字包括该数中所有的肯定数字再加上最后一可疑的数字具体来说有效数字就是实际上能测到的数字例如用万分之一天平秤量最多可精确到0.1mg称得的质量如以克为...
  • 数值计算 修约规则

    千次阅读 2014-02-28 09:41:22
    如果有修约 修约间隔 有效位数 保留位数 0.5修约 又称半个单位修约修约间隔为指定数的0.5单位,即修约到指定数的0.5单位。 例如,将60.28修约到个数的0.5单位,得60.5 0.2修约修约间隔为指定数的...
  • 话不多说,上代码: function returnFloat(value){ let value=Math.round(parseFloat(value)*100)/100;... } } 这是较为简易的处理,如果还要四舍五入,就截取第第四位小数进行判断从而确定第三位小数是否加一即可。
  • 有效数字的个数称为该数的有效位数。有效数字是误差理论的基本概念之一,若某数的近似值x*的误差不大于该数某一位数字的半个单位,该位到x*最左边的第...取x*₃=3.142作π的近似值,x*₃就有四位有效数字(3,1,4,...
  • [大学物理实验-0]修约规则和常见的实验数据的处理前言测量、误差与不确定度置信区间和置信概率实验数据的记录和处理总结(Sum up) 前言 大学物理实验中最重要的一部分就是对实验数据的处理,与单次的实验不同,关于...
  • 舍六入五成双

    2019-12-03 22:17:52
    需求描述 自定义修约要求 “request” 字段说明如下: ...type:修约类型,其中 1:小数点,2:有效数字,3:科学计数法的有效数字 digit:位数,配合type 例如: {“request”: [{“numberRange”: “Vgt0.1...
  •  对于位数很多的近似数,当有效位数确定后,其后面多余的数字应该舍去,只保留有效数字最末一,这种修约(舍入)规则是"舍六入五成双",也即"4舍6入5凑偶"这里""是指≤4 时舍去,"六"是指≥6时进上,"五"指的是...
  • sqlserver舍六入函数

    2020-03-06 16:36:29
    举例,用上述规则对下列数据保留3位有效数字: 9.8249=9.82, 9.82671=9.83 9.8350=9.84, 9.83501=9.84 9.8250=9.82, 9.82501=9.83 从统计学的角度,“舍六入五成双”比“舍五入”要科学,在大量运算时,它使...
  • 舍六入五留双规则

    2015-04-15 22:59:57
    为了避免四舍五入规则造成的结果偏高,误差偏大的现象出现,一般采用四舍六入五留双...例如将下列数字全部修约四位有效数字,结果为:0.53664——0.536610.2731——10.2718.5049——18.500.58344——0.583416.4005...
  • 数据舍五入

    2018-06-21 10:00:05
    前段时间做数据迁移的测试(Decimal类型数据),其中有个需求,要求小数舍五入保留两位有效数字,使用round,如:round(数字, 2)、round(Decimal(数字), 1)、'%.2f'%(数据)等方法,部分数据没有第三位小数没有逢5...
  • 如 10 mL单标线吸管有效数字位数为5,而10mL刻度吸管随移取溶液体积不同其有效数字位数可能为2,3或4。分析了环境监测中间接式数据的来源,如标准溶液的浓度、标准曲线的截距、斜率、样品最终浓度等,这些数据...
  • 近似数算术运算的误差和有效 近似数算术运算的误差 给定函数u=f(x,y)u=f(x,y)u=f(x,y),设x,yx,yx,y分别为x∗,y∗x^*,y^*x∗,y∗的近似值,则绝对误差为 e(u)=f(x∗,y∗)−f(x,y)≈∂f(x,y)∂x(x∗−x)+∂f(x,...
  • 硬件维修大全

    2015-12-07 19:12:08
    之后,物理坏道真的不难解决,而且可以有效避免扩散问题。但是需要注意的是,无论如何,此时的硬盘已经处于亚健康状态,其中的数据还是非常危险的。用 PQ6.0 处理物理坏道后,究竟这块硬盘还能用多少时间很难说,这...
  • 对于位数很多的近似数,当有效位数确定后,其后面多余的数字应该舍去,只保留有效数字最末一,这种修约(舍入)规则是“舍六入五成双”,也即“4舍6入5凑偶”这里“”是指≤4 时舍去,"六"是指≥6时进上,"五"指...
  • mtk手机维修

    万次阅读 2010-05-27 20:50:00
    (指的是没被别的师傅过的机,如果是别的师傅过的机子就别指望CPU, 字库,电源是好的了),少数情况,是插USB线时损坏CPU的,少数功放损坏的, 还有一部分是高频率波器损坏造成信号差,容易出显紧急呼叫下面...
  • 例如:某一测定结果为25.352,标准差为1.4,四分之一标准差为0.35,其首位有效数字所在数位是十分位,即定为该结果的末位,可报为25.4。2原始记录的有效数字在记录原始数据开始过程中,对任何一个有计算意义的数据都...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,046
精华内容 1,218
关键字:

修约四位有效数字