首页
所有分类
TAGS
文字工具 EMOJI BIBLE
编程 Javascript

JavaScript实现计算圆周率到小数点后100位的方法示例

Posted in Javascript onMay 08, 2018

本文实例讲述了JavaScript实现计算圆周率到小数点后100位的方法。分享给大家供大家参考，具体如下：

浮点数的有效数位是16位，我自己做了一个大数类，能存储100位有效数位，并实现了大数类的基本运算。我用它来计算圆周率（割圆法，即多边形逼近），得到了小数点后一百位有效数字，比对了Machin 公式的计算结果，没有误差。用时约2秒。

完整示例如下：

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>3water.com js计算圆周率</title>
</head>
<body>
<script>
<!--
function BigNum(str, n, b)
{
  /*
   BigNum -- 大数类
   私有成员：
         data -- 119 位数字，放在长度为 17 的数组里，每个数组元素存放 7 位数字。
         decimal_place -- 小数点的位置，从最左位开始算。
         positive -- 是否是正数。
         recalc() -- 为了尽可能存放最多的有效数位，去除前缀的 0，并重新计算小数点位置。
         init() -- 部分初始化工作。
   公有成员：
         BigNum( String str, INT n, BOOL b) --
              构造函数。参数：str -- 字符串，各个有效数位；n -- 整数，小数点位置，从最左位开始算，比如 BigNum("123", 2) = 12.3; BigNum("123", 0) = 0.123; BigNum("123", -2) = 0.00123；b -- 布尔值，是否是正数。
         Add( BigNum num ) -- 加法。
         Subtract( BigNum num ) -- 减法。
         Multiply( BigNum num ) -- 乘法。
         Divide( BigNum num ) -- 除法。
         SquareRoot() -- 平方根。
         toString() -- 转换为字符串（包括小数点），以便以文本形式输出计算结果。
         Clone() -- 复制。
  */
  this.recalc = function() /* 去除前缀的 0，并重新计算小数点位置 */
  {
    for(var i = 0; i < 17; i ++)
    {
       if(this.data[0] != 0) break;
       this.data.shift();
       this.data.push(0);
       this.decimal_place --;
    }
  }
  this.init = function() /* 部分初始化工作 */
  {
    this.decimal_place = Math.ceil( n / 7 ); //小数点位置
    this.data = new Array(17); //保存有效数位的数组
    if(n % 7 > 0)
    {
       var arr = new Array( 8 - n % 7 );
    }
    else
    {
       var arr = new Array( 1 - n % 7 );
    }
    str = arr.join("0") + str;
    if(str.length > 119)
    {
       str = str.substr(0, 119);
    }
    else if(str.length < 119)
    {
       var arr = new Array(120 - str.length);
       str += arr.join("0");
    }
    for( var i = 0; i < 17; i ++ )
    {
       this.data[i] = parseInt( str.substr(i * 7, 7) , 10 );
    }
  }
  /* 初始化开始 */
  this.positive = b;
  if( ! /^0*$/.test(str) )
  {
    this.init();
    this.recalc();
  }
  else
  {
    this.data = new Array(17);
    for( var i = 0; i < 17; i ++ )
    {
       this.data[i] = 0;
    }
    this.decimal_place = 0;
  }
  /* 初始化结束 */
  this.Add = function(num) /* 加法 */
  {
    if(this.positive && !num.positive)
    {
       num.positive = true;
       var result = this.Subtract(num);
       num.positive = false;
       return result;
    }
    else if(num.positive && !this.positive)
    {
       this.positive = true;
       var result = num.Subtract(this);
       this.positive = false;
       return result;
    }
    var result = new BigNum("", 0, this.positive);
    var num1,num2;
    if(this.decimal_place >= num.decimal_place)
    {
       num1 = this;
       num2 = num;
    }
    else
    {
       num1 = num;
       num2 = this;
    }
    result.decimal_place = num1.decimal_place;
    if(num1.decimal_place - num2.decimal_place >= 17)
    {
       for(var i = 0; i < 17; i ++)
       {
         result.data[i] = num1.data[i];
       }
       return result;
    }
    var nOffDec = num1.decimal_place - num2.decimal_place;
    var nTmp = 0;
    for( var i = 16; i >= 0; i -- )
    {
       var nTmp1 = i - nOffDec;
       var nTmp2 = 0;
       if(nTmp1 >= 0)
       {
         nTmp2 = num1.data[i] + num2.data[nTmp1];
       }
       else
       {
         nTmp2 = num1.data[i];
       }
       nTmp2 += nTmp;
       nTmp = Math.floor(nTmp2 / 10000000);
       result.data[i] = nTmp2 % 10000000;
    }
    if(nTmp > 0)
    {
       result.data.unshift(nTmp);
       result.decimal_place ++;
    }
    return result;
  }
  this.Subtract = function(num) /* 减法 */
  {
    if(this.positive && !num.positive)
    {
       num.positive = true;
       var result = this.Add(num);
       num.positive = false;
       return result;
    }
    else if(!this.positive && num.positive)
    {
       this.positive = true;
       var result = this.Add(num);
       result.positive = false;
       this.positive = false;
       return result;
    }
    else
    {
       var num1 = num2 = null;
       var bPositive;
       if(this.decimal_place > num.decimal_place)
       {
         num1 = this;
         num2 = num;
         bPositive = this.positive;
       }
       else if(this.decimal_place < num.decimal_place)
       {
         num1 = num;
         num2 = this;
         bPositive = !this.positive;
       }
       else
       {
         for( var i = 0; i < 17; i ++ )
         {
           if(this.data[i] > num.data[i])
           {
              num1 = this;
              num2 = num;
              bPositive = this.positive;
              break;
           }
           else if(this.data[i] < num.data[i])
           {
              num1 = num;
              num2 = this;
              bPositive = !this.positive;
              break;
           }
         }
       }
       if( num1 == null)
       {
         return new BigNum("", 0, true);
       }
       else
       {
         if(num1.decimal_place - num2.decimal_place >= 17)
         {
           var result = new BigNum("", 0, bPositive);
           for(var i = 0; i < 17; i ++)
           {
              result.data[i] = num1.data[i];
           }
           result.decimal_place = num1.decimal_place;
           return result;
         }
         var result = new BigNum("", 0, bPositive);
         result.decimal_place = num1.decimal_place;
         var nOffDec = num1.decimal_place - num2.decimal_place;
         var nTmp = 0;
         for( var i = 16; i >= 0; i -- )
         {
           var nTmp1 = i - nOffDec;
           var nTmp2 = 0;
           if(nTmp1 >= 0)
           {
              nTmp2 = 10000000 + nTmp + num1.data[i] - num2.data[nTmp1];
           }
           else
           {
              nTmp2 = 10000000 + nTmp + num1.data[i];
           }
           if(nTmp2 >= 10000000)
           {
              result.data[i] = nTmp2 - 10000000;
              nTmp = 0;
           }
           else
           {
              result.data[i] = nTmp2;
              nTmp = -1;
           }
         }
         result.recalc();
         return result;
       }
    }
  }
  this.Multiply = function(num) /* 乘法 */
  {
    var bPositive;
    var nDecimalPlace = this.decimal_place + num.decimal_place - 1;
    if(this.positive == num.positive)
    {
       bPositive = true;
    }
    else
    {
       bPositive = false;
    }
    var result = new BigNum("", 0, bPositive);
    var nTmpData = 0;
    for( var i = 16; i >= 0; i -- )
    {
       for( var j = 16; j >= 0; j -- )
       {
         if(isNaN(result.data[j + i]))
           result.data[j + i] = 0;
         result.data[j + i] += this.data[j] * num.data[i];
         if(result.data[j + i] >= 10000000)
         {
           if( j + i -1 >= 0 )
           {
              result.data[j + i -1] += Math.floor(result.data[j + i] / 10000000);
           }
           else
           {
              nTmpData += Math.floor(result.data[j + i] / 10000000);
           }
           result.data[j + i] = result.data[j + i] % 10000000;
         }
       }
    }
    if(nTmpData > 0)
    {
       result.data.unshift(nTmpData);
       result.data.pop();
       nDecimalPlace ++;
    }
    result.decimal_place += nDecimalPlace;
    return result;
  }
  this.Divide = function(num) /* 除法 */
  {
    var bPositive;
    var nDecimalPlace = this.decimal_place - num.decimal_place + 1;
    if(this.positive == num.positive)
    {
       bPositive = true;
    }
    else
    {
       bPositive = false;
    }
    var result = new BigNum("", 0, bPositive);
    var arrTemp = new Array(17);
    for( var i = 0; i < 17; i ++ )
    {
       arrTemp[i] = this.data[i];
    }
    var bTest = true;
    var nTest = 0;
    for( var i = 0; i < 17; i ++ )
    {
       if(bTest)
       {
         nTest = Math.floor( ( arrTemp[0] * 10000000 + arrTemp[1] ) / ( num.data[0] * 10000000 + num.data[1] ) );
       }
       else
       {
         bTest = true;
       }
       if(nTest == 0)
       {
         result.data[i] = 0;
         arrTemp[1] += arrTemp[0] * 10000000;
         arrTemp.shift();
         arrTemp.push(0);
         continue;
       }
       var arrTemp1 = new Array(17);
       for( var j = 0; j < 17; j ++ )
       {
         arrTemp1[j] = 0;
       }
       for( var j = 16; j >= 0; j -- )
       {
         arrTemp1[j] += nTest * num.data[j];
         if(arrTemp1[j] >= 10000000)
         {
           if(j != 0)
           {
              arrTemp1[j - 1] += Math.floor( arrTemp1[j] / 10000000);
              arrTemp1[j] = arrTemp1[j] % 10000000;
           }
         }
       }
       for( var j = 0; j < 17; j ++ )
       {
         if(arrTemp[j] < arrTemp1[j])
         {
           bTest = false;
           break;
         }
         else if(arrTemp[j] > arrTemp1[j])
         {
           break;
         }
       }
       if(bTest)
       {
         result.data[i] = nTest;
         for( var j = 16; j >= 0; j -- )
         {
           if(arrTemp[j] >= arrTemp1[j])
           {
              arrTemp[j] -= arrTemp1[j];
           }
           else
           {
              arrTemp[j] = 10000000 + arrTemp[j] - arrTemp1[j];
              arrTemp[j - 1] --;
           }
         }
       }
       else
       {
         nTest --;
         i --;
         continue;
       }
       arrTemp[1] += arrTemp[0] * 10000000;
       arrTemp.shift();
       arrTemp.push(0);
    }
    result.decimal_place = nDecimalPlace;
    result.recalc();
    return result;
  }
  this.SquareRoot = function() /* 平方根 */
  {
    var result = new BigNum("", 0, true);
    nDecimalPlace = Math.ceil(this.decimal_place / 2);
    var arrTemp = new Array(17);
    for(var i = 0; i < 17; i ++)
    {
       arrTemp[i] = this.data[i];
    }
    var bTest = true;
    for(var i = 0; i < 17; i ++)
    {
       if( i == 0 )
       {
         if(this.decimal_place % 2 == 0)
         {
           var nTemp = arrTemp[0] * 10000000 + arrTemp[1];
           var nTemp1 = Math.floor( Math.sqrt( nTemp ) );
           var nTemp2 = nTemp - nTemp1 * nTemp1;
           arrTemp[0] = 0;
           arrTemp[1] = nTemp2;
           arrTemp.shift();
           arrTemp.push(0);
         }
         else
         {
           var nTemp1 = Math.floor( Math.sqrt( arrTemp[0] ) );
           var nTemp2 = arrTemp[0] - nTemp1 * nTemp1;
           arrTemp[0] = nTemp2;
         }
       }
       else
       {
         if(bTest)
         {
           if( i == 1 )
           {
              nTemp1 = Math.sqrt( (arrTemp[0] * 10000000 + arrTemp[1]) + 100000000000000 * Math.pow(result.data[0], 2) ) - 10000000 * result.data[0];
              nTemp1 = Math.floor(nTemp1);
           }
           else
           {
              nTemp = result.data[0] * 10000000 + result.data[1];
              nTemp1 = Math.floor( ( arrTemp[0] * 10000000 + arrTemp[1] ) / ( 2 * nTemp ) );
           }
         }
         else
         {
           bTest = true;
         }
         var arrTemp1 = new Array(17);
         var nTemp3 = 0
         for( var j = i - 1; j >= 0; j -- )
         {
           arrTemp1[j] = result.data[j] * 2 + nTemp3;
           if( arrTemp1[j] >= 10000000 && j > 0 )
           {
              nTemp3 = 1;
              arrTemp1[j] = arrTemp1[j] % 10000000;
           }
           else
           {
              nTemp3 = 0;
           }
         }
         arrTemp1[i] = nTemp1;
         nTemp3 = 0;
         for( var j = i; j >= 0; j -- )
         {
           arrTemp1[j] = arrTemp1[j] * nTemp1 + nTemp3;
           if( arrTemp1[j] >= 10000000 && j > 0 )
           {
              nTemp3 = Math.floor( arrTemp1[j] / 10000000 );
              arrTemp1[j] = arrTemp1[j] % 10000000;
           }
           else
           {
              nTemp3 = 0;
           }
         }
         var arrTemp2 = new Array(17);
         for( var j = 0; j < 17; j ++ )
         {
           arrTemp2[j] = arrTemp[j];
         }
         for( var j = i; j >= 0; j -- )
         {
           if( arrTemp2[j] >= arrTemp1[j] )
           {
              arrTemp2[j] -= arrTemp1[j];
           }
           else
           {
              if(j > 0)
              {
                arrTemp2[j] = arrTemp2[j] + 10000000 - arrTemp1[j];
                arrTemp2[j - 1] --;
              }
              else
              {
                bTest = false;
                break;
              }
           }
         }
         if(bTest)
         {
           arrTemp = arrTemp2;
         }
         else
         {
           nTemp1 --;
           i --;
           continue;
         }
       }
       result.data[i] = nTemp1;
       arrTemp[1] += arrTemp[0] * 10000000;
       arrTemp.shift();
       arrTemp.push(0);
    }
    result.decimal_place = nDecimalPlace;
    result.recalc();
    return result;
  }
  this.toString = function() /* 转换为字符串（包括小数点），以便以文本形式输出计算结果 */
  {
    var szData = "";
    var szOutPut = "";
    this.recalc();
    for( var i = 0; i < 17; i ++ )
    {
       var szTmpData = this.data[i].toString()
       var arr = new Array(8 - szTmpData.length);
       szData += arr.join("0") + szTmpData;
    }
    if( /^0*$/.test(szData) )
    {
       return "0";
    }
    var n = this.decimal_place * 7;
    for(var i = 0; i < 7; i++)
    {
       if(szData.substr(i, 1) != 0) break;
       n --;
    }
    szData = szData.replace(/^0+/g,"");
    szData = szData.substr(0, 101);
    szData = szData.replace(/0+$/g,"");
    if( n < 1 )
    {
       szOutPut = szData.substr(0, 1) + 
         ( ( szData.length > 1 ) ? "." : "" ) + 
         szData.substr(1) + "e" + ( n - 1 ).toString();
    }
    else if(n == szData.length)
    {
       szOutPut = szData;
    }
    else if(n > szData.length)
    {
       szOutPut = szData.substr(0, 1) + "." + szData.substr(1) + "e+" + (n - 1).toString();
    }
    else
    {
       szOutPut = szData.substr(0, n) + "." + szData.substr(n);
    }
    return ( this.positive ? "" : "-" ) + szOutPut;
  }
  this.Clone = function()   /* 复制 */
  {
    var result = new BigNum("", 0, true);
    for( var i = 0; i < 17; i ++)
    {
       result.data[i] = this.data[i];
    }
    result.decimal_place = this.decimal_place;
    result.positive = this.positive;
    return result;
  }
}
var a = new BigNum("1", 1, true)
var count = 168;
var nTwo = new BigNum("2", 1, true);
function loop(intTmpvar,intCount)
{
  if(intCount == 0) return intTmpvar;
  var v1 = intTmpvar.Divide( nTwo );
  var v11 = v1.Clone();
  var nTemp = v1.Multiply( v11 );
  var a1 = a.Clone();
  a1 = a.Multiply(a1);
  var nTemp1 = a1.Subtract( nTemp )
  v2 = nTemp1.SquareRoot();
  v3 = a.Subtract( v2 );
  var v31 = v3.Clone();
  var nTemp2 = v3.Multiply( v31 );
  var nTemp3 = nTemp2.Add(nTemp);
  v4 = nTemp3.SquareRoot();
  return loop( v4 , -- intCount )
}
var a1 = a.Clone();
var nTemp = a.Multiply(a1);
var nTemp1 = nTemp.Clone();
nTemp = nTemp.Add(nTemp1);
nTemp = loop(nTemp.SquareRoot(), count);
var nFour = new BigNum("4", 1, true);
nTemp = nTemp.Multiply( nFour );
nTemp1 = new BigNum("2", 1, true);
var nTemp2 = new BigNum("2", 1, true);
for(var i = 0; i < count - 1; i ++)
{
  nTemp1 = nTemp1.Multiply( nTemp2 );
}
nTemp = nTemp.Multiply( nTemp1 );
nTemp = nTemp.Divide( nTwo );
nTemp = nTemp.Divide( a );
document.write( nTemp )
//-->
</script>
</body>
</html>

运行结果：

3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679

PS：这里再为大家推荐几款计算工具供大家进一步参考借鉴：

在线一元函数（方程）求解计算工具：
http://tools.3water.com/jisuanqi/equ_jisuanqi

科学计算器在线使用_高级计算器在线计算：
http://tools.3water.com/jisuanqi/jsqkexue

在线计算器_标准计算器：
http://tools.3water.com/jisuanqi/jsq

希望本文所述对大家JavaScript程序设计有所帮助。

JavaScript实现计算圆周率到小数点后100位的方法示例

- Author -

ncs2002

声明：登载此文出于传递更多信息之目的，并不意味着赞同其观点或证实其描述。

Javascript 相关文章推荐
为jquery.ui.dialog 增加“在当前鼠标位置打开”的功能
Nov 24 Javascript
jquery调用wcf并展示出数据的方法
Jul 07 Javascript
Javascript 中 null、NaN和undefined的区别总结
Apr 10 Javascript
JS中处理时间之setUTCMinutes()方法的使用
Jun 12 Javascript
Javascript函数式编程语言
Oct 11 Javascript
js实现模拟银行卡账号输入显示效果
Nov 18 Javascript
详谈Node.js之操作文件系统
Aug 29 Javascript
详解如何从零开始搭建Express+Vue开发环境
Jul 17 Javascript
vue使用v-if v-show页面闪烁,div闪现的解决方法
Oct 12 Javascript
js实现黑白div块画空心的图形
Dec 13 Javascript
Bootstrap Paginator+PageHelper实现分页效果
Dec 29 Javascript
使用vue2.6实现抖音【时间轮盘】屏保效果附源码
Apr 24 Javascript
Vue.js 实现微信公众号菜单编辑器功能(二)
May 08 #Javascript
详解基于mpvue的小程序markdown适配解决方案
May 08 #Javascript
Vue.js 实现微信公众号菜单编辑器功能(一)
May 08 #Javascript
浅谈React 服务器端渲染的使用
May 08 #Javascript
vue.js做一个简单的编辑菜谱功能
May 08 #Javascript
webstorm和.vue中es6语法报错的解决方法
May 08 #Javascript
vue2.0实现移动端的输入框实时检索更新列表功能
May 08 #Javascript
罗马尼亚购物网站(10) 冰岛购物网站(1) 约旦购物网站(1) PHP面试题(54) 哈萨克斯坦购物网站(2) 马耳他购物网站(1) 白俄罗斯购物网站(3) 保加利亚购物网站(3) 乌克兰购物网站(27) 希腊购物网站(6)
You might like
PHPMailer使用教程(PHPMailer发送邮件实例分析)
2012/12/06 PHP
PHP实现图片压缩的两则实例
2014/07/19 PHP
thinkPHP多语言切换设置方法详解
2016/11/11 PHP
[原创]PHP获取数组表示的路径方法分析【数组转字符串】
2017/09/01 PHP
Js callBack 返回前一页的js方法
2008/11/30 Javascript
JavaScript 基础知识 被自己遗忘的
2009/10/15 Javascript
javascript权威指南 学习笔记之null和undefined
2011/09/25 Javascript
详解JavaScript中的异常处理方法
2015/06/16 Javascript
js简单实现Select互换数据的方法
2015/08/17 Javascript
JavaScript获取当前cpu使用率的方法
2015/12/15 Javascript
基于JavaScript如何制作遮罩层对话框
2016/01/26 Javascript
Js与Jq获取浏览器和对象值的方法
2016/03/18 Javascript
JavaScript基础教程——入门必看篇
2016/05/20 Javascript
vue组件间通信解析
2017/03/01 Javascript
Vue.Js中的$watch()方法总结
2017/03/23 Javascript
详解有关easyUI的拖动操作中droppable，draggable用法例子
2017/06/03 Javascript
vue事件修饰符和按键修饰符用法总结
2017/07/25 Javascript
详解vue-cli构建项目反向代理配置
2017/09/07 Javascript
Vue.use源码学习小结
2018/06/20 Javascript
elementUI 动态生成几行几列的方法示例
2019/07/11 Javascript
[02:28]DOTA2英雄基础教程 灰烬之灵
2013/12/19 DOTA
[37:23]DOTA2上海特级锦标赛主赛事日 - 3 胜者组第二轮#2Secret VS EG第二局
2016/03/04 DOTA
详解python3百度指数抓取实例
2016/12/12 Python
Python实现1-9数组形成的结果为100的所有运算式的示例
2017/11/03 Python
Python实现定制自动化业务流量报表周报功能【XlsxWriter模块】
2019/03/11 Python
Python实现最大子序和的方法示例
2019/07/05 Python
Python使用ElementTree美化XML格式的操作
2020/03/06 Python
python opencv 实现读取、显示、写入图像的方法
2020/06/08 Python
html5实现微信打飞机游戏
2014/03/27 HTML / CSS
最好的意大利皮夹克：D’Arienzo
2018/12/04 全球购物
竞聘书模板
2014/03/31 职场文书
优秀研究生主要事迹
2014/06/03 职场文书
2014年度培训工作总结
2014/11/27 职场文书
2015年反腐倡廉工作总结
2015/05/14 职场文书
学生会副主席竞选稿
2015/11/19 职场文书
java如何实现socket连接方法封装
2021/09/25 Java/Android