精华内容
下载资源
问答
  • 在这种情况下,为使运算简洁、准确,应当根据一定的规则,正确选取运算中各被测量有效数字的位数。下面我们来说明对有效数字进行运算时应遵循的规则。 1.加减运算 在多个测量值相加减时,要把小数多测量数按舍...
  • 先考虑两个二进制数之间加法(对于补码数据来说,加减法运算规则相同,因此只讨论加法运算情况)运算。设数据位较大的位数为N,则加法运算结果需要用N+1位才能保证运算结果不溢出,也就是说两个长度为N(另一个...

        先考虑两个二进制数之间的加法(对于补码数据来说,加减法运算规则相同,因此只讨论加法运算情况)运算。设数据位较大的位数为N,则加法运算结果需要用N+1位才能保证运算结果不溢出,也就是说两个长度为N(另一个数据位长度也可以小于N)的二进制数进行加法运算,运算结果的有效数据位产长度为N+1。如果运算结果只能采用N位数据表示时,该如何对结果进行截取呢?截取后的结果如何能保证运算的正确性呢?

        对于两个长度为N的二进制数据进行加法运算,需要采用N+1位数据才能获得完全准确的结果。如果需要采用N位数据存放结果,则取低位N位会产生溢出,得出错误结果,取高N位不会出现溢出,但运算结果相当于降低了1/2。

        前面的分析实际上是将数据均当做整数,也就是说小数点位置均于最低位的右边。在数字信号处理中,定点数通常把数限制在-1~1之间。考虑小数运算时,运算结果的小数点位置又该如何确定呢?对比表中的数据(有一个表格作为分析数据的例子,这里省略了表格),如果采用N+1位数据表示运算结果,则小数点位置位于次高位的右边,而不再是最高位的右边;如果用N为数据表示运算结果,则小数点位置位于最高位的右边。也就是说,运算前后小数点右边的数据位数(也是小数位数)是恒定不变的。实际上,在Verilog HDL语言环境中,如果对两个长度为N的数据进行加法运算,为了得到N+1位的准确结果,必须先对参加运算的数进行以为符号位扩展。

    展开全文
  • 有效数字和数值修约及其运算分析部 柳 旭2015.03.19有效数字基本概念数值修约及其进舍规则运算规则注意事项有效数字基本概念有效数字系指在检验工作中所能得到有实际意义数值其最后一位数字欠准是允许这种...
  • 具体包括数值修约(说得简单些就是舍入,参考GB/T 8170-1987)和运算过程修约(就是加减乘除过程中对数值保留位数又有要求。具体规则我记不太清了,毕竟我又不做物理实验,待会问问我朋友看她能不能提供一份说明...

    数值修约程序(包括运算过程有效数字保留,Python3实现)

    今年疫情期间应物理系的朋友要求做了一个做所谓数值和运算修约的程序

    具体包括数值修约(说得简单些就是舍入,参考GB/T 8170-1987)和运算过程的有效数字的保留(就是加减乘除过程中对数值保留位数有要求。具体看我朋友给我提供的这份文件吧:https://shimo.im/docs/PH3hvV6CygW3wK36/

    不说废话了,下面直接贴完整代码吧,Python 3.7和3.8测试过是可以直接跑的。代码使用Python语言实现,所以需要Python解释器。限于篇幅,我在这里就不说怎么安装Python了。

    • 如果你也在找数值运算修约程序,为什么不试试呢?我试过,这个东西手算实在是太费脑筋了,还特别容易错。

    • 如果你看不懂 class或者self是什么,那就直接划到最底下看一下示范的用法,然后copy, paste and run吧。

    • 如果本程序使用的修约规则与你所需要的不同,你可以进行更改,毕竟很多基本的逻辑里面都已经实现好了。

    等我有时间再考虑要不要把实现思路给写出来吧。

    import math
    from decimal import *
    # Ver 0.4.1, Copyleft 2020.10 Peng Lingbo
    # The documentation is written in CHINESE, since the program is based on GB/T 8170-1987
    # if you can read Chinese but the following docs doesn't make sense, try to reopen file with UTF-8 encoding.
    # v0.3 增加debug功能,可以用于查看追踪过程
    # v0.4 支持用任何类型的数字来进行初始化,然而浮点类型本身存在精度问题,所以会收到一个警告要求你使用str()或者Decimal()
    #      此外,现在已经支持运算中加入非Number类对象(内置数字),不过出于上面的原因,还是
    #      建议用str类型--显式的str()转换或者是直接用'单引号'括起来--或者用Decimal类型.
    
    # 由于使用者所在单位采取的运算修约标准可能与本程序所使用的有轻微不同,建议使用者先用几个测例打开debug=True检查各类运算是否符合期望
    # 然后对于不符合的部分做自己的修改再使用。
    
    # 使用本程序,即代表你已经同意程序作者对由于使用本程序所带来的一切可能后果不负任何责任。
    
    class Number:
        """
        帮你自动完成数值运算修约!
        """
        def __init__(self,value,debug=False):
            """
            Args: 一个Decimal对象或一个数字的字符串形式,比如:
                a = Number('3.51E2')
                b = Number('-8.000') <-注意这里的引号
                x = Decimal('3.14159')
                c = Number(x)
            debug: 是否查看追踪过程,默认值False
            """
            if isinstance(value,Number):
                self = value
                return
            if isinstance(value,float):
                print(f"User Warning: Floating type for 'Number' can cause numerical problems. Use '{value}' or str({value}) instead of {value} to initialize to suppress this warning.")
            value = str(value)
            self.debug = debug
            assert isinstance(value,str)
            self.effective_digits = Number.eff(value) # 这个数字的有效数字位数
            self.value = Decimal(value) # 这个数字的数值,以Decimal对象形式保存
            if self.value != 0:
                self.highest_digit = math.floor(math.log10(abs(self.value)))     # 这个数字的最高位的log10值,也就是它最高位的幂数
                self.lowest_digit = self.highest_digit - self.effective_digits + 1 # 这个数字的最低位的log10值,也就是它最低位的幂数
            else:
                #self.value = Decimal('0') # 目前对数字0,默认有效位数为1,最高最低位幂指数为0
                self.highest_digit = 0
                self.lowest_digit = 0
            if self.debug:
                print(f"[{self.value}] Effectives={self.effective_digits}, Highest(log)={self.highest_digit}, Lowest(log)={self.lowest_digit}")
        
        def round(self, precision=0):
            """
            输入:precision(需要保留的有效数字数量),输出:舍入之后的Number对象\n
            ///不改变原变量
            """
            power = self.highest_digit - precision + 1
            if self.debug:
                print(f"                 rounding to 1e{power}, effectives={precision}")
            res = self.value.quantize(Decimal('1e'+str(power)),ROUND_HALF_EVEN)
            if self.debug:
                print(f"                 result={res}")
            return Number(res)
        
        @staticmethod
        def eff(num):
            """@静态方法:接受一个数字num(字符串形式)并返回其有效数字数量"""
            assert isinstance(num,str)
            digits = 0
            is_leading_zero = True
            for i in range(len(num)):
                if num[i]=='E' or num[i]=='e':
                    break
                digit = ord(num[i]) - ord('0')
                if 0 <= digit <= 9:
                    if digit > 0 or (digit == 0 and not is_leading_zero):
                        digits += 1 # 每遇到有效数字: digit++
                        is_leading_zero = False # 遇到第一个有效数字后所有的0都不是leading zero了,都是有效数字
            return max(digits,1)
    
        def __add__(self,rhs):
            if not isinstance(rhs,Number):
                rhs = Number(rhs)
            if self.value == 0:
                return rhs
            if rhs.value == 0:
                return self
            if rhs.debug:
                self.debug=True
            result = self.value + rhs.value
            low_digit = max(self.lowest_digit, rhs.lowest_digit)
            if self.debug:
                print(f"[{self}] + {rhs}, result_lowest_digit={low_digit}")
            result = result.quantize(Decimal('1e'+str(low_digit)), ROUND_HALF_EVEN)
            result = Number(result)
            if self.debug:
                print(f"=======>{result}")
            result.debug = self.debug or rhs.debug
            return result
        
        def __sub__(self,rhs):
            if not isinstance(rhs,Number):
                rhs = Number(rhs)
            if self.value == 0:
                rhs.value = -rhs.value
                return rhs
            if rhs.value == 0:
                return self
            if rhs.debug:
                self.debug=True
            result = self.value - rhs.value
            low_digit = max(self.lowest_digit, rhs.lowest_digit)
            if self.debug:
                print(f"[{self}] - {rhs}, result_lowest_digit={low_digit}")
            result = result.quantize(Decimal('1e'+str(low_digit)), ROUND_HALF_EVEN)
            result = Number(result)
            if self.debug:
                print(f"=======>{result}")
            result.debug = self.debug or rhs.debug
            return result
    
        def __str__(self):
            return str(self.value)
    
        def __neg__(self):
            tmp = self
            tmp.value = -tmp.value
            return tmp
        
        def __repr__(self):
            return self.value.__repr__()
    
        def __mul__(self,rhs):
            if not isinstance(rhs,Number):
                rhs = Number(rhs)
            if rhs.debug:
                self.debug=True
            result = self.value * rhs.value
            left_high = self.value // Decimal(10**self.highest_digit)
            right_high = rhs.value // Decimal(10**rhs.highest_digit)
            carry = (left_high.log10() + right_high.log10()).__floor__()
            if self.debug:
                print(f"[{self}] * {rhs}, carry={carry}")
            precision = min(self.effective_digits, rhs.effective_digits) + carry
            if self.debug:
                print(f"                 result_effectives={precision}")
            result = Number(result)
            result = result.round(precision)
            if self.debug:
                print(f"=======>{result}")
            result.debug=self.debug or rhs.debug
            return result
    
        def __truediv__(self,rhs):
            if not isinstance(rhs,Number):
                rhs = Number(rhs)
            assert rhs.value != 0, "Division By Zero"
            if rhs.debug:
                self.debug=True
            result = self.value / rhs.value
            precision = min(self.effective_digits, rhs.effective_digits)
            if self.debug:
                print(f"[{self}] / {rhs}, result.effectives={precision}")
            result = Number(result)
            result = result.round(precision)
            if self.debug:
                print(f"=======>{result}")
            result.debug=self.debug or rhs.debug
            return result
        
        def __floordiv__(self,rhs):
            if not isinstance(rhs,Number):
                rhs = Number(rhs)
            assert rhs.value != 0, "Division By Zero"
            if rhs.debug:
                self.debug=True
            result = self.value // rhs.value
            precision = min(self.effective_digits, rhs.effective_digits)
            if self.debug:
                print(f"[{self}] // {rhs},precision={precision}")
            result = Number(result, self.debug or rhs.debug)
            result = result.round(precision)
            if self.debug:
                print(f"                 result={result}")
            return result
        
        def __radd__(self, lhs):
            return self+lhs
        
        def __rsub__(self, lhs):
            return Number(lhs)-self
        
        def __rmul__(self, lhs):
            return self*lhs
    
        def __rtruediv__(self, lhs):
            return Number(lhs)/self
    
        def __rfloordiv__(self, lhs):
            return Number(lhs)//self
    
        def sqrt(self):
            """求平方根,自动完成修约"""
            res = self.value.sqrt()
            result = Number(res)
            return result.round(self.effective_digits)
    
        def log10(self):
            """求log10,自动完成修约"""
            res = self.value.log10()
            result = res.quantize(Decimal('1e-'+str(self.effective_digits)), ROUND_HALF_EVEN)
            return Number(result)
    
    
    if __name__ == "__main__":
        a = 4.00000
    
        a = Number('1',debug=True)
        b = Number('1.44')
        c = Number('2.25')
        p1,p2,p3=Number("0.3"),Number("0.2"),Number(".5")
        print(a*p1+b*p2+c*p3)
    
        c = 52.9e6
    
        print(a*b*c/1e+9+10.00000)
        pi = Number(math.pi)
        print(pi)
        pi = pi.round(2)
        print(pi)
    
    

    写在最后:

    她说所有要做大学物理实验的学生都要做这个东西,但是我们在网上怎么找也找不到能够满足要求的代码,大部分实现只实现了数值修约部分——然而如果你细看过程序,就会发现,Python的Decimal里面的quantize已经有所需要的舍入方法了(事实上,那里面什么都有!)。由于实在是找不到,而她又确实是有这样的需求,我那时(疫情期间嘛)比较闲,就干脆帮她做了,意外地并不难,第一版也就百来行。经过几次迭代,现在最终版本也只有近200行。

    说实话很奇怪,如果有这么大的需求,难道不是应该早就有这样的代码了吗?但是我们俩实在找不到这样的代码。所以虽然可能和其他人撞车,但是我(隔了几个月之后)最终还是决定把它公开,能帮到多少人是多少人。

    如果帮到了你,那最好咯。

    展开全文
  • ) 按位“与”操作符,如果二个数二进制,相同位数都是1,则该位结果是1,否则是0。 案例:Int 类型4个字节,4*8=32位有效字节位。 5 => 0000 0000 0000 0000 0000 0000 0000 0101 2 => 0000 0000 0000 0000...

    https://blog.csdn.net/mxiaoyem/article/details/78569782按位运算符详细讲解

    按位运算符

    1.与(&) 按位“与”操作符,如果二个数的二进制,相同位数都是1,则该位结果是1,否则是0。
    案例:Int 类型4个字节,4*8=32位有效字节位。
    5 => 0000 0000 0000 0000 0000 0000 0000 0101
    2 => 0000 0000 0000 0000 0000 0000 0000 0010
    &运算结果 0000 0000 0000 0000 0000 0000 0000 0000

    2.或(|) 按位“或”操作符,如果二个数的二进制,相同位数有一个是1,则该位结果是1,否则是0。
    案例:
    5 => 0000 0000 0000 0000 0000 0000 0000 0101
    2 => 0000 0000 0000 0000 0000 0000 0000 0010
    |运算结果 0000 0000 0000 0000 0000 0000 0000 0111

    3.异(^) 按位“异”操作符,如果二个数的二进制,相同位数只有一个是1,则该位结果是1,否则是0。
    案例:
    5 => 0000 0000 0000 0000 0000 0000 0000 0101
    2 => 0000 0000 0000 0000 0000 0000 0000 0010
    &运算结果 0000 0000 0000 0000 0000 0000 0000 0111

    4.非(~) 按位“非”操作符,属于一元操作符,只对一个操作数进行操作。按位“非”生成与输入位相反的值,若输入0,则输出1。可以采取取负减一法,即~i=(-i)-1;
    案例:
    5 => 0000 0000 0000 0000 0000 0000 0000 0101
    ~运算结果 1111 1111 1111 1111 1111 1111 1111 1010

    2 => 0000 0000 0000 0000 0000 0000 0000 0010
    ~运算结果 1111 1111 1111 1111 1111 1111 1111 1101

    补充知识点:
    1.电脑的世界中只有0和1,所以二进制的正负是从高位看,最高位如果是1,则是负数;如果是0,则是正数。
    2.负数的二进制转化,计算机计算是用补码!
    3.负数的反码是对除符号位(最高位)对原码取反,补码是对反码+1。

    案例:
    5 => 0000 0000 0000 0000 0000 0000 0000 0101
    -5 => 1000 0000 0000 0000 0000 0000 0000 0101

    反码 1111 1111 1111 1111 1111 1111 1111 1010
    补码 1111 1111 1111 1111 1111 1111 1111 1011

    展开全文
  • 1 测定值的运算和有效数字的修约应符合GB/T 8170数值修约规则和JJF 1027测量误差及数据处理的规定2 结果的表述报告平行样的测定值的算术平均值并报告计算结果表示道小数点后的位数或有效位数测定值的有效数的位数应...
  • 前一段时间,为了满足公司web...另外,还对页面输入,数据的有效位数等进行了处理,每个数据字段的有效位数,开发人员都可以自定义。   该公式解析计算器具体使用例子,在我另外一篇博客文章中(http://h

    前一段时间,为了满足公司的web报表系统的需求,利用javascript开发了一个自定义公式解析计算器。开发人员可以根据一定规则,自定义web页面元素或者json字段之间的公式关系,实现算术运算和一些逻辑运算。

     

    另外,还对页面的输入,数据的有效位数等进行了处理,每个数据字段的有效位数,开发人员都可以自定义。

     

    该公式解析计算器的具体使用的例子,在我另外一篇博客文章中(http://huangyuanmu.iteye.com/admin/blogs/469180),有兴趣的话,可以看看。

     

    下边给出具体实现代码:

    /**
     *  模拟java的包,或者C#中的命名空间的概念
     * */
    var tohot = tohot ? tohot : {};
    tohot.commons = tohot.commons ? tohot.commons : {};
    tohot.commons.declaration = tohot.commons.declaration ? tohot.commons.declaration : {};
    /**
     * 报表公式计算器实现
     */
    var tohotCalculator = tohot.commons.declaration.ExpressionCalculator = tohot.commons.declaration.ExpressionCalculator ? tohot.commons.declaration.ExpressionCalculator : {
    
    	description : "通用web报表公式解析计算器,根据自定义的报表计算公式,自动进行公式解析和报表数据计算,操作web报表页面数据和json数据。",
    	author : "huangyuanmu",
    	version : "1.0(2009-07-29)",
    
    	report : {},
    
    	// 根据公式,获取计算以后的值
    	getValue : function(report,formular_str,dataType)
    	{
    
    		// 解析公式
    		function _parseFormular() {
    			if (mathing_begin)
    	          {
    	            mathing_str += formular_str.substr(i,1);
    	            return true;
    	          }
    	          else
    	          {
    	            if (IsVar)
    	            {
    	              formular_str_ana += ")";
    	              CurVar_Length += ")".length;
    	              //判断当前的变量的值是否为空
    	              tmpEl = eval(formular_str_ana.substr(CurVar_start,CurVar_Length));
    	              if (isNaN(tmpEl))
    	              {
    	                formular_str_ana = formular_str_ana.substr(0,CurVar_start);
    	                formular_str_ana += "0";
    	              }
    	            }
    	            formular_str_ana += formular_str.substr(i,1);
    	            IsVar = false;
    	            return true;
    	          }
    	          return false;
    		}
    
    	    var formular_str_ana;
    	    var returnValue;
    	    var IsVar;   //表示该处的字符表示变量
    	    var CurVar_start,CurVar_Length;   //表示当前的变量型字符串
    	    var mathing_begin = false;   //字符串的匹配操作是否开始
    	    var mathing_str = "";  //接受并解析匹配字符串
    	    returnValue = 0;
    	    IsVar = false;
    	    var el_chang  =  "report.";
    	    formular_str_ana = "";
    
    	    if(dataType == null){
    	    	dataType = "2";
    	    }
    
    	    for (i = 0;i<formular_str.length;i++)
    	    {
    	      switch(formular_str.substr(i,1))
    	      {
    	        case "$":
    	        {
    	          if (mathing_begin)
    	          {
    	            mathing_str += formular_str.substr(i,1);
    	            break;
    	          }
    	          else
    	          {
    	            //变量的开始
    	            CurVar_start = formular_str_ana.length;
    	            formular_str_ana +=  "parseFloat("  + el_chang;
    	            CurVar_Length = ("parseFloat(" + el_chang).length;
    	            IsVar = true;
    	            break;
    	          }
    	        }
    	        case "@":
    	        {
    	          //匹配字符串的解释
    	          if (mathing_begin)
    	          {
    	            //匹配字符串结束
    	            mathing_begin = false;
    	            mathing_str_arr = mathing_str.split(";");
    	            formular_str_ana += "/^" + mathing_str_arr[0] + "$/i.test(";
    	            if (mathing_str_arr[1].substr(0,1)  == "$")
    	            {
    	              formular_str_ana += "report" + "." + mathing_str_arr[1].substr(1,mathing_str_arr[1].length-1) + ")";
    	            }
    	            else
    	            {
    	              //非变量
    	              formular_str_ana += "'" + mathing_str_arr[1].substr(0,mathing_str_arr[1].length) + "')";
    	            }
    	          }
    	          else
    	          {
    	            //匹配字符串开始
    	            mathing_begin = true;
    	            mathing_str = "";
    	          }
    	          break;
    	        }
    	        case "+":
    	        {
    				if(_parseFormular()) {
    					break;
    				}
    	        }
    	        case "-":
    	        {
    	          if(_parseFormular()) {
    					break;
    				}
    	        }
    	        case "*":
    	        {
    	          if(_parseFormular()) {
    					break;
    				}
    	        }
    	        case "/":
    	        {
    	          if(_parseFormular()) {
    					break;
    				}
    	        }
    	        case "%":
    	        {
    	          if(_parseFormular()) {
    					break;
    				}
    	        }
    	        case ")":
    	        {
    	          if(_parseFormular()) {
    					break;
    				}
    	        }
    	        case "?":
    	        {
    	          if(_parseFormular()) {
    					break;
    				}
    	        }
    	        case ":":
    	        {
    	          if(_parseFormular()) {
    					break;
    				}
    	        }
    	        case "<":
    	        {
    	          if(_parseFormular()) {
    					break;
    				}
    	        }
    	        case "=":
    	        {
    	          if(_parseFormular()) {
    					break;
    				}
    	        }
    	        case ">":
    	        {
    	          if(_parseFormular()) {
    					break;
    				}
    	        }
    	        case "!":
    	        {
    	          if(_parseFormular()) {
    					break;
    				}
    	        }
    	        case "|":
    	        {
    	          if(_parseFormular()) {
    					break;
    				}
    	        }
    	        case "&":
    	        {
    	          if(_parseFormular()) {
    					break;
    				}
    	        }
    	        default:
    	        {
    	          if (mathing_begin)
    	          {
    	            mathing_str += formular_str.substr(i,1);
    	            break;
    	          }
    	          else
    	          {
    	            if (IsVar)
    	            {
    	              CurVar_Length++;
    	            }
    	            formular_str_ana += formular_str.substr(i,1);
    	          }
    	        }
    	      }
    	    }
    	    if (IsVar)
    	    {
    	      formular_str_ana += ")";
    	      CurVar_Length += ")".length;
    	      //判断当前的变量的值是否为空
    	      tmpEl = eval(formular_str_ana.substr(CurVar_start,CurVar_Length));
    	      if (isNaN(tmpEl))
    	      {
    	        formular_str_ana = formular_str_ana.substr(0,CurVar_start);
    	        formular_str_ana += "0";
    	      }
    	      IsVar = false;
    	    }
    	    if (mathing_begin)
    	    {
    	      //匹配字符串结束
    	      mathing_begin = false;
    	      mathing_str_arr = mathing_str.split(",");
    	      formular_str_ana += "/" + mathing_str_arr[0] + "/i.test(";
    	      if (mathing_str_arr[1].substr(0,1) == "$")
    	      {
    	        formular_str_ana += "report" + "." + mathing_str_arr[1].substr(1,mathing_str_arr[1].length-1) + ")";
    	      }
    	      else
    	      {
    	        //非变量
    	        formular_str_ana += "'" + mathing_str_arr[1].substr(0,mathing_str_arr[1].length) + "')";
    	      }
    	    }
    	    returnValue = eval(formular_str_ana);
    	    // 如果公式计算的值小于0.005,则认为为零
    	    if (Math.abs((returnValue - 0.00))<0.005)
    	    {
    	    	returnValue = tohotCalculator.formatData("0",dataType);
    	    }else{
    			returnValue = tohotCalculator.formatData(returnValue + "",dataType);
    	    }
    	    return returnValue;
    	},
    
    	// 格式化整数
    	formatInteger: function (IntegerStr){
    	    //获取字符串的长度和首字符和次字符,然后进行判断
    	    var strLen = IntegerStr.length;
    	    var firstStr = IntegerStr.substr(0,1);
    	    var secondStr = IntegerStr.substr(1,1);
    	    var tmpStr = IntegerStr;
    	    //针对正数的处理
    	    if(firstStr != "-"){
    	      if ((firstStr == "0") && (strLen > 1)){
    	        tmpStr = tmpStr.substr(1,strLen-1);
    	        tmpStr = tohotCalculator.formatInteger(tmpStr);
    	      }
    	    }
    	    else{
    	      //负数的处理
    	      if((secondStr == "0") && (strLen > 2)){
    	        tmpStr = "-" + tmpStr.substr(2,strLen-2);
    	        tmpStr = tohotCalculator.formatInteger(tmpStr);
    	      }
    	    }
    	    return tmpStr;
    	},
    
    	 // 格式化浮点数
    	 formatFloat: function (FloatStr){
    	    //将字符串组合成整数部分和小数部分
    	    var FloatStrArr = FloatStr.split(".");
    	    var Integer_part = FloatStrArr[0];
    	    var Float_part = FloatStrArr[1];
    	    var FloatPartLen = Float_part.length;
    	    //处理整数部分
    	    if((Integer_part == "-") || (Integer_part == "")){
    	      Integer_part += "0";
    	    }
    	    Integer_part = tohotCalculator.formatInteger(Integer_part);
    	    //处理小数部分
    	    if(FloatPartLen == 0){
    	      Float_part += "00";
    	    }
    	    else{
    	      if(FloatPartLen == 1){
    	        Float_part += "0";
    	      }
    	    }
    	    //合并
    	    return (Integer_part + "." + Float_part);
    	},
    
    	// 数据验证,并设置json对象元素的值
    	formatData: function (DataStr,DataType){
    		var returnValue = "0.00";
    		var IntegerCode,FloatCode;//数字的整数验证码和小数验证码
    	    IntegerCode = /^[-]?[0-9]+$/i; //整数
    	    FloatCode = /^[-]?[0-9]*[.][0-9]+$/i;
    	    //整数
    	    if (DataStr != ""){
    			    if(DataType == "1")
    			    {
    			      if (DataStr.match(IntegerCode) == null)
    			      {
    			        if ((DataStr.match(FloatCode) == null))
    			           {
    			           	 returnValue = "0";
    			           }
    			           else{
    			           	 var reVal = parseFloat(tohotCalculator.formatFloat(DataStr));
    			             returnValue = ""+reVal.toFixed(0);
    			           }
    			      }
    			      else{
    			        returnValue = tohotCalculator.formatInteger(DataStr);
    			      }
    			    }
    			    else if((DataType == "2") || (DataType == "3") || (DataType == "4"))
    			         {
    			          if (DataStr.match(IntegerCode) == null)
    			     		 {
    				           if ((DataStr.match(FloatCode) == null))
    				           {
    				           	 if(DataType == "2")
    			     	   			returnValue = "0.00";
    			     	   		if(DataType == "3")
    			     	   			returnValue = "0.0000";
    			     	   		if(DataType == "4")
    			     	   			returnValue = "0.000000";
    				           }
    				           else{
    				           	 var reVal = parseFloat(tohotCalculator.formatFloat(DataStr));
    				             returnValue = reVal.toFixed(parseInt(DataType)+ (parseInt(DataType) - 2));
    				           }
    				         }
    						else{
    							if(DataType == "2")
    			     	   			returnValue = tohotCalculator.formatInteger(DataStr + ".00");
    			     	   		if(DataType == "3")
    			     	   			returnValue = tohotCalculator.formatInteger(DataStr + ".0000");
    			     	   		if(DataType == "4")
    			     	   			returnValue = tohotCalculator.formatInteger(DataStr + ".000000");
    			     		 }
    			     	}else{
    				           returnValue = "0.00";
    				         }
    
    	    }else{
    	    	if(DataType == "1"){
    	    	  	returnValue = "0";
    	    	}else if(DataType == "2"){
    			    returnValue = "0.00";
    		   	}else if(DataType == "3"){
    		   		returnValue = "0.0000";
    		   	}else if(DataType == "4"){
    		   		returnValue = "0.000000";
    		   	}else{
    		   		 returnValue = "0.00";
    		   	}
    	    }
    	    return returnValue;
    	},
    
    	doCalculateFormular : function (formular) {
    
    		var formualr_is_arr = /[,]/i;
    
    		//解析公式
    	      if (formular.match(formualr_is_arr) == null)
    	      {
    	        //单个公式
    	        each_formular_arr = formular.split("^");
    	        // 解析目标json值的有效位数
    		    var targetArray = each_formular_arr[1].split("#");
    	        // 设置报表json对象的值
    	        var value = tohotCalculator.getValue(tohotCalculator.report,targetArray[0],targetArray[1]);
    	        eval("tohotCalculator.report." + each_formular_arr[0] + "=value");
    			// 设置页面元素的值
    	        var el = eval(each_formular_arr[0]);
    	    	el.value = value;
    	      }
    	      else
    	      {
    	        //公式数组
    	        all_formular_arr = formular.split(",");
    	        for (k=0;k<all_formular_arr.length;k++)
    	        {
    	          //单个公式
    	          	each_formular_arr = all_formular_arr[k].split("^");
    	          	// 解析目标json值的有效位数
    		    	var targetArray = each_formular_arr[1].split("#");
    	        	// 设置报表json对象的值
    	        	var value = tohotCalculator.getValue(tohotCalculator.report,targetArray[0],targetArray[1]);
    		        eval("tohotCalculator.report." + each_formular_arr[0] + "=value");
    				// 设置页面元素的值
    		        var el = eval(each_formular_arr[0]);
    		    	el.value = value;
    	        }
    	      }
    	},
    
    	// 计算整个json报表对象,在保存报表的时候调用
    	doCalculateJson : function (reportFormular) {
    
    		_calculatorJson(reportFormular);
    
    		// 计算报表json对象的公式触发
    		function _calculatorJson(reportFormular) {
    			var EachArrStr = "";
    		    var FoumularArr; //公式数组
    		    var formualr_is_arr = /[,]/i;
    		    var e1;
    
    			//解析公式
    			for(key in reportFormular){
    				formular = reportFormular[key];
    				if (formular.match(formualr_is_arr) == null)
    				{
    				    //单个公式
    					each_formular_arr = formular.split("^");
    					// 解析目标json值的有效位数
    		        	var targetArray = each_formular_arr[1].split("#");
    					var value = tohotCalculator.getValue(tohotCalculator.report,targetArray[0],targetArray[1]);
    					eval("tohotCalculator.report." + each_formular_arr[0] + "=value");
    				}
    				else
    				{
    				    //公式数组
    					all_formular_arr = formular.split(",");
    					for (k=0;k<all_formular_arr.length;k++)
    					{
    					  	//单个公式
    					  	each_formular_arr = all_formular_arr[k].split("^");
    					  	// 解析目标json值的有效位数
    		        		var targetArray = each_formular_arr[1].split("#");
    						var value = tohotCalculator.getValue(tohotCalculator.report,targetArray[0],targetArray[1]);
    					 	eval("tohotCalculator.report." + each_formular_arr[0] + "=value");
    					}
    				}
    			}
    		}
    	},
    
    	// 根据公式计算当前页面的表单元素的值,在页面onblur事件的时候调用
    	doCalculateCurr : function (cur_el_name,el_value,formular,DataType){
    
    		_calculatorCurr(cur_el_name,el_value,formular,DataType);
    
    		// 计算当前页面的公式触发
    		function _calculatorCurr(cur_el_name,el_value,formular,DataType)
    		{
    		    var EachArrStr = "";
    		    var FoumularArr; //公式数组
    		    var formualr_is_arr = /[,]/i;
    		    var e1;
    		    if(_dataAuth(cur_el_name,el_value,DataType))
    		    {
    		      //解析公式
    		      if (formular.match(formualr_is_arr) == null)
    		      {
    		        //单个公式
    		        each_formular_arr = formular.split("^");
    
    		        // 解析目标单元格的有效位数
    		        var targetArray = each_formular_arr[1].split("#");
    
    		        // 设置报表json对象的值
    			    var form_el_value = tohotCalculator.formatData(el_value,DataType);
    			    eval("tohotCalculator.report." + cur_el_name + "=form_el_value");
    
    		        var value = tohotCalculator.getValue(tohotCalculator.report,targetArray[0],targetArray[1]);
    		        eval("tohotCalculator.report." + each_formular_arr[0] + "=value");
    				// 设置页面元素的值
    		        var el = eval(each_formular_arr[0]);
    		    	el.value = value;
    		      }
    		      else
    		      {
    		        //公式数组
    		        all_formular_arr=formular.split(",");
    		        for (k=0;k<all_formular_arr.length;k++)
    		        {
    		          //单个公式
    		          	each_formular_arr = all_formular_arr[k].split("^");
    
    		          	// 解析目标单元格的有效位数
    		        	var targetArray = each_formular_arr[1].split("#");
    
    		          	// 设置报表json对象的值
    			        var form_el_value = tohotCalculator.formatData(el_value,DataType);
    			    	eval("tohotCalculator.report." + cur_el_name + "=form_el_value");
    
    			        var value = tohotCalculator.getValue(tohotCalculator.report,targetArray[0],targetArray[1]);
    			        eval("tohotCalculator.report." + each_formular_arr[0] + "=value");
    					// 设置页面元素的值
    			        var el = eval(each_formular_arr[0]);
    			    	el.value = value;
    		        }
    		      }
    		    }
    		}
    
    		// 数据验证,并设置页面元素的值
    		function _dataAuth(DataStr_el_name,DataStr,DataType){
    			var DataStr_el = eval(DataStr_el_name);
    			DataStr_el.value = tohotCalculator.formatData(DataStr,DataType);
    		    return true;
    		}
    	}
    }
    展开全文
  • 图基础上FPGA 设计、设计前和设计后信号线传输效应分析、规则驱动 板卡设计和编辑、自动布线和完整CAM 输出能力等。 在嵌入式设计部分,增强了JTAG 器件实时显示功能,增强型基于FPGA 逻辑分析仪,可以...
  • 你必须知道495个C语言问题

    千次下载 热门讨论 2015-05-08 11:09:25
    5.3 用缩写指针比较“if(p)”检查空指针是否有效?如果空指针内部表达不是0会怎样? NULL宏 5.4 NULL是什么,它是怎么定义? 5.5 在使用非零位模式作为空指针内部表示机器上,NULL是如何定义? ...
  • Java语言中忽视细节

    2011-09-04 11:24:00
    因为Java语言对位移运算作了优化处理,Java语言对a 转化为a (b%32)来处理,所以当要移位的位数b超过32时,实际上移位的位数是b%32值,那么上面代码中a 相当于a ,所以输出结果是10。  2,可以让i!=i吗?  当你...
  • sqlserver四舍六入函数

    2020-03-06 16:36:29
    对于位数很多近似数,当有效位数确定后,其后面多余数字应该舍去,只保留有效数字最末一位,这种修约(舍入)规则是“四舍六入五成双”,也即“4舍6入5凑偶”,这里“四”是指≤4 时舍去,"六"是指≥6时进上,...
  • 《你必须知道495个C语言问题》

    热门讨论 2010-03-20 16:41:18
    5.3 用缩写指针比较“if(p)”检查空指针是否有效?如果空指针内部表达不是0会怎样? 55 NULL 宏 56 5.4 NULL是什么,它是怎么定义? 56 5.5 在使用非零位模式作为空指针内部表示机器上,NULL 是...
  • 5.3 用缩写指针比较“if(p)”检查空指针是否有效?如果空指针内部表达不是0会怎样? 55 NULL 宏 56 5.4 NULL是什么,它是怎么定义? 56 5.5 在使用非零位模式作为空指针内部表示机器上,NULL 是...
  • • 二进制数的运算规则。 • 计算机中带符号数与小数点的表示方法。 • 计算机中的常用码制。 本章小结: 本章着重介绍了计算机中数据的表示方法,重点讲述了二、八、十、十六进制数的相关概念及各类进制数之间相互...
  • 从本例可以看出,由于a 是单精度浮点型,有效位数只有七位。而整数已占五位,故小数二位后之后均为无效数字。b 是双精度型,有效位为十六位。但Turbo C 规定小数后最多保留六位,其余部分四舍五入。 [Practice] //...
  • 003 计算中的运算顺序 4 ◎灵活处理数据计算中的各种引用 5 004 利用快捷键调整单元格的引用方式 5 005 处理跨表引用 6 006 处理跨工作簿引用 8 ◎数据计算中的互换准则与数据区分 9 007 用数值指代逻辑...
  • 15.5.2 压缩的位数组 555 15.5.3 位运算符 556 15.5.4 使用位运算符实现特征向量 559 15.5.5 实现高级集合操作 561 15.5.6 使用混合实现 561 15.6 小结 561 15.7 复习题 563 15.8 编程练习 565 第16章 图 ...
  • 面向对象方法所强调基本原则,就是直接面对客观存在事物来进行软件开发,将人们在日常生活中习惯思维方式和表达方式应用在软件开发中,使软件开发从过分专业化方法、规则和技巧中回到客观世界,回到人们通常...
  • 会计理论考试题

    2012-03-07 21:04:40
    A、记录在存储介质上一组相关信息集合 B、记录在磁盘上一组相关信息集合 C、记录在磁盘上一组相关程序集合 D、记录在存储介质上一组相关程序集合 9.___B___是Windows管理文件特征,与MS-DOS目录...
  • 9.4.2 长度可变变元列表基本规则 344 9.5 main()函数 345 9.6 结束程序 346 9.7 函数库:头文件 347 9.8 提高性能 348 9.8.1 内联声明函数 348 9.8.2 使用restrict关键字 348 9.9 设计程序 349 9.9.1 ...

空空如也

空空如也

1 2
收藏数 32
精华内容 12
关键字:

有效位数的运算规则