dc.sed 解析（二）

hbmhalley

果然还是成了烂坑
唉 ..

之前（在这里）想要解剖天书 dc.sed，后来发现原作者是写过正版的解说的，这里把它搬过来，就当作翻译练习好了，欢迎指正。

----

子曰：sed 只有主缓冲（模式空间）和备用缓冲（保持空间）两个缓冲区。传统Unix sed通常将这些缓冲区的大小限制在几千个字符内。在dc.sed的处理过程中，数字以十进制存于主缓冲区中。缓冲区被 | 和 ~ 分为多个部分，这样可以在主栈和寄存器栈上存放任意多的数字。详细格式为：

        <stack>|P|K0|I10|O10|ra<stack>|rx<stack>|rZ<stack>|?<input-stack>

其中，<stack> 是一列0个或多个数字，每个数字以波浪号(~)标志结束（栈上元素不能包含 | 或 ~）。第一个stack是主栈，|P是干嘛的翻译君也没闹明白你还是看原文去吧，|K是运算精度，|I是输入进制，|O是输出进制，|rx是寄存器x，|?是输入栈。例如，若输入为 365 _3.14 66411sb，处理前后的缓冲区内容分别为：

        |P|K0|I10|O10|? 365 _3.14 66411sb
        -3.14~365~|P|K0|I10|O10|rb66411~|?

为了搞清计算过程，你可以简单地认为，底层的运算是通过将待处理的数字临时转换成更方便处理的形式（例如将 6 表示为 aaaaaa）来完成的，其余运算是利用dc代码配合简单运算完成的。底层运算在sed的备用缓冲里完成，这样运算时缓冲区里只需存储参与运算的部分。

底层运算有两种：加/减法和乘法。几乎所有运算都基于此。你可以认为加减法是通过“数字尺”来完成的。我在好几次尝试惨败（导致我罢工一年（的另外一个原因是当我会做了就懒得做了））之后，想出了一种加减通用的算法，除了lookup table不同外，代码是相同的。我这么蛋疼是因为我想让它满足传统Unix sed的199条命令的蛋疼上限。（开发过程中，我一直在算代码离这个上限有多远，最终勉强满足限制，虽然万不得已的话我也能在个别地方挤掉两三条命令。）

我记得加减法首先需要调整两操作数的形式，以减少需要考虑的情况数。例如，-5 - -8 和 8 + -5 都可以表示为 8 - 5。此时还需要dc的比较运算(<,=,>)，因为需要确定被减数和减数的位置（因为我的加减算法需要减数小于被减数）。比较运算从小数点（如果没有就从最右）开始，逐位向左数，数尽任意一个数时停止，此时没数完的那个数较大。

如果都数完了，那么可以利用一个妙招（出自我的 sort.sed）来找到这两个数里从左至右第一个不同的数字并得到它们的大小关系。此招简单来说就是在缓冲区后加一段lookup table。例如，38;0123456789 可以被 /^(.)(.).*\1.*\2/ 匹配，这意味着前两个数字（3和8）是升序出现的，因为它们在lookup table里就是升序的。除了这些，正则表达式还有另外一部分是用来跳过两数的公共前缀的（这部分用正则表达式的后向引用功能实现的话很爽）。

同样的lookup table技术还可以用在代码的其他地方。此技术大大减少了命令数，你只需两个 s/// 命令，一个用来追加lookup table，另一个复杂一点的用来做lookup和替换（同时把追加的lookup table删掉）。例如，缓冲区里有一个数字7，我想把它变成7个a，我会先追加一个lookup table：s/$/9876543210aaaaaaaaa/，另一个操作只需在lookup table里找到对应数字（利用后向引用）并跳过9个字符，剩下的a就是所求结果。对应命令为：s/(.).*\1.{9}//。如果数字为 7 的话，结果就是aaaaaaa。转换回去的办法也差不多：

                                # start with:    aaaaaaa
        s/$/9876543210/     # append table:  aaaaaaa9876543210
        s/.{9}(.).*/\1/     # final result:  7

然后回到加减操作。接下来，你需要从两数的小数点开始，用循环往右找，直到找到其中一个数的结尾为止。这是为了让加减法从同一数位开始进行。（必须用循环是因为正则表达式无法表述“以这个字符串的长度为准，找到那个字符串里的对应位置”这样的语意（除非对应数字都相同）。）没有数到结尾的那个数的剩余部分用来初始化结果。例如 3.14159 + 36.75，结果初始为 159。最后，另一个大循环从右至左逐位进行加减操作（之前追加的不同lookup table决定是加还是减）。

加减两个数字会用到一个叫“dynamic double”的技巧。比如，你需要算 5 加 8，你就在 9876543210;9876543210 这个lookup table里同时找 5 和 8，并将两数后面的数串同时取出，于是你分别为 5 和 8 找到了 43210 和 76543210。然后把它们拼起来并接上另一个lookup table，得到43210765432109876543210。从左往右数10个数字就能数到 3，即结果的个位。如果再往右还有超过10个数字，那就表明有进位。如果有进位，就给下一轮的lookup table加一个字符（因为table左边多1个字符，结果就会大1）。

幸运的是，我找到了一种办法，使得减法可以套用加法的代码，只需将第一个lookup table改为987654321;0123456789。这是某天我突然想出来的，因为我发现借位和进位实际上是一回事。加减法是整个代码里最难啃最讨厌的部分，因为办法太不好选了。同时，这也是最丑陋的部分（如果你觉得其余某段能算漂亮的话 →_→）。

乘法运算首先根据运算精度和两乘数的精度（小数位数）生成一个结果模板（确定小数点的位置）。Knuth给了一个办法，可以从右至左依次得到结果的每位数字，而不用像笔算那样保留所有中间结果。其实没啥，只需要以特殊的顺序去乘每位数，每次得到一列而非一行结果即可。在算单位数字乘法，比如 3*5 时，先依第一个因子 3 生成一个如下的辅助lookup table：
        9aaa8aaa7aaa6aaa5aaa4aaa3aaa2aaa1aaa0

然后在其中找到第二个因子 5 并取出之后的所有 a，这里是15个 a。乘积之和用一种压缩的辅助串存储，例如 427 存储为 cccbbaaaaaaa。这种格式使得单位数乘积可以方便地加到乘积和里，只需要把乘积所得的 a 接在乘积和后面，超过10个 a 就把前10个换成 b，超过10个 b 就把前10个换成c。当算完一列的乘积和之后，利用lookup table把 a 串转换成对应的数字，并把 b 和 c （十位和百位）作为进位替换成 a 和 b （个位和十位）。当没有进位的 a 或 b 时，乘法结束。

至于除法，Knuth帮了大忙。他提过一种“牛顿二阶收敛倒数法”（译者注：就是用牛顿迭代法求曲线 f(x) = 1/x - n 的零点 x0，进而 1/n = x0）：要求 n 的倒数，首先猜一个近似值 g，然后迭代计算 g' = 2g - n*g*g，直到解稳定为止。（这步要用的减法和乘法器已经写好。）之后把被除数乘上这个倒数就是待求的商。sed 里的那个循环只是用来生成迭代式右边的初始近似值的。一般来说，如果有 n>1 且 n 小数点左边有30位，初始近似值就是 .000...0001（小数点右边有30个0）。n<1 时类似。（译者注：初始解 g 需满足：f(x) 过 (g,f(g))的切线不能交x轴于负半轴，简单计算可知 g 需满足 g<2/n。）接下来把控制交给 dc 栈上的牛顿迭代的代码即可。

同样，平方根我也是这么算的。对于n，将它的一半数字删掉（如果 n<1 的话就删掉一半前导0）作为初始近似值 g，并用dc代码不断计算 g' = (g + n/g)/2，直到 g 不再下降。没想到的是，这种方法的第一个测试用例 8k2v 在除法和平方根都还有bug的时候居然出了正确结果。我觉得这也证明了牛顿迭代的收敛性确实很靠谱。Ken Pizzini (GNU sed POC（POC是啥？）) 之后找到了一个精度问题，当运算精度为0时（例如 16v，224v）会出错。我在之后的Perl版和1.1版里作了修正。

我本来可以省几条 sed 命令，直接把幂运算放到dc代码里用快速幂（原文是 binary algorithm，应该指这个意思）实现，但我已经有了一个用 sed 实现的版本，其中用到了一个有趣的十进制lookup table（实际上lookup做的是根据指数0~9找到一段可以做对应幂次运算的dc代码），我也不想就这么把这段代码扔了。在这个算法中，x^736 视为 ((x^7)^10 * x^3)^10 * x^6，平均每位做7.1次乘法。幂运算最难搞的部分之一是确保结果的精度正确（GNU dc 有时都不能保证（截至发文））。有一坨 dc 代码就是用来干这个的。和平常一样，我没有太数学，只是在纸上写了一堆例子，分析在不同情况下需要怎样的精度，然后就搞出来了。

当我最初脑抽想写 dc.sed 时，我从没想要实现进制转换，因为我觉得这太难写了，即使写了也不能满足 sed 199条命令的限制。但当我写完核心部分以后，我重新考虑了这个问题。我发现像一些其他功能把问题交给 dc 代码同样可以有效地实现这个功能。将非十进制的输入转换成十进制数需要用一些用到lookup table的sed命令来给做转换用的dc代码做初始化。然而将十进制数转换成非十进制输出可以*完全*用dc代码实现，虽然那是一坨6行长的翔。（带注释的dc代码在这里。）这个功能的第一个测试用例是 100o _1234567.1234567p (于 1:43am Feb 2, 1997 :)，结果正确，令人欣慰。

还有其他的一些功能，为了介绍完我也提一下，（但翻译君是在懒得动了自己翻去吧。）
（还有一些获奖感言。）

hbmhalley

审核速度真是逆天了 ...
顺便把代码粘过来 方便对照

1. 
   
2. #! /bin/sed -nf
   
3. #  dc.sed - an arbitrary precision RPN calculator
   
4. #  Created by Greg Ubben <gsu@romulus.ncsc.mil> early 1995, late 1996
   
5. #
   
6. #  Dedicated to MAC's memory of the IBM 1620 ("CADET") computer.
   
7. #  @(#)GSU dc.sed 1.1 06-Mar-1999 [non-explanatory]
   
8. #
   
9. #  Examples:
   
10. #        sqrt(2) to 10 digits:        echo "10k 2vp" | dc.sed
    
11. #        20 factorial:                echo "[d1-d1<!*]s! 20l!xp" | dc.sed
    
12. #        sin(ln(7)):                echo "s(l(7))" | bc -c /usr/lib/lib.b | dc.sed
    
13. #        hex to base 60:                echo "60o16i 6B407.CAFE p" | dc.sed
    
14. #        tests most of dc.sed:        echo 16oAk2vp | dc.sed
    
15. #
    
16. #  To debug or analyze, give the dc Y command as input or add it to
    
17. #  embedded dc routines, or add the sed p command to the beginning of
    
18. #  the main loop or at various points in the low-level sed routines.
    
19. #  If you need to allow [|~] characters in the input, filter this
    
20. #  script through "tr '|~' '\36\37'" first (or use dc.pl).
    
21. #
    
22. #  Not implemented:        ! \
    
23. #  But implemented:        K Y t # !< !> != fractional-bases
    
24. #  SunOS limits:        199/199 commands (though could pack in 10-20 more)
    
25. #  Limitations:                scale <= 999; |obase| >= 1; input digits in [0..F]
    
26. #  Completed:                1am Feb 4, 1997
    
27. 
    
28. s/^/|P|K0|I10|O10|?~/
    
29. 
    
30. :next
    
31. s/|?./|?/
    
32. s/|?#[         -}]*/|?/
    
33. /|?!*[lLsS;:<>=]\{0,1\}$/N
    
34. /|?!*[-+*/%^<>=]/b binop
    
35. /^|.*|?[dpPfQXZvxkiosStT;:]/b binop
    
36. /|?[_0-9A-F.]/b number
    
37. /|?\[/b string
    
38. /|?l/b load
    
39. /|?L/b Load
    
40. /|?[sS]/b save
    
41. /|?c/ s/[^|]*//
    
42. /|?d/ s/[^~]*~/&&/
    
43. /|?f/ s//&[pSbz0<aLb]dSaxsaLa/
    
44. /|?x/ s/\([^~]*~\)\(.*|?x\)~*/\2\1/
    
45. /|?[KIO]/ s/.*|\([KIO]\)\([^|]*\).*|?\1/\2~&/
    
46. /|?T/ s/\.*0*~/~/
    
47. #  a slow, non-stackable array implementation in dc, just for completeness
    
48. #  A fast, stackable, associative array implementation could be done in sed
    
49. #  (format: {key}value{key}value...), but would be longer, like load & save.
    
50. /|?;/ s/|?;\([^{}]\)/|?~[s}s{L{s}q]S}[S}l\1L}1-d0>}s\1L\1l{xS\1]dS{xL}/
    
51. /|?:/ s/|?:\([^{}]\)/|?~[s}L{s}L{s}L}s\1q]S}S}S{[L}1-d0>}S}l\1s\1L\1l{xS\1]dS{x/
    
52. /|?[ ~        cdfxKIOT]/b next
    
53. /|?\n/b next
    
54. /|?[pP]/b print
    
55. /|?k/ s/^\([0-9]\{1,3\}\)\([.~].*|K\)[^|]*/\2\1/
    
56. /|?i/ s/^\(-\{0,1\}[0-9]*\.\{0,1\}[0-9]\{1,\}\)\(~.*|I\)[^|]*/\2\1/
    
57. /|?o/ s/^\(-\{0,1\}[1-9][0-9]*\.\{0,1\}[0-9]*\)\(~.*|O\)[^|]*/\2\1/
    
58. /|?[kio]/b pop
    
59. /|?t/b trunc
    
60. /|??/b input
    
61. /|?Q/b break
    
62. /|?q/b quit
    
63. h
    
64. /|?[XZz]/b count
    
65. /|?v/b sqrt
    
66. s/.*|?\([^Y]\).*/\1 is unimplemented/
    
67. s/\n/\\n/g
    
68. l
    
69. g
    
70. b next
    
71. 
    
72. :print
    
73. /^-\{0,1\}[0-9]*\.\{0,1\}[0-9]\{1,\}~.*|?p/!b Print
    
74. /|O10|/b Print
    
75. 
    
76. #  Print a number in a non-decimal output base.  Uses registers a,b,c,d.
    
77. #  Handles fractional output bases (O<-1 or O>=1), unlike other dc's.
    
78. #  Converts the fraction correctly on negative output bases, unlike
    
79. #  UNIX dc.  Also scales the fraction more accurately than UNIX dc.
    
80. #
    
81. s,|?p,&KSa0kd[[-]Psa0la-]Sad0>a[0P]sad0=a[A*2+]saOtd0>a1-ZSd[[[[ ]P]sclb1\
    
82. !=cSbLdlbtZ[[[-]P0lb-sb]sclb0>c1+]sclb0!<c[0P1+dld>c]scdld>cscSdLbP]q]Sb\
    
83. [t[1P1-d0<c]scd0<c]ScO_1>bO1!<cO[16]<bOX0<b[[q]sc[dSbdA>c[A]sbdA=c[B]sbd\
    
84. B=c[C]sbdC=c[D]sbdD=c[E]sbdE=c[F]sb]xscLbP]~Sd[dtdZOZ+k1O/Tdsb[.5]*[.1]O\
    
85. X^*dZkdXK-1+ktsc0kdSb-[Lbdlb*lc+tdSbO*-lb0!=aldx]dsaxLbsb]sad1!>a[[.]POX\
    
86. +sb1[SbO*dtdldx-LbO*dZlb!<a]dsax]sadXd0<asbsasaLasbLbscLcsdLdsdLdLak[]pP,
    
87. b next
    
88. 
    
89. :Print
    
90. /|?p/s/[^~]*/&\
    
91. ~&/
    
92. s/\(.*|P\)\([^|]*\)/\
    
93. \2\1/
    
94. s/\([^~]*\)\n\([^~]*\)\(.*|P\)/\1\3\2/
    
95. h
    
96. s/~.*//
    
97. /./{ s/.//; p; }
    
98. #  Just s/.//p would work if we knew we were running under the -n option.
    
99. #  Using l vs p would kind of do \ continuations, but would break strings.
    
100. g
     
101. 
     
102. :pop
     
103. s/[^~]*~//
     
104. b next
     
105. 
     
106. :load
     
107. s/\(.*|?.\)\(.\)/\20~\1/
     
108. s/^\(.\)0\(.*|r\1\([^~|]*\)~\)/\1\3\2/
     
109. s/.//
     
110. b next
     
111. 
     
112. :Load
     
113. s/\(.*|?.\)\(.\)/\2\1/
     
114. s/^\(.\)\(.*|r\1\)\([^~|]*~\)/|\3\2/
     
115. /^|/!i\
     
116. register empty
     
117. s/.//
     
118. b next
     
119. 
     
120. :save
     
121. s/\(.*|?.\)\(.\)/\2\1/
     
122. /^\(.\).*|r\1/ !s/\(.\).*|/&r\1|/
     
123. /|?S/ s/\(.\).*|r\1/&~/
     
124. s/\(.\)\([^~]*~\)\(.*|r\1\)[^~|]*~\{0,1\}/\3\2/
     
125. b next
     
126. 
     
127. :quit
     
128. t quit
     
129. s/|?[^~]*~[^~]*~/|?q/
     
130. t next
     
131. #  Really should be using the -n option to avoid printing a final newline.
     
132. s/.*|P\([^|]*\).*/\1/
     
133. q
     
134. 
     
135. :break
     
136. s/[0-9]*/&;987654321009;/
     
137. :break1
     
138. s/^\([^;]*\)\([1-9]\)\(0*\)\([^1]*\2\(.\)[^;]*\3\(9*\).*|?.\)[^~]*~/\1\5\6\4/
     
139. t break1
     
140. b pop
     
141. 
     
142. :input
     
143. N
     
144. s/|??\(.*\)\(\n.*\)/|?\2~\1/
     
145. b next
     
146. 
     
147. :count
     
148. /|?Z/ s/~.*//
     
149. /^-\{0,1\}[0-9]*\.\{0,1\}[0-9]\{1,\}$/ s/[-.0]*\([^.]*\)\.*/\1/
     
150. /|?X/ s/-*[0-9A-F]*\.*\([0-9A-F]*\).*/\1/
     
151. s/|.*//
     
152. /~/ s/[^~]//g
     
153. 
     
154. s/./a/g
     
155. :count1
     
156.         s/a\{10\}/b/g
     
157.         s/b*a*/&a9876543210;/
     
158.         s/a.\{9\}\(.\).*;/\1/
     
159.         y/b/a/
     
160. /a/b count1
     
161. G
     
162. /|?z/ s/\n/&~/
     
163. s/\n[^~]*//
     
164. b next
     
165. 
     
166. :trunc
     
167. #  for efficiency, doesn't pad with 0s, so 10k 2 5/ returns just .40
     
168. #  The X* here and in a couple other places works around a SunOS 4.x sed bug.
     
169. s/\([^.~]*\.*\)\(.*|K\([^|]*\)\)/\3;9876543210009909:\1,\2/
     
170. :trunc1
     
171.         s/^\([^;]*\)\([1-9]\)\(0*\)\([^1]*\2\(.\)[^:]*X*\3\(9*\)[^,]*\),\([0-9]\)/\1\5\6\4\7,/
     
172. t trunc1
     
173. s/[^:]*:\([^,]*\)[^~]*/\1/
     
174. b normal
     
175. 
     
176. :number
     
177. s/\(.*|?\)\(_\{0,1\}[0-9A-F]*\.\{0,1\}[0-9A-F]*\)/\2~\1~/
     
178. s/^_/-/
     
179. /^[^A-F~]*~.*|I10|/b normal
     
180. /^[-0.]*~/b normal
     
181. s:\([^.~]*\)\.*\([^~]*\):[Ilb^lbk/,\1\2~0A1B2C3D4E5F1=11223344556677889900;.\2:
     
182. :digit
     
183.     s/^\([^,]*\),\(-*\)\([0-F]\)\([^;]*\(.\)\3[^1;]*\(1*\)\)/I*+\1\2\6\5~,\2\4/
     
184. t digit
     
185. s:...\([^/]*.\)\([^,]*\)[^.]*\(.*|?.\):\2\3KSb[99]k\1]SaSaXSbLalb0<aLakLbktLbk:
     
186. b next
     
187. 
     
188. :string
     
189. /|?[^]]*$/N
     
190. s/\(|?[^]]*\)\[\([^]]*\)]/\1|{\2|}/
     
191. /|?\[/b string
     
192. s/\(.*|?\)|{\(.*\)|}/\2~\1[/
     
193. s/|{/[/g
     
194. s/|}/]/g
     
195. b next
     
196. 
     
197. :binop
     
198. /^[^~|]*~[^|]/ !i\
     
199. stack empty
     
200. //!b next
     
201. /^-\{0,1\}[0-9]*\.\{0,1\}[0-9]\{1,\}~/ !s/[^~]*\(.*|?!*[^!=<>]\)/0\1/
     
202. /^[^~]*~-\{0,1\}[0-9]*\.\{0,1\}[0-9]\{1,\}~/ !s/~[^~]*\(.*|?!*[^!=<>]\)/~0\1/
     
203. h
     
204. /|?\*/b mul
     
205. /|?\//b div
     
206. /|?%/b rem
     
207. /|?^/b exp
     
208. 
     
209. /|?[+-]/ s/^\(-*\)\([^~]*~\)\(-*\)\([^~]*~\).*|?\(-\{0,1\}\).*/\2\4s\3o\1\3\5/
     
210. s/\([^.~]*\)\([^~]*~[^.~]*\)\(.*\)/<\1,\2,\3|=-~.0,123456789<></
     
211. /^<\([^,]*,[^~]*\)\.*0*~\1\.*0*~/ s/</=/
     
212. :cmp1
     
213.         s/^\(<[^,]*\)\([0-9]\),\([^,]*\)\([0-9]\),/\1,\2\3,\4/
     
214. t cmp1
     
215. /^<\([^~]*\)\([^~]\)[^~]*~\1\(.\).*|=.*\3.*\2/ s/</>/
     
216. /|?/{
     
217.         s/^\([<>]\)\(-[^~]*~-.*\1\)\(.\)/\3\2/
     
218.         s/^\(.\)\(.*|?!*\)\1/\2!\1/
     
219.         s/|?![^!]\(.\)/&l\1x/
     
220.         s/[^~]*~[^~]*~\(.*|?\)!*.\(.*\)|=.*/\1\2/
     
221.         b next
     
222. }
     
223. s/\(-*\)\1|=.*/;9876543210;9876543210/
     
224. /o-/ s/;9876543210/;0123456789/
     
225. s/^>\([^~]*~\)\([^~]*~\)s\(-*\)\(-*o\3\(-*\)\)/>\2\1s\5\4/
     
226. 
     
227. s/,\([0-9]*\)\.*\([^,]*\),\([0-9]*\)\.*\([0-9]*\)/\1,\2\3.,\4;0/
     
228. :right1
     
229.         s/,\([0-9]\)\([^,]*\),;*\([0-9]\)\([0-9]*\);*0*/\1,\2\3,\4;0/
     
230. t right1
     
231. s/.\([^,]*\),~\(.*\);0~s\(-*\)o-*/\1~\30\2~/
     
232. 
     
233. :addsub1
     
234.         s/\(.\{0,1\}\)\(~[^,]*\)\([0-9]\)\(\.*\),\([^;]*\)\(;\([^;]*\(\3[^;]*\)\).*X*\1\(.*\)\)/\2,\4\5\9\8\7\6/
     
235.         s/,\([^~]*~\).\{10\}\(.\)[^;]\{0,9\}\([^;]\{0,1\}\)[^;]*/,\2\1\3/
     
236. #          could be done in one s/// if we could have >9 back-refs...
     
237. /^~.*~;/!b addsub1
     
238. 
     
239. :endbin
     
240. s/.\([^,]*\),\([0-9.]*\).*/\1\2/
     
241. G
     
242. s/\n[^~]*~[^~]*//
     
243. 
     
244. :normal
     
245. s/^\(-*\)0*\([0-9.]*[0-9]\)[^~]*/\1\2/
     
246. s/^[^1-9~]*~/0~/
     
247. b next
     
248. 
     
249. :mul
     
250. s/\(-*\)\([0-9]*\)\.*\([0-9]*\)~\(-*\)\([0-9]*\)\.*\([0-9]*\).*|K\([^|]*\).*/\1\4\2\5.!\3\6,|\2<\3~\5>\6:\7;9876543210009909/
     
251. 
     
252. :mul1
     
253.     s/![0-9]\([^<]*\)<\([0-9]\{0,1\}\)\([^>]*\)>\([0-9]\{0,1\}\)/0!\1\2<\3\4>/
     
254.     /![0-9]/ s/\(:[^;]*\)\([1-9]\)\(0*\)\([^0]*\2\(.\).*X*\3\(9*\)\)/\1\5\6\4/
     
255. /<~[^>]*>:0*;/!t mul1
     
256. 
     
257. s/\(-*\)\1\([^>]*\).*/;\2^>:9876543210aaaaaaaaa/
     
258. 
     
259. :mul2
     
260.     s/\([0-9]~*\)^/^\1/
     
261.     s/<\([0-9]*\)\(.*[~^]\)\([0-9]*\)>/\1<\2>\3/
     
262. 
     
263.     :mul3
     
264.         s/>\([0-9]\)\(.*\1.\{9\}\(a*\)\)/\1>\2;9\38\37\36\35\34\33\32\31\30/
     
265.         s/\(;[^<]*\)\([0-9]\)<\([^;]*\).*\2[0-9]*\(.*\)/\4\1<\2\3/
     
266.         s/a[0-9]/a/g
     
267.         s/a\{10\}/b/g
     
268.         s/b\{10\}/c/g
     
269.     /|0*[1-9][^>]*>0*[1-9]/b mul3
     
270. 
     
271.     s/;/a9876543210;/
     
272.     s/a.\{9\}\(.\)[^;]*\([^,]*\)[0-9]\([.!]*\),/\2,\1\3/
     
273.     y/cb/ba/
     
274. /|<^/!b mul2
     
275. b endbin
     
276. 
     
277. :div
     
278. #  CDDET
     
279. /^[-.0]*[1-9]/ !i\
     
280. divide by 0
     
281. //!b pop
     
282. s/\(-*\)\([0-9]*\)\.*\([^~]*~-*\)\([0-9]*\)\.*\([^~]*\)/\2.\3\1;0\4.\5;0/
     
283. :div1
     
284.         s/^\.0\([^.]*\)\.;*\([0-9]\)\([0-9]*\);*0*/.\1\2.\3;0/
     
285.         s/^\([^.]*\)\([0-9]\)\.\([^;]*;\)0*\([0-9]*\)\([0-9]\)\./\1.\2\30\4.\5/
     
286. t div1
     
287. s/~\(-*\)\1\(-*\);0*\([^;]*[0-9]\)[^~]*/~123456789743222111~\2\3/
     
288. s/\(.\(.\)[^~]*\)[^9]*\2.\{8\}\(.\)[^~]*/\3~\1/
     
289. s,|?.,&SaSadSaKdlaZ+LaX-1+[sb1]Sbd1>bkLatsbLa[dSa2lbla*-*dLa!=a]dSaxsakLasbLb*t,
     
290. b next
     
291. 
     
292. :rem
     
293. s,|?%,&Sadla/LaKSa[999]k*Lak-,
     
294. b next
     
295. 
     
296. :exp
     
297. #  This decimal method is just a little faster than the binary method done
     
298. #  totally in dc:  1LaKLb [kdSb*LbK]Sb [[.5]*d0ktdSa<bkd*KLad1<a]Sa d1<a kk*
     
299. /^[^~]*\./i\
     
300. fraction in exponent ignored
     
301. s,[^-0-9].*,;9d**dd*8*d*d7dd**d*6d**d5d*d*4*d3d*2lbd**1lb*0,
     
302. :exp1
     
303.         s/\([0-9]\);\(.*\1\([d*]*\)[^l]*\([^*]*\)\(\**\)\)/;dd*d**d*\4\3\5\2/
     
304. t exp1
     
305. G
     
306. s,-*.\{9\}\([^9]*\)[^0]*0.\(.*|?.\),\2~saSaKdsaLb0kLbkK*+k1\1LaktsbkLax,
     
307. s,|?.,&SadSbdXSaZla-SbKLaLadSb[0Lb-d1lb-*d+K+0kkSb[1Lb/]q]Sa0>a[dk]sadK<a[Lb],
     
308. b next
     
309. 
     
310. :sqrt
     
311. #  first square root using sed:  8k2v at 1:30am Dec 17, 1996
     
312. /^-/i\
     
313. square root of negative number
     
314. /^[-0]/b next
     
315. s/~.*//
     
316. /^\./ s/0\([0-9]\)/\1/g
     
317. /^\./ !s/[0-9][0-9]/7/g
     
318. G
     
319. s/\n/~/
     
320. s,|?.,&K1+k KSbSb[dk]SadXdK<asadlb/lb+[.5]*[sbdlb/lb+[.5]*dlb>a]dsaxsasaLbsaLatLbk K1-kt,
     
321. b next
     
322. 
     
323. #  END OF GSU dc.sed
     

复制代码

laliheyi

不明觉厉啊

elu_ligao

。。大神啊，看起来很专业啊， 很多表示看不太懂，顶，慢慢消化

nswcfd

翻译也是极赞的！