使用中语言计算圆周率

中语言计算技术研究与发展联盟
舒生羽 wzyorg@gmail.com

圆周率是数学领域内的一个基本常数，甚至是整个世界的一个基本常数，也是最有用的常数之一，同时也是非常神秘的一个常数。因此自古以来就有非常多的人想尽办法来计算圆周率，以求更加精确，当然现在人们已经知道它是个无理数，而且是个超越数。计算它的意义似乎主要在于满足某种兴趣，当然人们也喜欢将此作为测试程序和机器性能的工具。

中国人在圆周率的计算上曾有不错的结果，这里最高成就当然是祖冲之了，他计算出了圆周率的位于3.1456926和3.1415927之间的这样一个领先世界近千年的结果，而刘徽之前也曾得到了来不起的结果。然而这样的成就在中国历史上从此成为绝响，而自唐宋之后中国人在计算能力以及其它科技能力上落后世界太多。从中可以窥见中国人在计算能力上的没落以及智力上的总体下降，更宏观的景象则是整个种族在文明的败落和精神上的颓废。
又联系到中国当前实质上基于计算的现代信息技术的状况和我们所处的环境，这种感觉更加令人沮丧。然而时代毕竟已经同曾经的历史惯性截然不同，前所未有的技术时代为有着伟大理想和不凡追求的人提供了前所未有的机遇。
中语言项目的诞生正当其时。它正如其旗图所展示的那样，它是黑暗中的光明，它有信心用自己穿透黑暗的光芒来唤醒中国那些处于迷失和恍惚中但却有着高贵和卓越天性的中国文明传承者，使得他们在不远的将来很有热情的投入到以自己的语言书写一片新的程序天地和以自己的智慧创造一个新的计算机世界这样一件伟大的事业中来。
下面，中语言将以自己的符号系统来实现圆周率的算法。这个程序翻译自gmp库用于计算圆周率的gmp-chudnovsky.c文件。它所采用的算法实质是Chudnovsky算法，这是一种使用快速收敛的级数序列计算圆周率的方法。
如果祖冲之能穿越时空来看到这个程序，他会认同吗？另外有趣的是，这个程序的原作者从其署名看似乎是个华裔，这似乎象征着某种轮回。而很有幸的是，中语言是这个轮回圆圈上的一点。
完整程序如下：
程序的执行结果如下（1000位）：

/*使用中语言计算圆周率.
此程序翻译自gmp库的圆周率计算程序的源代码gmp-chudnovsky.c.

中语言计算技术研究与发展联盟 舒生羽 2012.12.19

*/
/* Pi computation using Chudnovsky's algortithm.

* Copyright 2002, 2005 Hanhong Xue (macroxue at yahoo dot com)

* Slightly modified 2005 by Torbjorn Granlund to allow more than 2G
digits to be computed.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO
* EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
来 朴库.数学;
来 朴库.标准进出;
来 朴库.标准库;
来 朴库.串;

来 朴库.时;

名{
定 项子_一次部偏量: 向 目= 13591409;
定 项子_一次部倍量: 向 目= 545140134;
定 项母_旺式部底量: 向 目= 640320;
定 全项倍量: 向 目= 12;
定 每位爻数: 日 浮= 3.32192809488736234787;
定 每迭位数: 日 浮= 14.1816474627254776555;
定 双倍精度: 元= 53;
定 因子式_初始尺度: 元= 32;
因子式: 类=
公{
_最多因子: 向 目;
_因子数: 向 目;
_因子: <向 目>-址;
_幂次: <向 目>-址;
显示+: ()->();

复零+: ()->();

生+: (尺度: 目 元);

开启+: (尺度: 目 元)->();

生+: ();

死+: ();

清空+: ()->();

伸缩+: (比例: 目 元)->();

/* 己 = 底数^幂次 */
获值+: (底数: 向 目* 幂次: 目 元)->();

/* 果 = 左参 * 右参 */
相乘+: (果: <因子式>-牵* 左参: <因子式>-牵* 右参: <因子式>-牵)->();

/* 参数->* 几 */
累乘+: (参数: <因子式>-牵)->();

/* 底数^幂次 ->* 己 */
累乘+: (底数: 向 目* 幂次: 向 目)->();

/* 去掉幂0的因子*/
压缩+: ()->() 直;

/*  将因子化形式转化成数字*/
化式乘法+: 旁 (果: 太 元* 甲参: 目 元* 乙参: 目 元)->();

/* 左参 /= 基.公因数(左参,右参), 右参 /= 基.公因数(左参,右参) */
去掉共因子+: 旁 (左参: <太元>-牵* 左参因: <因子式>-牵* 右参: <太元>-牵* 右参因: <因子式>-牵)->();

};

筛型: 方=
{
因子: 目 元;
幂次: 目 元;
下邻: 目 元;
};

}
基{
程序名: <口>-址;
出掩: 元= 0;
筛组: <筛型>-址;
筛组尺度: 向 元;
因式累积: 因子式;
项母增式窖, 项子全式窖, 阶乘约式窖: <太元>-址;
因子式_项母增式窖, 因子式_阶乘约式窖: <因子式>-址;
底端: 向 元= 0;
进度, 百分比: 日 浮= 0;
}
母窖底: ()->(<太元>-牵)=基.项母增式窖[基.底端];

子窖底: ()->(<太元>-牵)=基.项子全式窖[基.底端];

约窖底: ()->(<太元>-牵)=基.阶乘约式窖[基.底端];

因母窖底: ()->(<因子式>-牵)=基.因子式_项母增式窖[基.底端];

因约窖底: ()->(<因子式>-牵)=基.因子式_阶乘约式窖[基.底端];

母窖底内侧: ()->(<太元>-牵)=基.项母增式窖[基.底端 + 1];

子窖底内侧: ()->(<太元>-牵)=基.项子全式窖[基.底端 + 1];

约窖底内侧: ()->(<太元>-牵)=基.阶乘约式窖[基.底端 + 1];

因母窖底内侧: ()->(<因子式>-牵)=基.因子式_项母增式窖[基.底端 + 1];

因约窖底内侧: ()->(<因子式>-牵)=基.因子式_阶乘约式窖[基.底端 + 1];

最小: (甲: 向 目* 乙: 向 目)->(向 目)=甲 > 乙 ? 乙 : 甲;

最大: (甲: 向 目* 乙: 向 目)->(向 目)=甲 < 乙 ? 乙 : 甲;

/* 返回以毫秒测量的用户的CPU时间.  */
计算机时刻: ()->(元)=
{
归 (现下时刻() -: [日 浮] * 1000 / CLOCKS_PER_SEC) -: [元];
}

因子式::显示: ()->()=
{
过(索@[0 : _因子数 -: [元] - 1])
若(_幂次[索] == 1)
打印文套("%ld ", _因子[索]);
否则
打印文套("%ld^%ld ", _因子[索], _幂次[索]);
打印文套("\n");
}

因子式::复零: ()->() 直=
{
0 -> _因子数;
}

因子式::生: (尺度: 目 元)=
{
开启(尺度);
}

因子式::开启: (尺度: 目 元)->()=
{
若(尺度 < 因子式_初始尺度)
因子式_初始尺度 -> 尺度;
地 生 <尺度 * 2, 向 目>-阵 -> _因子;
_因子 + 尺度 -> _幂次;
尺度 -> _最多因子;
复零();
}

因子式::生: ()=
{
开启(因子式_初始尺度);
}

因子式::清空: ()->()=
{
若(_因子 != 零址)
{
地 死 []_因子;
零址 -> _因子;
}
}

因子式::死: ()=
{
清空();
}

因子式::伸缩: (比例: 目 元)->() 直=
{
若(_最多因子 < 比例)
{
地 死 []_因子;
开启(比例);
}
}

/* 底数^幂次 -> 己 */
因子式::获值: (底数: 向 目* 幂次: 目 元)->()=
{
索: 目 元;
2 ->/ 底数;
过(索->[0 : ^(1;基.筛组[底数].下邻 -> 底数) : %(底数 > 0)])
{
基.筛组[底数].因子 -> _因子[索];
基.筛组[底数].幂次 * 幂次 -> _幂次[索];
}
索 -> _因子数;
}

/* 左参*右参 -> 果 */
因子式::相乘: (果: <因子式>-牵* 左参: <因子式>-牵* 右参: <因子式>-牵)->() 直=
{
左索, 右索, 小索: 目 元= 0, 0;
过(小索->[0 :  : %(左索 < 左参._因子数 && 右索 < 右参._因子数)])
{
逐
门(左参._因子[左索] == 右参._因子[右索])
{
左参._因子[左索] -> 果._因子[小索];
左参._幂次[左索] + 右参._幂次[右索] -> 果._幂次[小索];
左索++;
右索++;
}
门(左参._因子[左索] < 右参._因子[右索])
{
左参._因子[左索] -> 果._因子[小索];
左参._幂次[左索] -> 果._幂次[小索];
左索++;
}
门 ...
{
右参._因子[右索] -> 果._因子[小索];
右参._幂次[右索] -> 果._幂次[小索];
右索++;
}
}
过(左索->[ : <^(1;小索++) : 左参._因子数])
{
左参._因子[左索] -> 果._因子[小索];
左参._幂次[左索] -> 果._幂次[小索];
}
过(右索->[ : <^(1;小索++) : 右参._因子数])
{
右参._因子[右索] -> 果._因子[小索];
右参._幂次[右索] -> 果._幂次[小索];
}
小索 -> 果._因子数;
}

/* 乘参 ->* 己 */
因子式::累乘: (乘参: <因子式>-牵)->() 直=
{
基.因式累积.伸缩(_因子数 + 乘参._因子数);
相乘(基.因式累积, *己, 乘参);
//高效交换两个因子式
基.因式累积._最多因子 <-> 己.._最多因子;
基.因式累积._因子数 <-> 己.._因子数;
基.因式累积._因子 <-> 己.._因子;
基.因式累积._幂次 <-> 己.._幂次;
}

/* 底数^幂次 ->* 己*/
因子式::累乘: (底数: 向 目* 幂次: 向 目)->() 直=
{
临: 因子式;
临.获值(底数, 幂次);
累乘(临);
}

/* 去掉幂0的因子*/
因子式::压缩: ()->() 直=
{
实索: 目 元= 0;
过(索@[0 -: [目 元] : _因子数 - 1])
{
若(_幂次[索] > 0)
{
若(实索 < 索)
{
_因子[索] -> _因子[实索];
_幂次[索] -> _幂次[实索];
}
实索++;
}
}
实索 -> _因子数;
}

/*  将因子化形式转化成数字*/
因子式::化式乘法: (果: 太 元* 低界: 目 元* 高界: 目 元)->()=
{
若(高界 - 低界 <= 32)
{
1 -: [向 目] -> 果;
过(界索@[低界 : 高界 - 1][0 : 基.因式累积._幂次[界索] - 1])
基.因式累积._因子[界索] ->* 果;
}
否则
{
果二: 太 元;
同(果二, 低界, (低界 + 高界) / 2);
同(果, (低界 + 高界) / 2, 高界);
果二 ->* 果;
}
}

/* 左参因 /= 基.公因数(左参,右参), 右参因 /= 基.公因数(左参,右参) */
因子式::去掉共因子: (左参: <太元>-牵* 左参因: <因子式>-牵* 右参: <太元>-牵* 右参因: <因子式>-牵)->()=
{
左索, 右索, 共因数: 向 元= 0, 0, 0;
基.因式累积.伸缩(最小(左参因._因子数, 右参因._因子数));
环(左索 < 左参因._因子数 && 右索 < 右参因._因子数)
{
若(左参因._因子[左索] == 右参因._因子[右索])
{
共次: 向 元;
最小(左参因._幂次[左索], 右参因._幂次[右索]) -> 共次;
共次 ->- 左参因._幂次[左索];
共次 ->- 右参因._幂次[右索];
左参因._因子[左索] -> 基.因式累积._因子[共因数];
共次 -> 基.因式累积._幂次[共因数];
左索++;
右索++;
共因数++;
}
否则 若(左参因._因子[左索] < 右参因._因子[右索])
{
左索++;
}
否则
{
右索++;
}
}
共因数 -> 基.因式累积._因子数;
若(基.因式累积._因子数)
{
共因数: 太元;
化式乘法(共因数, 0, 基.因式累积._因子数);
左参.恰除(共因数, 左参);
右参.恰除(共因数, 右参);
左参因.压缩();
右参因.压缩();
}
}

/*///////////////////////////////////////////////////////////////////////////*/
/* 平方根(入参) -> 果*/
求向目平方根: (果: <太浮>-牵* 入参: 向 目)->()=
{
精度: 向 目;
原精度: 向 目= 果.精度();
若(原精度 <= 双倍精度)
{
平方根(入参 -: [日 浮]) -> 果;
归;
}
爻位数: 向 目= 0;
周(原精度 -> 精度; 精度 > 双倍精度; )
{
单双爻: 元= 精度 & 1;
(精度 + 单双爻) / 2 -> 精度;
爻位数 * 2 + 单双爻 -> 爻位数;
}
临一, 临二: 太浮;
临一.保原设置精度(双倍精度);
1 / 平方根(入参 -: [日 浮]) -> 临一;
环(精度 < 原精度)
{
2 ->* 精度;
若(精度 < 原精度)
{
/* 临一 = 临一+临一*(1-入参*临一*临一)/2; */
临二.保原设置精度(精度);
/* 一半 x 一半 -> 全部 */
临一 * 临一 -> 临二;
入参 ->* 临二;
1 - 临二 -> 临二;
临二.保原设置精度(精度 / 2);
1 ->>> 临二;
/* 一半 x 一半 -> 一半 */
临一 ->* 临二;
临一.保原设置精度(精度);
临二 ->+ 临一;
}
否则
{
跃;
}
爻位数 & 1 ->- 精度;
2 ->/ 爻位数;
}
/* 临二=入参*临一, 临一 = 临二+临一*(入参-临二*临二)/2; */
临二.保原设置精度(原精度 / 2);
临一 * 入参 -> 临二;
/* 一半 * 一半 -> 全部 */
临二 * 临二 -> 果;
入参 - 果 -> 果;
/* 一半 * 一半 -> 一半 */
果 ->* 临一;
1 ->>> 临一;
临一 + 临二 -> 果;
}

/*///////////////////////////////////////////////////////////////////////////*/
/*///////////////////////////////////////////////////////////////////////////*/
/* 二分切割 */
二分: (左界: 向 目* 右界: 向 目* 约旗: 向 元* 层: 目 元)->()=
{
界长, 中分值: 向 目;
若(右界 - 左界 == 1)
{
/*
约(右界-1,右界) = (6b - 5)(2b - 1)(6b - 1)
母(右界-1,右界) = 右界 ^ 3 * 项母_旺式部底量^3 / 24
子(右界-1,右界) = (-1)^右界 * g(右界 - 1, 右界) * (项子_一次部偏量+Bb).
*/
右界 -> 母窖底();
右界 ->* 母窖底();
右界 ->* 母窖底();
项母_旺式部底量 / 24 * (项母_旺式部底量 / 24) -: [向 目] ->* 母窖底();
项母_旺式部底量 * 24 ->* 母窖底();
2 * 右界 - 1 -> 约窖底();
6 * 右界 - 1 ->* 约窖底();
6 * 右界 - 5 ->* 约窖底();
右界 -> 子窖底();
项子_一次部倍量 -: [向 目] ->* 子窖底();
项子_一次部偏量 -: [向 目] ->+ 子窖底();
约窖底() ->* 子窖底();
若(右界 % 2)
子窖底().反向();
右界 -> 界长;
环((界长 & 1) == 0)
1 ->>> 界长;
/*  右界^3 */
因母窖底().获值(界长, 3);
因母窖底().累乘(3 * 5 * 23 * 29, 3);
因母窖底()._幂次[0]--;
因约窖底().获值(2 * 右界 - 1, 1);
因约窖底().累乘(6 * 右界 - 1, 1);
因约窖底().累乘(6 * 右界 - 5, 1);
若(右界 > 基.进度 -: [元])
{
打印文套(".");
簿冲(基.标准出口);
基.百分比 * 2 ->+ 基.进度;
}
}
否则
{
/*
母(左界,右界) = 母(左界, 中) * 母(中, 右界)
约(左界,右界) = 约(左界, 中) * 约(中, 右界)
子(左界,右界) = 子(左界, 中) * 母(中, 右界) + 子(中,右界) * 约(左界, 中)
*/
/* 调整参数 */
左界 + (右界 - 左界) * 0.5224 -> 中分值;
同(左界, 中分值, 1, 层 + 1);
基.底端++;
同(中分值, 右界, 约旗, 层 + 1);
基.底端--;
若(层 == 0)
放入串(1#"");
0 -> 层;
若(层 >= 4)
{
/* 调整参数 */
因子式::去掉共因子(母窖底内侧(), 因母窖底内侧(), 约窖底(), 因约窖底());

}
母窖底内侧() ->* 母窖底();
母窖底内侧() ->* 子窖底();
约窖底() ->* 子窖底内侧();
子窖底内侧() ->+ 子窖底();
因母窖底().累乘(因母窖底内侧());
若(约旗)
{
约窖底内侧() ->* 约窖底();
因约窖底().累乘(因约窖底内侧());
}
}
若(基.出掩 & 2)
{
打印文套("母(%ld,%ld)=", 左界, 右界);
因母窖底().显示();
若(约旗)
打印文套("约(%ld,%ld)=", 左界, 右界);
因约窖底().显示();
}
}

造筛: (几: 目 元* 筛: <筛型>-址)->()=
{
几 -> 基.筛组尺度;
方根限: 目 元= 平方根(几 -: [日 浮]);
笺设值(筛, 0, 容 (筛型) * 几 / 2);
1 -> 筛[1 / 2].因子;
1 -> 筛[1 / 2].幂次;
过(主索@[3 : ^(2) : 几])
{
若(筛[主索 / 2].因子 == 0)
{
主索 -> 筛[主索 / 2].因子;
1 -> 筛[主索 / 2].幂次;
若(主索 <= 方根限)
{
邻索: 目 元= 主索 / 2;
过(方索@[主索 * 主索 : ^(主索 + 主索;邻索++) : 几])
{
若(筛[方索 / 2].因子 == 0)
{
主索 -> 筛[方索 / 2].因子;
若(筛[邻索].因子 == 主索)
{
筛[邻索].幂次 + 1 -> 筛[方索 / 2].幂次;
筛[邻索].下邻 -> 筛[方索 / 2].下邻;
}
否则
{
1 -> 筛[方索 / 2].幂次;
邻索 -> 筛[方索 / 2].下邻;
}
}
}
}
}
}
}

道: (主佐长: 元* 主佐阵: <口>-址-阵)->(元)=
{
位数, 窖深: 目 元= 100, 1;
主佐阵[0] -> 基.程序名;
若(主佐长 > 1)
串变作向目(主佐阵[1], 0, 0) -> 位数;
若(主佐长 > 2)
串变作元(主佐阵[2]) -> 基.出掩;
项数: 目 元= 位数 / 每迭位数;
环(1$L << 窖深 < 项数)
窖深++;
窖深++;
项数 / 100.0 -> 基.百分比;
打印文套("#项数 = %ld, 深度 = %ld\n", 项数, 窖深);
起点: 目= 计算机时刻();
打印文套("造筛     ");
簿冲(基.标准出口);
最大(3 * 5 * 23 * 29 + 1, 项数 * 6) -> 基.筛组尺度;
地 生 <基.筛组尺度 / 2, 筛型>-阵 -> 基.筛组;
造筛(基.筛组尺度, 基.筛组);
中间零: 目= 计算机时刻();
//当前中语言基础库不能打印浮点数,暂时借用GMP库来实现浮点数的打印输出.
//这根源于microsoft在自己开的CRT代码上留了几手,我们在感谢microsoft
//的同时,也感叹microsoft挺坑爹的
//打印文套("时间 = %6.3f\n", (中间零 - 起点) -: 日 浮/1000);
打印文套("时间 = ");
帮浮: 太浮((中间零 - 起点) -: [日 浮] / 1000);
帮浮.写出(3);
打印字('\n');
/* 构造窖 */
地 生 <窖深, 太元>-阵 -> 基.项母增式窖;
地 生 <窖深, 太元>-阵 -> 基.项子全式窖;
地 生 <窖深, 太元>-阵 -> 基.阶乘约式窖;
地 生 <窖深, 因子式>-阵 -> 基.因子式_项母增式窖;
地 生 <窖深, 因子式>-阵 -> 基.因子式_阶乘约式窖;
/*开始二分切割过程 */
若(项数 <= 0)
{
1 -: [向 目] -> 母窖底内侧();
0 -: [向 目] -> 子窖底内侧();
1 -: [向 目] -> 约窖底内侧();
}
否则
{
二分(0, 项数, 0, 0);
}
中间一: 目= 计算机时刻();
//打印文套("\n二分     时间 = %6.3f\n", (中间一 - 中间零) -: 日 浮/1000);
打印文套("\n二分     时间 = ");
(中间一 - 中间零) -: [日 浮] / 1000 -> 帮浮;
帮浮.写出(3);
打印文套("\n");
/* 释放一些资源 */
地 死 基.筛组;
地 死 []基.阶乘约式窖;
地 死 []基.因子式_项母增式窖;
地 死 []基.因子式_阶乘约式窖;
/* 准备将整数转化成浮点数 */
太浮::设置默认精度((位数 * 每位爻数 + 16) -: [目 元]);
/*
母 * (项母_旺式部底量/全项倍量) * 平方根(项母_旺式部底量)
圆周率 = -----------------
(子 + 项子_一次部偏量 * 母)
*/
母尺度: 向 目= 母窖底().尺度(10);
子尺度: 向 目= 子窖底().尺度(10);
子窖底().加乘(母窖底(), 项子_一次部偏量);
项母_旺式部底量 / 全项倍量 -: [向 目] ->* 母窖底();
{
初率: 太浮= 母窖底();
圆周率: 太浮= 子窖底();
地 死 []基.项母增式窖;
地 死 []基.项子全式窖;
中间二: 目= 计算机时刻();
/* 打印文套("时间 = %6.3f\n", (中间二-中间一)-: 日 浮/1000); */
/* 最后步骤 */
打印文套("除       ");
簿冲(基.标准出口);
初率 / 圆周率 -> 圆周率;
中间三: 目= 计算机时刻();
//打印文套("时间 = %6.3f\n", (中间三 - 中间二) -: 日 浮/1000);
打印文套("时间 = ");
(中间三 - 中间二) -: [日 浮] / 1000 -> 帮浮;
帮浮.写出(3);
打印文套("\n");
打印文套("平方根   ");
簿冲(基.标准出口);
求向目平方根(初率, 项母_旺式部底量);
中间四: 目= 计算机时刻();
//打印文套("时间 = %6.3f\n", (中间四 - 中间三) -: 日 浮/1000);
打印文套("时间 = ");
(中间四 - 中间三) -: [日 浮] / 1000 -> 帮浮;
帮浮.写出(3);
打印文套("\n");
打印文套("乘       ");
簿冲(基.标准出口);
初率 ->* 圆周率;
终点: 目= 计算机时刻();
//打印文套("时间 = %6.3f\n", (终点 - 中间四) -: 日 浮/1000);
打印文套("时间 = ");
(终点 - 中间四) -: [日 浮] / 1000 -> 帮浮;
帮浮.写出(3);
打印字('\n');
//打印文套("总时间 = %6.3f\n", (终点 - 起点) -: 日 浮/1000);
打印文套("总时间 = ");
(终点 - 起点) -: [日 浮] / 1000 -> 帮浮;
帮浮.写出(3);
打印文套("\n");
簿冲(基.标准出口);
//打印文套("   母式 尺度 = %ld 位 (%f)\n"
//	"   子式 尺度 = %ld 位 (%f)\n", 母尺度, 母尺度 -: 日 浮 /位数, 子尺度, 子尺度 -: 日 浮/位数);
打印文套("  母式 尺度 = %ld 位 (", 母尺度);
母尺度 -: [日 浮] / 位数 -> 帮浮;
帮浮.写出(6);
打印文套(")\n");
打印文套("  子式 尺度 = %ld 位 (", 子尺度);
子尺度 -: [日 浮] / 位数 -> 帮浮;
帮浮.写出(6);
打印文套(")\n");
/* 输出圆周率跟计时统计数据*/
若(基.出掩 & 1)
{
打印文套("圆周率(0,%ld) = \n", 项数);
圆周率.写出(位数 + 2);
打印文套("\n");
}
}
退出(0);
}

官网文件参考：
http://www.zhongyuyan.org/ZStudy/超酷程序/计算圆周率.html