[20230922]dc命令复杂学习3.txt
[20230922]dc命令复杂学习3.txt
1.问题提出:
--//前一段时间简单学习了dc,累加的例子:
$ cat a.txt
1111
2222
3333
4444
$ cat a.txt | dc -f - -e "[+z1<r]srz1<rp"
11110
$ dc -f a.txt -e "[+z1<r]srz1<rp"
11110
--//实际上如果累加数据量很大,这样的执行效率很低的,因为每次都要判断堆栈是否还有数据(z命令,队列越长执行效率越低)
--//实际上开始我就想,如果根据开始插入堆栈的数量生成对应的数量的字符'+' ( 注:生成+的数量等于插入堆栈的数量-1),
--//那不是更加简单呢? 自己再做一些尝试:
2.尝试实现:
$ dc -f a.txt -e "zp"
4
$ (cat a.txt ; seq 2 $(dc -f a.txt -e "zp"| tr -d '\r') | xargs -IQ echo + ; echo pq ) | dc -f -
11110
--//注：我的测试在cygwin下，dc -f a.txt -e "zp"的输出结果多了1个\r字符，必须删除它。
--//我上面的例子使用seq 生成对应+,如何全部使用dc实现呢?
--//先做z操作插入堆栈的数量,然后产生对应数量的+就可以了.改写如下:
$ cat a.txt | dc -f - -e "z [+ la 1 - sa la 1<r ]sr sa la 1<r pq"
11110
$ dc -f a.txt -e "z [+ la 1 - sa la 1<r ]sr sa la 1<r pq"
11110
--//简单解析,不作记录我估计以后自己都看不懂代码表示怎么:
--//z 插入当前堆栈的数量到堆栈顶部,在该例子是4.
--//[+ la 1 - sa la 1<r ]sr 将[]括号的内容保存到寄存器r.以后循环执行里面的内容,同时出堆栈.
--//sa 保存堆栈顶部的值到寄存器a,同时出堆栈.这里寄存器a保存的值开始是4.
--//la 把寄存器a的内容放入堆栈,这里寄存器a=4的值放入堆栈.
--//1<r 插入1到堆栈 做比较如果1 < 4 ,调用寄存器r的内容执行.形成递规.注意执行<时,堆栈顶部的比较的2个值同时出堆栈.
--//单独解析: [+ la 1 - sa la 1<r ]
--// + 对当前堆栈顶部的2个数值做一次加法运算.
--// la 把寄存器a的内容放入堆栈.
--// 1 - 把1放入堆栈.并且与前面放入寄存器a的内容放入堆栈的值做减法运算.也就是做循环.
--// sa 保存堆栈顶部的值到寄存器a,同时出堆栈.
--// la 把寄存器a的内容放入堆栈
--// 1<r 插入1到堆栈 做比较如果1 < 寄存器a的值 ,调用寄存器r的内容执行.形成递规.注意执行<时,堆栈顶部的比较的2个值同时出堆栈.
--//加入一个显示整个堆栈的命令f就很清楚了.
$ dc -f a.txt -e "z [ + la 1 - sa la 1 f 61P 61P 61P 61P 10P <r ]sr sa la 1 f 61P 61P 61P 61P 10P <r pq"
1
4
4444
3333
2222
1111
====
1
3
7777
2222
1111
====
1
2
9999
1111
====
1
1
11110
====
11110
--//如果算法改一下,要输出对应数量的字符+,该如何操作呢?
--//+的ascii码=43 ,注:在vim下在移动到+字符下按ga,在vim的提示行显示对应ascii码值(10,16,8进制). 空格的ascii=32,换行的
--//ascii=10.
$ cat a.txt | dc -f - -e "z [43P la 1 - sa la 1<r ]sr sa la 1<r "
+++
--//注意我的以上测试并没有改变dc插入堆栈的值.你最后加入f显示整个堆栈.
$ cat a.txt | dc -f - -e "z [43P la 1 - sa la 1<r ]sr sa la 1<r 10P f"
+++
4444
3333
2222
1111
--//使用空格分开呢?
$ dc -f a.txt -e "z [43P 32P la 1 - sa la 1<r ]sr sa la 1<r "
+ + +
--//这样也可以写成如下:
$ (cat a.txt ; dc -f a.txt -e "z [43P 32P la 1 - sa la 1<r ]sr sa la 1<r 10P"; echo pq ) | dc -f -
11110
3.测试执行效率:
--//测试这样改进的执行效率如何?家里没有linux的环境,使用cygwin 在windows下测试:
--//cygwin的执行效率并不是很高.
$ seq 100000 > b.txt
$ time dc -f b.txt -e "[+z1<r]srz1<rp"
5000050000
real 0m10.630s
user 0m0.000s
sys 0m0.015s
$ time dc -f b.txt -e "z [+ la 1 - sa la 1<r ]sr sa la 1<r pq"
5000050000
real 0m0.648s
user 0m0.000s
sys 0m0.015s
--//明显快了一大截。测试使用bc看看
$ paste -sd+ b.txt | bc -l
(standard_in) 1: Function too big.
--//拚接为1行时太长了,实际上操作bc 1行接受的行长度存在限制,看下面的测试.
$ time ((sed -e 's/^/s+=/g' b.txt ; echo s ) | bc -l)
5000050000
real 0m0.658s
user 0m0.061s
sys 0m0.045s
--//两者相差不大。
--//顺便测试一行最大容纳多少字符。
$ head -2499 b.txt | paste -sd+ | bc -l
3123750
$ head -2500 b.txt | paste -sd+ | bc -l
(standard_in) 1: Function too big.
$ head -2500 b.txt | paste -sd+ | wc
1 1 11393
$ head -2499 b.txt | paste -sd+ | wc
1 1 11388
--//我估计是超出bc一行能输入的字符数量的限制。因为head -2500 b.txt | paste -sd+可以正常执行。
$ time (head -2499 b.txt | paste -sd+ | bc -l)
3123750
real 0m0.535s
user 0m0.015s
sys 0m0.030s
$ time (head -2499 b.txt | dc -f - -e "z [+ la 1 - sa la 1<r ]sr sa la 1<r pq")
3123750
real 0m0.355s
user 0m0.000s
sys 0m0.046s
--//还是dc略胜一筹。我估计是因为bc的执行过程中使用paste拼接的原因。
$ head -2499 b.txt | paste -sd+ > c.txt
$ echo quit >> c.txt
$ time bc -l c.txt
3123750
real 0m0.146s
user 0m0.000s
sys 0m0.000s
$ head -2499 b.txt > c.txt
$ (dc -f c.txt -e "z [43P la 1 - sa la 1<r ]sr sa la 1<r "; echo pq ) >> c.txt
$ time dc -f c.txt
3123750
real 0m0.192s
user 0m0.000s
sys 0m0.031s
--//在写好计算公式的情况下，两者差不多，bc也许更快一些。
4.补充说明:
--//测试看看dc 以及bc 一行能接受字符的限制的具体数值.
$ head -2499 b.txt | paste -sd+ > c.txt
$ time bc -l c.txt
3123750
quit
real 0m2.148s
user 0m0.000s
sys 0m0.000s
--//尝试修改c.txt 增加文件第一行字符数量.仅仅增加1个字符就出现如下错误。
$ time bc -l c.txt
quit
c.txt 2: Function too big.
real 0m2.140s
user 0m0.015s
sys 0m0.000s
$ wc c.txt
1 1 11389 c.txt
$ ls -l c.txt
-rw-r--r-- 1 Administrator None 11389 2023-09-23 20:29:27 c.txt
--//文件是linux格式,删除最后1个字符0x0a以及插入的字符,bc的一行输入缓存是11387字符。
--//多次尝试我发现实际上情况比我前面的测试要复杂：
$ head -5 e.txt
1
1
1
1
1
--//建立一个全部是数字1的文件。
$ wc e.txt
40000 40000 80000 e.txt
--//共40000行。
$ paste -sd+ e.txt | bc -l
(standard_in) 1: Function too big.
$ head -8192 e.txt | paste -sd+ |bc -l
8192
$ head -8193 e.txt | paste -sd+ |bc -l
(standard_in) 2: Function too big.
$ head -8194 e.txt | paste -sd+ | wc
1 1 16388
--//放弃探究，有点离题了。
--//测试dc的情况：
$ head -2499 b.txt | paste -sd' ' > d.txt
$ ls -l d.txt
-rw-r--r-- 1 Administrator None 11388 2023-09-23 20:32:51 d.txt
$ (dc -f d.txt -e "z [43P la 1 - sa la 1<r ]sr sa la 1<r "; echo pq ) >> d.txt
$ time dc -f d.txt
3123750
real 0m0.181s
user 0m0.000s
sys 0m0.015s
--//增加1个字符看看，修改最后的2499 为 24991。
$ time dc -f d.txt
3146242
real 0m0.214s
user 0m0.000s
sys 0m0.015s
--//3123750 - 2499 +24991 = 3146242 , 结果正确。
$ paste -sd' ' b.txt > d.txt
$ (dc -f d.txt -e "z [43P la 1 - sa la 1<r ]sr sa la 1<r "; echo pq ) >> d.txt
$ time dc -f d.txt
5000050000
real 0m0.461s
user 0m0.000s
sys 0m0.015s
$ ls -l d.txt
-rw-r--r-- 1 Administrator None 688897 2023-09-23 20:41:58 d.txt
$ cat d.txt | dc -f -
5000050000
--//dc没有这个限制,甚至bash shell命令行的限制。
--//bash shell命令行的限制我记忆里各个版本不一致，好像最大可以达到128K，有一些甚至2621440。我不测试了。
$ getconf -a | grep -i arg
_POSIX_ARG_MAX 4096
NL_ARGMAX 9
ARG_MAX 32000
$ getconf ARG_MAX
32000
--//我的cygwin测试环境32000.
1.问题提出:
--//前一段时间简单学习了dc,累加的例子:
$ cat a.txt
1111
2222
3333
4444
$ cat a.txt | dc -f - -e "[+z1<r]srz1<rp"
11110
$ dc -f a.txt -e "[+z1<r]srz1<rp"
11110
--//实际上如果累加数据量很大,这样的执行效率很低的,因为每次都要判断堆栈是否还有数据(z命令,队列越长执行效率越低)
--//实际上开始我就想,如果根据开始插入堆栈的数量生成对应的数量的字符'+' ( 注:生成+的数量等于插入堆栈的数量-1),
--//那不是更加简单呢? 自己再做一些尝试:
2.尝试实现:
$ dc -f a.txt -e "zp"
4
$ (cat a.txt ; seq 2 $(dc -f a.txt -e "zp"| tr -d '\r') | xargs -IQ echo + ; echo pq ) | dc -f -
11110
--//注：我的测试在cygwin下，dc -f a.txt -e "zp"的输出结果多了1个\r字符，必须删除它。
--//我上面的例子使用seq 生成对应+,如何全部使用dc实现呢?
--//先做z操作插入堆栈的数量,然后产生对应数量的+就可以了.改写如下:
$ cat a.txt | dc -f - -e "z [+ la 1 - sa la 1<r ]sr sa la 1<r pq"
11110
$ dc -f a.txt -e "z [+ la 1 - sa la 1<r ]sr sa la 1<r pq"
11110
--//简单解析,不作记录我估计以后自己都看不懂代码表示怎么:
--//z 插入当前堆栈的数量到堆栈顶部,在该例子是4.
--//[+ la 1 - sa la 1<r ]sr 将[]括号的内容保存到寄存器r.以后循环执行里面的内容,同时出堆栈.
--//sa 保存堆栈顶部的值到寄存器a,同时出堆栈.这里寄存器a保存的值开始是4.
--//la 把寄存器a的内容放入堆栈,这里寄存器a=4的值放入堆栈.
--//1<r 插入1到堆栈 做比较如果1 < 4 ,调用寄存器r的内容执行.形成递规.注意执行<时,堆栈顶部的比较的2个值同时出堆栈.
--//单独解析: [+ la 1 - sa la 1<r ]
--// + 对当前堆栈顶部的2个数值做一次加法运算.
--// la 把寄存器a的内容放入堆栈.
--// 1 - 把1放入堆栈.并且与前面放入寄存器a的内容放入堆栈的值做减法运算.也就是做循环.
--// sa 保存堆栈顶部的值到寄存器a,同时出堆栈.
--// la 把寄存器a的内容放入堆栈
--// 1<r 插入1到堆栈 做比较如果1 < 寄存器a的值 ,调用寄存器r的内容执行.形成递规.注意执行<时,堆栈顶部的比较的2个值同时出堆栈.
--//加入一个显示整个堆栈的命令f就很清楚了.
$ dc -f a.txt -e "z [ + la 1 - sa la 1 f 61P 61P 61P 61P 10P <r ]sr sa la 1 f 61P 61P 61P 61P 10P <r pq"
1
4
4444
3333
2222
1111
====
1
3
7777
2222
1111
====
1
2
9999
1111
====
1
1
11110
====
11110
--//如果算法改一下,要输出对应数量的字符+,该如何操作呢?
--//+的ascii码=43 ,注:在vim下在移动到+字符下按ga,在vim的提示行显示对应ascii码值(10,16,8进制). 空格的ascii=32,换行的
--//ascii=10.
$ cat a.txt | dc -f - -e "z [43P la 1 - sa la 1<r ]sr sa la 1<r "
+++
--//注意我的以上测试并没有改变dc插入堆栈的值.你最后加入f显示整个堆栈.
$ cat a.txt | dc -f - -e "z [43P la 1 - sa la 1<r ]sr sa la 1<r 10P f"
+++
4444
3333
2222
1111
--//使用空格分开呢?
$ dc -f a.txt -e "z [43P 32P la 1 - sa la 1<r ]sr sa la 1<r "
+ + +
--//这样也可以写成如下:
$ (cat a.txt ; dc -f a.txt -e "z [43P 32P la 1 - sa la 1<r ]sr sa la 1<r 10P"; echo pq ) | dc -f -
11110
3.测试执行效率:
--//测试这样改进的执行效率如何?家里没有linux的环境,使用cygwin 在windows下测试:
--//cygwin的执行效率并不是很高.
$ seq 100000 > b.txt
$ time dc -f b.txt -e "[+z1<r]srz1<rp"
5000050000
real 0m10.630s
user 0m0.000s
sys 0m0.015s
$ time dc -f b.txt -e "z [+ la 1 - sa la 1<r ]sr sa la 1<r pq"
5000050000
real 0m0.648s
user 0m0.000s
sys 0m0.015s
--//明显快了一大截。测试使用bc看看
$ paste -sd+ b.txt | bc -l
(standard_in) 1: Function too big.
--//拚接为1行时太长了,实际上操作bc 1行接受的行长度存在限制,看下面的测试.
$ time ((sed -e 's/^/s+=/g' b.txt ; echo s ) | bc -l)
5000050000
real 0m0.658s
user 0m0.061s
sys 0m0.045s
--//两者相差不大。
--//顺便测试一行最大容纳多少字符。
$ head -2499 b.txt | paste -sd+ | bc -l
3123750
$ head -2500 b.txt | paste -sd+ | bc -l
(standard_in) 1: Function too big.
$ head -2500 b.txt | paste -sd+ | wc
1 1 11393
$ head -2499 b.txt | paste -sd+ | wc
1 1 11388
--//我估计是超出bc一行能输入的字符数量的限制。因为head -2500 b.txt | paste -sd+可以正常执行。
$ time (head -2499 b.txt | paste -sd+ | bc -l)
3123750
real 0m0.535s
user 0m0.015s
sys 0m0.030s
$ time (head -2499 b.txt | dc -f - -e "z [+ la 1 - sa la 1<r ]sr sa la 1<r pq")
3123750
real 0m0.355s
user 0m0.000s
sys 0m0.046s
--//还是dc略胜一筹。我估计是因为bc的执行过程中使用paste拼接的原因。
$ head -2499 b.txt | paste -sd+ > c.txt
$ echo quit >> c.txt
$ time bc -l c.txt
3123750
real 0m0.146s
user 0m0.000s
sys 0m0.000s
$ head -2499 b.txt > c.txt
$ (dc -f c.txt -e "z [43P la 1 - sa la 1<r ]sr sa la 1<r "; echo pq ) >> c.txt
$ time dc -f c.txt
3123750
real 0m0.192s
user 0m0.000s
sys 0m0.031s
--//在写好计算公式的情况下，两者差不多，bc也许更快一些。
4.补充说明:
--//测试看看dc 以及bc 一行能接受字符的限制的具体数值.
$ head -2499 b.txt | paste -sd+ > c.txt
$ time bc -l c.txt
3123750
quit
real 0m2.148s
user 0m0.000s
sys 0m0.000s
--//尝试修改c.txt 增加文件第一行字符数量.仅仅增加1个字符就出现如下错误。
$ time bc -l c.txt
quit
c.txt 2: Function too big.
real 0m2.140s
user 0m0.015s
sys 0m0.000s
$ wc c.txt
1 1 11389 c.txt
$ ls -l c.txt
-rw-r--r-- 1 Administrator None 11389 2023-09-23 20:29:27 c.txt
--//文件是linux格式,删除最后1个字符0x0a以及插入的字符,bc的一行输入缓存是11387字符。
--//多次尝试我发现实际上情况比我前面的测试要复杂：
$ head -5 e.txt
1
1
1
1
1
--//建立一个全部是数字1的文件。
$ wc e.txt
40000 40000 80000 e.txt
--//共40000行。
$ paste -sd+ e.txt | bc -l
(standard_in) 1: Function too big.
$ head -8192 e.txt | paste -sd+ |bc -l
8192
$ head -8193 e.txt | paste -sd+ |bc -l
(standard_in) 2: Function too big.
$ head -8194 e.txt | paste -sd+ | wc
1 1 16388
--//放弃探究，有点离题了。
--//测试dc的情况：
$ head -2499 b.txt | paste -sd' ' > d.txt
$ ls -l d.txt
-rw-r--r-- 1 Administrator None 11388 2023-09-23 20:32:51 d.txt
$ (dc -f d.txt -e "z [43P la 1 - sa la 1<r ]sr sa la 1<r "; echo pq ) >> d.txt
$ time dc -f d.txt
3123750
real 0m0.181s
user 0m0.000s
sys 0m0.015s
--//增加1个字符看看，修改最后的2499 为 24991。
$ time dc -f d.txt
3146242
real 0m0.214s
user 0m0.000s
sys 0m0.015s
--//3123750 - 2499 +24991 = 3146242 , 结果正确。
$ paste -sd' ' b.txt > d.txt
$ (dc -f d.txt -e "z [43P la 1 - sa la 1<r ]sr sa la 1<r "; echo pq ) >> d.txt
$ time dc -f d.txt
5000050000
real 0m0.461s
user 0m0.000s
sys 0m0.015s
$ ls -l d.txt
-rw-r--r-- 1 Administrator None 688897 2023-09-23 20:41:58 d.txt
$ cat d.txt | dc -f -
5000050000
--//dc没有这个限制,甚至bash shell命令行的限制。
--//bash shell命令行的限制我记忆里各个版本不一致，好像最大可以达到128K，有一些甚至2621440。我不测试了。
$ getconf -a | grep -i arg
_POSIX_ARG_MAX 4096
NL_ARGMAX 9
ARG_MAX 32000
$ getconf ARG_MAX
32000
--//我的cygwin测试环境32000.
