├── README.md
├── Utils.js
└── calcuUtils.js


/README.md:
--------------------------------------------------------------------------------
1 | # JavaScript-precision-algorithm


--------------------------------------------------------------------------------
/Utils.js:
--------------------------------------------------------------------------------
 1 | // JavaScript Document
 2 | "use strict";
 3 | var Utils={};
 4 | if(!Utils){
 5 | 	Utils={};
 6 | }
 7 | Utils.valid=(function(){
 8 | 	var valid={};
 9 | 	if(!valid){
10 | 		valid={};
11 | 	}
12 | 	valid.regExp=(function(){
13 | 		var regExp={};
14 | 		//匹配非负正数
15 | 		regExp.regExpNonNegtiveInt=/^[1-9]\d*|0$/;
16 | 		//匹配数字
17 | 		regExp.number=/^[\-]?([0]|[1-9][0-9]*)([\.][0-9]+)?$/;
18 | 		//匹配含小数点的全零表达式，形如 0.00
19 | 		regExp.regExpZero=/^[0]+[\.][\d]+$/;
20 | 		//匹配不含小数点的全零表达式，形如 0.00
21 | 		regExp.regExpAllZero=/^[0]{1,}$/;
22 | 		//匹配表示零的数字
23 | 		regExp.regExpZero=/^[0]{1,}$|^[0]{1,}[\.][0]{1,}$/;		
24 | 		//匹配javascript的指数表达式的数字 例如：-2.1e-15   1.5e+46
25 | 		regExp.lge=/^[\-]?[1-9][0-9]*([\.][0-9]*[1-9]+)?[e][\+|\-][1-9]+[0-9]*$/;
26 | 		//返回带有各种校验的数字正则对象
27 | 		return regExp;
28 | 	})();
29 | 	valid.arrays=(function(){
30 | 		//数组内部全部为数字
31 | 		var arrays={};
32 | 		arrays.isAllNumber=function(array){
33 | 			if(array instanceof Array){
34 | 				for(var i=0;i<array.length;i++){
35 | 					if(!Utils.valid.regExp.number.test(array[i])){
36 | 						return false;
37 | 					}
38 | 				}
39 | 			}else{
40 | 				return false;
41 | 			}
42 | 			//返回带有各种校验的数字正则对象
43 | 			return true;			
44 | 		}
45 | 		arrays.isContain=function(array,obj){
46 | 			for(var i=0;i<array.length;i++){
47 | 				if(array[i]===obj){
48 | 					return true;
49 | 				}
50 | 			}
51 | 			return false;
52 | 		}
53 | 		return arrays;
54 | 	})();	
55 | 	return valid;
56 | })();
57 | 
58 | 


--------------------------------------------------------------------------------
/calcuUtils.js:
--------------------------------------------------------------------------------
  1 | 
  2 | /**
  3 | kangjin Super high precision
  4 | @author:kangjin.zhao(赵康进)
  5 | @email:kangjin.zhao@accenture.com ;zhaokangjin1@huawei.com; 270882007@qq.com
  6 | @since:2016-06-08 适用于各种浏览器
  7 | @version 2.1.realease
  8 | 有任何使用疑惑或关于此算法的交流意见请发邮件kangjin.zhao@accenture.com ;zhaokangjin1@huawei.com; 270882007@qq.com
  9 | 本算法是针对浏览器的超高精度算法，1万位的小数精度可以秒级完成，百万级的精度大约需要几分钟时间
 10 | 即便是java里的BigDecimal 的小数精度，在这个算法下也相形见绌。
 11 | 本算法借鉴了中国古代的算盘，运算中用内存构建了一个几乎可以无限拓展的算盘模型。
 12 | 本算法重构了加减乘除以及四舍五入的的基本算法，解决了浏览器领域（javascript)的高精度问题，填补了业界这一空白
 13 | */
 14 | "use strict";
 15 | /*
 16 | @author:kangjin.zhao;shijian.lin 
 17 | @email:kangjin.zhao@accenture.com ;270882007@qq.com
 18 | @since:2016-06-08
 19 | @version 2.1.realease
 20 | @parameter 子类对象 
 21 | @parameter 父类对象
 22 | @return 返回子类对象，子类对象已经继承了父类对象的方法
 23 | 
 24 | 定义继承体系，防止Function原型污染，由shijian.lin 林诗健改造  linshijian@huawei.com
 25 | 本算法遵守这个继承体系
 26 | */
 27 | var fnExtends=function(subFn,superClsass){
 28 | 	if(typeof superClsass!=="function"){
 29 | 		throw new Error("父类必须为函数");
 30 | 	}
 31 | 	function tempFn(){};
 32 | 	tempFn.prototype=superClsass.prototype;
 33 | 	subFn.prototype=new tempFn();
 34 | 	subFn.prototype.constructor=subFn.constructor;
 35 | 	subFn.superClass=superClsass;
 36 | 
 37 | 	return subFn;
 38 | }
 39 | /**
 40 | @author:kangjin.zhao;shijian.lin 
 41 | @email:kangjin.zhao@accenture.com ;270882007@qq.com
 42 | @since:2016-06-08
 43 | @version 2.1.realease
 44 | 
 45 | Calculator定义了父类，该父类定义了多种私有方法，为子类提供计算支撑
 46 | */
 47 | function Calculator(){
 48 | 
 49 | };
 50 | 
 51 | 
 52 | /**
 53 | 两个无符号单数字构成的长度相等的数组比较数字大小prototype
 54 | @author:赵康进
 55 | @email:kangjin.zhao@accenture.com ;270882007@qq.com
 56 | @parameter arr1 例如[1,2,3]
 57 | @parameter arr2 例如[1,2,4]
 58 | @return bool 
 59 | */
 60 | Calculator.prototype._compareArrABS=function(arr1,arr2){
 61 | 	if(this._compareStrNum(arr1.join(""),arr2.join(""))){
 62 | 		return true;
 63 | 	}else{
 64 | 		return false;
 65 | 	}
 66 | }
 67 | /**
 68 | 比较两个无符号,无小数点字符型数字串的大小
 69 | @author:赵康进
 70 | @email:kangjin.zhao@accenture.com ;270882007@qq.com
 71 | @parameter strNum1 例如: "123"
 72 | @parameter strNum2 例如: "124"
 73 | @return bool 
 74 | */
 75 | Calculator.prototype._compareStrNum=function(strNum1,strNum2){
 76 | 	if(strNum1===strNum2){
 77 | 		return true;
 78 | 	}
 79 | 	var temp=this._amplify(strNum1,strNum2);
 80 | 	var a=temp.str1,b=temp.str2;
 81 | 	if(a.length>b.length){
 82 | 		return true;
 83 | 	}else if(a.length<b.length){
 84 | 		return false;
 85 | 	}else if(a.length===b.length){
 86 | 		for(var i=0;i<a.length;i++){
 87 | 			if(parseInt(a.substr(i,1),10)>parseInt(b.substr(i,1),10)){
 88 | 				return true;
 89 | 			}else  if(parseInt(a.substr(i,1),10)<parseInt(b.substr(i,1),10)){
 90 | 				return false;
 91 | 			}
 92 | 		}	
 93 | 	}
 94 | }
 95 | /**
 96 | 把有符号数字（字符型或数字型）转换为字符串表示的数值
 97 | @author:赵康进
 98 | @email:kangjin.zhao@accenture.com ;270882007@qq.com
 99 | @parameter 数值型或字符串型数值，包括浮点型的数值，例如： -2.1e-15   1.5e+4
100 | 
101 | @return String 用字符串表示的数字
102 | 例如：123 被转换后  "123"
103 |     "123" 被转换后  "123"
104 | 	1.23e-15 被转换后 "0.0000000000000123"
105 | 	但限于数字的特殊性，比如：1000000000000.0000000000001  这类数字的小数部分会被忽略，或者一个过大的数，超过浏览器的数字范围，结尾会被忽略，面对这种情况，如果因为业务需要超级精度，建议采用字符串来描述数字，比如"1000000000000.0000000000001" 而不是 1000000000000.0000000000001 
106 | 	因此字符串表示的数字的计算精度会远远高于数字型的精度，尽管如此，针对数字的精度要比浏览器的基本算法（位移运算）要高出很多
107 |     这是兼容数字型的计算方法，能够确保数字型的数字计算的超高精度
108 | */
109 | Calculator.prototype._num2str=function(obj){
110 | 	if(typeof obj==="string"){
111 | 		return obj;
112 | 	}
113 | 	if(typeof obj ==="number"){
114 | 		var numStr=obj.toString();
115 | 		if(Utils.valid.regExp.lge.test(numStr)){
116 | 			var sign="";
117 | 			if(numStr.substr(0,1)==="-"){
118 | 				sign="-";
119 | 				numStr=numStr.substr(1);
120 | 			}
121 | 			var tempArr=numStr.split("e");
122 | 			var baseNumArr=tempArr[0].split(".");
123 | 			var smallNumLen=baseNumArr.length>1?baseNumArr[1].length:0;
124 | 			var power=tempArr[1].substr(1);
125 | 			var zerofill="";
126 | 			for(var i=0;i<power-smallNumLen-1;i++){
127 | 				zerofill+="0";
128 | 			}
129 | 			//解析形如 -2.1e-15   1.5e+4
130 | 			if(tempArr[1].substr(0,1)==="-"){
131 | 				//浮点型小于1的字符型表达式
132 | 				return sign+"0."+zerofill+baseNumArr[0]+(baseNumArr[1]?baseNumArr[1]:"");
133 | 			}else{
134 | 				//浮点型大于1的字符型表达式
135 | 				return sign+baseNumArr[0]+(baseNumArr[1]?baseNumArr[1]:"")+zerofill+"0";
136 | 			}
137 | 		}else{
138 | 			return numStr;
139 | 		}
140 | 	}
141 | }
142 | /**
143 | 返回两个操作数相乘或相除得到的符号，依据是同号得正，异号得负的原理
144 | @author:赵康进
145 | @email:kangjin.zhao@accenture.com ;270882007@qq.com
146 | @parameter 数值型或字符串型数值，包括浮点型的数值，例如： -2.1e-15   1.5e+4
147 | @return String 正负符号，负号用"-"表示，正号用空串表示
148 | */
149 | Calculator.prototype._mulSign=function(strNum1,strNum2){
150 | 	if((Utils.valid.regExp.regExpZero.test(strNum1)|Utils.valid.regExp.regExpZero.test(strNum2))
151 | 		|strNum1.split("-").length===strNum2.split("-").length){
152 | 		return "";
153 | 	}else{
154 | 		return "-";
155 | 	}
156 | }
157 | /**
158 | 对无符号的两个字符串同时放大相同倍数，去掉小数点
159 | @author:赵康进
160 | @email:kangjin.zhao@accenture.com ;270882007@qq.com
161 | @parameter strNum1 例如: "123.12"
162 | @parameter strNum2 例如: "124.1"
163 | @return JSON {str1:"12312",str2："12410",le:4,sm:3}
164 | */
165 | Calculator.prototype._amplify=function(strNum1,strNum2){
166 | 	var arr1=strNum1.split(".");
167 | 	var arr2=strNum2.split(".");
168 | 	var len1=arr1[1]?arr1[1].length:0;
169 | 	var len2=arr2[1]?arr2[1].length:0;
170 | 	var n=len1>=len2?len1-len2:len2-len1;
171 | 	var zeros="";
172 | 	var result={};
173 | 	for(var i=0;i<n;i++){
174 | 		zeros+="0";
175 | 	}
176 | 	if(zeros===""){
177 | 		result.str1=arr1[0]+(arr1[1]?arr1[1]:"");
178 | 		result.str2=arr2[0]+(arr2[1]?arr2[1]:"");
179 | 	}else{
180 | 		if(len1>=len2){//0.01,300  >>>1 ,30000
181 | 			result.str1=arr1[0]+arr1[1];
182 | 			result.str2=arr2[0]+(arr2[1]?arr2[1]:"")+zeros;
183 | 		}else{
184 | 			result.str1=arr1[0]+(arr1[1]?arr1[1]:"")+zeros;	
185 | 			result.str2=arr2[0]+arr2[1];	
186 | 		}
187 | 	}
188 | 	var tempM=0,tempN=0,strM=result.str1,strN=result.str2;
189 | 	for(var m=0;m<strM.length;m++){
190 | 		if(strM.substr(m,1)!=="0"){
191 | 			break;
192 | 		}
193 | 		tempM++;
194 | 	}
195 | 	result.str1=strM.slice(tempM);
196 | 	for(var n=0;n<strN.length;n++){
197 | 		if(strN.substr(n,1)!=="0"){
198 | 			break;
199 | 		}
200 | 		tempN++;
201 | 	}	
202 | 	result.str2=strN.slice(tempN);
203 | 	result.le=len1+len2+n;
204 | 	result.sm=len1+len2;
205 | 	return result;
206 | }
207 | //对两个字符串同时放大相同倍数，去掉小数点，并记录小数点的总长度
208 | Calculator.prototype._mulAmplify=function(strNum1,strNum2){
209 | 	var arr1=strNum1.split(".");
210 | 	var arr2=strNum2.split(".");
211 | 	var len1=arr1[1]?arr1[1].length:0;
212 | 	var len2=arr2[1]?arr2[1].length:0;
213 | 	var n=len1>=len2?len1-len2:len2-len1;
214 |     var result={};
215 | 	var strM= arr1.length>1?arr1[0]+arr1[1]:arr1[0];
216 | 	var strN= arr2.length>1?arr2[0]+arr2[1]:arr2[0];
217 | 	result.str1=strM;
218 | 	result.str2=strN;
219 | 	
220 | 	result.le=len1+len2+n;
221 | 	//所有小数点位数
222 | 	result.sm=len1+len2;
223 | 	return result;
224 | }
225 | 
226 | //被除数和除数的除法运算；被除数，除数
227 | Calculator.prototype._devidePower=function(dividend,divisor,n){
228 | 	if(Utils.valid.regExp.regExpZero.test(dividend)){
229 | 		return [0];
230 | 	}
231 | 	var lazyN=false;
232 | 	if(!n && !Utils.valid.regExp.regExpNonNegtiveInt.test(n)){
233 | 		n=12;
234 | 		lazyN=true;
235 | 	}
236 | 	var len=divisor.length;
237 | 	var num=parseInt(divisor,10);
238 | 	var flag=true;//当小数位数达到指定精度时，标记为false,退出循环体
239 | 	//定义除法轮次
240 | 	var i=0;
241 | 	//定义小数轮次，如果小数轮次和n相等，则退出循环
242 | 	var j=0;
243 | 	//定义小数点的标记，第一次满足添加小数点时标记
244 | 	var dotFlag=true;
245 | 	var result=[];
246 | 	//初始化第一次被除数的最高几位数，做第一个轮次除法
247 | 	var subDivi=dividend.substr(0,len);
248 | 	while(flag){
249 | 		//临时被除数，从最高位截取除数长度
250 | 		var temp=parseInt(subDivi,10);
251 | 		//余数  1=1%3
252 | 		var remainder=temp%num;  
253 | 		//商  0=(1-1%3)/3
254 | 		var quotient =(temp-temp%num)/num;
255 | 
256 | 		result.push(quotient);
257 | 	
258 | 		if(dividend.substr(i+len,1)===""){
259 | 			if(remainder===0 && lazyN){
260 | 				flag=false;
261 | 			}else{
262 | 				if(dotFlag && n!=0){
263 | 					result.push(".");
264 | 					dotFlag=false;			
265 | 				}			
266 | 			}
267 | 			subDivi=remainder+"0";
268 | 			j++;		
269 | 		}else{
270 | 			subDivi=remainder+dividend.substr(len+i,1);
271 | 		}		
272 | 		if(j===n+1){
273 | 			flag=false;
274 | 		}
275 | 		i++;
276 | 	}
277 | 	return result;
278 | }
279 | 
280 | //判断减法相减的结果的正负
281 | Calculator.prototype._sign=function(strNum1,strNum2){
282 | 	var a=strNum1.split("-");
283 | 	var b=strNum2.split("-");
284 | 	if(a.length===b.length && a.length==2){
285 | 		//结果为负数
286 | 		return false;
287 | 	}else if(a.length===b.length && a.length==1){
288 | 		//结果为正数
289 | 		return true;
290 | 	}else if(a.length!==b.length && a.length===1){
291 | 		////a>=0,b<0
292 | 		if(a[0]>=b[1]){
293 | 			return true;
294 | 		}else if(a[0]<b[1]){
295 | 			return false;
296 | 		}
297 | 	}else if(a.length!==b.length && b.length===1){
298 | 		//a<0,b>=0
299 | 		if(a[1]>=b[0]){
300 | 			return false;
301 | 		}else if(a[1]<b[0]){
302 | 			return true;
303 | 		}
304 | 	}
305 | }
306 | //两个相同长度的数组相加
307 | 
308 | Calculator.prototype._addArr=function(arr1,arr2){
309 | 	var a=arr1.slice(0);
310 | 	var b=arr2.slice(0);
311 | 	var len=arr1.length;
312 | 	var result=[];
313 | 	for(var i=len-1;i>0;i--){
314 | 		if(a[i]!=="."){
315 | 			var m=a[i]+b[i];
316 | 			if(m>9){
317 | 				if(a[i-1]==="."){
318 | 					a[i-2]=a[i-2]+1;
319 | 				}else{
320 | 					a[i-1]=a[i-1]+1;
321 | 				}
322 | 				
323 | 				result.splice(0,0,m-10);
324 | 			}else{
325 | 				result.splice(0,0,m);
326 | 			}
327 | 		}else{
328 | 			result.splice(0,0,".");
329 | 		}
330 | 	}
331 | 	if(a[0]+b[0]>9){
332 | 		result.splice(0,0,a[0]+b[0]-10);
333 | 		result.splice(0,0,1);
334 | 	}else{
335 | 		result.splice(0,0,a[0]+b[0]);
336 | 	}
337 | 	return result;
338 | }
339 | 
340 | //无符号两个相同长度的数组相减
341 | Calculator.prototype._minusArr=function(arr1,arr2){
342 | 	var a=arr1.slice(0);
343 | 	var b=arr2.slice(0);
344 | 	var len=arr1.length;
345 | 	var result=[];
346 | 	if(this._compareArrABS(a,b)){
347 | 		return this._minusArrUtils(a,b);
348 | 	}else{
349 | 		return this._minusArrUtils(b,a);
350 | 	}
351 | }
352 | 
353 | //两个相同长度的数组减，第一个参数绝对值比第二个绝对值大
354 | Calculator.prototype._minusArrUtils=function(arr1,arr2){
355 | 	var a=arr1.slice(0);
356 | 	var b=arr2.slice(0);
357 | 	var len=arr1.length;
358 | 	var result=[];
359 | 	for(var i=len-1;i>=0;i--){
360 | 		var m=a[i]-b[i];
361 | 		if(a[i]!=="."){
362 | 			if(m<0){
363 | 				if(a[i-1]==="."){
364 | 					a[i-2]=a[i-2]-1;
365 | 				}else{
366 | 					a[i-1]=a[i-1]-1;
367 | 				}
368 | 				result.splice(0,0,a[i]+10-b[i]);
369 | 			}else{
370 | 				result.splice(0,0,m);
371 | 			}
372 | 		}else{
373 | 			result.splice(0,0,".");
374 | 		}
375 | 	}
376 | 	return result;
377 | }
378 | //把两个数字型字符串加工成相同长度的数组，小数点对齐  a:strNum1,b:strNum2
379 | Calculator.prototype._fillArrZero=function(strNum1,strNum2){
380 | 	var result={};
381 | 	var temp={};
382 | 	var arr1=strNum1.split(".");
383 | 	var arr2=strNum2.split(".");
384 | 	var _a={};
385 | 	var _b={};
386 | 	var leftLen=arr1[0].length-arr2[0].length;
387 | 	if(leftLen>0){
388 | 		arr2[0]=this._fillZero(leftLen)+arr2[0];
389 | 	}else{
390 | 		arr1[0]=this._fillZero(-leftLen)+arr1[0];
391 | 	}
392 | 	_a.int=arr1[0].split("");
393 | 	_b.int=arr2[0].split("");
394 | 	if(arr1[1]||arr2[1]){
395 | 		var aRight=arr1[1]?arr1[1]:"";
396 | 		var bRight=arr2[1]?arr2[1]:"";
397 | 		var rightLen=aRight.length-bRight.length;
398 | 		if(rightLen>0){
399 | 			bRight+=this._fillZero(rightLen)
400 | 		}else{
401 | 			aRight+=this._fillZero(-rightLen)
402 | 		}
403 | 		_a.decimal=aRight.split("");
404 | 		_b.decimal=bRight.split("");
405 | 		
406 | 	}
407 | 	temp.left=_a;
408 | 	temp.right=_b;
409 | 	if(temp.left.decimal){
410 | 		result.arr1=temp.left.int.concat(".",temp.left.decimal);
411 | 		result.arr2=temp.right.int.concat(".",temp.right.decimal);
412 | 	}else{
413 | 		result.arr1=temp.left.int;
414 | 		result.arr2=temp.right.int;
415 | 	}
416 | 	for(var i=0;i<result.arr1.length;i++){
417 | 		if(result.arr1[i]!=="."){
418 | 			result.arr1[i]=parseInt(result.arr1[i],10);
419 | 			result.arr2[i]=parseInt(result.arr2[i],10);		
420 | 		}
421 | 	}
422 | 	return result;
423 | }
424 | //给指定的字符串补充零占位
425 | Calculator.prototype._fillZero=function(n){
426 | 	var zero="";
427 | 	for(var i=0;i<n;i++){
428 | 		zero+="0";
429 | 	}
430 | 	return zero;
431 | }
432 | //把字符型数字数组转为整数型数组
433 | Calculator.prototype._parInt=function(arr){
434 | 	for(var i=0;i<arr.length;i++){
435 | 		arr[i]=parseInt(arr[i],10)
436 | 	}
437 | 	return arr;
438 | }
439 | //去掉前置无效零
440 | Calculator.prototype._clearArrPreZero=function(strInt){
441 | 	//去掉001
442 | 	var count=0;
443 | 	for(var f=0;f<strInt.length-1;f++){
444 | 		if(strInt[f]!==0){
445 | 			break;
446 | 		}
447 | 		count++;
448 | 	}
449 | 	return strInt.slice(count);
450 | }
451 | 
452 | //单个数字乘以数组[3],3
453 | Calculator.prototype._nMulti=function(multiplier,n){
454 | 	//var arr1=this._clearArrPreZero(multiplier);
455 | 	var arr1=multiplier.slice(0);
456 | 	var result=[0],len=arr1.length;
457 | 	for(var i=len-1;i>=0;i--){
458 | 		var cur=result[0];
459 | 		var temp=arr1[i]*n+cur;
460 | 		var rem=temp%10;
461 | 		result[0]=rem;
462 | 		var high=(temp-temp%10)/10;
463 | 		if(i===0 && high===0){
464 | 			break;
465 | 		}
466 | 		result.splice(0,0,high);
467 | 	}
468 | 	return result;
469 | }
470 | //数组和数组相乘
471 | Calculator.prototype._arrMulti=function(multiplierArr,faciendArr){
472 | 	var arr1=multiplierArr.slice(0);
473 | 	var arr2=faciendArr.slice(0);
474 | 	var len2=arr2.length,len1=arr1.length;
475 | 	var j=0,result="0";
476 | 	var add=new Add();
477 | 	for(var i=len2-1;i>=0;i--){
478 | 		var zeros=[];
479 | 		for(var  k=0;k<j;k++){
480 | 			zeros.push(0);
481 | 		}
482 | 		result=add.add(result,this._nMulti(arr1,arr2[i]).concat(zeros).join(""));
483 | 	    j++;	
484 | 	}
485 | 	return result;
486 | }
487 | //去掉冗余的零
488 | Calculator.prototype._clearZeros=function(arr){
489 | 	var copyArr;
490 | 	if(arr instanceof Array){
491 | 		copyArr=arr.join("");
492 | 	}else{
493 | 		copyArr=arr;
494 | 	}
495 | 	if(Utils.valid.regExp.regExpZero.test(copyArr)){
496 | 		var result=copyArr.split(".");
497 | 		return "0."+result[1];
498 | 	}else{
499 | 		return copyArr;
500 | 	}	
501 | }
502 | //四则混合运算 被加字符串和精度
503 | Calculator.prototype._arithmetic=function(stringObj,n){
504 | 	
505 | 	//{2+3*5-(33-3/4)}
506 | 	
507 | }
508 | 
509 | function Add(){};
510 | 
511 | fnExtends(Add,Calculator);
512 | 
513 | Add.prototype.add=function(){
514 | 	Calculator.call(this);
515 | 	if(arguments.length===0){
516 | 		throw new Error("必须有加数");
517 | 		return;
518 | 	}	
519 | 	var arrAdd=arguments;
520 | 	if(arguments[0] instanceof Array){
521 | 		arrAdd=arguments[0].slice(0);
522 | 	}
523 | 	var result=this._num2str(arrAdd[0]);
524 | 	if(arrAdd.length===1){
525 | 		return result;
526 | 	}
527 | 	for(var i=0;i<arrAdd.length-1;i++){
528 | 		var param=this._num2str(arrAdd[i+1]);
529 | 		var sign=this._sign(result,param);
530 | 		var a=result.split("-"),b=param.split("-");
531 | 		var _a=a.length===1?a[0]:a[1],_b=b.length===1?b[0]:b[1];
532 | 		var json=this._fillArrZero(_a,_b);
533 | 		var temp;
534 | 		if(a.length===b.length){
535 | 			temp=this._addArr(json.arr1,json.arr2).join("");
536 | 			result=sign?temp:"-"+temp; 
537 | 		}else{
538 | 			temp=this._minusArr(json.arr1,json.arr2).join("");
539 | 			result=this._clearZeros(sign?temp:"-"+temp); 
540 | 		}
541 | 	}
542 | 	return result;
543 | };
544 | 	
545 | function Fixed(){};
546 | 
547 | fnExtends(Fixed,Calculator);
548 | 
549 | Fixed.prototype.toFixed=function(strNum1,n){
550 | 	Calculator.call(this);
551 | 	strNum1=this._num2str(strNum1);
552 | 	if(!Utils.valid.regExp.number.test(strNum1)){
553 | 		throw new Errors("参数不能被转化为有效的数字");
554 | 	}		
555 | 	if(!Utils.valid.regExp.regExpNonNegtiveInt.test(n)){
556 | 		throw new Error("四舍五入位数必须是非负整数");
557 | 		return;
558 | 	}
559 | 	var sign=strNum1.split("-").length>1?"-":"";
560 |  	var add=new Add();
561 |     if(n===0){
562 | 		var arrZ=strNum1.split(".");
563 | 		if(arrZ.length==1 || parseInt(arrZ[1].substr(0,1),10)<5){
564 | 			return arrZ[0];
565 | 		}else{
566 | 			return add.add(arrZ[0],sign+"1");
567 | 		}
568 | 	}
569 | 	var zero="0.",one="0.",result;
570 | 	for(var i=0;i<n;i++){
571 | 		zero+="0";
572 | 		if(i!==(n-1)){
573 | 			one+="0";
574 | 		}
575 | 	}
576 | 	zero+="0";//0.00
577 | 	one+="1";//0.1
578 | 	var temp=add.add(strNum1,zero);
579 | 	var dotAt=temp.indexOf(".");
580 | 	var at=dotAt+n+1;
581 | 	var cut=temp.substring(0,at+1);
582 | 	var lnum=parseInt(cut.charAt(at),10);
583 | 	if(lnum>=5){
584 | 		result=add.add(cut,sign+one).substring(0,at);
585 | 	}else{
586 | 		result=temp.substring(0,at);
587 | 	}
588 | 	return result;
589 | }
590 | //给String 类扩展四舍五入方法
591 | String.prototype.toFixed=function(n){
592 | 	var fix=new Fixed();
593 | 	return fix.toFixed(this,n);
594 | }
595 | function Multiplication(){};
596 | 
597 | fnExtends(Multiplication,Calculator);
598 | 
599 | Multiplication.prototype.multiply=function(strNum1,strNum2){
600 | 	Calculator.call(this);
601 | 	strNum1=this._num2str(strNum1);
602 | 	strNum2=this._num2str(strNum2);
603 | 	if(!Utils.valid.regExp.number.test(strNum1) || !Utils.valid.regExp.number.test(strNum2)){
604 | 		throw new Errors("参数不能被转化为有效的数字");
605 | 	}	
606 | 	var sign=this._mulSign(strNum1,strNum2)
607 | 	var a1=strNum1.split("-");
608 | 	var a2=strNum2.split("-");
609 | 	var s1=a1.length>1?a1[1]:a1[0];
610 | 	var s2=a2.length>1?a2[1]:a2[0];
611 | 	var temp=this._mulAmplify(s1,s2);
612 | 	var nArr1=[];
613 | 	var result=this._arrMulti(this._parInt(temp.str1.split("")),this._parInt(temp.str2.split("")));
614 | 	var n=temp.sm;
615 | 	var at=result.length-n;
616 | 	if(n===0){
617 | 		return sign+result;
618 | 	}
619 | 	var left=result.substr(0,at);
620 | 	if(Utils.valid.regExp.regExpAllZero.test(left)){
621 | 		left="0";
622 | 	}else{
623 | 		var count=0;
624 | 		var ar1=left.split("");
625 | 		for(var i=0;i<ar1.length;i++){
626 | 			if(ar1[i]!=="0"){
627 | 				break;
628 | 			}else{
629 | 				count++;
630 | 			}
631 | 		}
632 | 		left=left.substr(count);
633 | 	}
634 | 	var right=result.substr(at);
635 | 	return result=sign+left+"."+right;
636 | }
637 | //给String 类扩展乘法
638 | String.prototype.multiply=function(){
639 | 	var mul=new Multiplication();
640 | 	var param=this.split(/[\*|×]/);
641 | 	return mul.multiply(param[0],param[1]);
642 | }
643 | function Division(){};
644 | 
645 | fnExtends(Division,Calculator);
646 | 
647 | Division.prototype.divise=function(dividend,divisor,n){
648 | 	Calculator.call(this);
649 | 	dividend=this._num2str(dividend);
650 | 	divisor=this._num2str(divisor);
651 | 	if(!Utils.valid.regExp.number.test(dividend) || !Utils.valid.regExp.number.test(divisor)){
652 | 		throw new Errors("参数不能被转化为有效的数字");
653 | 	}
654 | 	var sign=this._mulSign(dividend,divisor)
655 | 	var temp1=dividend.split("-");
656 | 	var temp2=divisor.split("-");
657 | 	var t1=temp1.length>1?temp1[1]:temp1[0];
658 | 	var t2=temp2.length>1?temp2[1]:temp2[0];
659 | 	var temp=this._amplify(t1,t2);
660 | 	var a=temp.str1,b=temp.str2,t;
661 | 	var result=this._devidePower(a,b,n);
662 | 	if(result[0]===0 && result[1]!=="."){
663 | 		result.splice(0,1)
664 | 	}
665 | 	return sign+result.join("") ;
666 | }
667 | //给String 类扩展除法，非常优雅
668 | String.prototype.divise=function(n){
669 | 	var div=new Division();
670 | 	var param=this.split(/[\/|÷]/);
671 | 	return div.divise(param[0],param[1],n);
672 | }
673 | //给Array 类扩展加法，非常优雅
674 | Array.prototype.add=function(stringObj){
675 | 	obj="2*5+4";
676 | 	if(this.length>0 && Utils.valid.arrays.isAllNumber(this)){
677 | 		var add=new Add();
678 | 		return add.add(this)	
679 | 	}
680 | 	throw new Errors("数组元素有非数字元素");
681 | }


--------------------------------------------------------------------------------