dc ( เครื่องคิดเลขตั้งโต๊ะ ) เป็น เครื่องคิดเลข แบบย้อนกลับของโปแลนด์ที่ใช้งานได้หลายแพลตฟอร์ม ซึ่งรองรับ การ คำนวณเลขคณิตที่มีความแม่นยำสูง^{[ 1 ]}มันถูกเขียนขึ้นโดยLorinda CherryและRobert Morrisที่Bell Labs [ ^{2 ] dc}เป็นหนึ่งใน ยูทิลิตี้ Unix ที่เก่าแก่ที่สุด มาก่อนการพัฒนาภาษาโปรแกรม C เสียอีก เช่นเดียวกับยูทิลิตี้อื่นๆ ในยุคนั้น มันมีชุดคุณสมบัติที่ทรงพลังแต่มีไวยากรณ์ที่กระชับ^{[ 3 ] [ 4 ]} แม้ว่า โปรแกรมเครื่องคิดเลข bc (ซึ่งใช้สัญกรณ์แบบอินฟิกซ์ ) จะถูกนำไปใช้บนพื้นฐานของ dc มาแต่เดิม แต่การใช้งาน dc ใน GNU สมัยใหม่นั้นใช้ bc เป็นพื้นฐาน^{[ 5 ]}

dc เป็น โปรแกรมภาษา Unix ที่เก่าแก่ที่สุดที่ยังคงใช้งานอยู่ เมื่อBell Labsซึ่งเป็นสถานที่พัฒนา dc ได้รับPDP-11 dc ซึ่งเขียนด้วยภาษาBก็เป็นโปรแกรมแรกที่ทำงานบนคอมพิวเตอร์เครื่องใหม่ แม้กระทั่งก่อนภาษาแอสเซมเบลอร์^{[ 2 ]} Ken Thompsonได้แสดงความคิดเห็นว่า dc เป็นโปรแกรมแรกสุดที่เขียนขึ้นบนเครื่องนี้^{[ 6 ]}

ในการคูณเลขสี่และห้าในหน่วย dc (โปรดทราบว่าช่องว่างส่วนใหญ่ เป็น ช่องว่างที่ไม่จำเป็น):

$ cat << EOF > cal.txt 4 5 * p EOF$ dc cal.txt 20 $

สามารถดูผลลัพธ์ได้จากคำสั่งต่อไปนี้:

$ echo "4 5 * p" | dc 

หรือ

$ dc - 4 5*pq 20$ dc 4 5 * p 20 q$ dc -e '4 5 * p'

คำสั่งนี้แปลว่า "ผลักเลขสี่และห้าลงบนสแต็ก จากนั้นใช้ตัวดำเนินการคูณ ดึงองค์ประกอบสองตัวออกจากสแต็ก คูณกัน แล้วผลักผลลัพธ์ลงบนสแต็ก" จากนั้นpใช้คำสั่งเพื่อตรวจสอบ (แสดงผลบนหน้าจอ) องค์ประกอบบนสุดของสแต็กqคำสั่งนี้จะออกจากอินสแตนซ์ของ dc ที่เรียกใช้ โปรดทราบว่าตัวเลขต้องเว้นวรรคจากกัน แม้ว่าตัวดำเนินการบางตัวไม่จำเป็นต้องเว้นวรรคก็ตาม

ความแม่นยำในการคำนวณเลขคณิตจะถูกเปลี่ยนแปลงด้วยคำสั่งk`--number of fractional digits` (จำนวนหลักหลังจุด 0 ) ที่จะใช้ในการคำนวณเลขคณิต เนื่องจากความแม่นยำเริ่มต้นเป็นศูนย์ ลำดับของคำสั่งนี้0จึงให้ผลลัพธ์ดังนี้:

2 3 / หน้า 

โดยการปรับความแม่นยำด้วยค่าkสามารถสร้างจำนวนทศนิยมตามต้องการได้ ลำดับคำสั่งนี้จะแสดงผลลัพธ์.66666เป็น

5k 2 3 / หน้า 

เพื่อประเมินค่า: ( คำนวณรากที่สองของค่าบนสุดของสแต็ก และใช้ป้อนค่าลบ): ${\displaystyle {\sqrt {\left(12+\left(-3\right)^{4}\right) \over 11}}-22}$v_

12 _3 4 ^ + 11 / v 22 - พี 

หากต้องการสลับตำแหน่งสององค์ประกอบบนสุดของสแต็ก ให้ใช้rคำสั่ง หากต้องการทำซ้ำองค์ประกอบบนสุด ให้ใช้dคำสั่ง

ในการอ่านบรรทัดจากstdinให้ใช้?คำสั่งนี้ คำสั่งนี้จะประเมินบรรทัดนั้นเสมือนเป็นคำสั่ง dc ดังนั้นจึงจำเป็นต้องให้ถูกต้องตามหลักไวยากรณ์ และอาจก่อให้เกิดปัญหาด้านความปลอดภัยเนื่องจาก!คำสั่ง dc อนุญาตให้เรียกใช้คำสั่งใดๆ ก็ได้

ตามที่กล่าวไว้ข้างต้น คำสั่ง ` pprint` จะพิมพ์ค่าบนสุดของสแต็กโดยมีขึ้นบรรทัดใหม่ตามหลัง คำสั่ง ` npull` จะดึงค่าบนสุดของสแต็กออกมาและพิมพ์โดยไม่มีขึ้นบรรทัดใหม่ตามหลัง คำสั่ง ` fprint` จะพิมพ์สแต็กทั้งหมดโดยแต่ละรายการอยู่คนละบรรทัด

คำ สั่ง dc ยังรองรับฐานi ตัวเลขขาเข้าและขาออกที่กำหนดเองได้ ด้วย คำสั่งนี้จะดึงค่าบนสุดของสแต็กออกมาและใช้เป็นฐานตัวเลขขาเข้า ตัวเลขฐานสิบหกต้องเป็นตัวพิมพ์ใหญ่เพื่อหลีกเลี่ยงการชนกับคำสั่ง dc และจำกัดเฉพาะ AF เท่านั้นoคำสั่งนี้ทำเช่นเดียวกันสำหรับฐานตัวเลขขาออก แต่โปรดจำไว้ว่าฐานตัวเลขขาเข้ามีผลต่อการแยกวิเคราะห์ค่าตัวเลขทุกค่าในภายหลัง ดังนั้นโดยทั่วไปแล้วควรตั้งค่าฐานตัวเลขขาออกก่อน ดังนั้นคำสั่งนี้10oจะตั้งค่าฐานตัวเลขขาออกเป็นฐานตัวเลขขาเข้าปัจจุบัน แต่โดยทั่วไปจะไม่ใช่ 10 (สิบ) อย่างไรก็ตาม คำสั่งนี้Aoจะรีเซ็ตฐานตัวเลขขาออกเป็น 10 (สิบ) โดยไม่คำนึงถึงฐานตัวเลขขาเข้า ในการอ่านค่า คำสั่ง K, IและOจะผลักความแม่นยำปัจจุบัน ฐานตัวเลขขาเข้า และฐานตัวเลขขาออกไปยังด้านบนสุดของสแต็ก

ตัวอย่างเช่น การแปลงจากเลขฐานสิบหกเป็นเลขฐานสอง:

$ echo 16i2o DEADBEEFp | dc 11011110101101101101111101111

นอกเหนือจากการคำนวณทางคณิตศาสตร์พื้นฐานและการดำเนินการกับสแต็กแล้ว dc ยังรองรับมาโครเงื่อนไข และการจัดเก็บผลลัพธ์เพื่อเรียกใช้ในภายหลังอีกด้วย

กลไกพื้นฐานของมาโครและเงื่อนไขคือรีจิสเตอร์ซึ่งใน dc เป็นตำแหน่งจัดเก็บข้อมูลที่มีชื่อเป็นอักขระตัวเดียว ซึ่งสามารถจัดเก็บและเรียกค่าได้: scดึงค่าบนสุดของสแต็กออกมาเก็บไว้ในรีจิสเตอร์ c และlcผลักค่าของรีจิสเตอร์ c ลงบนสแต็ก ตัวอย่างเช่น:

3 sc 4 ​​lc * p 

นอกจากนี้ รีจิสเตอร์ยังสามารถถูกมองว่าเป็นสแต็กสำรองได้ ดังนั้นจึงสามารถผลักและดึงค่าระหว่างรีจิสเตอร์และสแต็กหลักได้โดยใช้คำสั่ง `push` Sและ ` pop`L

ค่าสตริงจะถูกล้อมรอบด้วย อักขระ [`&` และ]`&` และอาจถูกผลักลงบนสแต็กและเก็บไว้ในรีจิสเตอร์aคำสั่งนี้จะแปลงไบต์ลำดับต่ำสุดของค่าตัวเลขเป็น อักขระ ASCIIหรือหากส่วนบนสุดของสแต็กเป็นสตริง มันจะแทนที่ด้วยอักขระตัวแรกของสตริงนั้น ไม่มีวิธีอื่นในการสร้างสตริงหรือทำการจัดการสตริง นอกจากการเรียกใช้ด้วยxคำสั่ง หรือการพิมพ์ด้วยPคำสั่ง

ตัว#ละครเริ่มแสดงความคิดเห็นต่อจากตอนท้ายของบรรทัด

จากนั้นจึงนำมาโครมาใช้งานโดยอนุญาตให้รีจิสเตอร์และรายการในสแต็กเป็นได้ทั้งสตริงและตัวเลข สตริงสามารถพิมพ์ได้ แต่ยังสามารถเรียกใช้งานได้ด้วย (เช่น ประมวลผลเป็นลำดับของคำสั่ง dc) ตัวอย่างเช่น เราสามารถเก็บมาโครเพื่อบวกหนึ่งแล้วคูณด้วยสองลงในรีจิสเตอร์ m ได้:

[1 + 2 *] sm 

จากนั้น (โดยใช้xคำสั่งที่ดำเนินการกับส่วนบนสุดของสแต็ก) เราสามารถใช้งานได้ดังนี้:

3 lm xp 

สุดท้ายนี้ เราสามารถใช้กลไกมาโครนี้เพื่อสร้างเงื่อนไขได้ คำสั่งนี้=rจะดึงค่าสองค่าออกจากสแต็ก และเรียกใช้มาโครที่เก็บไว้ในรีจิสเตอร์rก็ต่อเมื่อค่าทั้งสองเท่ากันเท่านั้น ดังนั้น คำสั่งนี้จะพิมพ์สตริงequalก็ต่อเมื่อค่าสองค่าบนสุดในสแต็กมีค่าเท่ากันเท่านั้น

[[เท่ากับ]p] sr 5 5 =r 

เงื่อนไขอื่นๆ ได้แก่>, !>, <, !<, !=, ซึ่งจะเรียกใช้มาโครที่ระบุหากค่าสองค่าบนสุดของสแต็กมากกว่า น้อยกว่าหรือเท่ากับ ("ไม่มากกว่า") น้อยกว่า มากกว่าหรือเท่ากับ ("ไม่น้อยกว่า") และไม่เท่ากัน ตามลำดับ โปรดทราบว่าลำดับของตัวถูกดำเนินการในการเปรียบเทียบความไม่เท่ากันนั้นตรงกันข้ามกับลำดับสำหรับการคำนวณทางคณิตศาสตร์5 3 -จะมีค่าเท่ากับ5 - 3 = 2แต่ จะดำเนินการ ตาม เนื้อหาของรีจิสเตอร์เนื่องจาก5 3 <tt3 < 5

การวนซ้ำสามารถทำได้โดยการกำหนดมาโครซึ่ง (ตามเงื่อนไข) จะเรียกตัวเองซ้ำ การคำนวณแฟกทอเรียลอย่างง่ายของค่าบนสุดของสแต็กอาจทำได้ดังนี้:

# F(x): คืนค่า x! # ถ้า x-1 > 1 # คืนค่า x * F(x-1) # มิฉะนั้น # ส่งคืน x [d1-d1<F*]dsFxp 

คำสั่ง นี้1Qออกจากมาโคร ทำให้สามารถคืนค่าก่อนกำหนดได้qออกจากมาโครสองระดับ (และออกจาก dc เองหากมีระดับในสแต็กการเรียกน้อยกว่าสองระดับ) zผลักความลึกของสแต็กปัจจุบันก่อนzการดำเนินการ

วิธีการนี้ใช้มาโครที่เก็บไว้ในรีจิสเตอร์aซึ่งจะเรียกตัวเองแบบมีเงื่อนไข โดยทำการบวกทุกครั้งจนกว่าจะเหลือค่าเดียวบนสแต็ก ตัวzดำเนินการใช้สำหรับผลักจำนวนรายการในสแต็กเข้าไปในสแต็ก ตัวดำเนินการเปรียบเทียบ>จะดึงค่าสองค่าออกจากสแต็กเพื่อทำการเปรียบเทียบ

dc -e "1 2 4 8 16 100 0d[+z1<a]dsaxp"

และผลลัพธ์คือ 131

ตัวเลขเปล่าๆ ถือเป็นนิพจน์ dc ที่ถูกต้อง ดังนั้นจึงสามารถใช้เพื่อหาผลรวมของไฟล์ที่แต่ละบรรทัดประกอบด้วยตัวเลขเพียงตัวเดียวได้

วิธีการนี้ใช้มาโครที่เก็บไว้ในรีจิสเตอร์aซึ่งจะเรียกตัวเองแบบมีเงื่อนไข โดยทำการบวกทุกครั้ง จนกว่าจะเหลือค่าเดียวบนสแต็ก

dc -e "0d[?+z1<a]dsaxp" < file 

ตัว?ดำเนินการอ่านคำสั่งอื่นจากสตรีมอินพุต หากบรรทัดอินพุตมีตัวเลขทศนิยม ค่าดังกล่าวจะถูกเพิ่มลงในสแต็ก เมื่อไฟล์อินพุตถึงจุดสิ้นสุด คำสั่งจะเป็นค่าว่าง และจะไม่มีการเพิ่มค่าใด ๆ ลงในสแต็ก

{ echo "5" ; echo "7" ; } | dc -e "0d[?+z1<a]dsaxp"

และผลลัพธ์คือ 12

สายอินพุตอาจเป็นคำสั่ง DC ที่ซับซ้อนได้เช่นกัน

{ echo "3 5 *" ; echo "4 3 *" ; echo "5dd++" ; } | dc -e "0d[?+z1<a]dsaxp"

และผลลัพธ์คือ 42

โปรดทราบว่าเนื่องจาก dc รองรับความแม่นยำตามอำเภอใจ จึงไม่มีความกังวลเกี่ยวกับค่าเกินขีดจำกัดหรือการสูญเสียความแม่นยำ ไม่ว่าสตรีมอินพุตจะมีจำนวนบรรทัดกี่บรรทัดก็ตาม ซึ่งแตกต่างจากวิธีการแก้ปัญหาที่กระชับคล้ายกันใน AWK

ข้อเสียของวิธีแก้ปัญหานี้คือ: ลูปจะหยุดเมื่อพบบรรทัดว่างในสตรีมอินพุต (ในทางเทคนิคคือ บรรทัดอินพุตใดๆ ที่ไม่ได้เพิ่มค่าตัวเลขอย่างน้อยหนึ่งค่าลงในสแต็ก) และสำหรับการจัดการตัวเลขติดลบ เครื่องหมาย '-' ที่อยู่ข้างหน้าเพื่อแสดงเครื่องหมายลบจะต้องเปลี่ยนเป็น '_' ในสตรีมอินพุต เนื่องจากเครื่องหมายลบของ dc ไม่เป็นไปตามมาตรฐาน?ตัวดำเนินการใน dc ไม่มีวิธีที่ชัดเจนในการแยกแยะระหว่างการอ่านบรรทัดว่างกับการอ่านจุดสิ้นสุดของไฟล์

ตัวอย่างโปรแกรมที่ค่อนข้างง่ายใน dc คือคำสั่งนี้ (ในบรรทัดเดียว):

dc -e '[[ป้อนตัวเลข (เมตร) หรือ 0 เพื่อออก]PAP]sh[q]sz[lhx?d0=zAk.0254/.5+0kC~1/rn[ ฟุต ]Pn[ นิ้ว]PAPdx]dx'

โปรแกรมนี้แปลงระยะทางจากเมตรเป็นฟุตและนิ้ว โดยส่วนใหญ่จะเกี่ยวข้องกับการแจ้งให้ป้อนข้อมูล พิมพ์ผลลัพธ์ในรูปแบบที่เหมาะสม และวนซ้ำเพื่อแปลงตัวเลขอื่นต่อไป

ตัวอย่างเช่น นี่คือการนำอัลกอริทึมแบบยุคลิดมา ใช้ เพื่อหาตัวหารร่วมมาก (GCD) :

dc -e '??[dSarLa%d0<a]dsax+p' # เวอร์ชันที่สั้นที่สุด dc -e '[a=]P?[b=]P?[dSarLa%d0<a]dsax+[GCD:]Pp' # เวอร์ชันที่อ่านง่ายกว่า

การคำนวณแฟกทอเรียลของค่าอินพุต${\displaystyle n!=\prod _{i=1}^{n}i}$

dc -e '?[q]sQ[d1=Qd1-lFx*]dsFxp'

ในภาษาโปรแกรม dc ยังมีquines ซึ่งเป็นโปรแกรมที่สร้างซอร์สโค้ดของภาษาดังกล่าวออกมาเป็นผลลัพธ์

dc -e '[91Pn[dx]93Pn]dx' dc -e '[91PP93P[dx]P]dx'

dc -e '2p3p[dl!d2+s!%0=@l!l^!<#]s#[s/0ds^]s@[p]s&[ddvs^3s!l#x0<&2+lx]ds.x'

โปรแกรมนี้เขียนโดย Michel Charpentier มันแสดงลำดับของจำนวนเฉพาะ โปรดทราบว่าสามารถเขียนโปรแกรมให้สั้นกว่านี้ได้ โดยใช้สัญลักษณ์น้อยกว่าถึงสิบสี่ตัว

dc -e '2p3p[pq]s$[l!2+ds!l^<$dl!%0<#]s#[+dvs^1s!l#x2l.x]ds.x'

dc -e '[n=]P?[p]s2[lip/dli%0=1dvsr]s12sid2%0=13sidvsr[dli%0=1lrli2+dsi!>.]ds.xd1<2'

โปรแกรมนี้เขียนโดยมิเชล ชาร์ปองติเยร์เช่นกัน^{[ 7 ]}

มีแบบที่สั้นกว่า

dc -e "[n=]P?[lfp/dlf%0=Fdvsr]sF[dsf]sJdvsr2sf[dlf%0=Flfdd2%+1+sflr<Jd1<M]dsMx"

และวิธีแก้ปัญหาที่เร็วกว่า (ลองใช้ตัวเลข 200 บิต2 ²⁰⁰ -1 (อินพุต2 200^1-))

dc -e "[n=]P?[lfp/dlf% 0=Fdvsr]sFdvsr2sfd2%0=F3sfd3%0=F5sf[dlf%0=Flfd4+sflr>M]sN[dlf%0=Flfd2+sflr>N]dsMx[p]sMd1<M"

โปรดทราบว่ากระบวนการหลังนี้สามารถทำได้เร็วขึ้นอีก หากเปลี่ยนจากการเข้าถึงค่าคงที่ไปเป็นการเข้าถึงรีจิสเตอร์

dc -e "[n=]P?[lfp/dlf%l0=Fdvsr]sF2s2dvsr2sf4s4d2%0=F3sfd3%0=F5sf[dlf%l0=Flfdl4+sflr>M]sN[dlf%l0=Flfdl2+sflr>N]dsMx[p]sMd1<M"

นี่คือการนำอัลกอริทึมของชูดนอฟสกีมาเขียนด้วยภาษาโปรแกรม dc โปรแกรมจะแสดงค่าประมาณที่ดีขึ้นเรื่อยๆ ขณะที่ทำงาน แต่เนื่องจากพาย (pi) เป็นจำนวนอดิศัย โปรแกรมจะทำงานต่อไปจนกว่าจะถูกขัดจังหวะหรือทรัพยากรของเครื่องที่ใช้รันหมดลง

dc -e '_640320[0ksslk3^16lkd12+sk*-lm*lhd1+sh3^/smlxlj*sxll545140134+dsllm*lxlnk/ls+dls!=P]sP3^sj7sn[6sk1ddshsxsm13591409dsllPx10005v426880*ls/K3-k1/pcln14+snlMx]dsMx'

เป็นการนำสูตรเดียวกันมาใช้แบบแบ่งและพิชิตอย่างรวดเร็ว โดยขนาดของผลลัพธ์จะเพิ่มขึ้นเป็นสองเท่าในแต่ละรอบการคำนวณ สูตรนี้จะประเมินผลรวมของจำนวนจำกัดเป็นจำนวนตรรกยะที่แน่นอน และทำการหารและการหาค่ารากที่สองเพียงครั้งเดียวในแต่ละรอบ วิธีนี้รวดเร็ว แต่จะช้าลงอย่างรวดเร็วเมื่อขนาดของเศษส่วนเพิ่มขึ้น

dc -e '1Sk1SR13591409dSBSP426880dSQ4/3^9*SC[0r-]s-[lkE*1-k10005vlQ*lP/nAan0k]dSox[Lkd1+Skdd1+Sk3^lC*SQ2*1-d3*d*4-*dSR545140134LB+dSB*lk2%0=-SP]dszx[LRLRdLP*LPLQdLQ*SQ*+SP*SR]sc[d1-d0<yd0<yd0=z0=zlcx]sy0[lcxlox1+lyxllx]dslx'

ตัวอย่างที่ซับซ้อนกว่าของการใช้ dc ที่ฝังอยู่ใน สคริปต์ Perlดำเนินการแลกเปลี่ยนคีย์ Diffie–Hellmanซึ่งเป็นที่นิยมในฐานะบล็อกลายเซ็นในหมู่นักเข้ารหัสลับในช่วงที่ มีการถกเถียงเรื่อง ITARโดยสคริปต์สั้น ๆ สามารถเรียกใช้ได้ด้วย Perl และ dc เท่านั้น ซึ่งเป็นโปรแกรมที่แพร่หลายในระบบปฏิบัติการที่คล้าย Unix: ^{[ 8 ]}

#!/usr/bin/env perl -- -export-a-crypto-system-sig Diffie-Hellman-2-lines ( $g , $e , $m ) = @ARGV , $m || die "$0 gen exp mod\n" ; print `echo "16dio1[d2%Sa2/d0<X+d*La1=z\U$m%0]SX$e"[$g*]\EszlXx+p | dc`

เวอร์ชันที่มีคำอธิบายประกอบจะเข้าใจง่ายกว่าเล็กน้อย และแสดงวิธีการใช้ลูป เงื่อนไข และqคำสั่งในการส่งค่ากลับจากมาโคร สำหรับเวอร์ชัน GNU ของ dc นั้น|คำสั่งนี้สามารถใช้ในการยกกำลังแบบโมดูลาร์ที่มีความแม่นยำสูงได้โดยไม่ต้องเขียนฟังก์ชัน X เอง

#!/usr/bin/env perlmy ( $g , $e , $m ) = map { "\U$_" } @ARGV ; die "$0 gen exp mod\n" unless $m ;print `echo $g $e $m | dc -e ' # การรับและแสดงผลเลขฐานสิบหก16dio # อ่านค่า m, e และ g จาก stdin ในบรรทัดเดียว?SmSeSg# ฟังก์ชัน z: คืนค่า g * ด้านบนสุดของสแต็ก[lg*]sz# ฟังก์ชัน Q: ลบส่วนบนสุดของสแต็กและส่งคืนค่า 1 [sb1q]sQ# ฟังก์ชัน X(e): คำนวณ g^e % m แบบเรียกซ้ำ# เหมือนกับ Sm^Lm% แต่สามารถจัดการกับเลขชี้กำลังขนาดใหญ่ได้ตามอำเภอใจ# สแต็กที่ทางเข้า: e # สแต็กที่ทางออก: g^e % m # เนื่องจาก e อาจมีขนาดใหญ่มาก จึงใช้คุณสมบัติที่ว่า g^e % m == # ถ้า (e == 0) # คืนค่า 1 # x = (g^(e/2)) ^ 2 # ถ้า (e % 2 == 1) # x *= g # คืนค่า x % [  d 0=Q # คืนค่า 1 ถ้า e==0 (มิฉะนั้น สแต็ก: e)  d 2% Sa # เก็บ e%2 ไว้ใน a (สแต็ก: e)  2/ # คำนวณ e/2  lXx # เรียก X(e/2)  d* # คำนวณ X(e/2)^2  La1=z # คูณด้วย g ถ้า e%2==1  lm % # คำนวณ (g^e) % m ] SXle # โหลดค่า e จากรีจิสเตอร์lXx # คำนวณ g^e % m p # พิมพ์ผลลัพธ์'` ;

หากตัวแปรสภาพแวดล้อม DC_LINE_LENGTH มีอยู่และมีค่าเป็นจำนวนเต็มที่มากกว่า 1 และน้อยกว่า 0 การแสดงผลตัวเลข (ตามฐานการแสดงผล) จะถูกจำกัดไว้ที่ค่านี้ โดยจะมีการแทรกเครื่องหมายแบ็กสแลชและขึ้นบรรทัดใหม่ต่อท้าย ค่าเริ่มต้นของความยาวบรรทัดคือ 70 ค่าพิเศษ 0 จะปิดใช้งานการขึ้นบรรทัดใหม่ ${\displaystyle 2^{16}-1}$

• bc (ภาษาโปรแกรม)
• วิธีการป้อนข้อมูลเครื่องคิดเลข
• เครื่องคิดเลข HP
• เครื่องเรียงซ้อน
• สัญกรณ์โปแลนด์กลับด้าน

• แพ็คเกจdcในที่เก็บแพ็คเกจDebian GNU/Linux
• แพ็คเกจGNU bc-1.08.1 รุ่นล่าสุด ซึ่งรวมถึง dc ด้วย
• dc(1) –  คู่มือคำสั่งทั่วไปของ Linuxจาก ManKier.com
• dc(1) –  คู่มือโปรแกรมเมอร์Plan 9 เล่ม 1
• เวอร์ชันสำหรับ Windows โดยเฉพาะของbcซึ่งรวมถึง dc ด้วย