** advanced table
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:
   | DATA             | WHAT       | WHERE       | HOW MUCH |
   |------------------+------------+-------------+----------|
   | [2009-09-25 Fri] |            |             |    28.95 |
   |------------------+------------+-------------+----------|
   |                  | food       | supermarket |     7.85 |
   |                  | ticket bus |             |      2.3 |
   |                  | tea + ice  | ice uno     |      4.4 |
   |                  | ticket     |             |     14.4 |
   |------------------+------------+-------------+----------|
   | [2009-09-26 Sat] |            |             |       41 |

#+begin_src emacs-lisp
  (let ((total 0) (responding t) purchases)
    (while responding
      (setq purchases
            (cons
             (list ""
                   (read-from-minibuffer "What: ")
                   (read-from-minibuffer "Where: ")
                   (read-minibuffer "How Much: "))
             purchases))
      (setq responding (y-or-n-p "more? ")))
    (append 
     purchases
     (list
      (list
       (format-time-string "%Y-%m-%d" (current-time))
       "" "" (progn
               (mapc (lambda (purchase)
                       (setq total (+ total (fourth purchase))))
                     purchases)
               total)))))
#+end_src

#+resname:
| ""           | "fish and chips" | "diner"  |  9.78 |
| ""           | "food"           | "subway" |  5.45 |
| "2009-09-29" | ""               | ""       | 15.23 |

   

** and then more
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:
and more stuffs here
   

** asymptote cosine
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:
#+begin_src asymptote :exports code
  import graph;
  
  size(0,4cm);
  
  real f(real t) {return cos(t);}
  
  path g=polargraph(f,0,2pi,operator ..)--cycle;
  filldraw(g,pink);
  
  for(int i=0; i < 8; ++i) {
    real j = 0.125 + 0.125*i;
    real h(real t) {return j;};
    path k=polargraph(h, -(acos(j)), acos(j), operator ..);
    draw(k,blue);
  }
  
  xaxis("$x$",above=true);
  yaxis("$y$",above=true);
  
  dot("$(pi,0)$",(1,0),N);
#+end_src

   

** asymptote
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:

#+begin_src asymptote :file asymptote-test.png :exports code
  import graph;
  
  size(0,4cm);
  
  real f(real t) {return 1+cos(t);}
  
  path g=polargraph(f,0,2pi,operator ..)--cycle;
  filldraw(g,pink);
  
  xaxis("$x$",above=true);
  yaxis("$y$",above=true);
  
  dot("$(a,0)$",(1,0),N);
  dot("$(2a,0)$",(2,0),N+E);
#+end_src

#+resname:
[[file:asymptote-test.png]]

   

** cached results
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:
#+begin_src emacs-lisp :cache yes
   (setq org-babel-default-header-args '((:session . "none")
                                         (:results . "replace")
                                         (:exports . "code")(:cache)))
#+end_src

#+name[937269632ae5b5eee5c93f9eb50e0bc55e34520d]:
| (:session . none) | (:results . replace) | (:exports . code) | (:cache) |

#+name: eric-schulte
#+begin_src emacs-lisp :cache yes
   (+ 5 7 1)
#+end_src

#+name[005b04829608b3d22b61686e90309af3a9a6fe7c]: eric-schulte
: 13

#+begin_src ditaa :file caching-example.png
    +--------------------+
    |                    |     +-----------+
    |                    |     |           |
    |                    |     |           |
    |      +----+        |     |           |
    |      |    |        |     +-----------+
    |      +----+        |
    |                    |
    +--------------------+
#+end_src

#+name[fd11ddbfd00f6038e6e37db71ddaf43d65b0e200]:
[[file:caching-example.png]]

   

** changing source name
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:

#+name: emacs-nine
#+begin_src emacs-lisp
  8
#+end_src

#+resname: emacs-nine
: 8

#+resname: emacs-eight
: 8

   

** clojure
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:
#+begin_src clojure :results silent
  (list 8 9)
#+end_src

   

** code results
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:
*** emacs lisp
    :PROPERTIES:
    :DATE:     2009-11-20
    :END:
#+begin_src emacs-lisp :results code
  (mapcar (lambda (el) (lambda (item) (+ item el))) '(1 2 3 4 5))
#+end_src

#+resname:
#+BEGIN_SRC emacs-lisp
((lambda
   (item)
   (+ item el))
 (lambda
   (item)
   (+ item el))
 (lambda
   (item)
   (+ item el))
 (lambda
   (item)
   (+ item el))
 (lambda
   (item)
   (+ item el)))
#+END_SRC

#+begin_src emacs-lisp :results code
  (mapcar (lambda (el) (* el el)) '(1 2 3 89))
#+end_src

#+resname:
#+BEGIN_SRC emacs-lisp
(1 4 9 7921)
#+END_SRC

*** ruby
    :PROPERTIES:
    :DATE:     2009-11-20
    :END:

#+begin_src ruby :results code
  [1, 2, 33, 4].map{|n| "the number #{n}"}
#+end_src

#+resname:
#+BEGIN_SRC ruby
  ["the number 1", "the number 2", "the number 33", "the number 4"]
#+END_SRC

#+begin_src ruby :session :results code 
  [1, 2, 33, 4].map{|n| n + 10 }
#+end_src

#+resname:
#+BEGIN_SRC ruby
[11, 12, 43, 14]
#+END_SRC

*** python
    :PROPERTIES:
    :DATE:     2009-11-20
    :END:

#+begin_src python :results code
  ['one', 'two', 'three']
#+end_src

#+resname:
#+BEGIN_SRC python
['one', 'two', 'three']
#+END_SRC

#+begin_src python :results code
  [1, 2, 33, 4]
#+end_src

#+resname:
#+BEGIN_SRC python
[1, 2, 33, 4]
#+END_SRC

#+begin_src python :session :results code 
  [1, 2, 33, 4]
#+end_src

#+resname:
#+BEGIN_SRC python
[1, 2, 33, 4]
#+END_SRC

   

** dynamic table
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:
#+TBLNAME: todays-clock
#+BEGIN: clocktable :maxlevel 2 :block today :scope tree1 :link t
Clock summary at [2009-09-15 Tue 08:51], for Tuesday, September 15, 2009.

| L | Headline     | Time   |      |
|---+--------------+--------+------|
|   | *Total time* | *1:10* |      |
|---+--------------+--------+------|
| 1 | [[file:/Users/eschulte/Desktop/test.org::top][top]]          | 1:10   |    1 |
| 2 | [[file:/Users/eschulte/Desktop/test.org::show%20all][show all]]     |        | 1:00 |
| 2 | [[file:/Users/eschulte/Desktop/test.org::later][later]]        |        | 0:10 |
#+END: clocktable

#+begin_src emacs-lisp :var data=todays-clock(1,1)
(message "table is %S" data)
#+end_src

#+resname:
: table is (("L" "Headline" "Time" "") hline ("" "*Total time*" "*1:10*" "") hline (1 "[[file:/Users/eschulte/Desktop/test.org::top][top]]" "1:10" 1) (2 "[[file:/Users/eschulte/Desktop/test.org::show%20all][show all]]" "" "1:00") (2 "[[file:/Users/eschulte/Desktop/test.org::later][later]]" "" "0:10"))

#+begin_src R :session R-pie-example :var times=todays-clock :results silent
pie(times[2:length(times),4], labels = times[2:length(times),2])
#+end_src

   

** elisp references
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:

#+begin_src emacs-lisp :results silent
   (setq first 10)
#+end_src

#+name: resolve(name=nil)
#+begin_src emacs-lisp :results silent
  (eval (intern name))
#+end_src

#+begin_src python :var a=resolve(name="first")
  return a + 10
#+end_src

   

** elisp variables
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:

#+begin_src ditaa :file (format "%d.png" 45)
      +-----------+
      |           |
      |           |
      |           |
      |           |
      +-----------+
#+end_src

#+name:
[[file:45.png]]
   

** empty =output= results for emacs-lisp
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:
#+begin_src emacs-lisp :results output
   8
#+end_src

#+resname:

   

** gnuplot
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:
#+begin_src gnuplot
plot cosx
#+end_src


#+end_src
      

   

** haskell and tables
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:
#+begin_src haskell
  sumListCond :: Int -> Int -> [Int] -> Int
  sumListCond l n xs
      | foldl (+) 0 (take l xs) <= n = sumListCond (l + 1) n xs
      | otherwise = foldl (+) 0 (take (l - 1) xs)
#+end_src
#+begin_src oz
  
#+end_src

   

** haskell
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:
#+begin_src haskell
  powerSet :: [a] -> [[a]]
  powerSet = foldr (\ x ps -> map (\ y -> x : y) ps ++ ps ) [[]]
#+end_src

#+begin_src haskell
  powerSet [1, 2, 3]
#+end_src

   

** hiding results
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:
#+begin_src emacs-lisp
  (mapcar (lambda (el) (list el)) (number-sequence 0 20))
#+end_src

#+name:
|  0 |
|  1 |
|  2 |
|  3 |
|  4 |
|  5 |
|  6 |
|  7 |
|  8 |
|  9 |
| 10 |
| 11 |
| 12 |
| 13 |
| 14 |
| 15 |
| 16 |
| 17 |
| 18 |
| 19 |
| 20 |

   

** indentation
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:

#+begin_src python
          9
#+end_src

   

** indented
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:
   #+begin_src emacs-lisp
     (message "I ran!!")   
   #+end_src

#+resname:
: I ran!!

   

** indexing into gnuplot
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:

#+tblname: squares
| 1 |  1 |
| 2 |  4 |
| 3 |  9 |
| 4 | 16 |
| 5 | 25 |
| 6 | 36 |

#+begin_src gnuplot :var data=squares :results silent
plot data using 1:2 with lines
#+end_src

#+tblname: squares-with-sum
|  1 |  1 |
|  2 |  4 |
|  3 |  9 |
|  4 | 16 |
|  5 | 25 |
|  6 | 36 |
|----+----|
| 21 | 91 |

#+begin_src gnuplot :var data=squares-with-sum[0:-3] :results silent
  plot data using 1:2 with lines
#+end_src

   

** indexing into results
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:

#+name: indexable-table
| eric    |
| michael |
| schulte |
| is      |
| my      |
| name    |

#+begin_src emacs-lisp :var data=indexable-table[2:4]
   data
#+end_src

#+name:
| schulte |
| is      |
| my      |

#+tblname: multidimensional-indexing
| 1 |  2 |
| 3 |  4 |
| 5 |  6 |
| 7 |  8 |
| 9 | 10 |

#+begin_src emacs-lisp :var data=multidimensional-indexing[0:-2]
   data
#+end_src

#+resname:
| 1 | 2 |
| 3 | 4 |
| 5 | 6 |
| 7 | 8 |

   

** later
   CLOCK: [2009-09-15 Tue 09:41]--[2009-09-15 Tue 09:51] =>  0:10
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:
stuff here

   

** latex pngs
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:
$x \mapsto y$

*** Theorem
    :PROPERTIES:
    :DATE:     2009-11-20
    :END:
$|consts(t)| \leq sizes(t)$

- by induction on the structure of t
- base cases are $t \in [true, false, 0]$: 
  - $|consts(t)| = |[t]| = 1 = size(t)$
- inductive size
  - $t \in [succ(t_1), pred(t_1), iszero(t_1)]$:
    - $|consts(t)| = |consts(t_1)| = |[t]| \leq size(t_1) < size(t)$
  - $t = if\, t_1 \, then \, t_2 \, else t_3$
    - $|consts(t)| = |consts(t_1) \cup consts(t_1) \cup consts(t_1)|$
    - $\leq |consts(t_1)| + |consts(t_1)| + |consts(t_1)|$
    - $\leq size(t_1) + size(t_1) + size(t_1)$
    - $< size(t)$

   

** lua export
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:

#+name: determine the neighbors of the segments that the bisector hits
#+begin_src lua :tangle no :exports code
  local s1, s2 = intersecting_segs[1], intersecting_segs[2]
  local n1 = table_find_segment(cell.neighbors, s1)
  local n2 = table_find_segment(cell.neighbors, s2)
#+end_src

I got:
#+begin_example
\lstset{language=lua}
\begin{lstlisting}
local s1, s2 = intersecting_segs[1], intersecting_segs[2]
local n1 = table_find_segment(cell.neighbors, s1)
local n2 = table_find_segment(cell.neighbors, s2)
\end{lstlisting}
#+end_example

Emacs -Q got:
#+begin_example
\begin{verbatim}
local s1, s2 = intersecting_segs[1], intersecting_segs[2]
local n1 = table_find_segment(cell.neighbors, s1)
local n2 = table_find_segment(cell.neighbors, s2)
\end{verbatim}
#+end_example

Emacs -Q + Org-babel got:
#+begin_example
\begin{verbatim}
local s1, s2 = intersecting_segs[1], intersecting_segs[2]
local n1 = table_find_segment(cell.neighbors, s1)
local n2 = table_find_segment(cell.neighbors, s2)
\end{verbatim}
#+end_example

   

** multiple arguments
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:

#+begin_src emacs-lisp :var first=9 :var second=10
  (+ first second)
#+end_src

#+resname:
: 19

   

** noweb referernces
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:

#+name: noweb-example
#+begin_src ruby 
  a = 28
#+end_src

#+begin_src ruby :noweb
  # <<noweb-example>>
  a + 4
#+end_src

#+resname:
: 32

   

** persistent python
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:
#+begin_src python :session :results silent
  import types
#+end_src

#+begin_src python :session
  types.FunctionType
#+end_src

#+resname:
: function

*** more persistent python
    :PROPERTIES:
    :session:  default
    :DATE:     2009-11-20
    :END:

#+begin_src python :results silent
  import types
#+end_src

#+begin_src python
  types.FunctionType
#+end_src

#+resname:
: function

   

** =pp= results
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:
*** python
    :PROPERTIES:
    :DATE:     2009-11-20
    :END:
#+begin_src python :results pp :session
  ['one', 'two', 'three', 'one', 'two', 'three', 'one', 'two', 'three']
#+end_src

#+resname:
: ['one', 'two', 'three', 'one', 'two', 'three', 'one', 'two', 'three']

*** ruby
    :PROPERTIES:
    :DATE:     2009-11-20
    :END:
#+begin_src ruby :results pp
  class Schulte
    attr_accessor :name, :age
  end
  
  eric = Schulte.new
  eric.name = "eric"
  eric.age = 27
  
  eric
#+end_src

#+resname:


#+begin_src ruby :results pp
  a = [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]
  a
#+end_src

#+resname:
#+begin_example
[1,
 2,
 3,
 1,
 2,
 3,
 1,
 2,
 3,
 1,
 2,
 3,
 1,
 2,
 3,
 1,
 2,
 3,
 1,
 2,
 3,
 1,
 2,
 3,
 1,
 2,
 3]
#+end_example

   

** pretty print
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:

#+begin_src emacs-lisp :results scalar
  '(1 2 3 4)
#+end_src

   

** quoted latex
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:

The following latex isn't exported correctly

#+begin_latex
  \begin{code}
  data BTree = Leaf a
             | Node Tree Tree
  \end{code}
#+end_latex

#+begin_src haskell
  data BTree = Leaf a
             | Node Tree Tree
#+end_src

   

** reference parts of tables
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:

#+TBLNAME: squares
|  1 |   1 |
|  2 |   4 |
|  3 |   9 |
|  4 |  16 |
|  5 |  25 |
|  6 |  36 |
|  7 |  49 |
|  8 |  64 |
|  9 |  81 |
| 10 | 100 |
| 11 | 121 |
| 12 | 144 |
| 13 | 169 |
| 14 | 196 |
| 15 | 225 |
| 16 | 256 |
| 17 | 289 |
| 18 | 324 |
#+TBLFM: $2=$1*$1

#+begin_src gnuplot :var data=squares
set title "Implementing Gnuplot"
plot data using 1:2 with lines
#+end_src

   

** results switches
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:
#+begin_src ruby :results output :results_switches -n
  10.times do |n|
    puts "-"*n
  end
#+end_src

#+resname:
#+begin_example -n

-
--
---
----
-----
------
-------
--------
---------
#+end_example

#+begin_src ruby :results output
  10.times do |n|
    puts "-"*n
  end
#+end_src

#+resname:
#+begin_example
  -
  --
  ---
  ----
  -----
  ------
  -------
  --------
  ---------
#+end_example

   

** show all
   CLOCK: [2009-09-15 Tue 07:51]--[2009-09-15 Tue 08:51] =>  1:00
   :PROPERTIES:
   :exports:  both
   :DATE:     2009-11-20
   :END:

#+begin_src ditaa :file blue.png
   +----------------------+
   |                      |
   |                      |
   |          +-----------+
   |          |           |
   |          |           |
   |          |           |
   |          +-----------+
   |                      |
   +----------------------+
#+end_src

   

** simple R
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:

#+begin_src R :session R
8
#+end_src

#+resname:
: 8

   

** simple scalar
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:

#+begin_src emacs-lisp
  (+ 1 3)
#+end_src

#+resname:
: 4

   

** switches and references
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:

#+begin_src ruby -n -r -l "(ref:%s)" :results output
  class Schulte
    def self.eric
      puts :imp # (ref:imp)
    end
  end
  Schulte.eric
#+end_src

#+resname[bb4cebabe38a5d3d43835acebdbe17aa3314cef6]:
: imp

Line no. [[(imp)]] is important!

#+begin_src ruby -n -r -l "(ref:%s)" :results output
  class Schulte
    def self.eric
      puts :imp # (ref:imp)
    end
  end
  Schulte.eric # (ref:output)
#+end_src

#+resname: eric
: imp

   

** =:table= results param
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:
#+begin_src emacs-lisp :results table
  8
#+end_src

#+resname:
| 8 |

   

** testing srcname aliases
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:

#+name: two
#+begin_src emacs-lisp
  2
#+end_src

#+begin_src emacs-lisp :var input=two
  (+ input 1)
#+end_src

#+name[1ec6c8d3de6aaeac7b2720f1d801402e762875ea]:
: 3

   

** unresolved noweb references
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:

#+begin_src emacs-lisp :results silent
  (setq org-babel-noweb-error-langs '("ruby"))
#+end_src

#+name: i-have-a-name
#+begin_src ruby 
  1 + 2
#+end_src


#+begin_src ruby :noweb
  <<i-have-a-name>> + 3
#+end_src

#+resname:
: 6

   

** xml and n3
   :PROPERTIES:
   :DATE:     2009-11-20
   :END:

introduce org-babel to =xml= and =n3=
#+begin_src emacs-lisp :results silent
  (add-to-list 'org-babel-interpreters "xml")
  (add-to-list 'org-babel-interpreters "n3")
#+end_src

inform org-babel-tangle of their existence and file extensions
#+begin_src emacs-lisp :results silent
  (add-to-list 'org-babel-tangle-langs '("xml" "xml"))
  (add-to-list 'org-babel-tangle-langs '("n3" "n3"))
#+end_src

#+begin_src xml :tangle example
  <first>
  </first>
#+end_src

#+begin_src n3 :tangle example
  n3 stuff
#+end_src

   

** sh with sessions
   :PROPERTIES:
   :DATE:     2009-11-27
   :END:

#+begin_src sh :session eric
  cd ~/Desktop
#+end_src

#+begin_src sh :session eric
  cd ~/Desktop/clj/
  ls *.clj
#+end_src

#+name:
| "ants.clj" | "" | "concurrent.clj" | "" | "hello.clj" | "" | "spell-checker.clj" |

   

** whitespace/newline results issues
   :PROPERTIES:
   :DATE:     2009-11-27
   :END:

#+begin_src sh
  echo output
#+end_src

This
#+begin_src sh
  echo output
#+end_src
text here

results in

t#+results:
: output
ext here

#+begin_src emacs-lisp
  (+ 1 1)
#+end_src

#+name:
: 2

   

** debug hints
   :PROPERTIES:
   :DATE:     2009-11-30
   :END:
from mailing list

- edebug-defun: (in emacs-lisp mode, C-u C-M-x) will mark the function
  so that when it is called, the interpreter stops and you can then
  single-step through it with <SPACE>. At each point, you can press
  "e" and evaluate variables (actually arbitrary expressions).
- Insert a strategically placed (debug) call and then call the
  function.  If/when the debug call is executed, you are dropped into
  the debugger and you can then evaluate arbitrary expressions.

   

** gnuplot variable expansion
   :PROPERTIES:
   :DATE:     2009-11-30
   :END:

#+name: simple-function
#+begin_src emacs-lisp
  "sin(x)"
#+end_src

#+begin_src gnuplot :var fun=simple-function
  plot $fun
#+end_src

   

** sql exports to latex
   :PROPERTIES:
   :DATE:     2009-11-30
   :END:
example from email list
*** ECM
    :PROPERTIES:
    :DATE:     2009-11-30
    :END:

   - faire un script Bash (et =isql=) envoyant un /listing/ de stagiaires;

#+name: envoi-stg
   #+begin_src sql
       DECLARE @dateFmtStyleIn int; SET @dateFmtStyleIn = 120 -- ODBC canonical
       DECLARE @dateFmtStyleOut int; SET @dateFmtStyleOut = 103 -- French dd/mm/yyyy

       DECLARE @firstDayOfThisMonth smalldatetime
       SET @firstDayOfThisMonth = CONVERT(smalldatetime,
                                          CAST(YEAR(GETDATE()) AS char(4)) + '-'
                                          + CAST(MONTH(GETDATE()) AS char(2)) + '-'
                                          + '01' + ' 00:00:00',
                                          @dateFmtStyleIn)

       DECLARE @now smalldatetime
       SET @now = CONVERT(smalldatetime,
                          CAST(YEAR(GETDATE()) AS char(4)) + '-'
                          + CAST(MONTH(GETDATE()) AS char(2)) + '-'
                          + CAST(DAY(GETDATE()) AS char(2)) + ' '
                          + CAST(DATEPART(hh, GETDATE()) AS char(2)) + ':'
                          + CAST(DATEPART(mi, GETDATE()) AS char(2)) + ':'
                          + '00',
                          @dateFmtStyleIn)

       SELECT pfiID
       FROM dossier
#+end_src

   

** eval-buffer
   :PROPERTIES:
   :DATE:     2009-12-04
   :END:
#+begin_src emacs-lisp
  (+ 1 2)
#+end_src

#+name:
: 3

#+begin_src emacs-lisp
  (+ 3 4)
#+end_src

#+name:
: 7

   

** quoted session name
   :PROPERTIES:
   :DATE:     2009-12-04
   :END:

#+begin_src sh :session "eric"
  echo 'name-me'
#+end_src

#+name:
: name-me

   

** looking at double quotes
   :PROPERTIES:
   :DATE:     2009-12-18
   :END:

#+tblname: double-quote-test-input
| test | this | 8 | 9 |

#+name: double-quote-test-output
#+begin_src python :var data=double-quote-test-input
  return data
#+end_src

#+name: double-quote-test-output
| test | this | 8 | 9 |

   

** no noweb by default
   :PROPERTIES:
   :DATE:     2009-12-18
   :END:

#+name: sample
#+begin_src emacs-lisp 
  (message "sample")
#+end_src

#+begin_src emacs-lisp :noweb no
  <<sample>>
#+end_src

#+name:
: sample

   

** exporting and caching
   :PROPERTIES:
   :DATE:     2009-12-23
   :END:
#+begin_src ditaa :file data/example.png :exports none
    +------------------+
    |  ditaa example   |
    |                  |
    |                  |
    +------------------+
#+end_src

#+name:
[[file:data/example.png]]

   

** exporting org-source
   :PROPERTIES:
   :DATE:     2009-12-23
   :END:

#+begin_src org
  ,lets see how this org-mode code exports to html
  
  ,is this [[link]] blue?
  
  ,#+begin_src emacs-lisp
  ,  (+ 1 2)
  ,#+end_src
#+end_src

   

** fancier export
   :PROPERTIES:
   :DATE:     2010-01-05
   :END:

#+name: square
#+begin_src emacs-lisp :var input=1
  (* input input)
#+end_src

   

** links
   :PROPERTIES:
   :DATE:     2010-01-06
   :END:

can LaTeX link itself to the middle of a paragraph with a simple
inline link like <<keystone>> if not then we would probably need to
wrap source-code blocks in figures to make them referable.

how about a link back to [[keystone]]

The above appears to work in LaTeX, but not in HTML.

   

** load to session
   :PROPERTIES:
   :DATE:     2010-01-11
   :END:
#+begin_src clojure :session asm-gp
  (in-ns 'asm-gp)
#+end_src

#+begin_src ruby :session
  puts :eric
#+end_src

#+begin_src python :session
  5 + 1 
#+end_src

#+begin_src R :session
  6 + 1
#+end_src

#+begin_src sh :session
  date
#+end_src

#+begin_src ocaml :session
  eric
#+end_src

#+begin_src gnuplot :session
  plot sin(x)
#+end_src

   

** babel block overwrite
   :PROPERTIES:
   :DATE:     2010-01-18
   :END:

The first block overwrites
#+begin_src clojure
  (def overwriter "I'll show up everywhere")
#+end_src

this second block
#+begin_src diff
  3719d3718
  <       movl    $1024, 8(%esp)
#+end_src

   

** ditaa blocks
   :PROPERTIES:
   :DATE:     2010-02-03
   :END:

#+begin_src ditaa :file communication.png :cache yes
  -------------
#+end_src

#+name[4fbfc78b37abd8a788958d28a7335445e6042c96]:
[[file:communication.png]]

   

** exporting to a file
   :PROPERTIES:
   :EXPORT_FILE_NAME: simple
   :EXPORT_TITLE: testing file export
   :DATE:     2010-02-03
   :END:

this is the contents

and a block
#+begin_src clojure
  (println "is a nice lisp")
#+end_src

ah, it works!

   

** tangling w/o comments and shebang
   :PROPERTIES:
   :tangle:   yes
   :DATE:     2010-02-05
   :END:

#+begin_src emacs-lisp :comments no :shebang (identity my-shebang)
  (message "I should have no comments")
#+end_src

#+begin_src emacs-lisp :comments no
  (setq my-shebang "foo")
#+end_src

#+name:
: foo

#+begin_src ruby :shebang #!/usr/bin/ruby
  puts :nonstandard_shebang
#+end_src

   

** tables to shell scripts ideas
   :PROPERTIES:
   :DATE:     2010-02-06
   :END:

#+tblname: sec
| Hello | World |


1) allowing the user to specify a separator with a header argument as
   follows
   #+begin_src sh :var table=sec :separator ,
     cat <<EOF
     $table
     EOF
   #+end_src
   
   which would result in something like

   : "Hello, World"

2) writing the table to a tab or comma separated file and then
   replacing =$table= in the source block body with the path to the
   file name, s.t. something like
   
   #+begin_src sh :var table=data
     wc $table
   #+end_src

   would return reasonable results

   

** short shell test
   :PROPERTIES:
   :DATE:     2010-02-07
   :END:

#+begin_src sh
  date
#+end_src

#+name:
: Sun Feb  7 10:17:44 MST 2010

#+tblname: fibs
| 1 | 1 |
| 2 | 1 |
| 3 | 2 |
| 4 | 3 |
| 5 | 5 |
| 6 | 8 |

#+begin_src sh :var table=fibs
  echo "$table" |wc
#+end_src

#+name:
: 6      12      24

#+begin_src sh :var table=fibs
  echo "$table"
#+end_src

#+name:
| 1 | 1 |
| 2 | 1 |
| 3 | 2 |
| 4 | 3 |
| 5 | 5 |
| 6 | 8 |

#+begin_src sh :var table=fibs :separator --
  echo "$table" | head -1
#+end_src

#+name:
: 1--1

   

** looking at source name exports
   :PROPERTIES:
   :DATE:     2010-02-09
   :END:

#+name: fibonacci
#+begin_src emacs-lisp :var input=0
  (defun fib (n)
    (if (> n 1)
        (+ (fib (- n 1)) (fib (- n 2)))
        1))
  (fib input)
#+end_src

#+name: fibonacci
: 1

now applying our Fibonacci function

#+call: fibonacci(input=5)

   

** list index w/function style name
   :PROPERTIES:
   :DATE:     2010-02-14
   :END:

#+name: function-style-index
| 0 |
| 1 |
| 2 |
| 3 |
| 4 |
| 5 |
| 6 |
| 7 |
| 8 |
| 9 |

#+name: function-style-indexing(data=function-style-index[1:4,0])
#+begin_src emacs-lisp
  (message "%S" data)
#+end_src

#+name: function-style-indexing
: ((1) (2) (3) (4))

   

** haskell variables
   :PROPERTIES:
   :DATE:     2010-02-15
   :END:

playing with Haskell

#+name: haskell-stuff
: 9

#+begin_src haskell :var num=haskell-stuff
  num + 1
#+end_src

#+begin_src ruby :var num=haskell-stuff
  num + 1
#+end_src

#+name:
: 10

   

** results lines for function calls
   :PROPERTIES:
   :DATE:     2010-02-15
   :END:

#+call: fibonacci(input=5) :resname eric

#+name:
: 8

#+begin_src emacs-lisp :var fib=fibonacci(input=5)
  (message "fib(5)=%d" fib)
#+end_src

#+name:
: fib(5)=8

   

** variables into shell scripts
   :PROPERTIES:
   :DATE:     2010-02-23
   :END:
#+name: into-shell-scripts
| username | guest   |
| password | nothing |

#+begin_src sh :var username=into-shell-scripts[0,0] :var password=into-shell-scripts[1,1] :results output
  echo "$username -p $password"
#+end_src

#+name:
: username -p nothing

#+name: number-into-shell
: 9

#+begin_src sh :var num=number-into-shell
  for i in `seq $num`; do
      echo $i
  done
#+end_src

#+name:
| 1 |
| 2 |
| 3 |
| 4 |
| 5 |
| 6 |
| 7 |
| 8 |
| 9 |

   

** access to variables set in property drawers
   :PROPERTIES:
   :special:  89
   :text: schulte
   :DATE:     2010-03-22
   :END:

: "(org-entry-get nil "special" t)"

#+begin_src emacs-lisp :var special=(string-to-number (org-entry-get nil "special" t))
  (+ special 1)
#+end_src

#+name:
: 90

#+begin_src emacs-lisp :var special=(org-entry-get nil "text" t)
  special  
#+end_src

#+name:
: schulte

   

** latex attributes
   :PROPERTIES:
   :DATE:     2010-03-23
   :END:

#+ATTR_LaTeX: width=0.38\textwidth wrap placement={r}{0.4\textwidth}
#+begin_src ditaa :file=scrap.png
  +---------------------------+
  |                           |
  |       latex               |
  |                           |
  |      +------------+       |
  |      |            |       |
  |      |            |       |
  |      |       cBLU |       |
  |      +------------+       |
  |                      cPNK |
  +---------------------------+
#+end_src

   

** tangling and variable resolution
  :PROPERTIES:
  :ID:       18b4f1be-bb1d-49bc-a651-c97406a35bdd
  :tangle:   yes
  :DATE:     2010-03-31
  :END:

#+name: A
#+begin_src emacs-lisp :eval no :expand yes :var id=(org-entry-get nil "ID" t) :var two=2
  (concat "This is the entry ID: " id)
#+end_src

#+name: A
: This is the entry ID: 18b4f1be-bb1d-49bc-a651-c97406a35bdd

   

** evaluate references
   :PROPERTIES:
   :DATE:     2010-04-09
   :END:

#+begin_src emacs-lisp :var var=`(+ 9 ,(- 19 7)) :tangle yes
  (message "var is %S" var)
#+end_src

#+begin_src emacs-lisp
  (+ 1 2)
#+end_src

#+name:
: 3

#+begin_src ruby
  + 1 2
#+end_src

#+name:
: nil

   

** hline processing
   :PROPERTIES:
   :DATE:     2010-04-12
   :END:
#+tblname: many-cols
| a | b | c |
|---+---+---|
| d | e | f |
|---+---+---|
| g | h | i |

#+tblname: less-cols
| 1 |
|---|
| 2 |
| 3 |

#+tblname: less-cols2
| 1 | 2 | 3 |

#+begin_src emacs-lisp :var tab=many-cols
  (message "%S" tab)
  ;; (remove 'hline tab)
  ;; (flet ((rem-hline (el)
  ;;                   (if (listp el)
  ;;                       (remove nil (mapcar #'rem-hline el))
  ;;                     (if (equal 'hline el) nil el))))
  ;;   (rem-hline tab))
#+end_src

#+begin_src ruby :var tab=less-cols
  tab
#+end_src

#+name:
| 1 |
|---|
| 2 |
| 3 |

#+begin_src ruby :var one=2
  1 + 2
#+end_src

#+name:
: 3

#+begin_src python :var tab=less-cols
  return tab
#+end_src

#+name:
| 1 |
|---|
| 2 |
| 3 |

#+begin_src ruby :var tab=less-cols :colnames no
  tab
#+end_src

#+name:
| 1 |
| 2 |
| 3 |

#+begin_src emacs-lisp :var tab=row-and-col-names
   (message "%S" tab)
#+end_src

#+name:
: (("" "c1" "c2" "c3") hline ("r1" 1 4 7) ("r2" 2 5 8) ("r3" 3 6 9))

#+tblname: row-and-col-names
|    | c1 | c2 | c3 |
|----+----+----+----|
| r1 |  1 |  4 |  7 |
| r2 |  2 |  5 |  8 |
| r3 |  3 |  6 |  9 |

functions
#+begin_src emacs-lisp
  (defun org-babel-del-hlines (table)
    "Remove all 'hlines from TABLE."
    (remove 'hline table))
  
  (defun org-babel-get-colnames (table)
    "Return a cons cell, the `car' of which contains the TABLE
        less colnames, and the `cdr' of which contains a list of the
        column names"
    (if (equal 'hline (second table))
        (cons (cddr table) (car table))
      table))
    
  (defun org-babel-get-rownames (table)
    "Return a cons cell, the `car' of which contains the TABLE less
     colnames, and the `cdr' of which contains a list of the column
     names.  Note: this function removes any hlines in TABLE"
    (flet ((trans (table) (apply #'mapcar* #'list table)))
      (let ((table (trans (remove 'hline table))))
        (cons (cdr table) (car table)))))
  
  (defun org-babel-put-colnames (table colnames)
    "Add COLNAMES to TABLE if they exist."
    (if colnames (apply 'list colnames 'hline table) table))
  
  (defun org-babel-put-rownames (table rownames)
    "Add ROWNAMES to TABLE if they exist."
    (if rownames
        (mapcar (lambda (row)
                  (if (listp row)
                      (cons (or (pop rownames) "") row)
                    row)) table)
      table))
#+end_src

   

** test gnuplot
   :PROPERTIES:
   :DATE:     2010-04-17
   :END:

#+begin_src gnuplot
  plot sin(x), x+5
#+end_src

   

** colnames mismatched sizes
   :PROPERTIES:
   :DATE:     2010-04-23
   :END:
#+tblname: mismatch-colnames
| a |  b |
|---+----|
| 1 |  8 |
| 2 |  9 |
| 3 | 10 |
| 4 | 11 |

#+begin_src python :var tab=mismatch-colnames
  return [[1, 2, 3]]
#+end_src

#+name:
| 1 | 2 | 3 |

#+begin_src python :var tab=mismatch-colnames
  return [[1, 2]]
#+end_src

#+name:
| a | b |
|---+---|
| 1 | 2 |

#+begin_src python :var tab=mismatch-colnames :colnames yes
  return [1,2]
#+end_src

#+name:
| 1 | 2 |

   

** variable indexing
   :PROPERTIES:
   :DATE:     2010-04-23
   :END:
#+TBLNAME: MyTable
 |   X |  Y |
 |-----+----|
 |   0 |  0 |
 |   1 |  1 |
 |   2 |  4 |
 |   3 |  9 |
 |   4 | 16 |
 |   5 | 25 |
 |-----+----|
 | Sum | 55 |
 #+TBLFM: $2=$1*$1::@8$2=vsum(@2..@-1)

#+begin_src python :var sum=MyTable[2:7,1] :exports none
   return sum
#+end_src

#+name:
| 0 | 1 | 4 | 9 | 16 | 25 |

#+begin_src python :var sum=MyTable[9,1] :exports none
   return sum
#+end_src

#+name:
: 55

#+begin_src gnuplot :var data=MyTable[1:-2] :var sum=MyTable[7,1]
:results silent :exports none
  reset
  set label "Sum: %.0f",sum at graph 0.03, graph 0.93
  plot data with linespoints
#+end_src

   

** tangling org
   :PROPERTIES:
   :DATE:     2010-04-27
   :END:

#+begin_src org :tangle ~/Desktop/test.org
  ,* first
  ,| eric   | me     |
  ,| patton | my dog |
  
  ,* second
  
  ,some more stuff...
  
  ,#+HTML: <b>I bet this is quoted</b>
#+end_src

#+begin_src ruby :tangle ~/Desktop/test.rb
  # this is a comment
  eric.map{|l| puts l}
#+end_src

   

** lisps not fully eval'd
   :PROPERTIES:
   :DATE:     2010-04-30
   :END:

#+begin_src emacs-lisp
  (message "one")
  (message "two")
#+end_src

#+name:
: two

#+begin_src clojure :session :default
  (println "one")
  (println "two")
  (+ 1 2)
#+end_src

#+name:
: 3

   

** colnames
   :PROPERTIES:
   :DATE:     2010-05-04
   :END:

#+tblname: A
| a | b | c |
|---+---+---|
| d | e | f |
| g | h | i |

#+begin_src python :var tab=A :colnames yes
return [[val + '*' for val in row] for row in tab]
#+end_src

#+name:
| a  | b  | c  |
|----+----+----|
| d* | e* | f* |
| g* | h* | i* |

#+tblname: A
| a | b | c |
| d | e | f |
| g | h | i |

#+begin_src ruby :var tab=A :colnames yes
tab.map{|r| r.map{|e| e+"*"} }
#+end_src

#+name:
| a  | b  | c  |
|----+----+----|
| d* | e* | f* |
| g* | h* | i* |

   

** empty code blocks -- and latex vs. LaTeX
   :PROPERTIES:
   :DATE:     2010-05-26
   :END:
eric
#+begin_src latex
  
#+end_src

michael
#+begin_src LaTeX
  
#+end_src

schulte
#+begin_src emacs-lisp
  (message "error")
#+end_src

   

** visibility affecting execution
   :PROPERTIES:
   :DATE:     2010-05-27
   :END:

*** folding
    :PROPERTIES:
    :DATE:     2010-05-27
    :END:
lets test folding

**** folded
     :PROPERTIES:
     :DATE:     2010-05-27
     :END:
#+begin_src emacs-lisp
  (message "folded1")
#+end_src

#+name:
: folded1

#+begin_src emacs-lisp
  (message "folded2")
#+end_src

#+name:
: folded2
**** unfolded
     :PROPERTIES:
     :DATE:     2010-05-27
     :END:
#+begin_src emacs-lisp
  (message "unfolded1")
#+end_src

#+name:
: unfolded1
#+begin_src emacs-lisp
  (message "unfolded2")
#+end_src

#+name:
: unfolded2

   

** appending tangle
   :PROPERTIES:
   :tangle:   appended.el
   :DATE:     2010-05-28
   :END:
append all these block

#+begin_src emacs-lisp
  (message "block %d" 1)
#+end_src

#+begin_src emacs-lisp
  (message "block %d" 2)
#+end_src

#+begin_src emacs-lisp
  (message "block %d" 3)
#+end_src

   

** adding file names to literal values on export
   :PROPERTIES:
   :DATE:     2010-06-01
   :END:

#+name: three
: 9

#+begin_src R :var num=three :exports results
runif(n=num, min=0, max=1)
#+end_src

#+begin_src R :var num=3 :exports results
runif(n=num, min=0, max=1)
#+end_src

   

** inline expressions
   :PROPERTIES:
   :session:  'default
   :DATE:     2010-06-06
   :END:

#+begin_src R :exports code :results silent
  x<-4
#+end_src

the sum of 1 and x is equal to src_R{x+1}, now I'll sneakily reset
this value in a hidden inline block src_R[:exports none]{x<-2}, so
it's value is now src_R{x}.

   

** simple table
   :PROPERTIES:
   :DATE:     2010-06-06
   :END:
#+begin_src emacs-lisp
  '((1 2 3) (4 5 6) (7 8 900))
#+end_src

#+name:
| 1 | 2 |   3 |
| 4 | 5 |   6 |
| 7 | 8 | 900 |

   

** commas on tangling test
   :PROPERTIES:
   :DATE:     2010-06-07
   :END:
test comma protection on tangling

#+begin_src emacs-lisp :results silent
  (org-babel-add-interpreter "org")
  (add-to-list 'org-babel-tangle-langs '("org" "org"))
#+end_src

#+begin_src org :tangle commas.org
  ,* org-mode
  ,  :PROPERTIES:
  ,  :CUSTOM_ID: comma-protect
  ,  :END:
  
  ,#+begin_src emacs-lisp
  ,  protected?
  ,#+end_src
#+end_src

#+begin_example 
  ,* this should be
  # commented out
  
  and maybe not this...
#+end_example

   

** executing emacs-lisp on export
   :PROPERTIES:
   :DATE:     2010-06-07
   :END:

#+begin_src emacs-lisp
  (error "eric")
#+end_src

   

** export with existing results
   :PROPERTIES:
   :DATE:     2010-06-07
   :END:

#+begin_src emacs-lisp :exports none :results silent
  '((1 2) (3 4))
#+end_src

#+name:
| 1 | 2 |
| 3 | 4 |

#+begin_src ditaa :file /tmp/eric.png :exports none :results silent
    +---------------+
    |               |
    |               |
    |               |     +-----------------+
    |    Eric       |     |                 |
    |               |     |    Schulte      |
    |               |     |                 |
    |               |     +-----------------+
    +---------------+
#+end_src

#+name:
[[file:/tmp/eric.png]]

   

** indented source names
   :PROPERTIES:
   :DATE:     2010-06-07
   :END:

   #+name: i-am-indented
   #+begin_src emacs-lisp 
     (message "i am indented")
   #+end_src

#+name: i-am-indented
: i am indented

#+begin_src emacs-lisp :var output=i-am-indented
  (length output)
#+end_src

#+name:
: 13

  #+name:
  : eric

   

** inhibiting evaluation on export
   :PROPERTIES:
   :noeval:   don't do it
   :DATE:     2010-06-07
   :END:

#+begin_src clojure :session eric :exports none
  (+ 1 1 1 1)
  (error)
#+end_src

   

** non-empty comint prompt
   :PROPERTIES:
   :DATE:     2010-06-07
   :END:

#+begin_src ruby :session eric
  8 + 9
#+end_src

   

** stripping existing results
   :PROPERTIES:
   :DATE:     2010-06-07
   :END:
#+name: trickily-located-somehwere-else
: I shouldn't be exported

Neither of the result strings for the following two code blocks should
be included in the export.  And only one of the bodies should be
included...

#+begin_src emacs-lisp :exports code
  (+ 1 1 1 1)
#+end_src

#+name:
: don't include me in the export!!!!!!!

#+name: trickily-located-somehwere-else
#+begin_src emacs-lisp :exports none
  (message "I shouldn't be exported")
#+end_src

   

** unwind-protect with narrowing
   :PROPERTIES:
   :DATE:     2010-06-07
   :END:

I'm not in the subtree

*** I'm in the subtree
    :PROPERTIES:
    :DATE:     2010-06-07
    :END:
#+begin_src emacs-lisp
  (+ 6 "I'm not a number!!")
#+end_src

   

** updating results "in-situ"
   :PROPERTIES:
   :DATE:     2010-06-07
   :END:

#+name: in-situ
: update me in place please -- Mon Jun  7 16:44:44 2010
: update me in place please -- Mon Jun  7 16:44:43 2010
: update me in place please -- Mon Jun  7 16:44:42 2010
: update me in place please -- Mon Jun  7 16:44:37 2010
: update me in place please -- Mon Jun  7 16:42:14 2010
: update me in place please (at the bottom) -- Mon Jun  7 16:44:59 2010
: update me in place please (at the bottom) -- Mon Jun  7 16:45:00 2010
: update me in place please (at the bottom) -- Mon Jun  7 16:45:02 2010

the results should be *above* the block

#+name: in-situ
#+begin_src emacs-lisp :results prepend
  (format "update me in place please -- %s"
          (current-time-string))
#+end_src

#+name: in-situ
#+begin_src emacs-lisp :results append
  (format "update me in place please (at the bottom) -- %s"
          (current-time-string))
#+end_src

   

** not expand inlines in examples
   :PROPERTIES:
   :DATE:     2010-06-08
   :END:

: src_emacs-lisp{(+ 1 2 3)}

#+begin_example 
  src_emacs-lisp{(+ 1 2 3)}
#+end_example

src_emacs-lisp{(+ 1 2 3)}

#+begin_example 
  src_emacs-lisp{(+ 1 2 3)}
#+end_example

   

** indented source-code blocks and indented results
   :PROPERTIES:
   :DATE:     2010-06-10
   :END:

    #+name: time
    #+begin_src emacs-lisp :results append
      ;; (list (list (current-time-string)))
      (current-time-string)
    #+end_src

    #+name: time
    | 1 | 2 | 3 |


        #+call: time() :results prepend

        #+name: time()
        | 1 | 2 | 3 |
        : Thu Jun 10 14:13:21 2010
        : Thu Jun 10 14:13:21 2010
        : : Thu Jun 10 14:13:21 2010
        : : Thu Jun 10 14:13:21 2010
        : : Thu Jun 10 14:13:21 2010
        : nil
        : nil
        : Thu Jun 10 14:11:22 2010
        : Thu Jun 10 14:11:20 2010
        : nil
        : nil
        : Thu Jun 10 14:06:04 2010
        : Thu Jun 10 14:06:03 2010
        : Thu Jun 10 14:05:51 2010
        : Thu Jun 10 14:05:57 2010
        : Thu Jun 10 14:06:00 2010

   

** can't open indented results
   :PROPERTIES:
   :DATE:     2010-06-11
   :END:

   #+begin_src latex :packages '(("" "tikz") ("active,tightpage" "preview")) :file recursion.pdf
     \begin{preview}
     \ovalbox{
     \begin{tikzpicture}
     \node{$n$}
       child {
         node{$\left(\frac{n}{2}\right)^2$}
           child{
             node{$\left(\frac{n}{4}\right)^2$}
             node{$\left(\frac{n}{4}\right)^2$}
           }
         }
       child{
         node{$\left(\frac{n}{2}\right)^2$}
         child{
           node{$\left(\frac{n}{4}\right)^2$}
           node{$\left(\frac{n}{4}\right)^2$}
         }
       };
     \end{tikzpicture}
     }
     \end{preview}
   #+end_src

   #+name:
   [[file:recursion.pdf]]

   

** exporting with call lines
   :PROPERTIES:
   :DATE:     2010-06-11
   :END:
#+name: rpn-to-alg(alg)
#+begin_src clojure :results output :var alg="00+"
  (def binary-operators '(\+ \- \* \/))
  (def unary-operators '(\s))
  (defn rpn-to-alg [chars stack]
    (if (> (.size chars) 0)
      (let [el (first chars)]
        (if (some #{el} binary-operators)
          (rpn-to-alg (rest chars)
                      (cons
                       (apply str "(" (or (second stack) 1) " " el " " (or (first stack) 1) ")")
                       (rest (rest stack))))
          (if (some #{el} unary-operators)
            (rpn-to-alg (rest chars)
                        (cons
                         (apply str "(" el " " (or (first stack) 1) ")")
                         (rest (rest stack))))
            (rpn-to-alg (rest chars) (cons el stack)))))
      (first stack)))
  (println (apply str (rpn-to-alg (seq alg) '())))
#+end_src

#+name: distributed-best
: 73*x11/+4/++51xxx13*y/++6y5*6/6-+xx+*

#+call: rpn-to-alg(alg=distributed-best)
 
   

** simple reference
   :PROPERTIES:
   :DATE:     2010-06-13
   :END:
#+tblname: table-the-first
| 1 | 2 | 3 |
| 4 | 5 | 6 |
| 7 | 8 | 9 |

#+begin_src emacs-lisp :var data=table-the-first[1,1]
  data
#+end_src

#+name:
: 5

   

** don't eat me!
   :PROPERTIES:
   :DATE:     2010-06-15
   :END:
1) a source block inside of an =enumerate=
   #+begin_src emacs-lisp :exports results
     (list (list "I'm hungry" "I'm hungry")
           (list "I'm hungry" "I'm hungry")
           (list "I'm hungry" "I'm hungry"))
   #+end_src

   #+name:
   | I'm hungry | I'm hungry |
   | I'm hungry | I'm hungry |
   | I'm hungry | I'm hungry |

   #+begin_src emacs-lisp
     (message "don't eat me")
   #+end_src

   can cause problems

2) source blocks should be able to be on adjacent lines

   

** comments not commented
   :PROPERTIES:
   :DATE:     2010-06-16
   :END:

# $some stuff
# some more stuff$ -- I should be a comment line

1) a source block inside of an =enumerate=
   #+name: plotxy
   #+begin_src emacs-lisp :exports results
     (message "I think so")
   #+end_src
   #+begin_src emacs-lisp
     (message "don't eat me")
   #+end_src
   

   can cause problems

2) how about this one...
   

** foo org
   :PROPERTIES:
   :session:  *R*
   :DATE:     2010-06-16
   :END:
Figure \ref{fig:one} (p. \pageref{fig:one}) is produced by the following code
#+BEGIN_SRC R 
plot(x, y)
abline(out1)
#+END_SRC
Note that =x=, =y=, and =out1= are remembered from the preceding code
chunk.  We don't have to regenerate them.  All code chunks are part of
one R "session".
and more stuff here and then the results
#+attr_latex: width=0.8\textwidth,placement=[p]
#+label: fig:one
#+caption: Scatter Plot with Regression Line
[[file:fig1.pdf]]

   

** cache on export
   :PROPERTIES:
   :DATE:     2010-06-17
   :END:
do we export cached blocks

#+begin_src sh :cache yes :exports results
  date
#+end_src

#+name[06ed73c6d8d022cf9c323d92af885952865add17]:
: Thu Jun 17 07:35:19 PDT 2010

   

** tangling
   :PROPERTIES:
   :DATE:     2010-06-17
   :END:

#+begin_src sh :shebang #!/bin/sh :tangle yes
  date
#+end_src

#+begin_src sh :shebang #!/bin/bash :tangle whoisme :exports both
  echo $USER
#+end_src

#+begin_src emacs-lisp :tangle yes :comments yes
  (message "BAM")
#+end_src

#+begin_src fortran :exports both
  1+8
#+end_src

   

** multiple evals for refs
   :PROPERTIES:
   :DATE:     2010-06-25
   :END:
#+begin_src emacs-lisp
  (setq counter 0)
#+end_src

#+name:
: 0

#+name: counter
#+begin_src emacs-lisp
  (setq counter (+ 1 counter))
  counter
#+end_src

#+begin_src emacs-lisp :var counter_val=counter
  counter_val
#+end_src

#+name:
: 3

   

** protecting block bodies
   :PROPERTIES:
   :DATE:     2010-06-25
   :END:
neither of these work as expected

#+begin_src org
  ,#+TITLE: stuff
  
  ,#+begin_src emacs-lisp
  ,  (message "something")
  ,#+end_src
  
  ,more stuffs
  
  ,#+resname: something
  ,: value
  
  ,# and a comment
#+end_src

#+begin_src org
  ,* example org
  
  ,# this is a comment
  ,this is not a comment
#+end_src


#+begin_src org
  ,* escaped org-mode markup
  
  ,this should be exported as is
  ,#+results: escaping-example
  ,: 24
#+end_src


#+begin_html 
<pre>
#comment
#+end_src
</pre>
#+end_html
final

   

** hlines in python
   :PROPERTIES:
   :DATE:     2010-06-26
   :END:

#+tblname: many-cols
| a | b | c |
|---+---+---|
| d | e | f |
|---+---+---|
| g | h | i |

#+name: echo-table
#+begin_src python :var tab=many-cols :hlines yes :exports both :session
  return tab
#+end_src

#+begin_src emacs-lisp :var table=echo-table :exports none
  (butlast (apply #'append (mapcar (lambda (el) (list el 'hline)) table)))
#+end_src

#+call: echo-table(tab=many-cols)

#+begin_src python :exports results
  return [['foo', 'bar', 'baz'], ["a", "b", "None of the above"], ['1', 2, 3]]
#+end_src

#+begin_src emacs-lisp :exports results
  (message "Exist")
#+end_src

   

** possible prefixes
   :PROPERTIES:
   :DATE:     2010-06-26
   :END:

| prefix   | remaining characters |
|----------+----------------------|
| ob-      |                    5 |
| org-b-   |                    2 |
| orgb-    |                    3 |
| org-bbl- |                    0 |
| bbl-     |                    4 |
| babel-   |                    2 |
#+TBLFM: $2='(sbe leftover (prefix $$1))

#+name: leftover
#+begin_src emacs-lisp :var prefix=""
  (-
   ;; length w/o .el
   (- 13 (length ".el"))
   ;; length of prefix
   (length prefix))
#+end_src

   

** complex
   :PROPERTIES:
   :DATE:     2010-06-28
   :END:
#+name: raw-data
#+begin_src sh :results scalar
  wget --quiet -qO- "http://ogdi.cloudapp.net/v1/dc/RecreationParks?format=json"
#+end_src

#+name: dc-parks
#+begin_src emacs-lisp :var keys='(ward area) :var data=raw-data
  (mapcar
    (lambda (lis) (mapcar (lambda (key) (cdr (assoc key lis))) keys))
    (cdr (car (with-temp-buffer
                (insert data) (goto-char (point-min))
                (json-read)))))
#+end_src

#+name: dc-parks-metric
#+begin_src ruby :var data=dc-parks
  data.map{|f| [f[0], 2.59 * f[1]]}
#+end_src

#+begin_src R :var parkData=dc-parks-metric :file parks.png :session *R*
  plot(parkData)
  title(main="Park size by Ward")
#+end_src

#+name:
[[file:parks.png]]

   

** haskell issues
   :PROPERTIES:
   :DATE:     2010-06-28
   :END:

#+begin_src haskell
  length [1, 2]
#+end_src

#+name:
: 2

#+tblname: example-4-haskell
| 1 |
| 2 |
| 3 |
| 4 |
| 5 |
| 6 |
| 7 |

#+begin_src haskell :var this=example-4-haskell
  length this
#+end_src

#+name:
: 7

   

** table-label
   :PROPERTIES:
   :DATE:     2010-06-28
   :END:
#+label: bam
| 1 |
| 2 |
| 3 |

   

** booktabs
   :PROPERTIES:
   :DATE:     2010-06-29
   :END:
#+tblname: months
| num | Abbrev. |
|-----+---------|
|   1 | Jan.    |
|   2 | Feb.    |
|   3 | Mar.    |

#+call: booktabs(table=months, align="r|l") :results latex :exports results

   

** captions
   :PROPERTIES:
   :DATE:     2010-06-29
   :END:

#+caption: I'm not removed from export
#+label: also-not-removed
| A | B |
| 1 | 2 |

   

** latex literals in export
   :PROPERTIES:
   :DATE:     2010-06-30
   :END:

  #+ATTR_LaTeX: width=\textwidth
  [[./composite-pattern.png]]

   

** table comment issue
   :PROPERTIES:
   :DATE:     2010-06-30
   :END:
#+BEGIN_changemargin {-4.2cm}{0cm}
  #+TBLNAME: AutresFPNVE
  #+ATTR_LaTeX: align=lrrrrr
  |   |                                          | Montant total (\EUR) | Taux amort (\%) | Part pro. (\%) | Déduc (\%) | NVE (\EUR) |
  |---+------------------------------------------+----------------------+-----------------+----------------+------------+------------|
  |   | Documentation et formation               |                51.05 |                 |                |            |       0.00 |
  |   | Communications GSM                       |               831.16 |             100 |             25 |        100 |     207.79 |
  |   | Internet (Dommel)                        |               167.88 |             100 |             33 |        100 |      55.40 |
  |   | Fournitures à amortir (ordinateur + GSM) |               762.51 |              33 |             80 |        100 |     201.30 |
  |   | Restaurant                               |               304.70 |             100 |            100 |         69 |     210.24 |
  |---+------------------------------------------+----------------------+-----------------+----------------+------------+------------|
  |   | Total                                    |                      |                 |                |            |    1062.02 |
  | ^ |                                          |                      |                 |                |            |      Total |
  #+tblfm: $7=$3*$4*$5*$6/1000000;%.2f::@2$3=51.05::@3$3=9.00+184.88+51.22+201.82+45.67+69.03+62.93+54.16+38.87+39.77+36.35+37.46::@4$3=12*13.99::@6$3=146.50+158.20;%.2f::@7$7=vsum(@-I..@-II);%.2f
#+END_changemargin

save me!

#+begin_src org
  ,  #+TBLNAME: AutresFPNVE
  ,  #+ATTR_LaTeX: align=lrrrrr
  ,  |   |                                          | Montant total (\EUR) | Taux amort (\%) | Part pro. (\%) | Déduc (\%) | NVE (\EUR) |
  ,  |---+------------------------------------------+----------------------+-----------------+----------------+------------+------------|
  ,  |   | Documentation et formation               |                51.05 |                 |                |            |       0.00 |
  ,  |   | Communications GSM                       |               831.16 |             100 |             25 |        100 |     207.79 |
  ,  |   | Internet (Dommel)                        |               167.88 |             100 |             33 |        100 |      55.40 |
  ,  |   | Fournitures à amortir (ordinateur + GSM) |               762.51 |              33 |             80 |        100 |     201.30 |
  ,  |   | Restaurant                               |               304.70 |             100 |            100 |         69 |     210.24 |
  ,  |---+------------------------------------------+----------------------+-----------------+----------------+------------+------------|
  ,  |   | Total                                    |                      |                 |                |            |    1062.02 |
  ,  | ^ |                                          |                      |                 |                |            |      Total |
  ,  #+TBLFM: $7=$3*$4*$5*$6/1000000;%.2f::@2$3=51.05::@3$3=9.00+184.88+51.22+201.82+45.67+69.03+62.93+54.16+38.87+39.77+36.35+37.46::@4$3=12*13.99::@6$3=146.50+158.20;%.2f::@7$7=vsum(@-I..@-II);%.2f
#+end_src

#+begin_example 
#+tblname: example
| 1 | 2 |
#+end_example

   

** python errors
   :PROPERTIES:
   :DATE:     2010-07-04
   :END:
#+begin_src python :session :results value
  [1, [2], 3, 4]
#+end_src

#+name:
| 1 | (2) | 3 | 4 |

#+begin_src ruby :results output :session
  [1, 2, 3, 4, 6].map{|n| puts n}
#+end_src

#+name:
: 1
: 2
: 3
: 4
: 6

#+begin_src python :session :results output
  print 9
#+end_src

#+name: R-with-colnames
| one |
|-----|
| 1   |

#+begin_src R :results output
  "something"
#+end_src

#+name:
: [1] "something"

#+begin_src R :session *R* :results output
  1
  2
  3
  4
#+end_src

#+name:
: [1] 1
: [1] 2
: [1] 3
: [1] 4

#+begin_src perl :results output
  print "8\n";
  print "9\n";
#+end_src

#+name:
: 8
: 9

#+begin_src clojure
  (+ 8 7)
#+end_src

#+name:
: 15

#+begin_src clojure :session *clj*
  (println "eric")
#+end_src

#+name:
: nil

#+begin_src perl :results value
  8
#+end_src

#+name:
: 8

#+begin_src c++ :includes '(<stdio.h> <math.h> <cstdlib> <time.h>)
  printf("eric schulte\n");
#+end_src

#+name:
: eric schulte

#+begin_src sh
  echo 78
#+end_src

#+name:
: 78

   

** dot
   :PROPERTIES:
   :DATE:     2010-07-06
   :END:
#+begin_src dot :file models.png :cmdline -Tpng
  digraph data_relationships {
    "data_requirement" [shape=Mrecord, label="{DataRequirement|description\lformat\l}"]
    "data_product" [shape=Mrecord, label="{DataProduct|name\lversion\lpoc\lformat\l}"]
    "data_requirement" -> "data_product"
  }
#+end_src

#+name:
[[file:models.png]]

   

** Tom found a bug
   :PROPERTIES:
   :DATE:     2010-07-06
   :END:

#+begin_src emacs-lisp :tangle something.el
  (list 1 (+ 2 3))
#+end_src

#+name:
| 1 | 5 |

   

** scratch
   :PROPERTIES:
   :DATE:     2010-07-08
   :END:

#+begin_src emacs-lisp :exports results
  (+ 1 1 1 1)
  (setq org-export-babel-evaluate t)
#+end_src

and now for src_emacs-lisp{87} an inline block

looking at paths
#+begin_src emacs-lisp
  (buffer-file-name)
#+end_src

   

** export blocks w/o languages
   :PROPERTIES:
   :DATE:     2010-07-09
   :END:
should raise an error

source
#+begin_src emacs-lisp
  ;; this is a comment
  (+ 1 1 1)
#+end_src

broken source
#+begin_src 
  (+ 2 2 2)
#+end_src

example
#+begin_example 
  this is exampled
#+end_example

#+begin_src ruby
  # this is the first
  [1, 2, 3, 4, 5].map{|r| r+1}
#+end_src

   

** tangle R and load
   :PROPERTIES:
   :tangle:   with-comments.r
   :comments: yes
   :DATE:     2010-07-09
   :END:

#+begin_src R :tangle no
  z <- 0
#+end_src

#+begin_src R
  x <- 8
#+end_src

#+begin_src R
  y <- 9
#+end_src

#+name: i-have-a-name
#+begin_src R 
  x+y+z
#+end_src

   

** example w/o source name
   :PROPERTIES:
   :DATE:     2010-07-12
   :END:

delete emacs-lisp below for errors
#+begin_src emacs-lisp
  (* (+ 1 1 1) (+ 1 1 1) (+ 1 1 1) (+ 1 1 1) (+ 1 1 1) (+ 1 1 1) (+ 1 1 1))
#+end_src

   

** fixing result insertion
   :PROPERTIES:
   :DATE:     2010-07-12
   :END:
needs to replace the results when there is a new hash

*** normal results
    :PROPERTIES:
    :DATE:     2010-07-12
    :END:
#+begin_src sh
  date
#+end_src

#+name:
: Mon Jul 12 22:18:16 PDT 2010

*** unnamed source block results
    :PROPERTIES:
    :DATE:     2010-07-12
    :END:
#+begin_src emacs-lisp :cache yes
  (+ 1 2 3 4)
#+end_src

#+name[16a776d6d139e1d39e99d736536a546df115c2dc]:
: 10

#+begin_src emacs-lisp :cache yes
  (list '(1 2 3) '(4 5 6))
#+end_src

#+name[53f489ed6977857b9945d79d06e575b2cbbebf11]:
| 1 | 2 | 3 |
| 4 | 5 | 6 |

*** named source block results
    :PROPERTIES:
    :DATE:     2010-07-12
    :END:

#+name: something-w-table
#+begin_src emacs-lisp
  (sleep-for 2)
  (list '(1 2 3) '(4 5 8))
#+end_src

#+name: something
#+begin_src emacs-lisp :cache yes
  (+ 1 2 3 4 8)
#+end_src

Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do
eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enimad
minim veniam, quis nostrud exercitation ullamco laboris nisi ut
aliquip ex ea commodo consequat. Duis aute irure dolor in
reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla
pariatur. Excepteur sint occaecat cupidatat non proident, sunt in
culpa qui officia deserunt mollit anim id est laborum.

# something else
#+name[d053f6643d9dc52a0e804c15f2a762da73a00a07]: something
: 18

#+attr_latex: width=0.4\textwidth
#+name[5fac69648ab749ef9ee88ea65b3d49d93f3f6cc8]: something-w-table
| 1 | 2 | 3 |
| 4 | 5 | 8 |

   

** limited precision
   :PROPERTIES:
   :DATE:     2010-07-12
   :END:

#+name: anova-example
| Effect | DFn | DFd |             SSn |              SSd |                F |                    p | p<.05 |              pes |
|--------+-----+-----+-----------------+------------------+------------------+----------------------+-------+------------------|
| Days   |   9 | 153 | 166235.12250176 | 151101.038615303 | 18.7026979326383 | 8.99534541600196e-21 | *     | 0.52384550792003 |

#+begin_src emacs-lisp :var tab=anova-example :colnames yes :cache yes
  (mapcar
   (lambda (row)
     (mapcar
      (lambda (cell) (if (numberp cell) (format "%.4f" cell) cell))
      row))
   tab)
#+end_src

#+name[16ac354f1e7a65594bb59e252ab221e6a4b10f80]:
| Effect |    DFn |      DFd |         SSn |         SSd |       F |                    p | p<.05 |    pes |
|--------+--------+----------+-------------+-------------+---------+----------------------+-------+--------|
| Days   | 9.0000 | 153.0000 | 166235.1225 | 151101.0386 | 18.7027 | 8.99534541600196e-21 | *     | 0.5238 |

   

** input from an example block
   :PROPERTIES:
   :DATE:     2010-07-13
   :END:
#+name: lorem
#+begin_example 
  Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do
  eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut
  enimad minim veniam, quis nostrud exercitation ullamco laboris nisi
  ut aliquip ex ea commodo consequat. Duis aute irure dolor in
  reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla
  pariatur. Excepteur sint occaecat cupidatat non proident, sunt in
  culpa qui officia deserunt mollit anim id est laborum.
#+end_example

#+begin_src emacs-lisp :var lorem=lorem
  (message "%d words in Lorem" (length (split-string lorem)))
#+end_src

#+name:
: 68 words in Lorem

#+name: 1D
| 1 |
| 2 |
| 3 |
| 4 |

#+begin_src emacs-lisp :var lst=1D[:,0]
  lst
#+end_src

#+name:
: 1

   

** palendromic primes
   :PROPERTIES:
   :DATE:     2010-07-20
   :END:
Note that because Haskell is funny about what can be typed into the
interpreter, the following should be loaded with
=org-babel-load-in-session=.
#+begin_src haskell
  palendromic_primes = [x | x <- [1..], prime x, palendrome x]
      where
        factors n = [x | x <- [1..floor(sqrt(fromIntegral(n)))], n `mod` x == 0]
        prime n = factors n == [1]
        primes = [x | x <- [2..], prime x]
        palendrome n = show(n) == reverse(show(n))
  
  palendromic_prime_distances = map (\(x,y)-> y-x) neighbors
      where
        neighbors = (zip palendromic_primes (tail palendromic_primes))
#+end_src

#+name: palendromic_prime_distances
#+begin_src haskell
  take 180 (zip [1..] palendromic_prime_distances)
#+end_src

For high-quality png output from gnuplot, the following sequence of
graphing to a =.eps= file, and then converting to a =.png= can be
useful.
#+name: dist-graph
#+begin_src gnuplot :var data=palendromic_prime_distances :file pps.eps
  set term postscript landscape color enhanced
  set log y
  set title "distance between consecutive palendromic primes"
  plot "$data" with fs notitle
#+end_src

The =convert= command is part of the [[http://www.imagemagick.org/script/index.php][imagemagick]] suite.
#+begin_src sh :var input=dist-graph :results file
  convert -depth 300 -rotate 90 $input pps.png
  echo "pps.png"
#+end_src

   

** caption on code block
   :PROPERTIES:
   :DATE:     2010-07-22
   :END:

#+caption: Examples of variable declaration.
#+label: sql-block
#+begin_src sql
SELECT 6*9;
#+end_src

   

** colnames to specific variables
   :PROPERTIES:
   :DATE:     2010-07-22
   :END:

#+tblname: spec-colnames
| one | two | thee |
|-----+-----+------|
| 1   | 2   | 3    |

#+tblname: nospec-colnames
| three | two | one |
|-------+-----+-----|
|     3 |   2 |   1 |

#+begin_src python :var nospec=nospec-colnames :var spec=spec-colnames :colnames '(spec)
  return nospec
#+end_src

#+name:
| one   | two | thee |
|-------+-----+------|
| three | two | one  |
| 3     | 2   | 1    |

   

** comments in R blocks
   :PROPERTIES:
   :DATE:     2010-08-12
   :END:

#+begin_src R :session *R* :results output
  # this is a comment
  x <- rnorm(1)
  # this is another comment
  x
#+end_src

#+name:
: 
: [1] 1.320853

   

** importing the output of ledger
   :PROPERTIES:
   :DATE:     2010-08-12
   :END:
#+name: ledger-output
#+begin_example 
  09-Aug-21 CHEQUE : 9953055                    Expenses:Unknown                                    166.70 EUR            166.70 EUR
  09-Sep-17 CHEQUE : 7691785                    Expenses:Unknown                                    100.00 EUR            266.70 EUR
  09-Oct-16 REMISE CHEQUE N 8686318 001 105     Expenses:Unknown                                   -525.00 EUR           -258.30 EUR
#+end_example

#+begin_src emacs-lisp :var ledger=ledger-output
  (with-temp-buffer
    (insert ledger)
    (message ledger)
    (org-table-convert-region (point-min) (point-max) 2)
    (org-table-to-lisp))
#+end_src

#+name:
| 09-Aug-21 CHEQUE : 9953055                | Expenses:Unknown | 166.70 EUR  | 166.70 EUR  |
| 09-Sep-17 CHEQUE : 7691785                | Expenses:Unknown | 100.00 EUR  | 266.70 EUR  |
| 09-Oct-16 REMISE CHEQUE N 8686318 001 105 | Expenses:Unknown | -525.00 EUR | -258.30 EUR |

   

** lisp
   :PROPERTIES:
   :DATE:     2010-08-12
   :END:

#+begin_src lisp :var n=5
  (mapcar (lambda (el) (* el el)) (append '(1 7 3 4) (list n)))
#+end_src

#+name:
| 1 | 49 | 9 | 16 | 25 |

#+name: short-list
| 1 |
| 2 |
| 3 |

#+begin_src lisp :var lst=short-list :session t
  (+ 1 (length lst))
#+end_src

#+name:
: 4

   

** lob -- writing results out to files
   :PROPERTIES:
   :DATE:     2010-08-12
   :END:
#+name: table
#+begin_src emacs-lisp
  (mapcar
   (lambda (el) (number-sequence el (+ el 3)))
   (number-sequence 0 4))
#+end_src

writes the results out as csv file
#+call: write(data=table, file="~/Desktop/example.csv") :results silent

writes the results out as tab separated file
#+call: write(data=table, file="~/Desktop/example.tsv") :results silent

write the results out as a normal org-mode file
#+call: write(data=table, file="~/Desktop/example.org") :results silent

   

** tangle R and load
  :PROPERTIES:
  :tangle:   to-load.r
  :DATE:     2010-08-12
  :END:

evaluate this
#+begin_src emacs-lisp :results silent :tangle no
  (setq org-babel-post-tangle-hook nil)
  (add-hook 'org-babel-post-tangle-hook
            (lambda () (ess-load-file (buffer-file-name))))
#+end_src

then tangle

#+begin_src R :comments yes
x <- 10
#+end_src

#+begin_src R
 y <- 9
#+end_src

#+begin_src R :tangle file2.R
 y <- 9
#+end_src

   

** ledger example output text
   :PROPERTIES:
   :DATE:     2010-08-13
   :END:
#+name: ledger-stuff
#+begin_example
09-Aug-21 CHEQUE : 9953055                    Expenses:Unknown                                    166.70 EUR            166.70 EUR
09-Sep-17 CHEQUE : 7691785                    Expenses:Unknown                                    100.00 EUR            266.70 EUR
09-Oct-16 REMISE CHEQUE N 8686318 001 105     Expenses:Unknown                                   -525.00 EUR           -258.30 EUR
#+end_example

#+begin_src sh :var stuff=ledger-stuff
  echo "$stuff"
#+end_src

   

** org results and replace
   :PROPERTIES:
   :DATE:     2010-08-18
   :END:

#+begin_src emacs-lisp :results org
  "| 1 | 2 |
| 2 | 3 |"
#+end_src

#+name:
| 1 | 2 |
| 2 | 3 |

#+begin_src R
  rnorm(1)
#+end_src

#+begin_src R
  numbers <- matrix(c(51,43,22,92,28,21,68,22,9),ncol=3,byrow=TRUE)
  numbers
#+end_src

#+name:
| 51 | 43 | 22 |
| 92 | 28 | 21 |
| 68 | 22 |  9 |

#+begin_src R :colnames yes
  numbers <- matrix(c(51,43,22,92,28,21,68,22,9),ncol=3,byrow=TRUE)
  numbers
#+end_src

#+name:
| V1 | V2 | V3 |
|----+----+----|
| 51 | 43 | 22 |
| 92 | 28 | 21 |
| 68 | 22 |  9 |

   

** issues with shell evaluation
   :PROPERTIES:
   :DATE:     2010-08-25
   :END:
#+begin_src sh :results silent
  cd ~/src/org/
  make
#+end_src

   

** not caching
   :PROPERTIES:
   :session:  *R*
   :results:  output
   :exports:  both
   :cache:    yes
   :DATE:     2010-08-25
   :END:

#+begin_src R :noeval
  cat("random result:", runif(1), "\n")
  Sys.sleep(2)
  alarm()
#+end_src 

#+begin_src R :noeval
  cat("random result:", runif(1), "\n")
  Sys.sleep(2)
  alarm()
#+end_src 

*** cache on export
    :PROPERTIES:
    :DATE:     2010-08-25
    :END:
do we export cached blocks

#+begin_src emacs-lisp :cache yes :exports results
  (random)
#+end_src

#+name[46632b4fe2e3a23e847953c95adcba58c270b381]:
: 490528137

*** looks like this is a problem with info collection
    :PROPERTIES:
    :DATE:     2010-08-25
    :END:
#+begin_src emacs-lisp
  (format "%S" info)
#+end_src

#+begin_src emacs-lisp :results scalar :exports results :tangle yes :comments yes
  (mapcar (lambda (el) (list (car el) (cdr el))) (nth 2 info))
#+end_src

#+name[4184710f118ac768ea0d90632508792d695efd7a]:
| :cache    | yes                   |
| :colnames | no                    |
| :comments | yes                   |
| :exports  | results               |
| :hlines   | yes                   |
| :noweb    | no                    |
| :results  | output replace scalar |
| :session  | *R*                   |
| :shebang  |                       |
| :tangle   | yes                   |

#+begin_src emacs-lisp :exports results
  (message "calculating info")
  (org-babel-sha1-hash info)
#+end_src

#+name[0427db66afdc95462d1c8514b662829987d71ff5]:
: 0427db66afdc95462d1c8514b662829987d71ff5

   

** duplicate results on execute subtree
   :PROPERTIES:
   :DATE:     2010-08-26
   :END:
#+begin_src emacs-lisp :results org :exports results
  "- first
- second
- third
"
#+end_src

#+name:
#+BEGIN_SRC org
- first
- second
- third
#+END_SRC

   

** eval and noeval
   :PROPERTIES:
   :DATE:     2010-08-26
   :END:
date, should export both, but won't output results because of presence
of the =:noeval= header argument.
#+begin_src sh :noeval :exports both
  date
#+end_src

should export code, so no need to do anything
#+begin_src sh
  date
#+end_src

should export nothing, and should not query
#+name: this-is-ls
#+begin_src sh :eval query :exports code
  date
#+end_src

should export results, and should trigger query above
#+begin_src emacs-lisp :var ls=this-is-ls :exports results
  ls
#+end_src

   

** eval for side effect on export
   :PROPERTIES:
   :DATE:     2010-08-26
   :END:
- one plus one
  #+name: one-plus-one
  #+begin_src emacs-lisp :exports none :results silent
    (+ 1 1)
  #+end_src
- plus one is
  #+begin_src emacs-lisp :var two=one-plus-one :exports both
    (+ 1 two)
  #+end_src

   

** trying out plantuml
   :PROPERTIES:
   :DATE:     2010-08-26
   :END:
setup
#+begin_src emacs-lisp :results silent
  (require 'ob-plantuml)
  (setq org-plantuml-jar-path "~/src/org/contrib/scripts/plantuml.jar")
#+end_src

usage -- sequence diagram
#+begin_src plantuml :file tryout.png
  Alice -> Bob: synchronous call
  Alice ->> Bob: asynchronous call
#+end_src

#+name:
[[file:tryout.png]]

   

** wrapping up raw/org results
   :PROPERTIES:
   :DATE:     2010-08-26
   :END:
#+begin_src emacs-lisp :results org :exports results
  "- first
  - second
  - third
  "
#+end_src

#+name:
#+BEGIN_SRC org
- first
- second
- third
#+END_SRC

   

** initial javascript support
   :PROPERTIES:
   :DATE:     2010-08-27
   :END:
using node.js

#+begin_src js
  var n = 0;
  n = n+1;
  return n
#+end_src

#+name:
: 1

#+name: cars
#+begin_src js
  var cars = ["Saab","Volvo","BMW"];
  return cars;
#+end_src

#+name: cars
| Saab | Volvo | BMW |

#+begin_src js :var cars=cars
  return cars[0][0];
#+end_src

#+name:
: Saab

#+begin_src js :var cars=cars
  return cars[0].length;
#+end_src

#+name:
: 3

   

** initial scheme support
   :PROPERTIES:
   :DATE:     2010-08-27
   :END:
#+name: numbers
#+begin_src scheme
  (map (lambda (el) (+ el 1)) '(1 2 3))
#+end_src

#+name:
| 2 | 3 | 4 |

#+begin_src scheme :var numbers=numbers
  (map (lambda (el) (- el 1)) numbers)
#+end_src

#+name:
| 1 | 2 | 3 |

   

** pulling information from tags                                       :blue:
   :PROPERTIES:
   :DATE:     2010-08-30
   :END:

#+begin_src R :var color=(car (org-get-tags-at (point))) :tangle example.R
  color
#+end_src

#+name:
: blue

   

** conditional tangling
   :PROPERTIES:
   :DATE:     2010-08-31
   :END:
#+begin_src emacs-lisp :results silent
  (setq tangle-tag "right")
#+end_src

*** first subheading                                                   :left:
    :PROPERTIES:
    :DATE:     2010-08-31
    :END:
#+begin_src R :tangle (and (equal (car (org-get-tags-at (point))) tangle-tag) "yes")
  "first"
#+end_src

*** second subheading                                                 :right:
    :PROPERTIES:
    :DATE:     2010-08-31
    :END:
#+begin_src R :tangle (and (equal (car (org-get-tags-at (point))) tangle-tag) "yes")
  "second"
#+end_src

   

** scheme sessions
   :PROPERTIES:
   :DATE:     2010-08-31
   :END:
#+begin_src scheme :var number=9 :session *scheme* :scheme guile
  (+ number 0)
#+end_src

#+name:
: 9

#+begin_src scheme :var number=9 :session *scheme* :scheme racket
  (+ number 1)
#+end_src

#+name:
: 10

   

** ditaa with tilda in path
   :PROPERTIES:
   :DATE:     2010-09-01
   :END:
#+begin_src ditaa :file example.png
    +--------------+
    |              |
    |              |
    |              |
    |              |
    |              |
    +--------------+
#+end_src

   

** :session evaluation on export
   :PROPERTIES:
   :DATE:     2010-09-01
   :END:
This first block is evaluated but /doesn't/ appear in export.

/:session *R* :exports none/
#+begin_src R :session *R* :exports none
  x <- 8
#+end_src

This second block /does/ appear in export.

#+begin_src R :session *R* :exports results
  x
#+end_src

   

** quoting header args (e.g. :cmdline)
   :PROPERTIES:
   :DATE:     2010-09-03
   :END:
#+begin_src C :cmdline 1 2 3 4 5 :includes <stdio.h>
  int main(int argc, char **argv){
    printf("argv[1] %s\n", argv[1]);
    return 0;
  }
#+end_src

#+name:
: argv[1] 1

   

** :var (buffer-file-name)
   :PROPERTIES:
   :DATE:     2010-09-03
   :END:
during export (buffer-file-name) will return nil because the temporary
export buffer is not visiting any file.

/file=(vc-working-revision (buffer-file-name))/
#+begin_src sh :var file=(vc-working-revision (or (buffer-file-name) "")) :exports results
  echo $file Revision
#+end_src

/file=(vc-working-revision (or (buffer-file-name) org-current-export-file))/
#+begin_src sh :var file=(vc-working-revision (or (buffer-file-name) org-current-export-file)) :exports results
  echo $file Revision
#+end_src

   

** tangling with full comments
   :PROPERTIES:
   :comments: org
   :tangle:   full-comments.el
   :DATE:     2010-09-04
   :END:
The top block
#+begin_src emacs-lisp
  (message "first block")
#+end_src

here's some text which won't be tangled

*** subheading
    :PROPERTIES:
    :DATE:     2010-09-04
    :END:
another block
| 1 | first  |
| 2 | second |
#+begin_src emacs-lisp
  (message "second")
#+end_src

and finally a block with a =:noweb= header argument
#+begin_src emacs-lisp :noweb yes
  (progn
    <<tangle-el-the-second>>)
#+end_src

   

** customizable comment formats
   :PROPERTIES:
   :tangle:   yes
   :comments: yes
   :DATE:     2010-09-05
   :END:

#+begin_src emacs-lisp :results silent
  (setq org-babel-tangle-comment-format-beg "{-# LINE %start-line \"%file\" #-}"
        org-babel-tangle-comment-format-end ""
        org-babel-tangle-pad-newline)
#+end_src

#+begin_src haskell :tangle Main.hs
  test = length
  main = print $ test [1,2,3]
#+end_src

I would like the following output in the tangled file Main.hs:

: {-# LINE 4 "Haskell.org" #-}
: test = length
: main = print $ test [1,2,3]

   

** comparative speed of python evaluation
   :PROPERTIES:
   :DATE:     2010-09-07
   :END:
#+begin_src python :session test
  2+2
#+end_src

#+name:
: 4

#+begin_src python
  return 2+2
#+end_src

#+name:
: 4

#+begin_src python :session test
def add(a,b):
   return a+b
def sub(a,b):
   return a-b
add(sub(10,1),sub(10,2))
#+end_src

#+name:
: org_babel_python_eoe

   

** remove results when nil is returned
   :PROPERTIES:
   :DATE:     2010-09-07
   :END:
#+begin_src emacs-lisp
  (progn (+ 1 1) nil)
#+end_src

#+name:

   

** tangle org-mode block
   :PROPERTIES:
   :DATE:     2010-09-07
   :END:
#+name: org-list
#+begin_src org :results latex
  - one
  - two
  - three
#+end_src

#+begin_src emacs-lisp :tangle example.tangled :noweb yes
  "
  <<org-list()>>
  "
#+end_src

   

** empty-string results
   :PROPERTIES:
   :DATE:     2010-09-08
   :END:
test me one two 3

#+begin_src emacs-lisp
#+end_src

More test

#+begin_src emacs-lisp
  (mapcar
   (lambda (pair)
     (list (car pair) (cdr pair)))
   params)
#+end_src

#+name:
| :cache    | no      |
| :colnames | no      |
| :comments |         |
| :exports  | code    |
| :hlines   | yes     |
| :noweb    | no      |
| :results  | replace |
| :session  | none    |
| :shebang  |         |
| :tangle   | no      |

   

** header arguments on call line
   :PROPERTIES:
   :DATE:     2010-09-09
   :END:
#+name: eight
#+begin_src R
  8
#+end_src

#+call: eight() :results vector

#+name: eight()
| 8 |

maybe the following with the new proposed header arguments

#+call: eight[:session *R*]() :results vector

   

** splitting code blocks
   :PROPERTIES:
   :DATE:     2010-09-19
   :END:
- with indentation
  #+begin_src emacs-lisp
    ;;;###autoload
    (defun org-babel-previous-src-block (&optional arg)
      "Jump to the previous source block.
    With optional prefix argument ARG, jump backward ARG many source blocks."
      (interactive "P")
      (condition-case nil
          (re-search-backward org-babel-src-block-regexp nil nil (or arg 1))
        (error (error "No previous code blocks")))
      (goto-char (match-beginning 0)) (org-show-context))
  #+end_src
  
  #+begin_src emacs-lisp
    ;;;###autoload
    (defun org-babel-split-block-maybe (&optional arg)
      "Split the current source code block on the cursor."
      (interactive "p")
      ((lambda (info)
         (if info
             (let ((lang (nth 0 info))
                   (indent (nth 6 info))
                   (stars (make-string (org-current-level) ?*)))
               (insert (concat (if (looking-at "^") "" "\n")
                               (make-string indent ? ) "#+end_src\n"
                               (if arg stars (make-string indent ? )) "\n"
                               (make-string indent ? ) "#+begin_src " lang
                               (if (looking-at "[\n\r]") "" "\n  "))))
           (message "Not in src block.")))
       (org-babel-get-src-block-info)))
    
    ;; other stuff
  #+end_src

   

** Letter
   :PROPERTIES:
   :DATE:     2010-09-21
   :END:

#+name: body
#+begin_src org :results latex
  ,My body includes a list:
  
  ,- one
  ,- two
  
  ,and a small table:
  
  ,| first | second |
  ,| other | last   |
  
  ,Not more.
#+end_src

#+begin_src latex :noweb yes :tangle yes
\documentclass[11pt]{isodoc}
\usepackage[utf8x]{inputenc}
\usepackage[T1]{fontenc}

\setupdocument{
    to = {Eric},
    subject = {Tough to understand what to do...},
    opening = {Hi},
    closing = {Best}
}

\begin{document}
\letter{%
<<body()>>
}
\end{document}
#+end_src

   

** cycle -- the input is the output
   :PROPERTIES:
   :DATE:     2010-09-29
   :END:
and the rhythm is the base and the base is the treble

#+name: cycle
| one   |
| two   |
| three |

#+name: cycle
#+begin_src emacs-lisp :var table=cycle
  (append (last table) (butlast table))
#+end_src

#+begin_src emacs-lisp :exports results
  (+ 1 1 1)
#+end_src

   

** index into a scalar
   :PROPERTIES:
   :DATE:     2010-10-13
   :END:
#+tblname: short-list
| a |
| b |

#+begin_src emacs-lisp :var scalar=short-list[0,0]
  scalar
#+end_src

#+name:
: a

   

** preceding blank lines on tangle
   :PROPERTIES:
   :DATE:     2010-10-13
   :END:
#+begin_src emacs-lisp :results silent
  (setq org-babel-tangle-pad-newline nil)
#+end_src

#+begin_src sh :tangle something.reg
  # something
  echo "else"
#+end_src

   

** very very large numbers
   :PROPERTIES:
   :DATE:     2010-10-13
   :END:
#+tblname: numbers
|                           1 |
|                           2 |
|                          12 |
|                          45 |
|                         166 |
|                    12567890 |
| 231231282371983279389999999 |

#+begin_src emacs-lisp :var numbers=numbers
  (mapcar
   (lambda (line)
       (let ((number (car line)))
         (list number (type-of number))))
     numbers)
#+end_src

#+name:
|                      1 | integer |
|                      2 | integer |
|                     12 | integer |
|                     45 | integer |
|                    166 | integer |
|               12567890 | integer |
| 2.3123128237198328e+26 | float   |

   

** weaving with noweb links
   :PROPERTIES:
   :tangle:   yes
   :DATE:     2010-10-13
   :END:

#+name: name
#+begin_src emacs-lisp
  (message "eric")
#+end_src

#+begin_src emacs-lisp :noweb tangle
  ;; name
  <<name>>
#+end_src

   

** security problem with elisp in header arguments
   :PROPERTIES:
   :DATE:     2010-10-14
   :END:
#+begin_src emacs-lisp :var data=(setq org-confirm-babel-evaluate nil) :results silent
  (+ 1 1)
#+end_src

   

** export-specific header arguments
   :PROPERTIES:
   :DATE:     2010-10-26
   :END:

#+headers: :var out=(if (and (boundp 'latexp) latexp) "latex" "not latex") 
#+begin_src emacs-lisp
  out
#+end_src

#+name:
: not latex

   

** latex headers in latex code blocks
   :PROPERTIES:
   :DATE:     2010-10-26
   :END:

#+begin_src latex :headers \usepackage{lmodern} :file name1.pdf
  Eric Schulte
#+end_src

#+name:
[[file:name1.pdf]]

#+begin_src latex :headers '("\\usepackage{mathpazo}" "\\usepackage{fullpage}") :file name2.pdf
  Eric Schulte
#+end_src

#+name:
[[file:name2.pdf]]

   

** simple gnuplot tests
   :PROPERTIES:
   :DATE:     2010-10-26
   :END:
#+name: some-more-gnuplot
| 1 |  1 |
| 2 |  4 |
| 3 |  9 |
| 4 | 16 |
| 5 | 25 |
| 6 | 36 |
| 7 | 49 |
| 8 | 64 |
#+TBLFM: $2=$1*$1

#+begin_src gnuplot :var data=some-more-gnuplot
  plot "$data"
#+end_src

#+name:

Plotting data points from a table could look like this:
#+tblname: basic-plot
|   x |         y1 |         y2 |
|-----+------------+------------|
| 0.1 |      0.425 |      0.375 |
| 0.2 |     0.3125 |     0.3375 |
| 0.3 | 0.24999993 | 0.28333338 |
| 0.4 |      0.275 |    0.28125 |
| 0.5 |       0.26 |       0.27 |
| 0.6 | 0.25833338 | 0.24999993 |
| 0.7 | 0.24642845 | 0.23928553 |
| 0.8 |    0.23125 |     0.2375 |
| 0.9 | 0.23333323 |  0.2333332 |
|   1 |     0.2225 |       0.22 |

#+begin_src gnuplot :var data=basic-plot :exports code :file basic-plot.png
set title "Putting it All Together"

set xlabel "X"
set xrange [0:1]
set xtics 0,0.1,1

set ylabel "Y"
set yrange [0.2:0.5]
set ytics 0.2,0.05,0.5

plot data u 1:2 w p lw 2 title 'x vs. y1', \
     data u 1:3 w lp lw 1 title 'x vx. y2'
#+end_src

#+name:
[[file:basic-plot.png]]

   

** passing arguments through call lines
   :PROPERTIES:
   :DATE:     2010-10-29
   :END:

#+name: test
#+begin_src R :session :file test.pdf :var myarg="bla"
  plot(1:10, main=myarg)
#+end_src

#+name: test
[[file:test.pdf]]

#+call: test(myarg="hiho")

#+name: test(myarg="hiho")
: test.pdf

   

** playing with calc support
   :PROPERTIES:
   :DATE:     2010-11-03
   :END:
#+begin_src emacs-lisp
  (require 'ob-calc)
#+end_src

#+begin_src calc :var some=8
  some
  some
  '*
  8+8
  '+
#+end_src

#+name:
: 80

#+begin_src calc
  2*(8+8)
#+end_src

#+name:
: 32

#+begin_src calc
  2*e
#+end_src

#+name:
: 5.43656365692

#+begin_src calc :var something=9
  2*something
#+end_src

#+name:
: 18

   

** shell blocks returning a file name
   :PROPERTIES:
   :DATE:     2010-11-03
   :END:
#+begin_src sh :file quick.txt :results output
  date
#+end_src

#+name:
[[file:quick.txt]]

   

** clojure code blocks and the lazies
   :PROPERTIES:
   :DATE:     2010-11-06
   :END:
#+begin_src emacs-lisp :results silent
  (defun org-babel-execute:clojure (body params)
    (with-temp-buffer
      (insert body)
      (read
       (slime-eval
        `(swank:interactive-eval-region 
          ,(buffer-substring-no-properties (point-min) (point-max)))))))
#+end_src

#+begin_src clojure
  (map (fn [el] (list el (* el el)))(range 10))
#+end_src

#+name:
| 0 |  0 |
| 1 |  1 |
| 2 |  4 |
| 3 |  9 |
| 4 | 16 |
| 5 | 25 |
| 6 | 36 |
| 7 | 49 |
| 8 | 64 |
| 9 | 81 |

   

** lob calls with header argument pass through
   :PROPERTIES:
   :DATE:     2010-11-08
   :END:

#+name: lob-header
#+begin_src emacs-lisp :var n=20
  n
#+end_src

#+call: lob-header[:results vector](n=15)

#+name: lob-header[:results vector](n=15)
| 15 |

#+call: lob-header(n=10) :results vector

#+name: lob-header(n=10)
| 10 |

need ob-ref.el to pass through the header arguments in "[]"s
#+begin_src emacs-lisp :var n=lob-header[:results vector](n=8)
  n
#+end_src

#+name:
| 8 |

#+begin_src emacs-lisp :var n=lob-header[:results vector](n=8)[0,0]
  n
#+end_src

#+name:
: 8

   

** sqlite
   :PROPERTIES:
   :DATE:     2010-11-10
   :END:
#+begin_src sqlite :db paper/climate.sqlite
  select count(*) from temps;
#+end_src

#+name:
: 422689

   

** introducing =wrap= header argument
   :PROPERTIES:
   :DATE:     2010-11-19
   :END:
#+begin_src emacs-lisp :results wrap :exports both
  (mapcar (lambda (el) (list el (+ 1 (* el el)))) (number-sequence 0 10))
#+end_src

#+name:
#+BEGIN_RESULT
|  0 |   1 |
|  1 |   2 |
|  2 |   5 |
|  3 |  10 |
|  4 |  17 |
|  5 |  26 |
|  6 |  37 |
|  7 |  50 |
|  8 |  65 |
|  9 |  82 |
| 10 | 101 |
#+END_RESULT

now indented
- first
- second
  #+begin_src emacs-lisp :results wrap :exports both
    "something else"
  #+end_src

  #+name:
  #+BEGIN_RESULT
  : something else
  #+END_RESULT

   

** lists as data types
   :PROPERTIES:
   :DATE:     2010-11-19
   :END:

#+name: a-list
- org-mode
- and
- babel

#+name: a-list
#+begin_src emacs-lisp :var lst=a-list :results list
  (reverse lst)
#+end_src

also for a block inside of a list
1. First element
2. Second element -- has a block
   #+begin_src emacs-lisp
     (+ 1 1 1 1)
   #+end_src

   #+name:
   : 4

3. third element

   

** add column to table with awk
   :PROPERTIES:
   :question_author: Sébastien Vauban
   :DATE:     2010-11-23
   :END:
I want to *add a column* to the following table.

#+name: table-message
| This is line 1 of the message.        |
| This is line 2 of the message.        |
| This is the last line of the message. |

Its value should be dependant on a *regexp matching* the *current row*
(for example, if 1 is detected in the original column, then write "A"
in the new one, "B" if 2 is read, "C" if 3 is read, etc.).

Hence, I'm thinking using AWK as an easy solution.

    #+begin_src note
    I'm open to other ideas on how I could do this as easily. Just throw me
    ideas, if you have some.
    #+end_src

the easiest (for me) would be with the elisp =mapcar= function
#+begin_src emacs-lisp :var tbl=table-message
  (mapcar (lambda (row) (cons "New col" row)) tbl)
#+end_src

#+name:
| New col | This is line 1 of the message.        |
| New col | This is line 2 of the message.        |
| New col | This is the last line of the message. |

*First* trial: add a column whose cell contents will be *fixed* (here,
equal to =New col=).

#+name: add-col
#+begin_src sh :var data=table-message :results output raw :exports both
echo "$data" | awk '// {print "| New col | " $0 " |";}'
#+end_src

#+name: add-col
| New col | This is line 1 of the message.        |
| New col | This is line 2 of the message.        |
| New col | This is the last line of the message. |

   

** reading from single-quote-delim languages
   :PROPERTIES:
   :DATE:     2010-11-23
   :END:
#+BEGIN_SRC python
return [['607', 'Show license short, name on the deed'],
        ['255', "'(message (concat 'hello ' 'world))"]]
#+END_SRC

#+name:
| 607 | Show license short, name on the deed |
| 255 | '(message (concat 'hello ' 'world))  |

#+begin_src ruby
  [['607', 'Show license, short name on the deed'],
   ['255', "))'(message (concat 'hello ' 'world"]]
#+end_src

#+name:
| 607 | Show license, short name on the deed |
| 255 | ))'(message (concat 'hello ' 'world  |

#+begin_src haskell
  [["'single quotes'", "b"], ["\"double quotes\"", "d"]]
#+end_src

#+name:
| 'single quotes' | b |
| "double quotes" | d |

   

** safe lists for Haskell
   :PROPERTIES:
   :DATE:     2010-11-23
   :END:

#+tblname: mixed-table
| 1 | first  |
| 2 | second |
| 3 | third  |
| 4 | fourth | 

#+name: rec-string-wrap
#+begin_src emacs-lisp :var data=mixed-table
  (defun rec-string-wrap (in)
    (if (listp in) (mapcar #'rec-string-wrap in) (format "%S" in)))
  (rec-string-wrap data)
#+end_src

#+begin_src haskell :var tbl=rec-string-wrap(data=mixed-table)
  map head tbl
#+end_src

#+name:
| 1 | 2 | 3 | 4 |

   

** un-named R code blocks
   :PROPERTIES:
   :DATE:     2010-11-23
   :END:
#+begin_src R
  8
#+end_src

#+name:
: 8

#+begin_src emacs-lisp :eric
8  
#+end_src

#+name:
: 8

#+BEGIN_SRC R :session :results output
 xyz
#+END_SRC

#+BEGIN_SRC R :session *R-2* :results output |  xyz
9
#+END_SRC

#+name:
: [1] 9

   

** python with return header argument
   :PROPERTIES:
   :DATE:     2010-11-27
   :END:

#+begin_src python :return y
  x = 8
  y = 98
  2
#+end_src

#+name:
: 98

   

** =:eval query= shows the name
   :PROPERTIES:
   :DATE:     2010-11-30
   :END:
#+name: i-have-a-name
#+begin_src sh :eval query
  date
#+end_src

#+name: i-have-a-name
: Tue Nov 30 22:03:25 MST 2010

   

** sql variables
   :PROPERTIES:
   :DATE:     2010-11-30
   :END:
#+name: sql-param
| table       | valueTable0       |
| column      | valueColumn0      |
| type        | valueType0        |
| nullability | valueNullability0 |

I want to apply the values onto the following chunk of code:

#+name: add-column-in-table-0
#+begin_src sql :var table=sql-param[0,1] :var column=sql-param[1,1] :var type=sql-param[2,1] :var nullability=sql-param[3,1]
-- add column `@column' (if column does not exist yet)
IF NOT EXISTS (SELECT *
               FROM INFORMATION_SCHEMA.COLUMNS
               WHERE TABLE_NAME = '@table'
               AND COLUMN_NAME = '@column')
BEGIN
    ALTER TABLE $table
    ADD $column $type @nullability
END
#+end_src

   

** empty lines in R session output
   :PROPERTIES:
   :DATE:     2010-12-01
   :END:
#+begin_src R :results output :session
  x <- 1;
  x
  x + 1
  x + 4
#+end_src R

#+name:
: [1] 1
: [1] 2
: [1] 5

   

** Python requires a utf-8 coding prefix
   :PROPERTIES:
   :DATE:     2010-12-02
   :END:
#+begin_src python :prefix # -*- coding: utf-8 -*- :return s
s = "é"
#+end_src

#+name:
: é

#+begin_src python :prefix # -*- coding: utf-8 -*- :results output
s = "é"
print(s)
#+end_src

#+name:
: é

   

** missing lines on tangle
   :PROPERTIES:
   :ID:       83eb62fd-4147-405b-bdc2-567b2d5cbd70
   :DATE:     2010-12-13
   :END:
#+begin_src org :results latex :tangle latex-err.tex
  ,one
  ,two
  ,three
#+end_src

#+begin_src org :results latex :results replace
  ,- eric
  ,- schulte
#+end_src

#+name:
#+BEGIN_LaTeX
\begin{itemize}
\item eric
\item schulte
\end{itemize}
#+END_LaTeX

   

** tangle templates
   :PROPERTIES:
   :DATE:     2010-12-13
   :END:
#+name: template-heading
#+begin_src emacs-lisp
  some stuff here
#+end_src

#+name: template-footing
#+begin_src emacs-lisp
  some other stuff here
#+end_src

#+name: template
#+begin_src sh :results output :noweb yes :var body="body stuff"
heading=$(cat<<EOF
<<template-heading>>
EOF
)
footing=$(cat<<EOF
<<template-footing>>
EOF
)
echo $heading
echo "$body"
echo $footing
#+end_src

#+call: template[:noweb yes](body="something new")

#+name: template[:noweb yes](body="something new")
: some stuff here
: something new
: some other stuff here

   

** utf8 and latin-1 encodings
   :PROPERTIES:
   :DATE:     2010-12-13
   :END:
#+tblname: toto
| é |

#+begin_src python :var t=toto :preamble # -*- coding: latin1 -*- :return [len(babel), len(local)]
  babel = unicode (t[0][0],"latin1")
  local = unicode ("é","latin1")
#+end_src

#+name:
| 2 | 2 |

   

** new file handling
   :PROPERTIES:
   :DATE:     2010-12-20
   :END:

#+begin_src sh :sep , :file dirlisting
  ls -l
#+end_src

#+name:
[[file:dirlisting]]

#+begin_src ruby :file ruby-out
  [[1, 2, 3, 4],
   [2, 4, 6, 8]]
#+end_src

#+name:
[[file:ruby-out]]

#+begin_src emacs-lisp :results file :results append
  (let ((today (replace-regexp-in-string "[ \t]" "-" (current-time-string))))
    (with-temp-file today
      (insert (message "I'm feeling %s"
                       (nth (random 3) (list "good" "bad" "just fine")))))
    today)
#+end_src

#+name:
[[file:Mon-Dec-20-17:27:52-2010]]

from http://www.graphviz.org/Gallery/directed/fsm.gv.txt
#+begin_src dot :file fsa.png
  digraph finite_state_machine {
          rankdir=LR;
          size="8,5"
          node [shape = doublecircle]; LR_0 LR_3 LR_4 LR_8;
          node [shape = circle];
          LR_0 -> LR_2 [ label = "SS(B)" ];
          LR_0 -> LR_1 [ label = "SS(S)" ];
          LR_1 -> LR_3 [ label = "S($end)" ];
          LR_2 -> LR_6 [ label = "SS(b)" ];
          LR_2 -> LR_5 [ label = "SS(a)" ];
          LR_2 -> LR_4 [ label = "S(A)" ];
          LR_5 -> LR_7 [ label = "S(b)" ];
          LR_5 -> LR_5 [ label = "S(a)" ];
          LR_6 -> LR_6 [ label = "S(b)" ];
          LR_6 -> LR_5 [ label = "S(a)" ];
          LR_7 -> LR_8 [ label = "S(b)" ];
          LR_7 -> LR_5 [ label = "S(a)" ];
          LR_8 -> LR_6 [ label = "S(b)" ];
          LR_8 -> LR_5 [ label = "S(a)" ];
  }
#+end_src

#+name:
[[file:fsa.png]]
   

** eval query
   :PROPERTIES:
   :DATE:     2010-12-21
   :END:
#+begin_src emacs-lisp
  (setq org-confirm-babel-evaluate
        (lambda (lang body) (not (equal "ditaa" lang))))
#+end_src

#+name:
| lambda | (lang body) | (not (equal ditaa lang)) |

#+begin_src emacs-lisp :eval query
  (message "eval'd")
#+end_src

#+name:
: eval'd

#+begin_src ditaa
  ---
#+end_src

   

** language name abbreviations
   :PROPERTIES:
   :DATE:     2011-01-07
   :END:

#+begin_src emacs-lisp
  (add-to-list 'org-src-lang-modes '("clj" . clojure))
#+end_src

#+begin_src clj
  (map (partial + 1) (range 20))
#+end_src

   

** call lines
   :PROPERTIES:
   :DATE:     2011-01-11
   :END:
#+name: doubler
#+begin_src emacs-lisp :var n=2
  (* n 2)
#+end_src

#+call: doubler(n=3)

#+name: doubler(n=3)
: 6

#+call: doubler[:var n=3]()

#+name: doubler[:var n=3]()
: 6

   

** empty strings as arguments
   :PROPERTIES:
   :DATE:     2011-01-11
   :END:

#+begin_src emacs-lisp :results output :var foo=""
  (concat foo "bar")
#+end_src

#+name:
: bar

   

** noweb then variables
   :PROPERTIES:
   :DATE:     2011-01-13
   :END:
#+name: replaced-first
#+begin_src latex
  \begin{itemize}
  \item first
  \item data
  \item third
  \end{itemize}
#+end_src

#+begin_src latex :var data="second" :noweb yes
  \section{ordinals}
  \label{sec:ordinals}
  <<replaced-first>>
#+end_src

   

** replace inline code block
   :PROPERTIES:
   :DATE:     2011-01-13
   :END:
This is src_emacs-lisp{(+ 1 2 3)} an inline block.

#+begin_src emacs-lisp
  (defun replace-inline-block ()
    (interactive)
    (if (save-excursion (re-search-backward "[ \f\t\n\r\v]" nil t)
                        (looking-at org-babel-inline-src-block-regexp))
        (replace-match
         ((lambda (el) (if (stringp el) el (format "%S" el)))
          (org-babel-execute-src-block)) nil nil nil 1)
      (error "not inside of an inline source block.")))
#+end_src

   

** wrap noweb references in comments
   :PROPERTIES:
   :DATE:     2011-01-16
   :END:
#+name: wrappable
#+begin_src emacs-lisp
  (setq x (+ 4 x))
#+end_src

#+begin_src emacs-lisp :comments noweb :noweb yes :tangle yes
  (let ((x 1))
    (message "x=%s" x)
    <<wrappable>>
    (message "x=%s" x))
#+end_src

   

** passing arguments to the shell
   :PROPERTIES:
   :DATE:     2011-01-18
   :END:
#+name: something
: eric
:   schulte
:     yes
: more

#+name: something-list
| 1 |
| 2 |
| 3 |

#+begin_src sh :var data=something-list
  echo "$data"|wc -l
#+end_src

#+name:
: 3

#+begin_src emacs-lisp :results silent
  (setq org-babel-sh-var-quote-fmt "`cat <<'BABEL_TABLE'\n%s\nBABEL_TABLE\n`")
#+end_src

   

** creating a directory when needed for tangling
   :PROPERTIES:
   :DATE:     2011-01-19
   :END:
#+begin_src clojure :tangle (prog1 "src/foo.clj" (make-directory "src" "."))
  (ns something)
#+end_src

a helper function for the above
#+begin_src emacs-lisp
  (defun mkdir-p (file &optional dir)
    "Create any parent directories of FILE if missing and return FILE."
    (make-directory (file-name-directory file) (or dir ".")) file)
#+end_src

allows the following
#+begin_src clojure :tangle (mkdir-p "src/foo.clj")
  (ns something)
#+end_src

There is now a new header argument controlling this behavior
#+begin_src emacs-lisp :mkdirp yes :tangle novel/nested/directories/finally.clj
  (message "contents")
#+end_src

   

** inserting wrappers eats following characters
   :PROPERTIES:
   :DATE:     2011-01-20
   :END:
*** Test
    :PROPERTIES:
    :DATE:     2011-01-20
    :END:
  
  #+begin_src emacs-lisp :results latex
    "\\begin{equation}\\frac{1}{2}\n\\end{equation}"
  #+end_src

  #+name:
  #+BEGIN_LaTeX
  \begin{equation}\frac{1}{2}
  \end{equation}
  #+END_LaTeX
  
*** Watch me die :-(
    :PROPERTIES:
    :DATE:     2011-01-20
    :END:

   

** results replace not always working
   :PROPERTIES:
   :DATE:     2011-01-25
   :END:
#+begin_src sh :results output org replace :exports code
  for i in `seq 4`;do
      echo "- place $i in the list"
  done
#+end_src

#+name:
#+BEGIN_ORG
- place 1 in the list
- place 2 in the list
- place 3 in the list
- place 4 in the list
#+END_ORG

inline block src_emacs-lisp[:exports code :results replace]{(+ 1 1 1)} here is was

   

** simple calc example
   :PROPERTIES:
   :DATE:     2011-01-25
   :END:
#+begin_src calc 
2*3
#+end_src

#+name:
: 6

   

** non-inlined inline code block
   :PROPERTIES:
   :DATE:     2011-01-27
   :END:
The Date is src_sh[:results replace]{date} at the time of =this= export.

src_sh[:results replace]{ls}

   

** how to set no-expand in properties
   :PROPERTIES:
   :no-expand: yes
   :DATE:     2011-02-10
   :END:

#+begin_src emacs-lisp :var something="other thing" :tangle no-expand.el
  :test
#+end_src

tangles to

   

** two vars in a properties block -- not possible
   :PROPERTIES:
   :var:      test1=7
   :var:      test2=8
   :DATE:     2011-02-10
   :END:

#+begin_src emacs-lisp
  (message "test1=%S test2=%S" test1 test2)
#+end_src

results in Error
: let: Symbol's value as variable is void: test2

*** an alternative
    :PROPERTIES:
    :var:      tests=all-tests
    :DATE:     2011-02-10
    :END:

#+tblname: all-tests
- 7
- 8

#+begin_src emacs-lisp :var eric=89
  (message "test1=%S test2=%S" (first tests) (second tests))
#+end_src

#+name:
: test1=7 test2=8

*** another alternative
    :PROPERTIES:
    :var:      vars=variables
    :DATE:     2011-06-21
    :END:

#+tblname: variables
| var1 | 1 |
| var2 | 2 |

#+begin_src python
  print vars[0][1]
  print vars[1][1]
#+end_src

   

** passing keywords inside header arguments
   :PROPERTIES:
   :DATE:     2011-02-15
   :END:

#+begin_src emacs-lisp :var lst='(:no-expand :other)
  lst
#+end_src

#+name:
| :no-expand | other |

   

** recutils
   :PROPERTIES:
   :DATE:     2011-02-15
   :END:
#+begin_src sh :file book.rec
  cat <<EOF > book.rec
  # -*- mode: rec -*-
  %rec: Book
  %mandatory: Title
  %type: Location enum loaned home unknown
  %doc:
  + A book in my personal collection.
  
  Title: GNU Emacs Manual
  Author: Richard M. Stallman
  Publisher: FSF
  Location: home
  
  Title: The Colour of Magic
  Author: Terry Pratchett
  Location: loaned
  
  Title: Mio Cid
  Author: Anonymous
  Location: home
  
  Title: chapters.gnu.org administration guide
  Author: Nacho Gonzalez
  Author: Jose E. Marchesi
  Location: unknown
  
  Title: Yeelong User Manual
  Location: home
  
  # End of books.rec
  EOF
#+end_src

#+name:
[[file:book.rec]]

#+begin_src rec :data book.rec :fields Title,Author
  Location = 'loaned'
#+end_src

#+name:
| Title               | Author          |
| The Colour of Magic | Terry Pratchett |

#+begin_src rec :data book.rec :fields Title,Author
  
#+end_src

#+name:
| Title                                 | Author              | Author_2         |
| GNU Emacs Manual                      | Richard M. Stallman |                  |
| The Colour of Magic                   | Terry Pratchett     |                  |
| Mio Cid                               | Anonymous           |                  |
| chapters.gnu.org administration guide | Nacho Gonzalez      | Jose E. Marchesi |
| Yeelong User Manual                   |                     |                  |

   

** SQL --- example reading org-mode table into sql
   :PROPERTIES:
   :DATE:     2011-02-15
   :END:
#+tblname: example-table-for-sql
| a |  b |
|---+----|
| 1 | 10 |
| 2 | 11 |
| 3 | 12 |
| 4 | 13 |
| 5 | 14 |
| 6 | 15 |

#+headers: :var table=example-table-for-sql
#+begin_src sql :engine mysql
load data infile "$table" into mytable;
#+end_src

   

** inline code block
   :PROPERTIES:
   :DATE:     2011-02-18
   :END:

here is an inline block src_R{1+1}

   

** export of inline code blocks which are silent
   :PROPERTIES:
   :DATE:     2011-02-20
   :END:
#+begin_src emacs-lisp :results silent
  (setf org-babel-default-inline-header-args
        '((:session . "none")
          (:results . (if (boundp 'org-current-export-file) "replace" "silent"))
          (:exports . "results")))
#+end_src

Here is an inline code block src_sh{echo 8} <- there

   

** mentions of file names in file contents
   :PROPERTIES:
   :DATE:     2011-02-20
   :END:
directory to search
#+name: graph-dir
: graph-dir

list all files in dir
#+name: graph-files
#+begin_src sh :results vector :var dir=graph-dir
  find $dir -type f -exec basename {} \;
#+end_src

#+name: graph-files
| other |
| dan   |
| eric  |
| seb   |

association of files with mentions
#+name: graph-associations
#+begin_src sh :var dir=graph-dir :var files=graph-files
  for i in $files; do
      for j in `grep -l -r $i $dir`;do
          echo $i, `basename $j`
      done
  done
#+end_src

#+name: graph-associations
| other | eric |
| other | seb  |
| dan   | eric |
| eric  | seb  |
| seb   | dan  |

graphing with dot
#+name: to-dot
#+begin_src sh :var associations=graph-associations :results scalar
  echo "$associations"|awk '{print $1, "->", $2}'
#+end_src

#+name: to-dot
: other -> eric
: other -> seb
: dan -> eric
: eric -> seb
: seb -> dan

#+begin_src dot :var data=to-dot :file files.png
  digraph G{
    $data
  }
#+end_src

#+name:
[[file:files.png]]

   

** catch the file name during export
   :PROPERTIES:
   :DATE:     2011-02-21
   :END:

#+begin_src emacs-lisp :var file-name=(buffer-file-name) :exports both
  file-name
#+end_src

   

** new lists
   :PROPERTIES:
   :DATE:     2011-02-21
   :END:
*** results embedded inside of a list
    :PROPERTIES:
    :DATE:     2011-02-22
    :END:
1. this has results
   #+name: something-in-a-list
   : foo
2. and this doesn't work
   #+begin_src emacs-lisp :var data=something-in-a-list
     data
   #+end_src

   #+name:
   : foo

*** reading and writing
    :PROPERTIES:
    :DATE:     2011-02-22
    :END:
#+name: simple-list
- 1
- two
- 3
- four


#+name: simple-list
#+begin_src emacs-lisp :var lst=simple-list :results list
  (reverse lst)
#+end_src

   

** calc variables inside of parenthesis
   :PROPERTIES:
   :DATE:     2011-02-22
   :END:
#+BEGIN_SRC calc :var testvar=9000
testvar - 200
#+END_SRC

#+name:
: 8800

#+BEGIN_SRC calc :var testvar=9000
(testvar - 200) 800
#+END_SRC

#+name:
: 7040000

   

** sh return a list of elements with spaces
   :PROPERTIES:
   :DATE:     2011-02-26
   :END:
#+begin_src sh :results list
  echo "eric schulte"
  echo "dan davison"
  echo "seb vauban"
#+end_src

#+name:
- ("eric" "schulte")
- ("dan" "davison")
- ("seb" "vauban")

#+begin_src sh :results scalar
  echo "eric schulte"
  echo "dan davison"
  echo "seb vauban"
#+end_src

#+name:
: eric schulte
: dan davison
: seb vauban

   

** simple python block
   :PROPERTIES:
   :DATE:     2011-02-26
   :END:
#+begin_src python :return foo
  foo = 8
  foo += 1
#+end_src

#+name:
: 9

   

** source block names in current buffer
   :PROPERTIES:
   :DATE:     2011-02-26
   :END:
#+begin_src emacs-lisp :results list
 (org-babel-src-block-names)
#+end_src

   

** don't interpret tuples as elisp code
   :PROPERTIES:
   :DATE:     2011-02-27
   :END:
#+begin_src python :results value
  return (1,2)
#+end_src

#+name:
: (1, 2)

   

** exporting cache and noweb
   :PROPERTIES:
   :DATE:     2011-02-27
   :END:
#+name: test_sleep
#+begin_src R :session :exports code
  Sys.sleep(time=5)
  1:10
#+end_src

#+name: test_sleep
#+begin_src R :session :exports results :noweb yes :cache yes
  <<test_sleep>>
#+end_src

#+name[e2c9e6c2f84563b590a765502057d92463e50182]: test_sleep
|  1 |
|  2 |
|  3 |
|  4 |
|  5 |
|  6 |
|  7 |
|  8 |
|  9 |
| 10 |

   

** new block regexp tests
   :PROPERTIES:
   :DATE:     2011-02-27
   :END:
*** Block 1 (Exports OK)
    :PROPERTIES:
    :DATE:     2011-02-27
    :END:

#+BEGIN_SRC sh :tangle test-out
Block 1
#+END_SRC

*** Block 2 (Exports OK - double blank line no white-space in Block)
    :PROPERTIES:
    :DATE:     2011-02-27
    :END:

#+BEGIN_SRC sh :tangle test-out


#+END_SRC

*** Block 3 (Fails - single blank line no white-space in Block)
    :PROPERTIES:
    :DATE:     2011-02-27
    :END:

#+BEGIN_SRC sh :tangle test-out

#+END_SRC

*** Block 4 (Gets consumed by previous Block)
    :PROPERTIES:
    :DATE:     2011-02-27
    :END:

#+BEGIN_SRC sh :tangle test-out
Block 4
#+END_SRC

*** Block 5 (Fails - no lines in Block)
    :PROPERTIES:
    :DATE:     2011-02-27
    :END:

#+BEGIN_SRC sh :tangle test-out
#+END_SRC

*** Block 6 (Gets consumed by previous Block
    :PROPERTIES:
    :DATE:     2011-02-27
    :END:

#+BEGIN_SRC sh :tangle test-out
Block 6
#+END_SRC

   

** pass a vector to calc
   :PROPERTIES:
   :DATE:     2011-02-27
   :END:

#+begin_src calc :var y=[1 2 3]
  y
#+end_src

#+name:
: [1 2 3]

#+begin_src calc :var y=[1 2 3]
  3 y
#+end_src

#+name:
: [3, 6, 9]

#+begin_src emacs-lisp :var data=[1 2 3]
  (elt data 1)
#+end_src

#+name:
: 2

#+begin_src calc
  1 * 8
#+end_src

#+name:
: 8

   

** passing elisp-looking variables to code blocks
   :PROPERTIES:
   :DATE:     2011-02-27
   :END:
#+begin_src perl :var it="(+ 1 1)" :results output
  printf "passed in %s", $it
#+end_src

#+name:
: passed in (+ 1 1)

#+name: elisp-looking-table
| 1 | (+ 1 1) |
| 2 | (a b c) |
| 3 | (+ 3 3) |

#+begin_src perl :var data=elisp-looking-table[1,1]
  $data
#+end_src

#+name:
: (a b c)

#+begin_src emacs-lisp :var data=elisp-looking-table[1,1]
  data
#+end_src

#+name:
: (a b c)

   

** strip hline before processing a variables indices
   :PROPERTIES:
   :DATE:     2011-02-27
   :END:
#+name: table-w-hline
| 1 | a |
|---+---|
| 2 | b |
| 3 | c |
| 4 | d |

#+begin_src emacs-lisp :var table=table-w-hline[1,1] :hlines no
  table
#+end_src

#+name:
: hline

#+tblname: perl-table-w-hline
| colA | colB |
|------+------|
| a1   | b1   |
| a2   | b2   |

#+headers: :var b=perl-table-w-hline[2..,1]
#+headers: :var a=perl-table-w-hline[2..,0]
#+begin_src perl :tangle yes
  $a; $b;
#+end_src 

   

** literal reference in a table with sbe
   :PROPERTIES:
   :DATE:     2011-02-28
   :END:

| "eric schulte" | 12 |
#+TBLFM: @1$2='(sbe length (in $1))

#+name: length
#+begin_src emacs-lisp :var in="foo"
  (length in)
#+end_src

   

** reference to a commented out subtree
   :PROPERTIES:
   :DATE:     2011-02-28
   :END:
*** COMMENT I don't export
    :PROPERTIES:
    :DATE:     2011-02-28
    :END:
#+name: hidden-parameters
| 1 |
| 2 |
| 3 |
| 4 |

*** I do export
    :PROPERTIES:
    :DATE:     2011-02-28
    :END:
#+begin_src emacs-lisp :var params=hidden-parameters :exports both
  params
#+end_src

   

** leading/trailing spaces
   :PROPERTIES:
   :DATE:     2011-03-02
   :END:
#+name: spaces-wrapped-string
- " pass through with space "


#+begin_src emacs-lisp :var res=spaces-wrapped-string[0]
  res
#+end_src

#+name:
:  pass through with space 

   

** results org raw wrap
   :PROPERTIES:
   :DATE:     2011-03-02
   :END:
#+begin_src sh :results output org :exports none
  cat <<EOF
  - first
  - second
  EOF
#+end_src

#+name:
#+BEGIN_ORG
- first
- second
#+END_ORG

*** Version 1
    :PROPERTIES:
    :DATE:     2011-03-02
    :END:
This version only prints the org code for the table, but does not interprets it.
#+begin_src R :exports both :results output raw
  cat(
      "|--|--|\n",
      "|name|[[./pdf1.pdf]]|\n",
      "|--|--|\n"
      )
#+end_src

*** Version 2
    :PROPERTIES:
    :DATE:     2011-03-02
    :END:
This version prints the table including the graph as expected, but
:results is used twice as a header argument.
#+begin_src R :results output :exports both :results raw
  cat(
      "|--|--|\n",
      "|name|[[./pdf1.pdf]]|\n",
      "|--|--|\n"
      )
#+end_src

*** Version 3
    :PROPERTIES:
    :DATE:     2011-03-02
    :END:
Finally this version does only export the R code
#+begin_src R :exports both :results raw
  cat(
      "|--|--|\n",
      "|name|[[./pdf1.pdf]]|\n",
      "|--|--|\n"
      )
#+end_src

   

** export of inline R code
   :PROPERTIES:
   :DATE:     2011-03-03
   :END:
Here I test inline code evaluation in R.

#+begin_src R :session *R*
x <- 100
#+end_src

#+name:
: 100

Now I want to export the value of x, which should be
src_R[:session *R*]{x} .

Did the number 100 show up at the end of the previous sentence on export?

   

** simple mysql
   :PROPERTIES:
   :DATE:     2011-03-03
   :END:
#+begin_src sql :engine mysql
  show tables;
#+end_src

   

** eval results as a list
   :PROPERTIES:
   :DATE:     2011-03-06
   :END:
#+begin_src python :results value
  return "(mapcar (lambda (el) (+ 1 el)) '(1 2))"
#+end_src

#+name:
| 2 | 3 |

#+begin_src python :results value
  return "[1, 2]"
#+end_src

#+name:
| 1 | 2 |

#+begin_src python :results value
  return [1, 2]
#+end_src

#+name:
| 1 | 2 |

#+begin_src python :results value
  return "%r" % "[1 2]"
#+end_src

#+name:
: [1 2]

   

** looks like a pipe in a table
   :PROPERTIES:
   :DATE:     2011-03-07
   :END:
#+name: clean
#+begin_src emacs-lisp :var in=""
  (flet ((clean (in)
                (if (listp in)
                    (mapcar #'clean in)
                  (if (stringp in)
                      (replace-regexp-in-string "¦" "|" in)
                    in))))
    (clean in))
#+end_src

#+name: regexps
| first  | (a¦b) |
| second | (1¦2) |

#+begin_src perl :var a=clean(in=regexps)[0,1] :var b=clean(in=regexps)[1,1]
  $a; $b;
#+end_src

#+name:
: (1|2)

   

** conflicting header arguments
   :PROPERTIES:
   :DATE:     2011-03-14
   :END:

code block
#+name: conflict-block
#+begin_src sh :exports results :results silent
  echo eric
#+end_src

call line
#+call: conflict-block() :exports results

#+name: conflict-block()
: eric

   

** macros during tangling
   :PROPERTIES:
   :ID:       d2ff9d6f-b413-4072-91a9-3ae8aa32032c
   :DATE:     2011-03-14
   :END:

First, add macro expansion to the new `org-babel-tangle-body-hook'.

#+begin_src emacs-lisp :results silent
  (add-hook 'org-babel-tangle-body-hook
            (lambda () (org-export-preprocess-apply-macros)))
#+end_src

Then define the macro.  Note: you may need to export the buffer before
tangling so that the macro definition is noticed and processed by
Org-mode.

#+MACRO: CONFIG_PARAM01 45

Then on both export and tangling the macro in the following code block
will be replaced.

#+begin_src sh :tangle yes
  echo org-mode set CONFIG_PARAMETER to: {{{CONFIG_PARAM01}}}
#+end_src

   

** caching on export
   :PROPERTIES:
   :DATE:     2011-03-23
   :END:
#+name: testcache
#+begin_src R :cache yes :exports results
  dat <-  matrix(runif(12), 3, 4)
  print(dat)
#+end_src

#+name[e7b83e61596da84f85c5a24e61569576c802f9a2]: testcache
| 0.590091332094744 | 0.101750465808436 | 0.487125408137217 |  0.92315583024174 |
| 0.483292032498866 | 0.427640072302893 | 0.974636133294553 | 0.995571716455743 |
|  0.60190233332105 | 0.122638279106468 | 0.437959408387542 | 0.015639441087842 |

   

** colnames with call lines
   :PROPERTIES:
   :DATE:     2011-03-29
   :END:
#+TBLNAME: data
| x | parameter | value |
|---+-----------+-------|
| 0 | heat      |    30 |
| 1 | heat      |    30 |

#+name: func5
#+begin_src R :var name=data :var a="one" :colnames yes
  names(name)
#+end_src

#+name: func5
| x         |
|-----------|
| x         |
| parameter |
| value     |

#+call: func5(name=data, a="two") :colnames yes

#+name: func5(name=data, a="two")
| x         |
|-----------|
| x         |
| parameter |
| value     |

   

** CL example
   :PROPERTIES:
   :DATE:     2011-04-01
   :END:
#+begin_src lisp
  (defun range (n &optional m)
    "Return the numbers in range."
    (loop for num from (if m n 0) to (if m m (- n 1)) collect num))
  
  (mapcar #'list (mapcar #'1+ (range 10)))
#+end_src

#+name:
|  1 |
|  2 |
|  3 |
|  4 |
|  5 |
|  6 |
|  7 |
|  8 |
|  9 |
| 10 |

   

** detangling example
   :PROPERTIES:
   :tangle:   yes
   :comments: yes
   :shebang:  #!/bin/sh
   :ID:       7a22cf71-6be3-4fca-a700-4c8be8237303
   :DATE:     2011-04-01
   :END:

#+name: sh-for-tangling
#+begin_src sh
  echo "this is the `sh-for-tangling' code block"
  num=`expr 1 + 1`
  echo "the value of num is $num"
#+end_src

#+begin_src sh
  echo "this is an unnamed code block"
#+end_src

   

** grabbing the current buffer during export
   :PROPERTIES:
   :DATE:     2011-04-01
   :END:
Eric

#+begin_src emacs-lisp :var buf=(buffer-file-name (current-buffer)) :exports both
  (message "buffer %S!" buf)
#+end_src

#+begin_src sh :exports results :results output
  git log -1
#+end_src

   

** tangling out vc information
   :PROPERTIES:
   :DATE:     2011-04-01
   :END:

#+headers: :var STATE=(vc-state (or (buffer-file-name) org-current-export-file))
#+headers: :var REV=(vc-working-revision (or (buffer-file-name) org-current-export-file))
#+begin_src sh :tangle yes
  rm -rf ./R
  rm -f ./spreadSim.sub
  REVISION=$REV.$STATE
  tar -xf nsa.$REVISION.tar.gz
  $HOME/R/R/R-2.12.0/bin/Rscript --vanilla -e
"source('./R/generateLatinHypercubeScenarios.R'); doIt()"
  for SCENARIO in ./R/scenarios/*.R; do
    export SCENARIO=${SCENARIO#./R/scenarios/}
    qsub nsa.sub
  done
#+end_src

   

** vc-log
   :PROPERTIES:
   :DATE:     2011-04-01
   :END:

A version control log of this file.  The =vc-log= code block lives in
the library of babel.
#+call: vc-log() :exports results

   

** session associated with R block
   :PROPERTIES:
   :DATE:     2011-04-02
   :END:
#+begin_src R :session *chris*
  x <- 1
  y <- 2
  y-x
#+end_src

#+name:
: 1

   

** headers in R tables during export
   :PROPERTIES:
   :DATE:     2011-04-04
   :END:
#+TBLNAME: Chuah07
| condition | Mean.offer |
|-----------+------------|
| 1.MMM     |      48.49 |
| 2.MMU     |      42.59 |
| 3.MUM     |      44.87 |
| 4.UMU     |      46.43 |
| 5.UUM     |      44.15 |
| 6.UUU     |      43.80 |
| MAL       |      46.28 |
| UK        |       44.1 |
| All       |      45.29 |

#+headers: :var data=Chuah07
#+begin_src R :results output :exports both :cache yes
  str(data)
#+end_src

#+name[135a7f73839b69d118780ca29a64c3840601f7b9]:
: 'data.frame': 9 obs. of  2 variables:
:  $ condition : chr  "1.MMM" "2.MMU" "3.MUM" "4.UMU" ... 
:  $ Mean.offer: num  48.5 42.6 44.9 46.4 44.1 ... eric

   

** emacs-lisp printing with output to string
   :PROPERTIES:
   :DATE:     2011-04-10
   :END:

#+begin_src emacs-lisp :results output
  (let ((dog (sqrt 2))
        (cat 7))
    (print (format "%s %f" "Dog: " (eval dog)))
    (print (format "%s %d" "Cat: " (eval cat)) nil)
    (print "Fish."))
#+end_src

#+name:
: 
: "Dog:  1.414214"
: 
: "Cat:  7"
: 
: "Fish."

#+begin_src emacs-lisp
  (let ((dog (sqrt 2))
        (cat 7))
    `((dog ,dog)
      (cat ,cat)
      (fish)))
#+end_src

#+name:
| dog  | 1.4142135623730951 |
| cat  |                  7 |
| fish |                    |

   

** complex numbers in tables and python, reference in table formula
   :PROPERTIES:
   :DATE:     2011-04-13
   :END:

#+name: parameter-variation(data=0)
#+begin_src python :result values
  return 'text'
#+end_src

|---------------------------------------|
| "(0.0331901438056,0.000535222885197)" |
| "(0.0333434157791,0.000537930174356)" |
| "(0.0345727512157,0.000559346040457)" |
| "(0.0353146483908,0.000571501584524)" |
| "(0.0355522909393,0.000574387067408)" |
| "(0.0356575682336,0.000574851263615)" |
| "(0.0357806926897,0.000575051685084)" |
|---------------------------------------|
| text                                  |
#+TBLFM: @8$1='(sbe parameter-variation (nums @1$1..@7$1))

| '(1 2 3 4) |
|------------|
|          4 |
#+TBLFM: @2$1='(sbe quote (it @1$1))

| (1 2 3 4) |
|-----------|
| #ERROR    |
#+TBLFM: @2$1='(sbe quote (it @1$1))

*** using vectors to represent complex number is lisp
    :PROPERTIES:
    :DATE:     2011-04-15
    :END:
| [1 2]            |
|------------------|
| real:1 complex:2 |
#+TBLFM: @2$1='(sbe real (it @1$1))

#+name: real(it='())
#+begin_src emacs-lisp
  (format "real:%d complex:%d" (aref it 0) (aref it 1))
#+end_src

*** reference the table in a table formula
    :PROPERTIES:
    :DATE:     2011-04-13
    :END:
#+name: complex-data
|-------------------------------------|
| (0.0331901438056,0.000535222885197) |
|-------------------------------------|
|                                   4 |
#+TBLFM: @2$1='(sbe quote (it "complex-data"))

*** externally referencing the table
    :PROPERTIES:
    :DATE:     2011-04-13
    :END:
#+name: complex-data
|-------------------------------------|
| (0.0331901438056,0.000535222885197) |
| (0.0333434157791,0.000537930174356) |
| (0.0345727512157,0.000559346040457) |
| (0.0353146483908,0.000571501584524) |
| (0.0355522909393,0.000574387067408) |
| (0.0356575682336,0.000574851263615) |
| (0.0357806926897,0.000575051685084) |
#+TBLFM: @8$1='(sbe parameter-variation (nums @1$1..@7$1))

#+begin_src python :var data=complex-data
  return data
#+end_src

#+name:
| (0.0331901438056,0.000535222885197) |
| (0.0333434157791,0.000537930174356) |
| (0.0345727512157,0.000559346040457) |
| (0.0353146483908,0.000571501584524) |
| (0.0355522909393,0.000574387067408) |
| (0.0356575682336,0.000574851263615) |
| (0.0357806926897,0.000575051685084) |

   

** Ocaml appending blocks
   :PROPERTIES:
   :DATE:     2011-04-19
   :END:
block

#+begin_src ocaml
  [|1;2;3|];;
#+end_src

#+name:
| 1 | 2 | 3 |

   

** simple Oz example
   :PROPERTIES:
   :DATE:     2011-04-19
   :END:
#+begin_src oz :results output
  {Browse 'Hello'}
#+end_src

   

** units in R plot
   :PROPERTIES:
   :DATE:     2011-04-21
   :END:
#+begin_src R  :results graphics :file test.png :width 8 :height 8 :res 200 :units cm
  x <- -10:10
  y <- x^2
  plot(x, y, type="l", col="red", lty=1)
#+end_src

#+name:
[[file:test.png]]

   

** automatic org-mode formatting
   :PROPERTIES:
   :DATE:     2011-04-27
   :END:

#+name: raw-results
#+begin_src sh :results output tabular
  echo "| 1 |"
  echo "| 2 |"
#+end_src

#+begin_src emacs-lisp :var in=raw-results
  (stringp in)
#+end_src

#+name:
: t

   

** inserting complicated results
   :PROPERTIES:
   :DATE:     2011-05-05
   :END:
#+begin_src emacs-lisp :results scalar
  ((lambda (result) (condition-case nil (read result) (error result)))
   "(:return
   (:ok \"{:model #<MINLP f(x,y)={(x[0]-5)^2+(x[1]-3)^2-y*sqrt($x),2}>, :v #<Variables x={ 4.0, 4.0 } y={ 0 }>, :z nil}\")
   13)")
#+end_src

#+name:
| :return | (:ok {:model #<MINLP f(x,y)={(x[0]-5)^2+(x[1]-3)^2-y*sqrt($x),2}>, :v #<Variables x={ 4.0, 4.0 } y={ 0 }>, :z nil}) | 13 |

   

** simple latex verbatim wrap example
   :PROPERTIES:
   :DATE:     2011-05-05
   :END:
#+begin_src emacs-lisp :results silent
  (setq org-export-latex-verbatim-wrap
        '("{\\scriptsize\n\\begin{verbatim}\n" . "\\end{verbatim}\n}\n"))
#+end_src

#+begin_src sh
  echo eric schulte
  echo another
#+end_src

   

** new names for results
   :PROPERTIES:
   :DATE:     2011-05-06
   :END:

#+name: simple
: 1

#+begin_src emacs-lisp :var data=simple
  data
#+end_src

#+name:
: 1

changing the variable used to label data
#+begin_src emacs-lisp :results silent
  (setq org-babel-result-fmt
        "^[ \t]*#\\+\\(TBLNAME\\|RESNAME\\|RESULTS\\|DATA\\):[ \t]*%s[ \t]*$")
#+end_src

#+name: not-so-simple
: 2

#+begin_src emacs-lisp :var data=not-so-simple
  data
#+end_src

#+name:
: 2

   

** ocaml
   :PROPERTIES:
   :DATE:     2011-05-06
   :END:

#+begin_src ocaml
  [3;2;3] @ [3;2;3;4;5];;
#+end_src

#+name:
| 3 | 2 | 3 | 3 | 2 | 3 | 4 | 5 |

   

** append tables
   :PROPERTIES:
   :DATE:     2011-05-14
   :END:
#+name: table-names
- first-table
- second-table
- third-table

#+name: first-table
| a | 1 |
| b | 2 |

#+name: second-table
| c | 3 |
| d | 4 |

#+name: third-table
| e | 5 |
| f | 6 |

#+begin_src emacs-lisp :var table-names=table-names
  (mapcar #'org-babel-ref-resolve table-names)
#+end_src

#+name:
| (a 1) | (b 2) |
| (c 3) | (d 4) |
| (e 5) | (f 6) |

   

** don't match end_src inside of a block
   :PROPERTIES:
   :DATE:     2011-05-14
   :END:

#+name: the_issue
#+begin_src sh :results output
  echo '#+end_src'
#+end_src

#+name: the_issue
: #+end_src block

   

** awk example
   :PROPERTIES:
   :DATE:     2011-05-26
   :END:

#+name: simple-table
| 1 | 2 | 3 |
| 4 | 5 | 6 |
| 7 | 8 | 9 |

#+begin_src awk :stdin simple-table
  {print $1}
#+end_src

#+name:
| 1 |
| 4 |
| 7 |

   

** passing values through to STDIN of shell code blocks
   :PROPERTIES:
   :DATE:     2011-05-26
   :END:
#+name: square-table
| 1 | 2 | 3 |
| 4 | 5 | 6 |
| 7 | 8 | 9 |

#+name: first-col
#+begin_src sh :stdin square-table
  awk '{print $1}'
#+end_src

#+begin_src sh :stdin first-col
  sed 's/4/middle/g'
#+end_src

#+name:
|      1 |
| middle |
|      7 |

   

** example =#+call= line expansion
   :PROPERTIES:
   :DATE:     2011-05-27
   :END:
this code block peeks inside of the `params' variable which is used by
babel during code block evaluation
#+name: callee
#+begin_src emacs-lisp
  ;; this is cheating and shouldn't be done in user code :)
  (or (cdr (assoc :foo params)) 'unset)
#+end_src

this code block evaluates to the following,
#+name: callee
: unset

this call line,
#+call: callee[:foo bar]() :results org

expands into the following which is evaluated as a normal code block
by Babel.
#+begin_src emacs-lisp :var results=callee[:foo bar]() :results org
  results
#+end_src

this code block evaluates to the following,
#+name:
#+BEGIN_ORG
nothing
#+END_ORG

   

** lisp body with multiple forms
   :PROPERTIES:
   :DATE:     2011-05-31
   :END:

#+begin_src lisp :results value
  (format t "~&eric")
  (+ 1 2)
#+end_src

#+name:
: 3

   

** default directory examples in lisp
   :PROPERTIES:
   :DATE:     2011-06-01
   :END:

#+begin_src lisp
  *default-pathname-defaults*
#+end_src

#+begin_src sh
  pwd
#+end_src

#+begin_src lisp :dir
  *default-pathname-defaults*
#+end_src

#+name:
: #P""

   

** testing new data names
   :PROPERTIES:
   :DATE:     2011-06-02
   :END:

#+name: simple-123
: 123

#+begin_src emacs-lisp :var simple=simple-123 :exports both
  (* simple 2)
#+end_src

results

data

my data is results

#+name:
: 246

   

** =:file= and python
   :PROPERTIES:
   :DATE:     2011-06-06
   :END:
#+begin_src python :file /tmp/test.png
  return 1
#+end_src

#+name:
[[file:/tmp/test.png]]

   

** quick testing new session code
   :PROPERTIES:
   :DATE:     2011-06-06
   :END:
#+begin_src sh :session test :results output
  echo foo
#+end_src

#+name:
: foo

#+begin_src ruby :results output :session simple
  puts "foo"
#+end_src

#+name:
: foo

   

** simple shell
   :PROPERTIES:
   :DATE:     2011-06-06
   :END:
#+begin_src sh
  sleep 10 && ls
#+end_src

#+name:
| _config.yml     |
| data            |
| development.org |
| elsevier        |
| index.org       |
| paper           |
| publish.org     |
| scraps          |
| scraps.html     |
| scraps.org      |
| scraps.tex      |

#+begin_src ruby :session eric
  puts [1..4]
#+end_src

#+name:
: nil

   

** continued code blocks
   :PROPERTIES:
   :tangle:   yes
   :comments: yes
   :DATE:     2011-06-10
   :END:
#+name: foo
#+begin_src emacs-lisp
  (message "foo:%S" 1)
#+end_src

#+begin_src emacs-lisp
  (message "un-named")
#+end_src

#+name: bar
#+begin_src emacs-lisp
  (message "bar:%S" 1)
#+end_src

#+name: foo
#+begin_src emacs-lisp
  (message "foo:%S" 2)
#+end_src

#+name: bar
#+begin_src emacs-lisp
  (message "bar:%S" 2)
#+end_src

#+begin_src emacs-lisp :tangle no :results silent
  (with-temp-buffer
    (insert-file-contents "scraps.el")
    (eval-buffer))
#+end_src

   

** ruby with xmpfilter
   :PROPERTIES:
   :DATE:     2011-06-10
   :END:
#+begin_src ruby :results xmp code
  2 + 2 # =>
  3.times{ puts :hello }
#+end_src

#+name:
#+BEGIN_SRC ruby
2 + 2 # => 4
3.times{ puts :hello }
# >> hello
# >> hello
# >> hello
#+END_SRC

   

** tangle test
   :PROPERTIES:
   :DATE:     2011-06-10
   :END:
#+begin_src R :tangle test.R :shebang #!/bin/cat :padline no
This is
a test
#+end_src

   

** named code block export
   :PROPERTIES:
   :DATE:     2011-06-13
   :END:
This has a name which is not exported.

#+name: rand(n)
#+begin_src R
  runif(n)
#+end_src

   

** python session
   :PROPERTIES:
   :DATE:     2011-06-19
   :END:
#+begin_src python :results output :session mypy 
x = 1
for i in range(1,5):
  x = x + i
  print x

print "I throw an error"
#+end_src

#+name:
: 
: ... ... ... 2
: 4
: 7
: 11
: I throw an error

#+begin_src python :results output :session
  print y
#+end_src

#+name:
: Traceback (most recent call last):
:   File "<stdin>", line 1, in <module>
: NameError: name 'y' is not defined

   

** scalar emacs lisp results
   :PROPERTIES:
   :DATE:     2011-06-19
   :END:
#+begin_src emacs-lisp :results scalar
  '(1 2 3)
#+end_src

#+name:
: (1 2 3)

   

** expand variable during tangling
   :PROPERTIES:
   :tangle:   yes
   :DATE:     2011-06-20
   :END:

#+begin_src sh :var VER=(vc-working-revision (buffer-file-name))
  echo $VER
#+end_src

   

** clojure =:results scalar=
   :PROPERTIES:
   :DATE:     2011-06-21
   :END:
#+begin_src clojure :results scalar
  '(1 2 3)
#+end_src

   

** large code in inline blocks
   :PROPERTIES:
   :DATE:     2011-06-22
   :END:

#+name: big-block
#+begin_src emacs-lisp :exports none
  "something complex"
#+end_src

Here is some text with src_emacs-lisp[:var it=big-block]{it} in the middle.

   

** text and graphics from R
   :PROPERTIES:
   :DATE:     2011-06-24
   :END:

#+begin_src R :results output :session
print(seq(1,10))
#+end_src

#+begin_src R :file example.png :results graphics :session
plot(seq(1,10))
#+end_src

#+name:
[[file:example.png]]

   

** inline call line
   :PROPERTIES:
   :DATE:     2011-06-27
   :END:

#+name: double
#+begin_src emacs-lisp :var it=0
  (* 2 it)
#+end_src

This is the number src_sh[:var it=double(it=1)]{echo $it} in the middle

The following exports as a normal call line
#+call: double(it=1)

Now here is an inline call call_double(it=1) stuck in the middle of
some prose.

This one should not be exported =call_double(it=2)= because it is
quoted.

Finally this next one should export, even though it starts a line
call_double(it=3) because sometimes inline blocks fold with a
paragraph.

And, a call with raw results call_double(4)[:results raw] should not
have quoted results.

   

** multiple variables
   :PROPERTIES:
   :DATE:     2011-06-27
   :END:

Should work call_concat(1, 2, 3) =123= in order.

#+name: concat
#+begin_src emacs-lisp :var a=0 :var b=0 :var c=0
  (format "%S%S%S" a b c)
#+end_src

Should be positive call_lob-minus(4, 3) =1= by order.

   

** un-named variables
   :PROPERTIES:
   :DATE:     2011-06-27
   :END:

#+name: square
#+begin_src emacs-lisp :var it=0
  (* it it)
#+end_src

#+call: square(8)

first we can name the argument with call_square(it=4) =16=

then we can pass the argument unnamed with call_square(4) =16=

#+name: minus
#+begin_src emacs-lisp :var a=0 :var b=0
  (- a b)
#+end_src

To ensure that these arguments are passed in the correct order we can
use the following call_minus(8, 4) =-4=

   

** another test
   :PROPERTIES:
   :DATE:     2011-06-29
   :END:
#+name: square
#+begin_src emacs-lisp :var it=0
  (* it it)
#+end_src

Here is a call_square(it=4), stuck in the middle of some prose.

Here is another 25^2=call_square(it=25).

   

** longtable label and attr lines on code block results
   :PROPERTIES:
   :DATE:     2011-06-29
   :END:

#+name: faz
#+begin_src emacs-lisp :exports results
  '((foo foo)
    (bar baz))
#+end_src

#+LABEL: Foo
#+name: faz
| foo | foo |
| bar | baz |

   

** define a block with a name for noweb expansion
   :PROPERTIES:
   :tangle:   yes
   :noweb:    yes
   :DATE:     2011-07-01
   :END:

#+name: simple(something="something")
#+begin_src emacs-lisp
  something
#+end_src

another block including the first block
#+begin_src emacs-lisp
  <<simple(something="something else")>>
#+end_src