博客园_Neil Chen's Blog

时隔3年，再做双倍超立方数的题目，这次用Lisp

2012-05-15T13:32:00Z

09年的时候，有一阵子大家都在做网易的“有道难题”里面的双倍超立方数问题。我当时看到题目后也随手用 Python 做了一下，但当时那个解法是最笨的穷举法，所以除了练习了一次 Python 的基本语法之外，也没有什么特别的收获了。

最近又把 SICP 翻出来看到了流这一部分。在我发自内心的赞叹那些用流描述的数列在形式上是何等优美的同时，我想实际测量一下应用了这么多复杂的流的函数操作之后，程序的执行效率如何。而双倍超立方数正好是一个适合拿来练习的题目。

这次我用的开发环境是 DrRacket. 这个东西的前身其实叫做 DrScheme. 是 scheme 的一种开发环境，在 Windows 上比较容易安装。而因为 SICP 是用 scheme 语言描述的，所以用这个环境来开发就是理所当然的事了。

双倍超立方数的表述形式为：

c = a^3 + b^3

对给定的c，如果有且只有两组正整数(a, b)使上式成立，那么c就称为双倍超立方数。

基于对称性，可以设 a <= b.

下面我们来观察一下从 1^3 + 1^3 开始的两个自然数的立方和组成的数列是怎样的：

容易观察到，上述图中的 (a, b) 组合是没有重复的。也就是说，这代表了所有 (a, b) 的可能的组合情况。双倍超立方数题目的要求是，比如我们需要求出不超过n（比如100万）的所有双倍超立方数的个数。如果我们能够对上述流中的数字在仅进行一趟从小到大的遍历，在遍历过程中判断出其中哪些立方和出现了2次，则可以有效的减少遍历的次数，得到答案。因此问题的关键转化为如何有效的按立方和从小到大的次序遍历上述矩阵。

可以看到，矩阵中横向、纵向、以及从左下到右上的每一条对角线方向上的数字的立方和都是单调递增的。但是很难直观的对整个矩阵找到这样一条单调递增的遍历路径。

进一步观察计算结果，可以发现，沿对角线方向的数字序列，两两数字之间的间隔最小。可以把每一条对角线上的数字序列定义为一个流，然后所有对角线组成的流进行合并（merge）。合并的方式是，依次取每个流的头部元素互相比较大小，按从小到大的次序组合进结果流中。因为按对角线方向元素间隔相对来说最小，在流进行合并的时候，能够连续的从同一个流中获取多个连续的元素，那么在合并时需要不断切换从不同的流中获取下一个元素的情况应该就比较少一些，如果实现得当，代码的局部性 (locality) 也许会比较好，也许合并算法上也可以有进一步优化的可能。（当然这个只是我目前的推断，还没有证实）

按照这个思路，整个问题解法的步骤如下：

1. 得到一个按大小顺序排列的两个数立方和的流（通过多个对角线的数字流 merge 得到）
在合并的同时，对每个和数出现的次序进行 count. 同时在结果流里面保留每个和出现的次数；
2. 对步骤1得到的流，进行过滤操作 (stream-filter)，仅保留上述出现次数恰好为 2 的那些结果；
3. 对步骤2得到的流计算长度 (stream-length），结果就是 <= N 的双倍超立方数的个数。

测试下来发现，N=100万的时候，执行速度还是非常快的，跟 Python 版解法的速度差不多。可以看到，利用流，以及作用于流的各种函数（filter, map, merge 等等操作）作为一种高级的数据结构抽象，可以从另一个角度理解问题。而因为流是惰性求值的，这个特性也使得运算的时间和空间开销等方面都处于一个可接受的范围。

下面是我调试通过的代码。其中还有很大的优化空间，比如很简单的就可以对同一个数字反复求立方的操作进行记忆，避免重复运算的时间开销。

代码的上半部分都是用来操作流的一些通用的帮助函数，有些是 SICP 书里的，另外有几个是我自己写的。双倍超立方数问题的相关实现可以直接看代码的后半部。

执行这个代码可以正确的打印出100万以下双倍超立方数的数目：43.

下面代码中关于流的一些辅助函数的解释，可以参考我上一篇随笔：Racket, SICP stream learning

#lang racket
;***********************************************
; 双倍超立方数问题求解。
;
; 木野狐(Neil Chen)@博客园
;
; 开发环境：DrRacket v5.2.1
; 2012-05-15
;***********************************************

;=========== 准备工作（流操作相关函数）开始 =====
(define (stream-car stream) (car stream))

(define (stream-cdr stream) (force (cdr stream)))

(define-syntax cons-stream
(syntax-rules ()
[(cons-stream x y) (cons x (delay y))]))

(define the-empty-stream '())

(define (stream-null? stream)
(null? stream))

(define (stream-filter pred stream)
(cond ((stream-null? stream) the-empty-stream)
((pred (stream-car stream))
(cons-stream (stream-car stream)
(stream-filter pred (stream-cdr stream))))
(else (stream-filter pred (stream-cdr stream)))))

(define (stream-ref s n)
(if (stream-null? s) the-empty-stream
(if (= n 0)
(stream-car s)
(stream-ref (stream-cdr s) (- n 1)))))

(define (stream-map proc . argstreams)
(if (stream-null? (car argstreams))
the-empty-stream
(cons-stream (apply proc (map stream-car argstreams))
(apply stream-map
(cons proc (map stream-cdr argstreams))))))

(define (stream-enumerate-interval low high)
(if (> low high)
the-empty-stream
(cons-stream low
(stream-enumerate-interval (+ low 1) high))))

(define (enumerate-interval low high)
(if (> low high)
'()
(cons low
(enumerate-interval (+ low 1) high))))

(define (stream-length stream)
(define (iter s acc)
(if (stream-null? s) acc
(iter (stream-cdr s) (+ 1 acc))))
(iter stream 0))
;=========== 准备工作（流操作相关函数）结束 ======

(define (integers-starting-from n)
(cons-stream n (integers-starting-from (+ n 1))))

(define integers
(integers-starting-from 1))

(define (cube n)
(* n n n))

(define cube-numbers
(stream-map cube integers))

(define (merge-with-count s1 s2)
(cond ((stream-null? s1) s2)
((stream-null? s2) s1)
(else
(let ((s1car (stream-car s1))
(s2car (stream-car s2)))
(let ((e1 (if (list? s1car) (car s1car) s1car))
(c1 (if (list? s1car) (cadr s1car) 1))
(e2 (if (list? s2car) (car s2car) s2car))
(c2 (if (list? s2car) (cadr s2car) 1)))
(cond ((< e1 e2) (cons-stream (list e1 c1)
(merge-with-count (stream-cdr s1) s2)))
((> e1 e2) (cons-stream (list e2 c2)
(merge-with-count s1 (stream-cdr s2))))
(else (cons-stream (list e1 (+ c1 c2)) (merge-with-count (stream-cdr s1) (stream-cdr s2))))))))))

(define (stream-merge-with-count . argstreams)
(if (= 0 (length argstreams))
the-empty-stream
(merge-with-count (car argstreams)
(apply stream-merge-with-count (cdr argstreams)))))

; 得到第 n 条对角线上的数字的流
(define (diag n)
(stream-map (lambda (i)
(+ (cube i)
(cube n)))
(stream-enumerate-interval 1 n)))

(define (new-double-cubic-numbers-below n)
(let ((max (floor (expt (- n 1) (/ 1 3)))))
(stream-map car
(stream-filter
(lambda (s)
(and (list? s)
(= 2 (cadr s))
(not (> (car s) n))))
(apply stream-merge-with-count
(map diag
(enumerate-interval 1 max)))))))

(stream-length (new-double-cubic-numbers-below 1000000))

本文链接

Racket, SICP stream learning

2012-05-10T17:23:00Z

在 windows 上重新安装了最新的 Racket 5.2.1.

恍然发现，Common-Lisp 的安装真的比较坑爹啊，Racket 可能才是研究和学习 lisp 比较理想的选择！

不管是 Windows 还是 Ubuntu，自学习 Lisp 以来，Common Lisp 的各种实现 + 开发环境也安装了很多了，每一个配置起来都比较麻烦，也都有这样那样的问题。而相比而言，安装 Racket 却超级傻瓜化。

一番周折后，终于调通了 SICP 220 页开始的对于 stream 的一些示例代码。其中需要注意的是：

书中提到的 cons-stream 是一个 special form, 但是我一开始写成了简单的 function 如下：

; this won't work as a simple function
(define (cons-stream a b)
(cons a (delay b)))

但这个实际是是不 work 的。如果流比较大或者是无限流，几乎一定会导致无限递归、内存溢出。解决的办法参考了 stack overflow 上一个答案，利用 Racket 的 define-syntax 语法定义宏。其实和 Common Lisp 里宏有点接近，只是定义时使用的语法有差异，用到方括号，详见代码。

和 Common Lisp 中列表的 subseq 函数相似，我简单的实现了一个 stream-subseq 函数，用于截取流中某一区间的子序列，配合 display-stream 函数打印会比较方便的了解流中间任意一段的信息，后面的测试输出代码我基本都这么写了。

通过无限流移位后相加、相乘甚至配合其他运算进行任意组合，是流使用起来感觉最妙的地方。代码中包含了 SICP 原书中附带的一个筛法求素数序列的实现。

通过几个例子简单的试验下来发现，的确 stream 的功效是强大的。因为本质上每一步计算都是惰性求值，所以即使是要估算序列中很后面的数值，也不会像列表那样带来很多分配空间的开销。斐波那契数列可以轻而易举的算到很后面。下面是我调试通过的测试代码：

#lang racket

;(define (delay exp)
; (lambda () exp))
; ;(memo-proc (lambda ()
; ; exp)))
;
;(define (force delayed-object)
; (delayed-object))
;
;(define (memo-proc proc)
; (let ((already-run? false) (result false))
; (lambda ()
; (if (not already-run?)
; (begin (set! result (proc))
; (set! already-run? true)
; result)
; result))))

(define (stream-car stream) (car stream))

(define (stream-cdr stream) (force (cdr stream)))

; this won't work as a simple function
;(define (cons-stream a b)
; (cons a (delay b)))

; This is scheme syntax for macro
; http://stackoverflow.com/questions/5610480/scheme-sicp-r5rs-why-is-delay-not-a-special-form
(define-syntax cons-stream
(syntax-rules ()
[(cons-stream x y) (cons x (delay y))]))

(define the-empty-stream '())

(define (stream-null? stream)
(null? stream))

(define (stream-filter pred stream)
(cond ((stream-null? stream) the-empty-stream)
((pred (stream-car stream))
(cons-stream (stream-car stream)
(stream-filter pred (stream-cdr stream))))
(else (stream-filter pred (stream-cdr stream)))))

(define (stream-ref s n)
(if (stream-null? s) the-empty-stream
(if (= n 0)
(stream-car s)
(stream-ref (stream-cdr s) (- n 1)))))

(define (stream-map proc . argstreams)
(if (stream-null? (car argstreams))
the-empty-stream
(cons-stream (apply proc (map stream-car argstreams))
(apply stream-map
(cons proc (map stream-cdr argstreams))))))

(define (stream-for-each proc s)
(if (stream-null? s)
'done
(begin (proc (stream-car s))
(stream-for-each proc (stream-cdr s)))))

; Neil, 2012-05-10
(define (stream-subseq stream a b)
(cond ((stream-null? stream) the-empty-stream)
((= a b) the-empty-stream)
((> a b) the-empty-stream)
(else (cons-stream (stream-ref stream a)
(stream-subseq stream (+ a 1) b)))))

(define (display-line x)
(newline)
(display x))

(define (display-stream s)
(stream-for-each display-line s))

; examples
;(let ((x (delay (+ 1 2))))
; (for ([i (in-range 1 10)])
; (display (force x))))
;
(define (integers-starting-from n)
(cons-stream n (integers-starting-from (+ n 1))))

(define integers
(integers-starting-from 1))

;(display-line (stream-ref integers 0))
(let ((x (stream-subseq integers 10000 10010)))
(display-stream x))

(define odd-numbers
(stream-filter odd? integers))

(display-stream (stream-subseq odd-numbers 50 60))

;(let ((x (cons-stream 1 (cons-stream 2 '(3)))))
; (display-stream x))

(define (stream-add s n)
(stream-map (lambda (x)
(+ x n)) s))

(define (add-streams s1 s2)
(stream-map + s1 s2))

(define fib
(cons-stream 1
(cons-stream 1
(add-streams fib
(stream-cdr fib)))))

(display-stream (stream-subseq fib 150 160))

(define (divisible? x y)
(= (remainder x y) 0))

(divisible? 10 2)

(define (sieve stream)
(cons-stream
(stream-car stream)
(sieve (stream-filter
(lambda (x)
(not (divisible? x (stream-car stream))))
(stream-cdr stream)))))

(define primes
(sieve (integers-starting-from 2)))

(display-stream (stream-subseq primes 1000 1010))

接下来打算认真体会一下书中提到的欧拉发明的序列加速器的算法。真的是很厉害的 idea.

本文链接

Operation is not valid due to the current state of the object

2012-04-28T10:17:00Z

在一个 asp.net webform 的程序 postback 时，碰到了这个异常，而且无法调试。

Google 了一下，发现原因原来是 asp.net 对一个 form post 的字段数有限制，在打过最新的安全更新后，这个限制的数目是1000个，超过了就会报这个异常。

解决的办法是在 web.config 里面加一个设置，增大这个限制值：

而为什么会有这么多 field 被提交呢，我这个页面用了一个 Telerik 的 RadGrid，其中每一行都有一个 checkbox 进行多选提交，但记录数才100多条，远没到1000.

看来原因可能是 telerik Grid 生成的 html 里面，多生成了很多非必要的表单字段，用来维护一些状态信息之类的，导致表单提交的字段数膨胀了几乎10倍。如果改用轻量级的表格自己实现的话，优化的空间还是很大的。

http://stackoverflow.com/questions/8832470/operation-is-not-valid-due-to-the-current-state-of-the-object-error-during-pos

本文链接

lisp 笔记 - 闭包

2012-03-21T03:25:00Z

一般语言由 primitives 组成, lisp 由 meta-primitives 组成。lisp 不定义 primitives. “Any time there is a primitive, there is a barrier, a non-orthogonality, in the design of the system.”

let 用来创建 lexical scope.

lexical scope 的好处是这些绑定在编译后不需要为其实际分配任何内存 slot, 甚至一些显而易见的逻辑会被直接编译优化成简单的常量。

lisp 中 dynamic scope 通过 defvar 创建，类似于全局变量。dynamic scope 的变量必须在 environment 中开辟实际内存区域（runtime). 因此性能可能稍微不如 lexical scope. dynamic scope 的变量在遇到同名的 lexical scope 变量时可能被 shadow. shadow 的过程实际是在进入 lexical scope 时在 dynamic scope 的那个 environment 中先备份原来的值，然后改写该值，在退出 scope 前再次从备份中恢复原来的值。

let over lambda 是用来创建闭包的惯用法；

闭包本质是 state + 1个 function.

object 是 state + multiple functions.

在 let over lambda 结构中用 values 返回多个引用了相同 bindings 的 lambdas，可以实现 class 和 object.

let over lambda over let over lambda 可以实现 class variable (static variable).

let + lambda 的各种组合用法可以实现大多数语言中的 OO 系统特性。该组合甚至可以实现更独特的一些应用场景。抛开继承，在大多数情况下一个 OO 系统是不必要的。OO 系统是基于 let 和 lambda 的一种特定实现。

本文链接

Common Lisp 在 Windows 上的开发环境比较

2011-12-30T17:05:00Z

经过最近试验用 EMacs 玩 Lisp 后，发现在 Windows 上使用各种坑爹：

快捷键不符合 Windows 正常操作习惯（当然也可以用插件模拟，不过麻烦）；

点击菜单经常假死；

切换 buffer 经常会假死；

实在受不鸟了。

重新切换回去用之前配置的 Eclipse + CUSP 插件，发现原来是没学会怎样使用——比如不知道怎样仅仅 Eval 一段选中的表达式。现在会了，重新用上了现代 IDE 各种爽。

本文链接

翻译英文技术文章是一件很可耻的事情吗？

2011-12-29T05:57:00Z

不知从何时起，在博客园首页上我看到了越来越多的翻译文章，其特点是 —— 仅阅读标题或者 80% 甚至 90% 的正文，你无法判断这是一篇译文。而英文文章原作者的名字都被可耻的藏匿到了翻滚好几屏以后的最底端。作为一个老的博客园用户，我心生疑惑：难道翻译别人的文章是一件很可耻的事情吗？这么见不得人？

根据我本人的学习成长经验，在翻译原文文章的过程中，当你逐字逐句体会一篇经典时，译者自身也能得到技术上更细致的体会和认识。这就和我们学习编程时，习惯照书敲一遍代码是一个道理。我想这应该也是大部分译者的目的吧？—— 在自己提高的同时，顺带造福别人。

每个人学习技术都有一个成长阶段的。一般看的原文文章多了之后，渐渐的就只看原文的了，可能逐字逐句来翻译的时间也变少了，通过快速浏览原文就可以对某个技术获得认知。通过翻译文章来提高技术，也渐渐变成了一项奢侈的时间投资。当然，也有人会完全出于公益的目的，翻译很多文章或者书籍来造福初学者或英文不太好的同行。

不管是哪种目的，出于对原文作者最起码的尊重，我真诚的建议：大家在翻译文章时应该在一开头就写明该文章是译文，原作者是谁，以及原文的链接。

对翻译技术文章你有什么看法？欢迎讨论。

本文链接

写了个博客备份的 ruby 程序

2011-12-28T16:58:00Z

现在网上账号随时都有被盗的危险，感觉不太放心，于是用 ruby 做了一个备份我在博客园的所有随笔的小程序，总共只用了110行代码，包括长段的注释，还是面向对象，结构良好的。

第一次写正经的 ruby 程序，发现抽象层次高的语言做事情就是省心省力啊，爽。

本文链接

体验 Clozure CL

2011-12-19T17:43:00Z

Clozure CL 简称 CCL. 网站在 http://ccl.clozure.com/

是一个高性能的开源 Common Lisp 实现，其特性包括 native 线程的支持等等。还包括一个 IDE，但好像只是 for Mac 的。windows 上估计跑不起来。不过不要紧，我也可以将它 setup 到 Emacs 中。

CCL 可以通过 svn 直接下载到本机的一个目录。然后打开 .emacs.d\init.el 文件，将原先 clisp 的配置注释掉，加入一行指向 CCL 的 exe 即可：

;(setq inferior-lisp-program "clisp")
(setq inferior-lisp-program "e:/ccl/wx86cl.exe")

接下来我简单的测试对比了一下 clisp 和 CCL 的性能。各进行1千万次简单的加法运算：

clisp:

CL-USER> (time (loop for i from 1 to 10000000 do (+ 100 100)))
Real time: 16.82791 sec.
Run time: 16.8125 sec.
Space: 4580 Bytes
NIL

CCL:

CL-USER> (time (loop for i from 1 to 10000000 do (+ 100 100)))
(LOOP FOR I FROM 1 TO 10000000 DO (+ 100 100)) took 78 milliseconds (0.078 seconds) to run
with 2 available CPU cores.
During that period, 78 milliseconds (0.078 seconds) were spent in user mode
0 milliseconds (0.000 seconds) were spent in system mode
32 bytes of memory allocated.
NIL

天壤之别！CCL 还利用上了我电脑上的双核 CPU. 比较下来 clisp 的性能可以用垃圾来形容。而且，CCL 是支持多线程的，clisp 不支持。

虽然 clisp 性能差，不过，目前来说保留它的理由是可以用来运行 Portable Allegro Serve 的代码。而我粗略的试了一下在 CCL 下跑这个代码会报错。

本文链接

试用 Portable Allegro Serve

2011-12-15T11:34:00Z

安装好 Common Lisp 的开发环境后，想试试看 web 开发。

虽然 Allegro Serve 运行起来更简单，但是要在 Allegro CL 中运行，而后者是个商业软件，暂时我没有购买的打算。退而求其次，只好用 Portable Allegro Serve.

这个开源代码貌似很久没更新了。下载后，运行出了很多小问题。简要记录如下：

用 CLisp 来运行的时候，可能下载的 aserve 代码里包含的那些中间文件是由其他 lisp 实现生成的，也可能是 clisp 的早期版本，会报错误提示这些中间文件 out-dated 了。解决的办法很简单，只要将 aserve 代码的子孙目录中所有 .fas 和 .lib 文件全部删掉即可，可以写个简单的脚本来做这个 clean 的工作。删掉后，重新加载时会自动重新生成这些中间文件。这个非常类似于 Python 的 .pyc 文件。
加载 install.lisp 的时候会报一个函数调用 ipaddr-to-dotted 找不到。这是因为代码里有个地方的调用少写了该函数所在包的前缀。解决办法是，打开 aserve\log.cl, 找到这个函数调用的地方，将函数写法替换为 acl-compat.socket:ipaddr-to-dotted 即可。
执行 (start :port 8080) 启动服务器的时候，会报错如下：

Evaluation aborted on #<SIMPLE-TYPE-ERROR #x1A2AAEF9>.
Lisp connection closed unexpectedly: connection broken by remote peer

首先需要通过 Emacs 里打开 *inferior-lisp* buffer，然后重新加载这些代码来测试。得到一个更为详细的错误：

*** - FUNCALL: undefined function ACL-COMPAT.MP:MAKE-PROCESS

可以判断是因为 clisp 不支持多线程造成的问题。

解决办法：启动 aserve 多提供一个参数如下：

(start :port 8080 :listeners 0)

本文链接

Windows XP, Emacs, CLisp, SLIME

2011-12-14T05:09:00Z

LispBox 已经不再维护了，很多代码跑不起来，只好手工配置这套工具。

终于搞定了所有的安装配置，好麻烦。其中 clisp 最新的2.49版本配置了总是报错，只好用2.48版。其他都是当前最新的。

Emacs 23.3

CLisp 2.48

SLIME (CVS current snapshot)

安装的步骤如下。

首先下载 clisp 2.48 的 exe 版本，安装到 c:\clisp.
打开 CLisp，查看当前 HOME 目录的位置。方法是输入 (user-homedir-pathname). 找到后，在其中建立一个空的文本文件命名为 .clisprc.lisp.
我机器上的目录如下：C:\Documents and Settings\[UserName]\.clisprc.lisp
安装 Emacs. 直接将下载的 zip 包解压到一个目录就好。我是 c:\emacs.
下载 SLIME 的 CVS 快照版本，解压到 c:\emacs\slime-2011-12-13
打开 Emacs，确定当前的 HOME 目录。方法是输入 (insert (getenv “HOME”)) 命令后输入 C-c C-e 来执行，看输出。我机器上得到的结果是：
C:\Documents and Settings\[UserName]\Application Data
建立一个文本文件到：
C:\Documents and Settings\[UserName]\Application Data\.emacs.d\init.el
输入内容如下并保存：

安装 Quicklisp. 下载 quicklisp.lisp 后，打开 CLisp 控制台 load 该文件，然后执行之，按提示执行安装命令即可。
修改配置文件 C:\Documents and Settings\[UserName]\.clisprc.lisp 如下：

安装过程完全参考的这里：http://yellosoft.us/installing-common-lisp

接下来可以大干一场了。

本文链接