[Haskell] Read the contents from the clipboard in Haskell

有時候只是想要做一點簡單的事情的時候，其實會直接貼上 string 做處理。但是因為不知道怎麼在 ghci 上貼入 multiple line string，所以想到可以直接讀取複製的內容直接做處理。

在 Mac OSX 裡有一個相當好用的指令是 pbpaste，可以直接蛉出在剪貼簿中的指令。開一個 subprocess 把指令的 output pipe 進來就可以了。嘗試如下。

嘗試執行結果如下

Prelude> :l read_pbpaste.hs
[1 of 1] Compiling Main             ( read_pbpaste.hs, interpreted )
Ok, modules loaded: Main.
*Main> import Data.Char
*Main Data.Char> processPaste Data.Char.to
Data.Char.toLower  Data.Char.toTitle  Data.Char.toUpper
*Main Data.Char> processPaste $ map Data.Char.toUpper
Loading package array-0.4.0.1 ... linking ... done.
Loading package deepseq-1.3.0.1 ... linking ... done.
Loading package filepath-1.3.0.1 ... linking ... done.
Loading package old-locale-1.0.0.5 ... linking ... done.
Loading package time-1.4.0.1 ... linking ... done.
Loading package bytestring-0.10.0.2 ... linking ... done.
Loading package unix-2.6.0.1 ... linking ... done.
Loading package directory-1.2.0.1 ... linking ... done.
Loading package process-1.1.0.2 ... linking ... done.
ING PACKAGE ARRAY-0.4.0.1 ... LINKING ... DONE.
LOADING PACKAGE DEEPSEQ-1.3.0.1 ... LINKING ... DONE.
LOADING PACKAGE FILEPATH-1.3.0.1 ... LINKING ... DONE.
LOADING PACKAGE OLD-LOCALE-1.0.0.5 ... LINKING ... DONE.
LOADING PACKAGE TIME-1.4.0.1 ... LINKING ... DONE.
LOADING PACKAGE BYTESTRING-0.10.0.2 ... LINKING ... DONE.
LOADING PACKAGE UNIX-2.6.0.1 ... LINKING ... DONE.
LOADING PACKAGE DIRECTORY-1.2.0.1 ... LINKING ... DONE.
LOADING PACKAGE PROCESS-1.1.0.2 ... LINKING ... DONE.
HTTPS://EN.WIKIPEDIA.ORG/WIKI/CONTINUATION-PASSING_STYLE
*Main Data.Char>

---

2013/09/08 09:17 AM 早上試一下，還可以這樣子幹也蠻方便的

Prelude System.Process> putStrLn =<< readProcess "pbpaste" [] []
http://hackage.haskell.org/packages/archive/process/1.0.1.1/doc/html/System-Process.html
Prelude System.Process> import Data.Char
Prelude System.Process Data.Char> putStrLn . (map toUpper) =<< readProcess "pbpaste" [] []
HTTP://HACKAGE.HASKELL.ORG/PACKAGES/ARCHIVE/PROCESS/1.0.1.1/DOC/HTML/SYSTEM-PROCESS.HTML

所以想要寫完全沒有彈性的碼可以這樣子寫。

epub 簡轉繁

我知道這個題目已經做到爛掉了，不過在之前看到 OpenCC Projrect，決定利用一個中午休息時間把 epub 簡體轉繁體 + OpenCC 這件事做完。

暫時成果在 epubs2t_opencc.py。

下載之後，只要輸入 python epubs2t_opencc.py filename 即可轉檔。

這個檔案最大的問題是，其實 opencc-python 安裝會失敗，必需自己 download source code 之後，在該 source code folder 加上 distributed_setup.py 之後執行 python setup.py install，才有辦法把 opencc-python 安裝成功(或許我應該送一個 patch 給原作者 XD)。

這也算是剛當完兵後寫寫小程式的暖身吧，還是要趕快開始念書才是。

---

更新 2013/09/01 10:49 AM - 我直接參考 opencc-python package 的內容，直接把該 function 貼上到 epubs2t_opencc.py裡。現在直接下載不需額外安裝其他套件即可使用，使用方法仍然是 python epubs2t_opencc.py filename，但是需安裝 opencc 才可以使用。如果有需要，我再分別寫 Mac OSX 和 Fedora, ubuntu 的使用文件(其實不難寫，只是我好懶 XD)。

中文直書與 Kindle DX

其實我在兩年前寫了關於 Kindle DX 如何閱讀中文小說的 blog，但是其實後來自己對於這樣子的方法不甚滿意，最主要的原因是。

用橫書看金庸感覺很怪 XD

但是我又是個懶人，於是這問題一直放著，一直到現在 iPad 或者是 Android 平板都有出相應的好讀網站閱讀軟體，我自己用 KDX 也是看英文居多，於是這問題就一直一直放著 ... 直到我開始看 "明朝的那些事兒"。剛開始我是用我自己的 ipod touch 看的 ... Orz，其實非常的耗時 (因為我翻了好多好多頁)，後來索性再看看現在 KDX 破解的現況，KDX 現今可以看中文的破解，大抵上來說都是換掉內建的字體，比較好的可以做到英文字體是原本 KDX 內建，中文是黑體，也就是說，可以直接看中文的 mobi 檔，但是，它還是橫書 XD。只是那一瞬間覺得不能再懶下去了，所以乖乖來找解決方案。

如果自己不想去 hack KDX 但是又想看直書，最快的方法，把文字複製到 Word 上貼上，然後設定成直書之後輸出成 PDF 應該就解決了 XD 可惜我比較喜歡用 LaTeX ，所以就使用了一個簡單的方法: 在 XeLaTeX 上的 xeCJK package 配合 fontspec package 可以直接把字旋轉 90 度並中文輸出就可以了。最主要關於字型的設定如下

# use fontspect package
\usepackage{fontspec}
  
# use xeCJK package
\usepackage{xeCJK}     

# set CJK main font and rotate
\setCJKmainfont[Vertical=RotatedGlyphs]{Hei TC}

最主要的設定只有最後一行，其他的都是使用所需要的套件，於是乎，剩下的就是讀出內容，加上 header 和 footer 形成 tex 檔，然後 complie 生成 pdf 檔，丟到 Kindle DX 上，收工。

在 Kindle DX 上的效果如下圖，照片中所使用的字體是 "華康明體 Std W5"，實際看起來對比照片略粗

為此，我自己寫了一個簡單的好讀網站的 pdb file 轉成 tex file 的小程式，也符上一個簡單的 XeLaTeX template，皆放在 github 上，如果有使用上的問題，歡迎留言或來信。

github: PDB-TeX-Converter

其中有幾點討論如下。

1. 為什麼生出來的檔案沒有頁碼 ?
   頁碼在 LaTeX 直書排版上一直是一個很大的問題，但是 Kindle DX 本身就有頁碼，所以直接省略。
2. 為什麼不讀 updb 檔 ?
   我嘗試搞了幾個晚上之後放棄，我對於編碼實在是不了解，如果可以，我會試試看。
3. 如何使用 XeLaTeX ?
   這個要講要講很久，在 Mac OSX 上是安裝 MacTeX，在 Linux 上是安裝 TeXLive，在 Windows 上 ... 嗯，應該是 TeXLive，但是我沒研究 XD。如果你使用的是 Mac OSX 或者是在 Linux 從 package manager 直接安裝 TeXLive，這隻小程式在運作上應該不會有問題。目前已知在安裝好 MacTeX 2011 的 Mac OSX 上運作可直接生出 pdf 檔。
4. 如何知道字體的英文名稱?
   首先，先行建立字體列表，在 command line 中輸入fc-cache -f -c -v接下來，在 command line 中輸入fc-list
   即可看到字體的相對應英文名稱，在上面的範例是 Hei TC，這其實就是 Mac OSX 中的 "黑體 TC"。
   

---
這個應該是很小眾的需求 XD。

---

2012/06/07 --- 根據 Josh Ko 的建議，還是使用直向直書模式，不過生出來的 pdf 需手動旋轉頁面。示範圖更新如上，代碼更新已上傳至 github 。

2012/08/08 --- 根據 anynomous 的建議，天火藏書排版系統是現有的方案，而我自己也已經建立了一個新專案為 convert2tex ，主要是可以把 epub/ txt/ pdb (限好讀網站格式)轉換成 tex 檔和支援簡體轉繁體。雖然現在已經是 stable，但還在補強中，修好就會上傳並說明關於這個專案。(可能會很久很久 XDXD)

在 Mac OSX 下觀看 process 的記憶體使用量

寫這個小程式的目的只是想知道 Chrome 總共吃了多少記憶體而己 ... Orz (我好無聊 XD)

這件事其實很簡單，但是我不太會用 shell，所以仿造 godfat 以前寫的 mem_usb.rb (原 po 提供連結了 XD)(連結找不到了 XD)。寫了一個簡單的 proc_mem.py 程式碼如下

#!/usr/bin/env python
import subprocess
import sys

def main():
    proc_name = sys.argv[1] if len(sys.argv) >=2 else "Google Chrome"
    proc_list = subprocess.check_output(["ps", "-Ao", "rss,comm"])
    print str(sum([int(proc.split()[0]) for proc in proc_list.split('\n') if proc.count(proc_name)>0])/1024.0) + " M"

if __name__ == "__main__":
    main()

使用上很簡單，輸入你想看的 process 名字就可以看到了，如果什麼都不輸入，預設是 "Google Chrome"。

---

我的 Google Chrome 吃了 3.5 gb 啊 ... (遠目)。

[Note] A small difference between Haskell and Python in FP

我不得不說，寫關於數學的東西，Haskell 看起來真的漂亮的多。舉個例子來說說，我想要寫的 function 是

m = 8
rs_m = 0.9 
gramma = 6.27
d_st(a_st) = 1+m*a_st
d_dyn(a_dyn) = rs_m + (1-rs_m)*a_dyn
d(a_st, a_dyn) = d_st(a_st)/d_dyn(a_dyn)

用 Haskell 寫的話，其實跟上面很像 XD

d_st a_st = 1 + m*a_st
d_dyn a_dyn = rs_m + (1-rs_m)*a_dyn 
d a_st a_dyn = (d_st a_st)/(d_dyn a_dyn)

用 Python 寫的話，就會變成 ...

delta_st = lambda alpha_st: 1 + 8*alpha_st
delta_dyn = lambda alpha_dyn: rs_m + (1-rs_m)*alpha_dyn
delta = lambda alpha_st, alpha_dyn: delta_st(alpha_st)/ delta_dyn(alpha_dyn)

用 Python 最大的問題是 ... 看不太到參數，當然可以用 def delta(alpha_st, alpha_dyn): ... 寫，只是我好懶，其實也不是很大的差別(當然在其他的特性上會差很多)，不過就基本的寫法來說，我還是比較喜歡 Haskell 的。這或許也有可能是某個程度寫 Python 寫到累了想換新口味 XD? 就很單純的想法嘍 XD。

---
單純記錄 XDXD。

gcc Notes

最近 blog 應該會有很多這種小型文章，暫時記起來備忘 XD。

Basic Profiling with gcc

其實沒很難，重點是知不知道而己。這是我最近無聊看文件發現的。假設我們有一個 main.cpp 那麼編譯的時候，加入 -pg option 在這個範例中，產生的是 main.out 的執行檔

g++ -g -Wall -pg main.cpp -o main.out

接著執行該程式

./main.out

那麼會得到一個 gmon.out，這個時候再執行。

gprof main.out gmon.out

那麼你應該就看到一堆資訊吐出來，而在最後的部分

granularity: each sample hit covers 4 byte(s) no time accumulated
  %   cumulative   self              self     total           
 time   seconds   seconds    calls  ms/call  ms/call  name    
  0.0       0.00     0.00   176165     0.00     0.00  __ZN2LS17 ...
  0.0       0.00     0.00   148611     0.00     0.00  __ZN2LS23 ...
  0.0       0.00     0.00   122722     0.00     0.00  __ZN2LS17 ...
  0.0       0.00     0.00   100775     0.00     0.00  __ZN2LS7 ...
  0.0       0.00     0.00   100226     0.00     0.00  __ZN2LS7 ...

可以看到每個 function call 被呼叫的次數及使用了多少時間。

昨天剛發現這個技巧，這代表我真的對 gcc 不夠熟。不然這個技巧蠻有趣的，可以快速的看出一些基本的事。不過這個方法的問題就是我不熟，其實在這個表的原始的 name 真的蠻醜的 ... 不知道是不是 C++ 的關係，有空再測測看了 XD。

gdb - print macro

在 GDB中应该知道的几个调试方法 - Coolshell.cn 看到的，必要的時候可以在編譯的時候加上參數

-ggdb3

nm

看 symbol file 的好工具，雖然知道很好用，不過目前功力不足，但是先記著吧

---
純粹記錄，我的功力還是好弱 ... Orz

小試牛刀 - 算出檔案每一列的總和

今天處理程式的時候，遇到一個很簡單的檔案，長的如下

19 2 1 1 1
6 2 0 0 0
1 2 0 0 0
3 2 0 0 0
3 1 0 0 0
4 2 2 2 2
...

每一行代表一筆資料，然而，我想要得到每一列的總和。這其實是一個很簡單不過的題目，大一程式設計就可以寫的出來 XD。那麼有趣之處是什麼 XD? 如果我用 Python 來撰寫的話，要怎麼樣才可以寫的很有趣 ?

首先是讀檔，轉換資料成一個 list。我不打算浪費太多時間在寫這個方面，所以我是用暴力法撰寫。

f = open('filename.txt', 'r')
data = [[int(d) for d in l.split()] for l in f.readlines()]
f.close()

這樣子我們可以得到一個 list of list，每一個 element 的 type 皆為 integer，所以問題是，如何得到每一行的縱向總和 ? 直覺方式是雙層迴圈來搞定，這可能是最快也最直接想到的方法，不過我不想要，因為我覺得這實在是不美好 XD。就我的想法是，我當下想到的是 fold， fold list of list to a list. 稍微想了一下，就寫出了下面這行 code

sum_list = reduce(lambda x, y: [u+v for u, v in zip(x,y)], data)

其實用 Haskell 寫會更漂亮 ... 不過我還沒學 monad ... Orz (趕快學!!)

---
臨時筆記 XD

程式架構雜想

最近一直都在嘗試設計對於自己而言一個比較大型的程式，這對我而言算是很充滿挑戰性的事，因為我從來沒有用過正規方法來設計這樣子的一個程式，我一直以來都是且戰且走型，這也難怪我的程式一直都寫不大，不然就是充滿破爛 XD。

庖丁解牛，恢恢乎游刃而有餘。 - 莊子

這大概是我對於設計架構上最大的感想，基本上我還是非常習慣紙筆思考，對我而言，不管是傳統的 OO 設計方式抑或是 eXtreme Programming 的設計方式 (在這幾天終於了解為什麼會叫 eXtreme 了，誤用真的很危險)，事前的分析與設計是一定需要的，如果一開始的需求就是固定不太會變動，其實傳統的 OO 設計方式應該是相當的夠用，重點是，如果在途中一半更改需求的時候該如何因應 ? 這是我這次設計程式不會遇到的問題。我想我可以日後再好好的想想，因為我也不覺得用 XP 會是最佳解。

如果是設計演算法的程式時，其實我覺得算是最好設計的，但是在轉換上的時候，必需對數學的 set 要有一定程度的認知及轉換上的經驗(基本上 set 可以表示任何事情，int 也是一個數學的 set，一個 struct 也是一個 set，只是是一個 set * set ...)，也就是說，如果轉換到一個夠簡單夠容易處理的模型，要設計起來也相對容易的多。但是對於 set 的轉換，其實到目前還是沒有頭緒，以後想到再補述好了。

架構設計的時候，ycma 建議的是 top-down approach，而我自己使用的是 button-up approach，他很堅持我的方法是錯的，會造成寫程式時候的災難，不過我還是蠻堅持先用 button-up run 過一次，再使用 top-down 把所有東西連起來，因為兩種方法的交錯使用，讓我學到很多事，在此在思考，是否只用 top-down approach 就可以解決呢，我不這樣子覺得，這或許也是等到設計完的時候，會有一些有趣的事發生。

設計架構會遇到的三個主要問題，data consistency, unduplicated code, consider function side effect，最後一個其實是最好解決的(拜 Functional Programming 所賜，現在寫程式很想會觀察 code 之間的相依性，把 code 視為一個 block，雖然這不是 FP 的主意，但是我卻是因為這樣子學會的 ... Orz)，data consistency 一開始的設計就很重要，我會嘗試把資料集中放在少數幾個 Class 裡，其他使用 id 存取 (不一定非得用 Pointer or reference，有時候我太執著於用語言的層面來解決這個問題，不過這個問題的確也是還在思考)，而 unduplicated code 是最困難的，因為很容易會有相同的功能，這也不是用個 Generic Type 就可以把這個問題處理的很好，這目前還在思考怎麼辦。

基本上算是雜亂的記錄，希望一個月過後，自己再看到這一篇的時候，能給自己一些解答。

---
如果錯的話，就指正吧，我好久沒有寫技術文了，雖然這篇也稱不上技術文就是了 XD。

Synopsys Design Compiler Primer

這篇只是單純做個紀錄。最主要還是要感謝 ycma 寫了一個 sample script，我只是從中學習到一些事 XD。

其帢從 shell 底下打 design_vesion 就可以進入 GUI 畫面，但是每次進去都有重覆要設定的，而且重覆修改程式之後每次都用 design_version 的話並不是一個好動作，而 design compiler 提供一個 dc_shell，Synopsys 公司用的都是 tcl script，所以如果會撰寫的話會可以省下相當多的重覆性工作。

那麼寫 dc_shell command 會很困難嗎 ? 其實不會，design_version 打開後執行相對應的動作，都可以看到相對應的指令顯示在最下方，照抄就可以了。根據這個簡單有效的方法(還有記得參考本身的 doc)，很快就可以寫出如下的 script

set COMPILEFILE {decoder.v reg.v reg_entry.v}
set MAINMODULE "RegisterFile"

set search_path {., /cad/celllib/CBDK90_UMC_Faraday/CIC/SynopsysDC/db}
set target_library {fsd0a_a_generic_core_bc.db}
set symbol_library {fsd0a_a_generic_core_bc.sdb}
set link_path {fsd0a_a_generic_core_bc.db}
read_file -format verilog $COMPILEFILE
current_design $MAINMODULE
create_clock -name "clk" -period 10 -waveform { 0 5 }  { clk }
compile -exact_map

report_timing
report_area

exit

其實 tcl 蠻好懂也蠻難用的 (汗)，這個 script 也算的上是一目了然，大抵上來說讀入三個 Verilog File ，指定主要 Module 為何，指定 clock 訊號線，然後 Compiler 接著報告出 slack time 與晶片使用面積為何。

如果想要知道指令更多的 option，可以在 dc_shell 使用 man ，如果我今天想要知道的 report_area 的話，那麼會出現如下畫面

dc_shell> man report_area
2.  Synopsys Commands                                        Command Reference
                                  report_area

NAME
       report_area
              Displays area information for the current design or instance.
...

可能有需要我才會去查更多的細節吧，暫時先這樣子做個非常粗略的筆記嘍 XD

---
這篇是寫給自己看的，不然品質實在是不怎麼樣 XD

FLOAC 10 - Program Construction and Reasoning Quiz

這是我個人的答案，基於老師說要練習 (不想被 fire 掉 XD)，我就練習了，但是我還不會排這種版型，傷眼就請見諒了 XDXD。

題目很簡單(不過我把寫對的答案擦掉改成錯的答案 XD)，寫一個，寫一個滿足 P_0 的 program，這不難寫就是，利用上課教的技巧及 Exercise 3 的第一題，應該可以很快看出來，於是我們很快的就有下列推導。

重點是把 (a[i]-a[n])^2 = a[i]^2 - 2a[i]a[n] + a[n]^2 ，這樣子我們就可以在一個 loop 完成它。

所以這個時候我們就會得到四個變數 P_0, P_1, S_0, S_1，答案就呼之欲出啦。

待補，發現許多錯，先出門 XD

---
寫錯不知道會不會被罵 XD

Haskell Learning Source

從 wiki 上移過來，大概會改變寫長文的寫作風格，拆成許多個小篇的來寫。

• Hayoo, Hoogle - function's type information (include hackageDB's package)
• hackageDB - package information, we can use cabal command install it.
• Haskell Cafe – Mailing List. You can google keyword, for example you can use google search like the following

  keyword site:http://www.haskell.org/pipermail/haskell-cafe/

---
持續寫作

Compiler Research: The Next 50 Years

這篇是寫在嵐達網上，在自己的 blog 上做個備份。本文不開放回覆，統一至這篇回覆(寫這麼差...Orz)

Compiler Research: The Next 50 Years
Communication of the ACM - Febuary 2009

這篇是一篇很有趣的文章，在 CACM 上的文章都是接近科普類型，這篇也不例外，所以我花了幾天看懂這篇文章，又著實想了好幾天。

其實在這個領域中，要預測下一個十年比預測下一個五十年容易的多，那麼他覺得下一個 50 年的問題是什麼 ? 簡單的來說就是。 Program Optimization (Mulit-core, Architecture-Specific ... etc) 與 Security & Robust

就 parallel program 來說，multi-core 是一個趨勢(因為 Moore's Law 逼得大家努力的製作 multi-core CPU XD)，在過去的三十年來，Compiler 對於 parallel 並沒有一個泛用的方案(General Solution)，不管怎麼操作，lock, race condition 都是避免不了的問題，很多人嘗試要提出方案來解決，不過到目前為止沒有成功。

就 Security 來說，現在的 Compiler 勢必得去面對如何讓一個更複雜更為大型的程式保持正確(Corectess)且穩固(Robustic)，要用到很多手段報分析，讓一個程式在各個方面都 保持穩定。

回到 parallel 與 Compiler 的關係來說，用一個小故事來開個頭。有一天，我的指導老師問我，在 Embedded System 上，大部分的 CPU 是沒有 Floating Point Unit ，可是勢必得要去處理很多相關的運算，請問是怎麼解決的 ? 我想了很久想不出來，他說，其實解決不了(我被框了 ... Orz)，但是如果切割成許多個領域來解決是可以的，以 FFT 來說，在硬體上，只需要數個加法器與乘法器就可以搞定，以某個影像編碼來說，雖然每次都會用到 sin, cos，但是實際上來說，會轉的角度只有九個，所以查表即可解決。

回到正題，parallel programming 對於 Compiler 來說，如果切割成許多個領域來分別進行最佳化，其實到目前為止算是有相當的成果的， MIT 的 StreamIt Programming Langauge & Raw Processor (for streaming)，Google 的 Map Reduce (從 Functional Programming 來的 XD)，切割開來的時候，每個領域的平行其實都可以用巧妙的方式來解決，但是組在一起卻沒這麼容易。所以這篇文章有嘗試建議一些方法，例如說，撰寫高效能 的平行演算法並加以封裝，而寫程式的人就使用這些封裝的好的演算法來組合(BLAST ?)，這大概是目前可以做到的，或者是你可以想出一個全新的方法來解決現在的問題。綜合以上，這篇文章寫了很有趣的話，誰可以在平行上做出突破就可以引領 下一個研究年代。

而針對不同的平台來說，現在寫程式並比較不會這麼局限在單一架構上，你有可能寫程式寫在手機上，一張開發版上，自己的 CPU 上，針對不同的平台要做最佳化，其實是有一定的困難度的，而這也是 Compiler 下一個很重要的事。如果以 Embedded System 來說，多個晶片要協同運作是一個很常見的事，而這件事都需要很多方面來配合 (OS, Programming Langauge, Compiler ...etc)。這也是一個值得著力的點。

要寫出一個安全且穩固的程式是一件相當困難的事，可以就程式語言層面設計出一個更為安全的程式語言，教育程式員怎麼寫，或者是利用 Compiler 去做一些事，program analysis 就 wiki 來說有 Program Optimization 與 Program Correctness ，前者我不清楚，不過現在已經有很多現成工具可以用了，硬體設計上，用以分析出一個電路的 critical path，軟體設計上用以分析耗掉多少記憶體，那邊佔用的時間最多之類的。但是 Program Corectness 來說，我覺得是很重要，但是並不是我所了解的領域(這讓我想到這次 FLOLAC 10 的 Frama-C)，要如何保證程式在每個層面皆能正確運作，我相信有許多的議題需要討論。Compiler 在過去這麼多年來越來越重要有一個原因是因為 high-level programming language 受到了廣泛的使用，然而分析這些語言會不會產生更多的問題呢 ? (這個問題是個人猜測)

最後這篇文章提到一些有趣的建議，不外乎是針對 Compiler 設計一連串的專門課程啦，建立一個 Compiler 協會之類的，老實說，我覺得每個領域都會想這樣子建議吧 XD。所以我這個部分就沒有很認真的看了 XD。

題外話： 我的指導老師跟我說，這篇文章提到許多論點是許多傳統做 Compiler 的人不願意接受的，我看起來是覺得很不錯啊，至少我覺得蠻有趣的，他舉了一個例子，你要一個練了許多年武功的人不用這個武功來解決問題是很困難的。老實說 我也不知道是什麼，或許聽了 CHTPC 會有一些感覺吧 ... ?

---
為什麼我覺得我怎麼寫都像寫廢話一樣 ... Orz

gdb save breakpoints

define bsave
    shell rm -f brestore.txt
    set logging file brestore.txt
    set logging on
    info break
    set logging off
    # reformat on-the-fly to a valid gdb command file
    shell perl -n -e 'print "break $1\n" if /^\d+.+?(\S+)$/g' brestore.txt > bps.gdb 
end

其實這是從網路上來的，不過這個 code 在 cgdb, gdbtui 上似乎不可行，看懂 code 之後(大概只有 Perl 那行比較難懂 XD)，其實發現蠻暴力的，gdb 在 v7 之後支援 Python Scirpt binding ，是該來研究研究，今天也是試著用很破爛的方法達成 gdb 自動環境設定的方法就是了。大概這幾天持續嘗試之後再說。

gdb note's wiki

---
最近常備份 XD。

cgdbrc

單純備個份，參考自網路上的，自己單純加了兩行，除非有必要，不然我應該是不會用 gdb 原生 XD (可能連 qemu 例外之類的 XD)。

以下放在 ~/.cgdb/cgdbrc

set arrowstyle=highlight
set autosourcereload
set tabstop=4
set winsplit=top_big
set showtgdbcommands
map <F2> :set<SPACE>winsplit=top_big<CR>
map <F3> :set<SPACE>winsplit=bottom_big<CR>
hi Statement cterm=bold ctermfg=6
hi PreProc cterm=bold ctermfg=4
hi IncSearch ctermfg=2
hi LineHighlight cterm=bold ctermfg=3 ctermbg=4

這樣子按 F2 或 F3 時即可選擇要放大上面視窗，還是放大下面視窗

---

紀念不事生產的日子

Slide: Programming Tempratory Integrated Distributed Embedded System
僅紀念我這一兩個月不事生產的日子。

在 ycma 的指導下，我終於破破爛爛的讀完這篇 paper 了(還是是想完 XD?) 簡單的來說，就是學習如何建立 programming model ，學習怎麼樣思考問題，建立模型及描述進而解決問題。以後會做相關 paper 的問題嗎? 我想不會，我單純相信，這篇只是單純訓練而己。在這念這篇 paper 的過程中也學了 Haskell ，也決定了下個要念的主題 --- Precision-Time Machine

所有的事情也該繼續前進而不要再裝死了。該寫的 lambdawn, Perfume, Haskell 是該繼續進行了。

---
希望能繼續過著開心的生活。

Haskell Practice - Ugly Numbers

題目就在這，我就不再多做說明了，這題寫完，暫時要停下來，把 scm 老師的信消化，然後鳥書繼續前進 XD。

is_un n
    | n == 1 = True
    | n `mod` 2 == 0 = is_un (truncate (fromIntegral n/fromIntegral 2))
    | n `mod` 3 == 0 = is_un (truncate (fromIntegral n/fromIntegral 3))
    | n `mod` 5 == 0 = is_un (truncate (fromIntegral n/fromIntegral 5))
    | otherwise = False


is_un2 n
    | n == 1 = True
    | n `mod` 2 == 0 = is_un2 (until (\x -> x `mod` 2 /= 0) (\x -> truncate (fromIntegral x/ fromIntegral 2)) n) 
    | n `mod` 3 == 0 = is_un2 (until (\x -> x `mod` 3 /= 0) (\x -> truncate (fromIntegral x/ fromIntegral 3)) n)
    | n `mod` 5 == 0 = is_un2 (until (\x -> x `mod` 5 /= 0) (\x -> truncate (fromIntegral x/ fromIntegral 5)) n)
    | otherwise = False

is_un3 n = foldl judge n [2,3,5] == 1
    where judge n y = until (\x -> x `mod` y /= 0) (\x -> truncate (fromIntegral x/ fromIntegral y)) n

un_list :: [Integer] -> Integer -> [Integer]
un_list (x:xs) n 
    | n == 0 = (x:xs)
    | otherwise = un_list (min:x:xs) (n-1) 
    where min = minimum (filter (>x) [u*v | u<-(x:xs), v<-[2, 3, 5]])

傳說中這題是一行就可以寫完的，但是我不知道怎麼寫，我還是一樣照我的想法寫 XD，剛開始的想法非常簡單，一直除 2, 3, 5，最後的結果不等於 1 就不是，這方法當然很慢，不過練習還是有用的，因為從 is_un 至 is_un3 可以讓我練一下 foldl ，也讓我明確的了解到 foldl 和 foldr 的根本性不同 (沒錯，我之前又完全搞錯了，剩下只有 fold fusion 要搞懂了)

最後一個 un_list 的想法則是比較正面，找到前面 list 乘於 2, 3, 5 然後大於 list 最大的數的數列最小值，這速度顯然快很多 XD。在這樣子的狀況下寫成 tail recursive 比較直覺，但是其實將整個數列反過來算也是 ok 的，所以我就索性反過來算了。測試結果如下 ...

*Main> reverse (un_list [5, 4, 3, 2, 1] 1495)
[1,2,3,4,5,6,8,9,10,12,15,16,18,20,24,25,27,30,32,36,40,45,48,50,54,60,64,72,75,80,81,90,96,100,108,120,125,128,135,144,150,160,162,180,192,200,216,225,240,243,250,256,270,288, ...

同場加映 Python 版，不過真的只能說 Haskell 影響 Python 很深，在 list 操作部分很像，但是沒有 Haskell 來的漂亮 XD

def ugly_number(list_size):
    ug_list = [1]
    for i in range(0, list_size-1):
        ug_list.append(min(filter(lambda x: x>ug_list[len(ug_list)-1], [x*y for x in ug_list for y in [2,3,5]])))
    return ug_list

---
該繼續打底了 ... XD

---

2010/03/15 05:58 pm 今天晚上可能無法再做練習了，可能要先看一下 paper ，不過初步的破爛想法是

makePrime x = if prime (x+add) then (x+add)
            else makePrime (x+add) 
            where add = if x `mod` 6 == 1 then 4 else 2
primes = 5: map primeCircule2 primes

其實不是沒有想過一次生二個 element (試著寫 let p = 5:7: map (6+) p)，但是回傳時一定要產生一個 element，如果不是的時候總不能丟 0 XD，所以只好先交出一個破爛方法，剩下的明天再試。

---

2010/03/18 11:06 am 後來想到兩個數列分開算再用 merge 即可，不過速度上應該是佔不到便宜就是了 ...

makePrime_plusn n x = if prime (x+n) then (x+n) else makePrime_plusn n (x+6) 
primes = 5: map makePrime primes
primes2 = merge primes_plus2 primes_plus4 
    where primes_plus2 = 5: map (makePrime_plusn 6) primes_plus2 
          primes_plus4 = 7: map (makePrime_plusn 6) primes_plus4

Haskell Practice - Merge Sort

老實說我也不太清楚是不是 Merge Sort ，只是照著感覺寫，而且感覺是效率不佳的 Merge Sort ... Orz，其中的 merge 是 scm 老師寫的，他寫了一封信，我很認真的看再很認真的忘掉再重寫中。

insertionSort [] = []
insertionSort (x:xs) = merge [x] (insertionSort xs)

merge [] ys = ys
merge xs [] = xs
merge (x:xs) (y:ys) 
    | x <= y = x : merge xs (y:ys)
    | otherwise = y : merge (x:xs) ys

測試結果如下:

*Main> mergeSort [3,1,5,2,6, -1, 10]
[-1,1,2,3,5,6,10]

---
想要改寫，不過應該是晚上的事了。

---

事情比想像中更糟，自己推一次，發現根本不是 Merge Sort 啊 ... Orz

---

上面那個應該是 insertion sort ... 緊急之間寫了下面這個 code 出來，但是會出錯 ... meeting 在即，等回來再說了 ...

mergeSort [] = []
mergeSort x = 
    if length x > 1 then 
        merge (mergeSort (fst (splitAt half x))) (mergeSort (snd (splitAt half x)))
    else x
    where half = truncate ( (fromIntegral (length x))/ (fromIntegral 2))

---

看起來是沒有出錯了，接下來該開始思考怎麼寫會比較好一點 XD。

---

2010/03/12 00:09 結果根本就在惡補怎麼操作 list ，發現自己是有看了，但是都忘完了 ... 到目前為止的版本

mergeSort (x:xs) 
    | xs == [] = [x]
    | otherwise = merge (mergeSort (take half (x:xs))) (mergeSort (drop half (x:xs)))
    where half = truncate ( (fromIntegral (length (x:xs)))/ (fromIntegral 2))

---

2009/03/12 10:19 AM 只是嘗試將 length 帶入 argument 中，實質上並無太大改變，我一直在想著長度的問題 ... 可是腦袋又是空掉了 ...

mergeSort [] = []
mergeSort x = mergeSort' x (length x) 

mergeSort' x l
    | l == 1 = x
    | otherwise = merge (mergeSort' (take half x) half) (mergeSort' (drop half x) (l-half))
    where half = truncate ((fromIntegral l)/(fromIntegral 2))

---

2009/03/14 11:38 pm 依 scm 在 comments 裡的建議把 uninterleave 寫出來，自己重寫 interleave ，發現有一點不太一樣(還好功能一樣 XD)

interleave [] ys = ys
interleave xs [] = xs
interleave (x:xs) (y:ys) = x:y:(interleave xs ys)
-- interleave (x:xs) (y:ys) = x:(interleave (y:ys) xs)

uninterleave :: [a] -> ([a],[a])
uninterleave [] = ([], [])
uninterleave (x:xs) = uninterleave' (x:xs) [] [] 

uninterleave':: [a] -> [a] -> [a] -> ([a], [a])
uninterleave' [] ys zs = (zs, ys)
uninterleave' (x:xs) ys zs = uninterleave' xs zs (x:ys)

mergeSort2 :: (Ord t) => [t] -> [t]
mergeSort2 [] = []
mergeSort2 (x:[])  = [x]
mergeSort2 xs = merge (mergeSort2 (fst (uninterleave xs))) (mergeSort2 (snd(uninterleave xs)))

Haskell Practice - Prime (2)

在寫了一個第一篇之後，scm 老師給予了很多建議

scm 提到...
Interesting code :). Some comments:

1. 如你所說 isPrime 是 map 加上 foldr (不過這個 isPrime 測的好像是「不是質數」？）。另外，makePrimeList 是 filter.
2. 其實 (&&) 這個 operator 碰到第一個參數是 False 的時候也並不會去算第二個。isPrime2 和 isPrime 的另一個不同點是碰到 y < sq 就停下來吧？這也可以用先做一個 takeWhile 達成。
3. 用 makeList 的版本為什麼比較慢不能馬上斷定，一個猜測是和 x ++ [c] 有關係。串列的 (++) 花的時間和第一個參數的長度成正比，所以每產生一個新的 c 都得從最開頭把這個串列旅行一遍。
   另外，由於 makeList 是 tail recursive 的，makePrimeList 必須等到整個 6n+1 6n+5 的串列產生完畢後才能動作。（比較之下 makePrimeList_2 則可以隨到隨做，[2..x] 這個 list 的元素生出來、測試過後，就丟掉了，並不佔空間。）不知道 makeList 會不會使得 heap 使用量變大，GC 變多，程式就慢了。你可寫一個不是 tail recursive 的 makeList 試試看嗎？

所以第一個問題 isPrime 是錯的，因為我一開始是寫 notPrime XD，但是問題算小，我馬上重寫了一下(順帶一提， scm 老師說的 && 特性，我不確定 Haskell 有，現在知道有了，記得這有一個名詞稱呼這種特性，但是忘了是什麼，在寫 C/C++ 時很常用，大部分是用在 pointer check is not null 上。)

prime :: Integer -> Bool
prime x 
    | x == 2 = True
    | otherwise = 
        isPrime x [2..sq]
        where sq = truncate (sqrt (fromIntegral x)) + 1

isPrime :: Integer -> [Integer] -> Bool
isPrime x y
    | x == 2 = True
    | otherwise =
         case y of 
             [] -> True
             y:ys -> (x `mod` y /= 0) && isPrime x ys

這樣子應該就沒有錯了...(汗)，然後我們再很快速的寫成 map 格式，也連帶的使用到 lambda function ，因為我不知道怎麼樣寫的比較精簡了 XD

isPrime4 :: Integer -> [Integer] -> Bool
isPrime4 x y
    | x == 2 || y == [] = True
    | otherwise = and (map ( \e -> x `mod` e /= 0) y)
--     | otherwise = and (map (/=0) (map (x `mod`) y)) 

接著我再把稍微改版的程式試著用 takeWhile 改寫(takeWhile 的相對是 dropWhile)

isPrime5 :: Integer -> [Integer] -> Bool
isPrime5 x y 
    | x == 2 = True
    | otherwise =
        isPrime5' x (takeWhile  (< (truncate (sqrt (fromIntegral x)) + 1)) y)

isPrime5' :: Integer -> [Integer] -> Bool
isPrime5' x y =
     case y of
         [] -> True
         y:ys -> (x `mod` y /= 0) && isPrime5' x ys

最後一個問題就是 makeList，我就沒有寫了，我把 makePrimeList 寫成如下型式

makePrimeList4 :: Integer -> [Integer]
makePrimeList4 x = [2, 3] ++ makePrimeList4' 5 x False [] 

makePrimeList4' :: Integer -> Integer -> Bool -> [Integer] -> [Integer]
makePrimeList4' c e b x
    = if c < e then
          if isPrime5 c x then
              makePrimeList4' (c+add) e (not b) (x ++ [c])
          else 
              makePrimeList4' (c+add) e (not b) x
      else x
      where add = if b then 4 else 2

這樣子的 code 就不需要另外產生 list ，因為產生的當下就檢查，不要就丟掉了，然而在生成 prime list 的時候還是 tail recursive ，有嘗試過另外的方法，卻發現快不起來。

如果要將 (x ++ [c]) 變成 ([c] ++ x)，我嘗試寫了另外一個 isPrime7

isPrime7 :: Integer -> [Integer] -> Bool
isPrime7 x y 
    | x == 2 = True
    | otherwise =
        isPrime5' x (dropWhile (> (truncate (sqrt (fromIntegral x)) + 1)) y)

這樣子的確可以完全避免掉 tail recursive 的問題，但是速度會比較慢，因為產生的數列是 11 7 5 3 2 這樣子的排序，一般檢查是否為質數是正向檢查，逆向的時候能夠在檢查次數上佔到的便宜其實不多 (如果該數是被 5 整除的話...)，所以這樣子寫反而比較慢，目前的想法是，如果想要完全漂亮的解決 tail recursive 問題的話，勢必是得重新設計方法而且更了解這個語言的。

---
可見自己數學真的不好 ... Orz

Haskell Pratice - Prime

今日目標算是達成了，明天再繼續。原始想法很簡單，如何寫出一個 prime list ? 於是我就寫了第一版

prime :: Integer -> Bool
prime x 
    | x == 2 = True
    | otherwise = 
            isPrime [2..sq] x
            where sq = truncate (sqrt (fromIntegral x)) + 1

isPrime :: [Integer] -> Integer -> Bool
isPrime x y =
    case x of 
        [] -> False
        x:xs -> (y `mod` x == 0) || isPrime xs

makePrimeList :: [Integer] -> [Integer]
makePrimeList x =
    case x of
        [] -> [] 
        x:xs -> if prime x then  
                    [x] ++ makePrimeList xs
                else 
                    makePrimeList xs

其中的 where sq = truncate (sqrt (fromIntegral x)) + 1 是在 Josh Ko 的幫助下寫出來的，但是我得隔日再戰，我很明確的知道是轉型問題，但是並不是能夠完全說清楚為什麼要這樣做(他有說明，但是我得再看一下書)。

而且在這一版中的 isPrime 實在是太暴力了，其實可以用 map + and (or fold) 寫出來，並不一定要用 recursive 寫，所以我採用了另外一個寫法，即是檢查到 `mod` == 0 就停下來。

isPrime_2 :: Integer -> [Integer] -> Bool
isPrime_2 x y
    | x == 2 = True
    | otherwise =
        case y of
            [] -> True
            y:ys -> if y < sq then
                        if (x `mod` y == 0) then False
                        else isPrime_2 x ys
                    else True 
                    where sq = truncate (sqrt (fromIntegral x)) + 1

速度是明顯快上不少，但這版對我而言只剩最後一個問題，就是每呼叫一次 sq 就要算一次，我目前唯一想到的解法是，把 sq 也當成引數，於是我就寫成

isPrime_3 :: Integer -> [Integer] -> Bool
isPrime_3 x y 
    | x == 2 = True
    | otherwise =
        isPrime_3' x y (truncate (sqrt (fromIntegral x)) + 1)

isPrime_3' :: Integer -> [Integer] -> Integer -> Bool
isPrime_3' x y sq =
    case y of
        [] -> True
        y:ys -> if y < sq then
                    if (x `mod` y == 0) then False
                    else isPrime_3' x ys sq
                else True

最後，再寫一個 makePrimeList 的 code 就搞定了

makePrimeList :: Integer -> [Integer]
makePrimeList x = makePrimeList_2 [2..x] []

makePrimeList_2 :: [Integer] -> [Integer] -> [Integer]
makePrimeList_2 u v =
    case u of 
        [] -> []
        x:xs -> if isPrime_3 x v then
                    [x] ++ makePrimeList_2 xs (v++[x])
                else
                    makePrimeList_2 xs v

最後 run 一下成果

*Main> makePrimeList 100
[2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97]

其實還可以更快，但是就明天再來來，依現在的程度寫出的 code ，雖然普通，可是很開心。

---
本週目標：練習 Prime

---

馬上就打了自己的嘴吧，我試著嘗試產生 6n+1 6n+5 的 list 用以減少 prime 的檢查次數，於是很粗糙的寫了如下的 code

makeList :: Integer -> Integer -> Bool -> [Integer] -> [Integer]
makeList e c b x =
    if c < e then
        if b then
            makeList e (c+4) False (x ++ [c])
        else
            makeList e (c+2) True (x ++ [c])
    else
        x

然後將 makePrimeList 改成如下

makePrimeList :: Integer -> [Integer]
makePrimeList x = makePrimeList_2 ([2, 3] ++ makeList x 5 False []) []

結果速度反而慢到嚇人啊...Orz 完全不知道為什麼，看來要好好研究了 XD。

Literate Programming in Haskell

Literate Programming 簡單的來說就是讓你在寫文件和寫程式的同時，能用 programming language compiler(e.g ghc) & typeseeting compiler (e.g. LaTeX) 分別產生文件和程式，通常最常見的是寫書，不過一般的 imperative programming language 要進行這樣子的動作是很困難的(code dependence & side effect)，在 Haskell 中，這樣子的問題顯的相對的簡單而且容易處理。

Literal Programming in Haskell 的 programming compiler 通常是選用 ghc，而 typesetting 則是使用 LaTeX (XeLaTeX 也可以，代表你可以寫中文)，一個文件的過程大抵如下

• 寫作一個 latex + Haskell 的 code ，但是 Haskell 的 code 必需寫在 \begin{code}\end{code}
• 該檔案存成的副檔名是 .lhs (vim 認的出來)，而我們在這個時候必需再使用另外一個套件 lhs2TeX 來處理，基本上我們可以使用 cabal 來安裝。
• 使用 lhs2Tex 將該檔轉成 .tex 檔供 LaTeX 編譯

Document

LaTeX 的寫作就有如 LaTeX XDXD，就請參考其他的 LaTeX 文件嘍，而在 lhs2TeX 的這方面有兩份文件，分別是

• Manual(pdf) – Guide2lhs2TeX
• Slide(pdf) – Typesetting Haskell and more with lhs2TeX

Example

以下是從 Slide 中來的 example，sample code 如下

\documentclass{article}
%include lhs2TeX.fmt
%include lhs2TeX.sty
\begin{document}
This is the famous ``Hello world'' example,
written in Haskell:
\begin{code}
main :: IO ()
main = putStrLn "Hello, world!"
\end{code}
\end{document}

• compile to tex file

  lhs2TeX --tt test.lhs -o test.tex
  pdflatex test.tex
  pdflatex test.tex

  and you will see test.tex
  當然 --tt 可以換成其他的選項，例如 --verb, --math, --poly，細節可以看簡報的說明。
• compile .lhs to executable

  ghc -o hello.out hello.lhs

  基本上跟一般 compile 程式是相同的。

---
感覺上好像寫了一篇很簡單的說明 XD。draft