Updating docs to reflect new examples.

* Changed literalinclude paths to point to /examples.
* Removed parallel options demo from parallel_demos.txt as it
  is now a notebook. Eventually we will find a way to integrate
  notebooks with the sphinx docs, but that is beyond the scope of
  this branch.

docs/source/interactive/reference.txt

@@ -841,13 +841,13 b' The following sample file illustrating how to use the embedding'
 functionality is provided in the examples directory as example-embed.py.
 It should be fairly self-explanatory:
 
-.. literalinclude:: ../../examples/core/example-embed.py
+.. literalinclude:: ../../../examples/core/example-embed.py
     :language: python
 
 Once you understand how the system functions, you can use the following
 code fragments in your programs which are ready for cut and paste:
 
-.. literalinclude:: ../../examples/core/example-embed-short.py
+.. literalinclude:: ../../../examples/core/example-embed-short.py
     :language: python
 
 Using the Python debugger (pdb)
@@ -1111,7 +1111,7 b' want to continue, you simply execute the next block of the demo. The'
 following listing shows the markup necessary for dividing a script into
 sections for execution as a demo:
 
-.. literalinclude:: ../../examples/lib/example-demo.py
+.. literalinclude:: ../../../examples/lib/example-demo.py
     :language: python
 
 In order to run a file as a demo, you must first make a Demo object out

docs/source/parallel/asyncresult.txt

@@ -103,7 +103,7 b' Map results are iterable!'
 When an AsyncResult object has multiple results (e.g. the :class:`~AsyncMapResult`
 object), you can actually iterate through results themselves, and act on them as they arrive:
 
-.. literalinclude:: ../../examples/parallel/itermapresult.py
+.. literalinclude:: ../../../examples/parallel/itermapresult.py
     :language: python
     :lines: 20-67
     

docs/source/parallel/dag_dependencies.txt

@@ -81,7 +81,7 b' The code to generate the simple DAG:'
 For demonstration purposes, we have a function that generates a random DAG with a given
 number of nodes and edges.
 
-.. literalinclude:: ../../examples/parallel/dagdeps.py
+.. literalinclude:: ../../../examples/parallel/dagdeps.py
     :language: python
     :lines: 20-36
 
@@ -140,7 +140,7 b' These objects store a variety of metadata about each task, including various tim'
 We can validate that the dependencies were respected by checking that each task was
 started after all of its predecessors were completed:
 
-.. literalinclude:: ../../examples/parallel/dagdeps.py
+.. literalinclude:: ../../../examples/parallel/dagdeps.py
     :language: python
     :lines: 64-70
 

docs/source/parallel/parallel_demos.txt

@@ -99,7 +99,7 b' compute the two digit counts for the digits in a single file. Then in a final'
 step the counts from each engine will be added up. To perform this
 calculation, we will need two top-level functions from :file:`pidigits.py`:
 
-.. literalinclude:: ../../examples/parallel/pi/pidigits.py
+.. literalinclude:: ../../../examples/parallel/pi/pidigits.py
    :language: python
    :lines: 47-62
 
@@ -186,78 +186,6 b' compared to the 10,000 digit calculation.'
 
 .. image:: figs/two_digit_counts.*
 
-
-Parallel options pricing
-========================
-
-An option is a financial contract that gives the buyer of the contract the
-right to buy (a "call") or sell (a "put") a secondary asset (a stock for
-example) at a particular date in the future (the expiration date) for a
-pre-agreed upon price (the strike price). For this right, the buyer pays the
-seller a premium (the option price). There are a wide variety of flavors of
-options (American, European, Asian, etc.) that are useful for different
-purposes: hedging against risk, speculation, etc.
-
-Much of modern finance is driven by the need to price these contracts
-accurately based on what is known about the properties (such as volatility) of
-the underlying asset. One method of pricing options is to use a Monte Carlo
-simulation of the underlying asset price. In this example we use this approach
-to price both European and Asian (path dependent) options for various strike
-prices and volatilities.
-
-The code for this example can be found in the :file:`docs/examples/parallel/options`
-directory of the IPython source. The function :func:`price_options` in
-:file:`mckernel.py` implements the basic Monte Carlo pricing algorithm using
-the NumPy package and is shown here:
-
-.. literalinclude:: ../../examples/parallel/options/mckernel.py
-   :language: python
-
-To run this code in parallel, we will use IPython's :class:`LoadBalancedView` class,
-which distributes work to the engines using dynamic load balancing. This
-view is a wrapper of the :class:`Client` class shown in
-the previous example. The parallel calculation using :class:`LoadBalancedView` can
-be found in the file :file:`mcpricer.py`. The code in this file creates a
-:class:`LoadBalancedView` instance and then submits a set of tasks using
-:meth:`LoadBalancedView.apply` that calculate the option prices for different
-volatilities and strike prices. The results are then plotted as a 2D contour
-plot using Matplotlib.
-
-.. literalinclude:: ../../examples/parallel/options/mcpricer.py
-   :language: python
-
-To use this code, start an IPython cluster using :command:`ipcluster`, open
-IPython in the pylab mode with the file :file:`mckernel.py` in your current
-working directory and then type:
-
-.. sourcecode:: ipython
-
-    In [7]: run mcpricer.py
-    
-    Submitted tasks:  30
-
-Once all the tasks have finished, the results can be plotted using the
-:func:`plot_options` function. Here we make contour plots of the Asian
-call and Asian put options as function of the volatility and strike price:
-
-.. sourcecode:: ipython
-
-    In [8]: plot_options(sigma_vals, strike_vals, prices['acall'])
-
-    In [9]: plt.figure()
-    Out[9]: <matplotlib.figure.Figure object at 0x18c178d0>
-
-    In [10]: plot_options(sigma_vals, strike_vals, prices['aput'])
-
-These results are shown in the two figures below. On our 15 engines, the
-entire calculation (15 strike prices, 15 volatilities, 100,000 paths for each)
-took 37 seconds in parallel, giving a speedup of 14.1x, which is comparable
-to the speedup observed in our previous example.
-
-.. image:: figs/asian_call.*
-
-.. image:: figs/asian_put.*
-
 Conclusion
 ==========