查看“︁Dc (程序)”︁的源代码

{{lowercase|title=dc (Unix)}}
{{noteTA|G1=IT}}
{{Infobox software
| name                   = dc
| logo                   = 
| screenshot             = 
| screenshot size        = 
| caption                = 
| author                 = {{en-link|Robert Morris|Robert Morris (cryptographer)|Robert Morris}}<br />（于[[AT&T贝尔实验室]]）<br />{{en-link|Lorinda Cherry}}
| developer              = 各种[[开源软件|开源]]和[[商业软件|商业]]开发者
| released               = 
| programming language   = [[B语言|B]]
| operating system       = [[Unix]], [[类Unix]],  [[Plan 9]]
| platform               = [[跨平台]]
| genre                  = [[命令 (计算机)|命令]]
| license                = 
| website                = 
}}
'''dc'''（'''d'''esk '''c'''alculator：桌面计算器）是采用[[逆波兰表示法]]的[[跨平台]]计算器，它支持[[高精度计算|任意精度算术]]<ref>{{man|1|dc|die.net|an arbitrary precision calculator}}</ref>。它是{{en-link|Robert Morris|Robert Morris (cryptographer)|Robert Morris}}在[[贝尔实验室]]工作期间书写的<ref name="KenThompson" />，作为最老的[[Unix]][[实用工具]]，先于[[C语言]]的发明。像那个年代的其他实用工具一样，它有着一组强力的特征和简洁的语法<ref>{{cite web
|url=https://minnie.tuhs.org/cgi-bin/utree.pl?file=V7/usr/man/man1/dc.1
|title=The sources for the manual page for 7th Edition Unix dc
|accessdate=2020-09-25
|archive-date=2019-09-24
|archive-url=https://web.archive.org/web/20190924231550/https://minnie.tuhs.org/cgi-bin/utree.pl?file=V7%2Fusr%2Fman%2Fman1%2Fdc.1
|dead-url=no
}}</ref><ref>{{cite web 
 |author=Ritchie, Dennis M. 
 |date=Sep 1979 
 |url=http://cm.bell-labs.com/cm/cs/who/dmr/hist.html 
 |title=The Evolution of the Unix Timesharing System 
 |deadurl=yes 
 |archiveurl=http://webarchive.loc.gov/all/20100506231949/http://cm.bell-labs.com/cm/cs/who/dmr/hist.html 
 |archivedate=2010-05-06 
 |df= 
 |accessdate=2019-05-31 
 }}</ref>。传统上，采用[[中缀表示法]]的[[bc (编程语言)|bc]]计算器程序是在dc之上实现的。

==历史==
dc是幸存的最老的[[Unix]]语言<ref name="KenThompson">{{cite av media|url=https://www.youtube.com/watch?v=EY6q5dv_B-o|people=Brian Kernighan and Ken Thompson|title=A nerdy delight for any Vintage Computer Fest 2019 attendee: Kernighan interviewing Thompson about Unix|accessdate=September 3, 2019|publisher=YouTube|time=29m45s|archive-date=2022-02-01|archive-url=https://web.archive.org/web/20220201205033/https://www.youtube.com/watch?v=EY6q5dv_B-o|dead-url=no}}</ref>。在[[贝尔实验室]]收到第一台[[PDP-11]]的时候，用[[B语言]]写成的dc是在这个新机器上运行的第一个语言，甚至在汇编器之前<ref name="reader">{{cite techreport |first1=M. D. |last1=McIlroy |authorlink1=Doug McIlroy |year=1987 |url=http://www.cs.dartmouth.edu/~doug/reader.pdf |title=A Research Unix reader: annotated excerpts from the Programmer's Manual, 1971–1986 |series=CSTR |number=139 |institution=Bell Labs |access-date=2019-05-31 |archive-date=2019-11-30 |archive-url=https://web.archive.org/web/20191130000850/https://www.cs.dartmouth.edu/~doug/reader.pdf |dead-url=no }}</ref>。

==基本运算==
在dc中要做4和5的乘法：
<syntaxhighlight lang="console" highlight="4">
$ dc
4 5 *
p
20
q
</syntaxhighlight>
这可转译为“把4和5压入[[堆栈|栈顶]]，通过乘法算符，从栈中弹出两个元素，将二者相乘并把结果压回栈顶”。接着使用<code>p</code>命令打印栈顶的元素。使用<code>q</code>命令退出此次调用的dc实例。注意数值相互间必须以空白分隔，但某些算符可以不必如此。
还可以用如下命令得到这个结果：
<syntaxhighlight lang="console" highlight="7">
$ dc -e '4 5 * p'
20
$ echo "4 5 * p" | dc
20
$ dc -
4 5*pq
20
$ cat <<EOF > cal.txt
4 5 *
p 
EOF
$ dc cal.txt
20
</syntaxhighlight>
使用命令<code>k</code>来变更[[有效数字|算术精度]]，它设置算术运算的小数位数。因为缺省精度是<code>0</code>，例如：
<syntaxhighlight lang="console">
$ dc -e '10946 6765 / p'
1
</syntaxhighlight>
通过使用命令<code>k</code>调整精度，可以产生任意数目的小数数位，例如：
<syntaxhighlight lang="console">
$ dc -e '7k 10946 6765 / p'
1.6180339
</syntaxhighlight>
dc有科学计算器的基本运算功能，比如求[[黄金分割率]]<math display="inline">\frac {\sqrt{5} + 1} {2}</math>的值：
<syntaxhighlight lang="console">
$ dc -e '7k 5 v 1 + 2 / p'
1.6180339
</syntaxhighlight>

dc将输入数值的前导<code>_</code>识别为[[负号]]，命令<code>^</code>计算幂，命令<code>v</code>计算平方根。

<code>d</code>命令用于复制栈顶元素。<code>r</code>命令用于对栈顶和仅次栈顶的两个元素进行对换。<code>z</code>命令用于压入当前栈深度，即执行<code>z</code>命令前栈中元素的数目。

==输入/输出==
使用<code>?</code>命令，从[[stdin]]读取一行并执行它。这允许从宏中向用户要求输入，故而此输入必须是语法上正确的，并且这有潜在的安全问题，因为dc的<code>!</code>命令可以执行任意系统命令。

前面提及过，<code>p</code>命令打印栈顶元素，带有随后的一个换行。<code>n</code>命令弹出栈顶元素并输出它，没有尾随换行。<code>f</code>命令打印整个[[堆栈|栈]]，从栈顶到栈底并且一项一行。

dc还支持控制输入和输出的[[进位制|底数]]。<code>o</code>命令设置输出底数，输出底数必须大于等于2。<code>i</code>命令弹出栈顶元素并将它用作输入底数，输入底数必须在2和16之间，十六进制数字必须大写以避免和dc命令冲突。要记住输入底数将影响对后面的所有数值的分析，所以通常建议在设置输入底数之前先设置输出底数。例如将二进制转换成十六进制：
<syntaxhighlight lang="console">
$ echo '16o2i 1001101010111100110111101111 p' | dc
9ABCDEF
</syntaxhighlight>
要读取设置的这些数值，<code>K</code>、<code>I</code>和<code>O</code>命令将压入当前精度、输入基数和输出基数到栈顶。

==语言特征==
除了上述的基本算术和[[堆栈|栈]]操作，dc包括了对[[宏]]、条件和存储结果用于以后检索的支持。

===寄存器===
寄存器在dc中是有着单一字符名字的存贮位置，它可以通过命令来存储和检索，它是宏和条件的底层机制：<code>sc</code>弹出栈顶元素并将它存储入寄存器<code>c</code>，而<code>lc</code>将寄存器<code>c</code>的值压入栈顶。例如：
<syntaxhighlight>
3 sc 4 lc * p
</syntaxhighlight>
寄存器还被当作次要栈，可以使用<code>S</code>和<code>L</code>命令在它们和主要栈之间压入和弹出数值。存储栈顶元素到寄存器中并把这个元素留在栈顶，需要联合使用<code>ds</code>命令。

===字符串===
字符串是包围在<code>[</code>和<code>]</code>之中的字符，可以被压入栈顶和存入寄存器。使用<code>x</code>命令从栈顶弹出字符串并执行它，使用<code>P</code>命令从栈顶弹出并打印字符串，无尾随换行。<code>a</code>命令可以把数值的低位字节转换成[[ASCII#ASCII可打印字符|ASCII]]字符，或者在栈顶是字符串时把它替换为这个字符串的第一个字符。此外没有方法去建造字符串或进行字符串操纵。

<code>#</code>字符开始一个注释直到此行结束。

===宏===
通过允许寄存器和栈项目像数值一样存储字符串，从而实现了[[宏]]。一个字符串可以被打印，也可以被执行，就是说作为dc命令的序列而传递。例如可以把一个宏“加<code>1</code>并接着乘以<code>2</code>”存储到一个寄存器<code>m</code>中：
<syntaxhighlight>
[1 + 2 *]sm
</syntaxhighlight>
通过使用<code>x</code>命令弹出栈顶的字符串并执行之，如下这样使用存储的宏：
<syntaxhighlight>
3 lmx p
</syntaxhighlight>
<code>Q</code>命令从栈顶弹出一个值作为退出宏的层数，比如<code>2Q</code>命令退出2层宏，它永不导致退出dc。<code>q</code>命令退出2层宏，如果宏少于2层则退出dc。

===条件===
最后提供了有条件执行宏的机制。命令<code>=r</code>将从栈顶弹出两个值，如果二者相等，则执行存储在寄存器<code>r</code>中的宏。如下命令序列将在原栈顶元素等于5的条件下打印字符串<code>equal</code>。
<syntaxhighlight>
[[equal]p]sm d5=m
</syntaxhighlight>

这里使用了<code>d</code>命令保留原栈顶元素。其他条件有<code>></code>、<code>!></code>、<code><</code>、<code>!<</code>、<code>!=</code>，如果栈顶元素分别大于、不大于（小于等于）、小于、不小于（大于等于）、不等于仅次于栈顶的元素，则执行指定的宏。注意不同于[[Forth]]、[[PostScript#PostScript语言|PostScript]]和[[Factor语言|Factor]]，在不等式比较中的运算元的次序同在算术中的次序相反，{{code|5 3 -}} 等价于中缀表示法的{{code|5 - 3}}，然而{{code|5 3 <t}}在{{code|3 < 5}}时运行寄存器{{code|t}}的内容。下面是其执行示例：
<syntaxhighlight lang="console">
$ echo 5 | dc -e '? [[equal]p]sm d5=m'
equal
$ echo 5 | dc -e '? [[[equal]pq]sm d5=m [not equal]p]x'
equal
$ echo 4 | dc -e '? [[[equal]pq]sm d5=m [not equal]p]x'
not equal
</syntaxhighlight>

===迭代示例===
通过定义进行有条件的[[递归]]调用的宏，可以实行[[迭代]]运算。

====阶乘====
下面是对栈顶元素计算[[阶乘]]<math display=inline> n! = n\cdot (n-1)!</math>的[[递归 (计算机科学)|递归]][[子程序|过程]]：
<syntaxhighlight>
# F(x):
#   if x > 1
#     x * F(x-1)
#   else 
#     x
</syntaxhighlight>
它在<code>x > 0</code>时有效，它可采用[[互递归]]写为：
<syntaxhighlight>
# F(x):
#   x > 1 ? G(x) : x
# G(x):
#   x * F(x-1)
</syntaxhighlight>
这里的[[伪代码]]采用了[[条件运算符]]而非[[条件语句]]。它可实现为：
<syntaxhighlight>
[d 1- lFx *]sG [d1<G]dsFx
</syntaxhighlight>
它可以进一步采用[[尾递归]]实现为：
<syntaxhighlight>
[d 1- lFx]sG [d1<G]dsFx 1 [* z1<H]dsHx
</syntaxhighlight>
这里的运算由两个步骤[[串接式编程语言|串接]]而成，首先将递减的整数压入堆栈形成[[整数集]]<math>\mathbb{Z}</math>上[[偏序关系]]<math>\ge</math>的[[区间]]<math>[n, 1]</math>，然后在这个[[数列]]上进行应用[[乘法]]运算的[[fold (高阶函数)|右归约]]得出一个最终的结果值。这里的命令<code>z</code>，将当前的堆栈深度即堆栈中元素数目压入栈顶。还可以进一步增加针对<code>x ≤ 0</code>情况的预处理。下面是其执行示例：
<syntaxhighlight lang="console">
$ echo 0 | dc -e '? [d-1+]sad0!<a [d 1- lFx]sG [d1<G]dsFx 1 [* z1<H]dsHx p'
1
$ echo 9 | dc -e '? [d-1+]sad0!<a [d 1- lFx]sG [d1<G]dsFx 1 [* z1<H]dsHx p'
362880
</syntaxhighlight>

下面的例子采用[[迭代法]]打印出[[阶乘]]<math display=inline>n!  = \prod_{i = 1}^n i</math>的前<code>n</code>项的[[数列]]：
<syntaxhighlight>
# n := x
# i := 0
# F(x):
#   i := i + 1
#   x := x * i 
#   print(x)
#   i < n ? F(x) : x
# F(1)
</syntaxhighlight>
这里迭代的是需要[[初始化]]的堆栈中的[[自动变量]]<code>x</code>，它是<math>n!</math>，其初始值<code>1</code>是<math>0!</math>；<code>i</code>既是迭代的递增[[循环计数器|计数器]]，也是{{en-link|迭代二元运算|Iterated binary operation}}的[[运算元]]，其递增形成[[整数集]]<math>\mathbb{Z}</math>上[[偏序关系]]<math>\le</math>的[[区间]]<math>[1, n]</math>，同步地在这个数列上进行输出中间值的应用[[乘法]]运算的[[fold (高阶函数)|左归约]]得出结果[[数列]]，这里的<code>x</code>所起到的作用也被称为[[累加器]]，其含义为“累计”或“累积”而不必然采用加法或乘法。它可实现为：
<syntaxhighlight>
sn 0si 1 [li1+dsi *p liln>F]dsFx
</syntaxhighlight>
下面是其执行示例： 
<syntaxhighlight lang="console">
$ echo 6 | dc -e '? sn 0si 1 [li1+dsi *p liln>F]dsFx'
1
2
6
24
120
720
</syntaxhighlight>
可以将它改为计算单个的阶乘：
<syntaxhighlight lang="console">
$ echo 0 | dc -e '? sn 0si 1 [li1+dsi * liln>F]dsFx p'
1
$ echo 9 | dc -e '? sn 0si 1 [li1+dsi * liln>F]dsFx p'
362880
</syntaxhighlight>

====斐波那契数====
下面是对栈顶元素计算[[斐波那契数]]的[[递归 (计算机科学)|递归]]过程：
<syntaxhighlight>
# F(x):
#   if x > 1 
#     F(x-1) + F(x-2)
#   else
#     x
</syntaxhighlight>
它在<code>x ≥ 0</code>时有效，它可采用[[互递归]]写为：
<syntaxhighlight>
# F(x):
#   x > 1 ? G(x) : x
# G(x):
#   F(x-1) + F(x-2)
</syntaxhighlight>
它可实现为：
<syntaxhighlight>
[d 2- lFx r 1- lFx +]sG [d1<G]dsFx
</syntaxhighlight>
这里的<code>r</code>命令反转（交换）栈顶元素和仅次于栈顶的元素二者的次序。它可以进一步采用[[记忆化]]而写为：
<syntaxhighlight>
# F(x):
#   x > 1 ? M(x) : x
# M(x):
#   if x in a
#     a[x]
#   else 
#     temp := G(x)
#     a[x] := temp 
#     temp
# G(x):
#   F(x-1) + F(x-2)
</syntaxhighlight>
基于[[数组]]保存命令<code>:</code>和访问命令<code>;</code>，它可实现为：
<syntaxhighlight>
0Sa 1si [d 2- lFx r 1- lFx +]sG [;aq]sN [dli!<N lGx dli1+dsi:a]sM [d1<M]dsFx Lasa
</syntaxhighlight>
或者更一般化的写为：
<syntaxhighlight>
# a[0] := 0
# a[1] := 1
# F(x):
#   if x in a
#     a[x]
#   else 
#     temp := G(x)
#     a[x] := temp 
#     temp
# G(x):
#   F(x-1) + F(x-2)
</syntaxhighlight>
它可实现为：
<syntaxhighlight>
0Sa 0 0:a 1 1:a 1si [d 2- lFx r 1- lFx +]sG [;aq]sN [dli!<N lGx dli1+dsi:a]dsFx Lasa
</syntaxhighlight>
下面是其执行示例，展示了通过给它加打印[[断点]]来观察其递归调用的规模和详细步骤：
<syntaxhighlight lang="console">
$ echo 0 | dc -e '? [d 2- lFx r 1- lFx +]sG [d1<G]dsFx p'
0
$ echo 20 | dc -e '? [d 2- lFx r 1- lFx +]sG [d1<G]dsFx p'
6765
$ echo 21 | dc -e '? [d 2- lFx r 1- lFx +]sG [d1<G]dsFx p'
10946
$ echo 20 | dc -e '? [p d 2- lFx r 1- lFx +]sG [d1<G]dsFx' | wc -l
10945
$ echo 20 | dc -e '? 0Sa 0 0:a 1 1:a 1si [d 2- lFx r 1- lFx +]sG [;aq]sN [p dli!<N lGx dli1+dsi:a]dsFx Lasa' | wc -l
39
$ echo 6 | dc -e '? 0Sa 1si [d 2- lFx r 1- lFx +]sG [;aq]sN [zn[ F]np dli!<N lGx dli1+dsi:a]sM [d1<M]dsFx Lasa'
1 F6
2 F4
3 F2
3 F3
4 F2
2 F5
3 F3
3 F4
$ echo 6 | dc -e '? 0Sa 1si [d 1- lFx r 2- lFx +]sG [;aq]sN [zn[ F]np dli!<N lGx dli1+dsi:a]sM [d1<M]dsFx Lasa'
1 F6
2 F5
3 F4
4 F3
5 F2
4 F2
3 F3
2 F4
</syntaxhighlight>
在[[递归定义]]<math>F_n = F_{n-1} + F_{n-2}</math>的[[递归]]调用中，随着<math>F_n</math>的索引<code>n</code>的递减，而递归下降至被计算出来并保存的第一项<math>F_2 = F_1 + F_0</math>，然后沿着调用链逐级返回；在递归的每个步骤中都要计算并保存<math>F_{n}</math>，它所需要的<math>F_{n-1}</math>和<math>F_{n-2}</math>这两项之中，如果首先进行<math>F_{n-2}</math>递归调用并从其返回，则<math>F_{n-1}</math>也需要计算并保存，为此需要访问已保存的<math>F_{n-2}</math>和<math>F_{n-3}</math>；如果首先进行<math>F_{n-1}</math>递归调用并从其返回，则需要访问已保存的<math>F_{n-2}</math>；这种递归返回形成了[[递推关系]]，每个<math>F_n</math>的值被用到一次或两次，首次是从递归调用直接返回，再次是对其已保存的值进行访问，每个步骤要么访问两项并保存两项，要么访问一项并保存一项。故而它可以进一步写为：
<syntaxhighlight>
1si [d 2- lFx r 1- lFx +]sG [2%;aq]sN [dli!<N lGx dli1+dsi2%:a]sM [d1<M]dsFx
</syntaxhighlight>
在[[递归定义]]<math>F_n = F_{n-1} + F_{n-2}</math>的上述两种求值次序中，首先进行<math>F_{n-1}</math>递归调用的这种形式，其[[记忆化]]实现从一开始就持续进行递归调用直到首次递归返回，然后就逐级递归返回而不再进行递归调用，故而它可以进一步写为：
<syntaxhighlight>
# a := 0
# F(x):
#   x > 1 ? G(x) : x
# G(x):
#   curt := F(x-1)
#   prev := a 
#   a := curt
#   curt + prev
</syntaxhighlight>
这里的<code>a</code>被[[初始化]]为<math>F_0</math>的值<code>0</code>，<code>x</code>在步入递归调用之后，除了在被递减至<math>F_1</math>的值<code>1</code>之时作为调用结果来返回之外，没有参与到后续的[[加法]]运算之中，而主要起到了递减[[循环计数器|计数器]]的作用。它可实现为：
<syntaxhighlight>
0sa [1- lFx la r dsa +]sG [d1<G]dsFx
</syntaxhighlight>
下面的例子采用[[迭代法]]打印出[[斐波那契数列]]的不含第<code>0</code>项的前<code>n</code>项：
<syntaxhighlight>
# i := x
# a := 1
# F(x):
#   i > 0 ? G(x) : x
# G(x):
#   prev := a
#   a := x
#   x := x + prev
#   print(x)
#   i := i - 1
#   F(x)
# F(0)
</syntaxhighlight>
针对[[递推关系]]<math>F_{n} = F_{n-1} + F_{n-2}</math>，它总共进行<code>n</code>次迭代运算得出<math>F_1</math>到<math>F_n</math>。这里的<code>i</code>是进行迭代的递减[[循环计数器|计数器]]，所迭代的是需要[[初始化]]的两个变量<code>x</code>和<code>a</code>：在堆栈中的[[自动变量]]<code>x</code>，先是被迭代的<math>F_{n-1}</math>，再是迭代出来的<math>F_{n}</math>，其初始值<code>0</code>是<math>F_{0}</math>，它所起到的作用也被称为[[累加器]]；作为[[全局变量]]的<code>a</code>，以<math>F_1-F_0</math>所得的<code>1</code>作为初始值，在首次迭代之后它是始于<math>F_0</math>的<math>F_{n-2}</math>。它可实现为：
<syntaxhighlight>
si 1sa 0 [lardsa +p li1-si lFx]sG [li0<G]dsFx
</syntaxhighlight>
下面是其执行示例： 
<syntaxhighlight lang="console">
$ echo 6 | dc -e '? si 1sa 0 [lardsa +p li1-si lFx]sG [li0<G]dsFx'
1
1
2
3
5
8
</syntaxhighlight>
可以将它改为计算单个的斐波那契数：
<syntaxhighlight lang="console">
$ echo 0 | dc -e '? si 1sa 0 [lardsa + li1-si lFx]sG [li0<G]dsFx p'
0
$ echo 9 | dc -e '? si 1sa 0 [lardsa + li1-si lFx]sG [li0<G]dsFx p'
34
</syntaxhighlight>

==参见==
*[[bc (编程语言)|bc]]
*[[逆波兰表示法]]
*[[面向堆栈编程]]
*[[隐式编程]]
*[[堆栈机器]]

==引用==
{{Reflist|2}}

==外部链接==
*软件包[http://packages.debian.org/search?keywords=dc&searchon=names&exact=1&suite=all&section=all dc]{{Wayback|url=http://packages.debian.org/search?keywords=dc&searchon=names&exact=1&suite=all&section=all |date=20170312103911 }}在[[Debian GNU/Linux]]仓库中
*[[bc (编程语言)|bc]]的[https://web.archive.org/web/20160222234922/http://gnuwin32.sourceforge.net/packages/bc.htm 原生Windows移植]包括了dc
*[http://dc.pr0.uk 嵌入到网页中的dc]{{Wayback|url=http://dc.pr0.uk/ |date=20171214073950 }}
*[https://esolangs.org/wiki/Dc The unix dc(1) command, this is the esoteric language that "made it big". ]{{Wayback|url=https://esolangs.org/wiki/Dc |date=20200102213208 }}

{{Unix commands}}
{{程序设计语言}}

[[Category:面向堆栈编程语言]]
[[Category:跨平台软件]]
[[Category:Unix软件]]
[[Category:软件计算器]]
[[Category:自由数学软件]]
[[Category:数值分析语言]]