An initial group sets the metadata used in any title pages, headers, footers, etc. used by the various exporters:

#+TITLE: Emacs org-mode examples
#+AUTHOR: Eric H. Neilsen, Jr.
#+EMAIL: neilsen@fnal.gov

Configue the org-mode tags for forcing inclusion of exclusion of sections in exported documents

#+EXPORT_SELECT_TAGS: export
#+EXPORT_EXCLUDE_TAGS: noexport

Additional options handle interpretation of special characters in the buffer, numbering of headings, etc.

#+OPTIONS: H:2 num:nil toc:nil \n:nil @:t ::t |:t ^:{} _:{} *:t TeX:t LaTeX:t

THE STARTUP keyword sets how the buffer is displayed when the file is opened in emacs:

#+STARTUP: showall

A few other are used exclusively by the html exporter:

#+LANGUAGE: en
#+INFOJS_OPT: view:showall toc:t ltoc:t mouse:underline path:http://orgmode.org/org-info.js
#+LINK_HOME: http://ehneilsen.net
#+LINK_UP: http://ehneilsen.net/notebook
#+HTML_HEAD: <link rel="stylesheet" type="text/css" href="../css/notebook.css" />

The LANGUAGE keyword sets the lang option in the html declaration.

The INFOJS_OPT keyword configures the org-info.js, javascript used to assist navigation of org-mode generated pages.

The LaTeX class and any LaTeX commands to be included at the head of exported LaTeX files. For example, on my laptop the header looks like this:

#+LaTeX_CLASS: smarticle
#+LaTeX_HEADER: \pdfmapfile{/home/neilsen/texmf/fonts/map/dvips/libertine/libertine.map}
#+LaTeX_HEADER: \usepackage[ttscale=.875]{libertine}
#+LaTeX_HEADER: \usepackage{sectsty}
#+LaTeX_HEADER: \sectionfont{\normalfont\scshape}
#+LaTeX_HEADER: \subsectionfont{\normalfont\itshape}

It looks a little different in my account on the DES cluster:

#+LaTeX_CLASS: smarticle
#+LaTeX_HEADER: \pdfmapfile{/home/s1/neilsen/texmf/fonts/map/dvips/libertine/libertine.map}
#+LaTeX_HEADER: \usepackage{sectsty}
#+LaTeX_HEADER: \usepackage{libertine}
#+LaTeX_HEADER: \usepackage[T1]{fontenc}
#+LaTeX_HEADER: \sectionfont{\normalfont\scshape}
#+LaTeX_HEADER: \subsectionfont{\normalfont\itshape}

Of course, LaTeX should be installed, and for the above to work, so must the libertine package, and the pdfmapfile must be set.

LaTeX installaction instruction can be found here.

A typical header that I use for org-mode files:

#+TITLE: Emacs org-mode examples
#+AUTHOR: Eric H. Neilsen, Jr.
#+EMAIL: neilsen@fnal.gov
#+LANGUAGE: en
#+INFOJS_OPT: view:showall toc:t ltoc:t mouse:underline path:http://orgmode.org/org-info.js
#+LINK_HOME: http://ehneilsen.net
#+LINK_UP: http://ehneilsen.net/notebook
#+HTML_HEAD: <link rel="stylesheet" type="text/css" href="../css/notebook.css" />
#+LaTeX_CLASS: smarticle
#+LaTeX_HEADER: \pdfmapfile{/home/neilsen/texmf/fonts/map/dvips/libertine/libertine.map}
#+LaTeX_HEADER: \usepackage[ttscale=.875]{libertine}
#+LaTeX_HEADER: \usepackage{sectsty}
#+LaTeX_HEADER: \sectionfont{\normalfont\scshape}
#+LaTeX_HEADER: \subsectionfont{\normalfont\itshape}
#+EXPORT_SELECT_TAGS: export
#+EXPORT_EXCLUDE_TAGS: noexport
#+OPTIONS: H:2 num:nil toc:nil \n:nil @:t ::t |:t ^:{} _:{} *:t TeX:t LaTeX:t
#+STARTUP: showall

dataa generates figures from ASCII "art". Examples of ditaa syntax can be found here.

#+begin_src ditaa :file ditaa-simpleboxes.png
+---------+
| |
| Foo |
| |
+----+----+---+
|Bar |Baz |
| | |
+----+--------+
#+end_src

#+begin_src ditaa :file ditaa-simpleboxes-unsep.png :cmdline -E
+---------+
| |
| Foo |
| |
+----+----+---+
|Bar |Baz |
| | |
+----+--------+
#+end_src

#+begin_src ditaa :file ditaa-seqboxes.png
+------+ +-----+ +-----+ +-----+
|{io} | |{d} | |{s} | |cBLU |
| Foo +---+ Bar +---+ Baz +---+ Moo |
| | | | | | | |
+------+ +-----+ +--+--+ +-----+
 |
 /-----\ | +------+
 | | | | c1AB |
 | Goo +------+---=--+ Shoo |
 \-----/ | |
 +------+
#+end_src

This:

#+begin_src plantuml :file class_diagram.png
skinparam monochrome true
FitsHdu <|-- PrimaryHdu
FitsHdu <|-- ExtensionHdu

FitsHdu : header
FitsHdu : getHeaderKeyword()

ExtensionHdu <|-- ImageHdu
ImageHdu : image
ImageHdu : getPixel(row, column)

ExtensionHdu <|-- BinaryTableHdu
BinaryTableHdu : table
BinaryTableHdu : getRow(row)
BinaryTableHdu : getColumn(column)
#+end_src

gives this:

This:

#+begin_src plantuml :file sequence_diagram.png
skinparam monochrome true
 Foo -> Bar: synchronous call
 Foo ->> Bar: asynchronous call
#+end_src

results in this:

Starting with this:

#+BEGIN_SRC calc :var x=5 :var y=2
2+a*x**y
#+END_SRC

If you place the cursor on the #+BEGIN_SRC and hit ctrl-c twice, it will produce a "results" section thus:

#+BEGIN_SRC calc :var x=5 :var y=2
2+a*x**y
#+END_SRC

#+RESULTS:
: 25 a + 2

Which results in this if the exported document

2+a*x**y

If you want the original formula in the exported document, you need to add an :exports both flag, thus:

#+BEGIN_SRC calc :exports both
x*2+x=4
#+END_SRC

#+results:
: 3 x = 4

Which results in this:

x*2+x=4

3 x = 4

GNU calc has many additional capabilities. It can be used to solve formula:

#+BEGIN_SRC calc :exports both
fsolve(x*2+x=4,x)
#+END_SRC

#+results:
: x = 1.33333333333

which exports to:

fsolve(x*2+x=4,x)

x = 1.33333333333

#+BEGIN_SRC calc
fsolve([x + y = a, x - y = b],[x,y])
#+END_SRC

#+RESULTS:
: [x = a + (b - a) / 2, y = (a - b) / 2]

#+BEGIN_SRC calc :exports both
finv(sqrt(x),x)
#+END_SRC

#+results:
: x^2

#+BEGIN_SRC calc :exports both
deriv(sqrt(x),x)
#+END_SRC

#+RESULTS:
: 0.5 / sqrt(x)

#+BEGIN_SRC calc :exports both
integ(x**2,x)
#+END_SRC

#+RESULTS:
: x^3 / 3

#+BEGIN_SRC calc :exports both
taylor(sin(x),x,6)
#+END_SRC

#+RESULTS:
: 0.0174532925199 x - 8.86096155693e-7 x^3 + 1.34960162314e-11 x^5

#+name: myformula
#+BEGIN_SRC calc
2+a*x**y
#+END_SRC

#+BEGIN_SRC calc :noweb yes :var x=5 :var y=2
<<myformula>>
#+END_SRC

#+RESULTS:
: 25 a + 2

#+BEGIN_SRC calc :noweb yes :var x=10 :var y=2
<<myformula>>
#+END_SRC

#+RESULTS:
: 100 a + 2

You can accomplish roughtly the same thing like this:

#+NAME: mynewformula
#+BEGIN_SRC calc
2+a*x**y
#+END_SRC

#+CALL: mynewformula(x=10,y=2)

#+RESULTS:
: 100 a + 2

2+a*x**y

100 a + 2

The first mechanism is somewhat more versatile, as you can combine multiple code blocks.

| airmass | zenith_seeing | delivered_seeing |
|---------+---------------+------------------|
| 1.3 | 0.95 | 1.1119612 |
| 1.3 | 1.0 | 1.1704854 |
| 1.3 | 1.1 | 1.2875340 |
| 1.3 | 1.2 | 1.4045825 |
| 1.3 | 1.25 | 1.4631068 |
| 1.3 | 1.3 | 1.5216311 |
| 1.3 | 1.5 | 1.7557281 |
| 1.3 | 1.8 | 2.1068738 |
| 1.2 | 1.8 | 2.0080811 |
| 1.3 | 2.0 | 2.3409709 |
#+TBLFM: $3=$2*($1**0.6)

results in this in the output:

airmass	zenith\_seeing	delivered\_seeing
1.3	0.95	1.1119612
1.3	1.0	1.1704854
1.3	1.1	1.2875340
1.3	1.2	1.4045825
1.3	1.25	1.4631068
1.3	1.3	1.5216311
1.3	1.5	1.7557281
1.3	1.8	2.1068738
1.2	1.8	2.0080811
1.3	2.1	2.4580194

To recalculate the column, put the cursor on the #+TBLFM column and hit ctrl-c twice.

This:

#+NAME: sampformula
#+BEGIN_SRC python :var angle=90 :var r=2 :exports none
from math import radians, cos
result = r*cos(radians(angle))
return result
#+END_SRC

| angle | r | x |
|-------+----+---------------|
| 30 | 10 | 8.66025403784 |
| 45 | 10 | 7.07106781187 |
| 60 | 10 | 5.0 |
#+TBLFM: $3='(org-sbe "sampformula" (angle $1) (r $2))

Results in this:

angle	r	x
30	10	8.66025403784
45	10	7.07106781187
60	10	5.0

This:

Foo bar \(f(x) = \frac{x^3}{n}\) chicken checken.

renders as this:

Foo bar \(f(x) = \frac{x\^3}{n}\) chicken checken.

This:

Our best estimate of F(\nu) will be 
\[
\hat{F}(\nu) = \frac{G(\nu)}{H(\nu)}.
\]

renders as this:

Our best estimate of F(ν) will be \[ \hat{F}(\nu) = \frac{G(\nu)}{H(\nu)}. \]

This:

\begin{eqnarray*}
\hat{f}(x) & \propto & \sum_{\nu} \frac{|F(\nu)H(\nu)|^2}{|N(\nu)|^2} 
 \frac{G(\nu)}{H(\nu)} e^{\frac{2 \pi i \nu x}{N}}\\
 & \propto & \sum_{\nu} \frac{|F(\nu)|^2}{|N(\nu)|^2} H(\nu) H^*(\nu) 
 \frac{G(\nu)}{H(\nu)} e^{\frac{2 \pi i \nu x}{N}}\\
 & \propto & \sum_{\nu} H^*(\nu) G(\nu) e^{\frac{2 \pi i \nu x}{N}}
\end{eqnarray*}

renders as this:

\begin{eqnarray*} \hat{f}(x) & \propto & \sum\_{\nu} \frac{|F(\nu)H(\nu)|\^2}{|N(\nu)|\^2} \frac{G(\nu)}{H(\nu)} e\^{\frac{2 \pi i \nu x}{N}}\\ & \propto & \sum\_{\nu} \frac{|F(\nu)|\^2}{|N(\nu)|\^2} H(\nu) H\^*(\nu) \frac{G(\nu)}{H(\nu)} e\^{\frac{2 \pi i \nu x}{N}}\\ & \propto & \sum\_{\nu} H\^*(\nu) G(\nu) e\^{\frac{2 \pi i \nu x}{N}} \end{eqnarray*}

If you have an org-mode table with a name:

#+tblname: delsee
| airmass | zenith_seeing | delivered_seeing |
|---------+---------------+------------------|
| 1.3 | 0.95 | 1.1119612 |
| 1.3 | 1.0 | 1.1704854 |
| 1.3 | 1.1 | 1.2875340 |
| 1.3 | 1.2 | 1.4045825 |
#+TBLFM: $3=$2*($1**0.6)

you can use it from within R code as a data frame:

#+begin_src R :results output :var delsee=delsee 
summary(delsee)
#+end_src

#+RESULTS:
: airmass zenith_seeing delivered_seeing
: Min. :1.3 Min. :0.9500 Min. :1.112 
: 1st Qu.:1.3 1st Qu.:0.9875 1st Qu.:1.156 
: Median :1.3 Median :1.0500 Median :1.229 
: Mean :1.3 Mean :1.0625 Mean :1.244 
: 3rd Qu.:1.3 3rd Qu.:1.1250 3rd Qu.:1.317 
: Max. :1.3 Max. :1.2000 Max. :1.405

This:

#+tblname: delsee
| airmass | zenith_seeing | delivered_seeing |
|---------+---------------+------------------|
| 1.3 | 0.95 | 1.1119612 |
| 1.3 | 1.0 | 1.1704854 |
| 1.3 | 1.1 | 1.2875340 |
| 1.3 | 1.2 | 1.4045825 |
#+TBLFM: $3=$2*($1**0.6)

#+begin_src R :exports both :results output graphics :var delsee=delsee :file delsee-r.png :width 400 :height 300
library(ggplot2)
p <- ggplot(delsee, aes(zenith_seeing, delivered_seeing))
p <- p + geom_point()
p
#+end_src

#+RESULTS:
file:delsee-r.png

Results in this:

airmass	zenith\_seeing	delivered\_seeing
1.3	0.95	1.1119612
1.3	1.0	1.1704854
1.3	1.1	1.2875340
1.3	1.2	1.4045825

library(ggplot2)
p <- ggplot(delsee, aes(zenith_seeing, delivered_seeing))
p <- p + geom_point()
p

The simple way is just to return the value of the data frame:

#+BEGIN_SRC R :colnames yes
d <- data.frame(foo=c('a','b','n'), bar=c(1.0/3.0,22,32))
d
#+END_SRC

#+RESULTS:
| foo | bar |
|-----+-------------------|
| a | 0.333333333333333 |
| b | 22 |
| n | 32 |

To limit significant figures, use the ascii R package. For example, this:

#+BEGIN_SRC R :results output raw :exports both
d <- data.frame(foo=c('a','b','n'), bar=c(1.0/3.0,22,32))

library(ascii)
options(asciiType="org")
ascii(d,format=c('s','f'),digits=c(5,4),include.rownames=FALSE)
#+END_SRC

#+RESULTS:
| foo | bar |
|-----+---------|
| a | 0.3333 |
| b | 22.0000 |
| n | 32.0000 |

produces this:

d <- data.frame(foo=c('a','b','n'), bar=c(1.0/3.0,22,32))

library(ascii)
options(asciiType="org")
ascii(d,format=c('s','f'),digits=c(5,4),include.rownames=FALSE)

foo	bar
a	0.3333
b	22.0000
n	32.0000

#+tblname: delsee
| airmass | zenith_seeing | delivered_seeing |
|---------+---------------+------------------|
| 1.3 | 0.95 | 1.1119612 |
| 1.3 | 1.0 | 1.1704854 |
| 1.3 | 1.1 | 1.2875340 |
| 1.3 | 1.2 | 1.4045825 |
#+TBLFM: $3=$2*($1**0.6)

#+BEGIN_SRC python :var delsee=delsee :results output
print delsee
#+END_SRC

#+RESULTS:
: [[1.3, 0.95, 1.1119612], [1.3, 1.0, 1.1704854], [1.3, 1.1, 1.287534], [1.3, 1.2, 1.4045825]]

This:

#+tblname: delsee
| airmass | zenith_seeing | delivered_seeing |
|---------+---------------+------------------|
| 1.3 | 0.95 | 1.1119612 |
| 1.3 | 1.0 | 1.1704854 |
| 1.3 | 1.1 | 1.2875340 |
| 1.3 | 1.2 | 1.4045825 |
#+TBLFM: $3=$2*($1**0.6)

#+BEGIN_SRC python :var fname="delseepy.png" :var delsee=delsee :results file
import matplotlib.pyplot as plt

x, y, z = zip(*delsee)

fig = plt.figure()
axes = fig.add_subplot(1,1,1)
axes.plot(y, z, marker='o')
fig.savefig(fname)

return fname
#+END_SRC

#+RESULTS:
file:delseepy.png

Results in this:

Following the structure outlined in Code Like a Pythonista, construct the python source file in sections:

#+BEGIN_SRC python :noweb yes :tangle HelloWorld.py :exports none
"""This is a hello world example document"""

# imports
import sys
<<helloworld-main-imports>>

# constants

# exception classes

# interface functions

# classes
<<HelloWorld-defn>>

# internal functions & classes

<<helloworld-main>>

if __name__ == '__main__':
 status = main()
 sys.exit(status)
#+END_SRC

When M-x org-babel-tangle is run within emacs, the :tangle HelloWorld.py line will cause it to generate a the file HelloWorld.py from the contents of the code blocks.

The bracketed lines (helloworld-classes, for example) are code fragments that will be defined later. org-mode will automatically substitute these blocks when createing the HelloWorld.py file.

Define the HelloWorld class thus:

#+NAME: HelloWorld-defn
#+BEGIN_SRC python
 class HelloWorld(object):
 def __init__(self, who):
 self.who = who

 def say_hello(self):
 print "Hello %s" % self.who
#+END_SRC

In the org-mode document, it will look like this:

class HelloWorld(object):
def __init__(self, who):
self.who = who

def say_hello(self):
print "Hello %s" % self.who

It's usually a good idea to have an argument parser in main. Start by creating a code block the performs the required imports:

#+NAME: helloworld-main-imports
#+BEGIN_SRC python
from argparse import ArgumentParser
#+END_SRC

which comes out like this in the document:

from argparse import ArgumentParser

Then, define the main function itself:

#+NAME: helloworld-main
#+BEGIN_SRC python
 def main():
 parser = ArgumentParser(description="Say hi")
 parser.add_argument("-w", "--who", 
 type=str,
 default="world",
 help="Who to say hello to")
 args = parser.parse_args()

 who = args.who

 greeter = HelloWorld(who)
 greeter.say_hello()

 return 0
#+END_SRC

which comes out like this:

def main():
parser = ArgumentParser(description="Say hi")
parser.add_argument("-w", "--who", 
type=str,
default="world",
help="Who to say hello to")
args = parser.parse_args()

who = args.who

greeter = HelloWorld(who)
greeter.say_hello()

return 0

Create a section to make it easy to run the generated code from within the orgmode document:

#+NAME: bashrun-helloworld
#+BEGIN_SRC sh :results output :exports none
python HelloWorld.py --w Eric 2>&1
true
#+END_SRC

The "true" command at the end of this shell script makes sure that the output gets incorportated into the org-mode buffer even if the code crashes.

The output looks like this in your orgmode buffer:

python HelloWorld.py --w Eric 2>&1
true

Hello Eric

Create interactive tests. It's a good idea to use the restructured text mode in emacs, so that the result can be a ReStructuredText test document, traditional to python.

Here is one, for example:

#+NAME: doctest-foo
#+BEGIN_SRC rst
 example foo::
 >>> from HelloWorld import *
 >>>
 >>> foo = HelloWorld('foo')
 >>> foo.say_hello()
 Hello foo

#+END_SRC

and another:

#+NAME: doctest-bar
#+BEGIN_SRC rst
 example bar::
 >>> from HelloWorld import *
 >>>
 >>> bar = HelloWorld('bar')
 >>> bar.say_hello()
 Hello bar

#+END_SRC

Create a document to "tangle" them into

#+BEGIN_SRC text :noweb yes :tangle test_HelloWorld.txt :exports none
<<doctest-foo>>
<<doctest-bar>>
#+END_SRC

You can run the doctests from with org-mode with this bash code snippet:

#+NAME: bashrun-helloworld-doctest
#+BEGIN_SRC sh :results output :exports both
python -m doctest test_HelloWorld.txt 2>&1
true
#+END_SRC

If the test succeeds, it will produce no output

Define the unit test like any other piece of python code:

#+NAME: unittest-foo
#+BEGIN_SRC python
 class TestFoo(unittest.TestCase):
 def test_foo(self):
 greeter = HelloWorld('foo')
 self.assertEqual(greeter.who, 'foo')
#+END_SRC

Define the main testing module like this:

#+BEGIN_SRC python :noweb yes :tangle TestHelloWorld.py :exports none
 import sys
 import unittest
 from doctest import DocFileSuite
 from HelloWorld import *

 <<unittest-foo>>

 def main():
 suite = unittest.TestSuite()
 suite.addTests( DocFileSuite('test_HelloWorld.txt') )
 suite.addTests( 
 unittest.defaultTestLoader.loadTestsFromModule(sys.modules[__name__]))
 unittest.TextTestRunner(verbosity=2).run(suite)
 return 0

 if __name__ == '__main__':
 status = main()
 sys.exit(status)
#+END_SRC

Use this bash source block to run all tests:

#+NAME: bashrun-helloworld-alltest
#+BEGIN_SRC sh :results output :exports both
python -m doctest test_HelloWorld.py 2>&1
#+END_SRC

The output looks like this:

python TestHelloWorld.py 2>&1

test_HelloWorld.txt
Doctest: test_HelloWorld.txt ... ok
test_foo (__main__.TestFoo) ... ok

----------------------------------------------------------------------
Ran 2 tests in 0.004s

OK