# HG changeset patch
# User amit
# Date 1284646233 -19800
# Node ID b9ae88095adeeb0ae6cc8f7589f09d3c999e27a2
# Parent  60a4616dbf55f994e65467dbd8114bf70c9105e3# Parent  81a74c2aef61d413887b824a293eecfc7c0e421b
Merging the changes from Nishanth and Punch

diff -r 60a4616dbf55 -r b9ae88095ade accessing-pieces-arrays.rst
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/accessing-pieces-arrays.rst	Thu Sep 16 19:40:33 2010 +0530
@@ -0,0 +1,339 @@
+========
+ Script
+========
+
+
+{{{ Screen shows welcome slide }}}
+
+Welcome to the tutorial on accessing pieces of arrays
+
+{{{ Show the outline for this tutorial }}} 
+
+In this tutorial we shall learn to access individual elements of
+arrays, get rows and columns and other chunks of arrays using
+slicing and striding. 
+
+{{{ switch back to the terminal }}}
+
+As usual, we start IPython, using 
+::
+
+  ipython -pylab 
+
+Let us have two arrays, A and C, as the sample arrays that we will
+use to work through this tutorial. 
+
+::
+
+  A = array([12, 23, 34, 45, 56])
+
+  C = array([[11, 12, 13, 14, 15],
+             [21, 22, 23, 24, 25],
+             [31, 32, 33, 34, 35],
+             [41, 42, 43, 44, 45],
+             [51, 52, 53, 54, 55]])
+
+Pause the video here and make sure you have the arrays A and C,
+typed in correctly.
+
+Let us begin with the most elementary thing, accessing individual
+elements. Also, let us first do it with the one-dimensional array
+A, and then do the same thing with the two-dimensional array. 
+
+To access, the element 34 in A, we say, 
+
+::
+
+  A[1]
+
+Like lists, indexing starts from 0 in arrays, too. So, 34, the
+third element has the index 2. 
+
+Now, let us access the element 34 from C. To do this, we say
+::
+
+  C[2, 3]
+
+34 is in the third row and the fourth column, and since indexing
+begins from zero, the row index is 2 and column index is 3. 
+
+Now, that we have accessed one element of the array, let us change
+it. We shall change the 34 to -34 in both A and C. To do this, we
+simply assign the new value after accessing the element. 
+::
+
+  A[2] = -34
+  C[2, 3] = -34
+
+Now that we have accessed and changed a single element, let us
+access and change more than one element at a time; first rows and
+then columns.
+
+Let us access one row of C, say the third row. We do it by saying, 
+::
+
+  C[2] 
+
+How do we access the last row of C? We could say,
+::
+
+  C[4] 
+
+for the fifth row, or as with lists, use negative indexing and say
+::
+
+  C[-1]
+
+Now, we could change the last row into all zeros, using either 
+::
+
+  C[-1] = [0, 0, 0, 0, 0]
+
+or 
+
+::
+  
+  C[-1] = 0
+
+Now, how do we access one column of C? As with accessing
+individual elements, the column is the second parameter to be
+specified (after the comma). The first parameter, is now replaced
+with a ``:`` to say, that we want all the elements of that
+dimension, instead of one particular element. We access the third
+column by
+
+::
+  
+  C[:, 2]
+
+%%1%% Pause the video here and change the last column of C to
+zeroes and then resume the video.
+
+::
+  
+  C[:, -1] = 0
+
+Since A is one dimensional, rows and columns of A don't make much
+sense. It has just one row and 
+::
+
+  A[:] 
+
+gives the whole of A. 
+
+%%2%% Pause the video here and change ``A`` to ``[11, 12, 13, 14, 15]``
+and then resume the video. 
+
+To change A, we say
+::
+
+  A[:] = [11, 12, 13, 14, 15]
+
+Now, that we know how to access, rows and columns of an array, we
+shall learn how to access other pieces of an array. For this
+purpose, we will be using image arrays. 
+
+To read an image into an array, we use the ``imread`` command. We
+shall use the image ``squares.png`` present in ``/home/fossee``. We
+shall first navigate to that path in the OS and see what the image
+contains. 
+
+{{{ switch to the browser and show the image }}}
+
+{{{ switch back to the ipython terminal }}}
+
+Let us now read the data in ``squares.png`` into the array ``I``. 
+::
+
+  I = imread('/home/fossee/squares.png')
+
+We can see the contents of the image, using the command
+``imshow``. We say, 
+::
+
+  imshow(I) 
+
+to see what has been read into ``I``.
+
+To see that ``I`` is really, just an array, we say, 
+::
+
+  I 
+
+at the prompt, and see that an array is displayed. 
+
+To check the dimensions of any array, we can use the method
+shape. We say
+::
+
+  I.shape 
+
+to get the dimensions of the image. As we can see, ``squares.png``
+has the dimensions of 300x300. 
+
+Our goal for this part of the tutorial would be to get the
+top-left quadrant of the image. To do this, we need to access, a
+few of the rows and a few of the columns of the array. 
+
+To access, the third column of C, we said, ``C[:, 2]``. Essentially,
+we are accessing all the rows in column three of C. Now, let us
+modify this to access only the first three rows, of column three
+of C. 
+
+We say, 
+::
+
+  C[0:3, 2]
+
+to get the elements of rows indexed from 0 to 3, 3 not included
+and column indexed 2. Note that, the index before the colon is
+included and the index after it is not included, in the slice that
+we have obtained. This is very similar to the ``range`` function,
+where ``range`` returns a list, in which the upper limit or stop
+value is not included.
+
+Now, if we wish to access the elements of row with index 2, and in
+columns indexed 0 to 2 (included), we say, 
+::
+
+  C[2, 0:3]
+
+E%% %% Pause the video here, and first, obtain the elements [22,
+23] from C. Then, obtain the elements [11, 21, 31, 41] from
+C. Finally, obtain the elements [21, 31, 41, 0]. Then, resume the
+video.
+::
+
+  C[1, 1:3] 
+
+gives the elements [22, 23]
+::
+
+  C[0:4, 0]
+
+gives the elements [11, 21, 31, 41]
+::
+
+  C[1:5, 0]
+
+gives the elements [21, 31, 41, 0]
+
+Note that when specifying ranges, if you are starting from or
+going up-to the end, the corresponding element may be dropped. So,
+in the previous example to obtain [11, 21, 31, 41], we could have
+simply said, 
+::
+
+  C[:4, 0]
+
+and 
+::
+
+  C[1:, 0]
+
+gives the elements [21, 31, 41, 0]. If we skip both the indexes,
+we get the slice from end to end, as we already know. 
+
+E%% %% Pause the video here. Obtain the elements [[23, 24], [33,
+-34]] and then resume the video. 
+::
+
+  C[1:3, 2:4] 
+
+gives us the elements, [[23, 24], [33, -34]]. 
+
+Now, we wish to obtain the top left quarter of the image. How do
+we go about doing it? Since, we know the shape of the image to be
+300, we know that we need to get the first 150 rows and first 150
+columns. 
+::
+
+  I[:150, :150]
+
+gives us the top-left corner of the image. 
+
+We use the ``imshow`` command to see the slice we obtained in the
+form of an image and confirm. 
+::
+
+  imshow(I[:150, :150])
+
+E%% %% Pause the video here, and obtain the square in the center
+of the image. 
+::
+
+  imshow(I[75:225, 75:225])
+
+Our next goal is to compress the image, using a very simple
+technique to reduce the space that the image takes on disk while
+not compromising too heavily on the image quality. The idea is to
+drop alternate rows and columns of the image and save it. This way
+we will be reducing the data to a fourth of the original data but
+losing only so much of visual information. 
+
+We shall first learn the idea of striding using the smaller array
+C. Suppose we wish to access only the odd rows and columns (first,
+third, fifth). We do this by, 
+::
+
+  C[0:5:2, 0:5:2]
+
+if we wish to be explicit, or simply, 
+::
+
+  C[::2, ::2]
+
+This is very similar to the step specified to the ``range``
+function. It specifies, the jump or step in which to move, while
+accessing the elements. If no step is specified, a default value
+of 1 is assumed. 
+::
+
+  C[1::2, ::2] 
+
+gives the elements, [[21, 23, 0], [41, 43, 0]]
+
+E%% %% Pause the video here, and obtain the following. 
+[[12, 0], [42, 0]]
+[[12, 13, 14], [0, 0, 0]]
+Then, resume the video. 
+::
+
+  C[::3, 1::3]
+
+gives the elements [[12, 0], [42, 0]]
+::
+
+  C[::4, 1:4]
+
+gives the elements [[12, 13, 14], [0, 0, 0]]
+
+Now, that we know how to stride over an image, we can drop
+alternate rows and columns out of the image in I. 
+::
+
+  I[::2, ::2]
+
+To see this image, we say, 
+::
+
+  imshow(I[::2, ::2])
+
+This does not have much data to notice any real difference, but
+notice that the scale has reduced to show that we have dropped
+alternate rows and columns. If you notice carefully, you will be
+able to observe some blurring near the edges. To notice this
+effect more clearly, increase the step to 4. 
+::
+
+  imshow(I[::4, ::4])
+
+{{{ show summary slide }}}
+
+That brings us to the end of this tutorial. In this tutorial, we
+have learnt to access parts of arrays, specifically individual
+elements, rows and columns and larger pieces of arrays. We have
+also learnt how to modify arrays, element wise or in larger
+pieces.
+
+Thank You!
diff -r 60a4616dbf55 -r b9ae88095ade additional_ipython.rst
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/additional_ipython.rst	Thu Sep 16 19:40:33 2010 +0530
@@ -0,0 +1,189 @@
+Hello friends and welcome to the tutorial on Additional Features of IPython
+
+{{{ Show the slide containing title }}}
+
+{{{ Show the slide containing the outline slide }}}
+
+In this tutorial, we shall look at additional features of IPython that help us
+to retreive the commands that we type on the interpreter and then save them
+into a file and run it.
+
+Let us start ipython with pylab loaded, by typing
+::
+
+    $ ipython -pylab
+
+on the terminal
+
+{{{ shit to terminal and type ipython -pylab }}}
+
+We shall first make a plot and then view the history and save it.
+::
+
+    x = linspace(-2*pi, 2*pi, 100)
+    plot(x, xsinx(x))
+
+xsin(x) is actually x * sin(x)
+::
+
+    plot(x, x*sin(x))
+    plot(x, sin(x))
+    xlabel("x")
+    ylabel("$f(x)$")   
+    title("x and xsin")
+
+We now have the plot. Let us look at the commands that we have typed in. The
+history can be retreived by using =%hist= command. Type
+::
+
+    %hist
+
+As you can see, it displays a list of recent commands that we typed. Every
+command has a number in front, to specify in which order and when it was typed.
+
+Please note that there is a % sign before the hist command. This implies that 
+%hist is a command that is specific to IPython and not available in vannila 
+Python interpreter. These type of commands are called as magic commands.
+
+Also note that, the =%hist= itself is a command and is displayed as the most
+recent command. This implies that anything we type in is stored as history, 
+irrespective of whether it is command or an error or IPython magic command.
+
+If we want only the recent 5 to be displayed, we pass the number as an argument
+to =%hist= command. Hence
+::
+
+    %hist 5 
+
+displays the recent 5 commands, inclusive of the =%hist= command.
+The default number is 40.
+
+{{{ Pause here and try out the following exercises }}}
+
+%% 1 %% Read through the %hist documenatation and find out how can we list all
+        the commands between 5 and 10
+
+{{{ continue from paused state }}}
+
+As we can see from =%hist= documentation,
+::
+
+    %hist 5 10
+
+displays the commands from 5 to 10
+
+Now that we have the history, we would like to save the required line of code
+from history. This is possible by using the =%save= command.
+
+Before we do that, let us first look at history and identify what lines of code
+we require.Type
+::
+
+    %hist
+
+
+{{{ point to the lines }}}
+
+The first command is linspace. But second command is a command that gave us an
+error. Hence we do not need seconf. The commands from third to sixth are 
+required. The seventh command although is correct, we do not need it since we
+are setting the title correctly in the eigthth command.
+
+So we need first third to sixth and the eigthth command for our program.
+Hence the syntax of =%save= is
+::
+
+    %save /home/fossee/plot_script.py 1 3-6 8
+
+{{{ point to the output of the command }}}
+
+The command saves first and then third to sixth and eighth lines of code into
+the specified file.
+
+The first argument to %save is the path of file to save the commands and the
+arguments there after are the commands to be saved in the given order.
+
+{{{ goto the file and open it and show it }}}
+
+{{{ Pause here and try out the following exercises }}}
+
+%% 2 %% change the label on y-axis to "y" and save the lines of code
+        accordingly
+
+{{{ continue from paused state }}}
+
+we use the command =ylabel= on interpreter as
+::
+
+    ylabel("y")
+
+and then do
+::
+
+    %save /home/fossee/example_plot.py 1 3-6 10
+
+Now that we have the required lines of code in a file, let us learn how to run
+the file as a python script.
+
+We use the IPython magic command =%run= to do this. Type
+::
+
+   %run -i /home/fossee/plot_script.py
+
+The script runs but we do not see the plot. This happens because we are running
+a script and we are not in interactive mode anymore.
+
+Hence on your terminal type
+::
+
+    show()
+
+to show the plot.
+
+{{{ Pause here and try out the following exercises }}}
+
+%% 3 %% Use %hist and %save and create a script that has show in it and run it
+        to produce and show the plot.
+
+{{{ continue from paused state }}}
+
+We first look at the history using
+::
+
+    %hist 20
+
+Then save the script using
+::
+
+    %save /home/fossee/show_included.py 1 3-6 8 10 13
+    %run -i /home/fossee/show_included.py
+
+We get the desired plot.
+
+The reason for including a -i after run is to tell the interpreter that if any
+name is not found in script, search for it in the interpreter. Hence all these
+sin, plot, pi and show which are not available in script, are taken from the
+interpreter and used to run the script.
+
+{{{ Show summary slide }}}
+
+This brings us to the end of the tutorial.
+we have looked at 
+
+ * Retreiving history using =%hist= command
+ * Vieweing only a part of history by passing an argument to %hist
+ * saving the required lines of code in required order using %save
+ * using %run -i command to run the saved script
+
+{{{ Show the "sponsored by FOSSEE" slide }}}
+
+#[Nishanth]: Will add this line after all of us fix on one.
+This tutorial was created as a part of FOSSEE project, NME ICT, MHRD India
+
+Hope you have enjoyed and found it useful.
+Thankyou
+ 
+.. Author              : Nishanth
+   Internal Reviewer 1 : 
+   Internal Reviewer 2 : 
+   External Reviewer   :
diff -r 60a4616dbf55 -r b9ae88095ade advanced-features-functions.rst
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/advanced-features-functions.rst	Thu Sep 16 19:40:33 2010 +0530
@@ -0,0 +1,4 @@
+========
+ Script
+========
+
diff -r 60a4616dbf55 -r b9ae88095ade embellishing_a_plot.rst
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/embellishing_a_plot.rst	Thu Sep 16 19:40:33 2010 +0530
@@ -0,0 +1,243 @@
+Hello friends and welcome to the tutorial on Embellishing Plots
+
+{{{ Show the slide containing title }}}
+
+{{{ Show the slide containing the outline slide }}}
+
+In this tutorial, we shall look at how to modify the colour, thickness and 
+linestyle of the plot. We shall then learn how to add title to the plot and 
+then look at adding labels to x and y axes. we shall also look at adding 
+annotations to the plot.
+
+Let us start ipython with pylab loaded, by typing
+::
+
+    ipython -pylab
+
+on the terminal
+
+{{{ shit to terminal and type ipython -pylab }}}
+
+We shall first make a simple plot and start with decorating it.
+::
+
+    x = linspace(-2, 4, 20)
+    plot(x, sin(x))
+
+As you can see, the colour and thickness of line as decided by pylab. It would
+be nice if we could control these parameters in the plot. This is possible by
+passing additional arguments to the plot command.
+
+The second argument that we shall be passing is colour. We shall first clear
+the figure and plot the same in red colour.Hence
+::
+
+    clf()
+    plot(x, sin(x), 'r')
+
+Plots the same curve but now in red colour.
+
+To alter the thickness of the line, we use the =linewidth= argument in the plot
+command.Hence
+::
+
+    plot(x, cos(x), linewidth=2)
+
+produces a plot with a thicker line.
+
+{{{ Show the plot and compare the sin and cos plots }}}
+
+{{{ Pause here and try out the following exercises }}}
+
+%% 1 %% Plot sin(x) in blue colour and with linewidth as 3
+
+{{{ continue from paused state }}}
+
+A combination of colour and linewidth would do the job for us. Hence
+::
+
+    plot(x, sin(x), 'b', linewidth=3)
+
+produces the required plot
+
+#[Nishanth]: I could not think of a SIMPLE recipe approach for introducing
+             linestyle. Hence the naive approach.
+
+Occasionally we would also want to alter the style of line. Sometimes all we
+want is just a bunch of points not joined. This is possible by passing the
+linestyle argument along with or instead of the colour argument.Hence
+::
+
+    clf()
+    plot(x, sin(x), '.')
+
+produces a plot with only points.
+
+To produce the same plot but now in blue colour, we do
+::
+
+    clf()
+    plot(x, sin(x), 'b.')
+
+Other available options can be seen in the documentation of plot.
+::
+
+    plot?
+
+{{{ Run through the documentation and show the options available }}}
+
+{{{ Pause here and try out the following exercises }}}
+
+%% 2 %% Plot the sine curve with green filled circles.
+
+{{{ continue from paused state }}}
+
+All we have to do is use a combination of linestyle and colour to acheive this.
+Hence
+::
+
+    clf()
+    plot(x, cos(x), 'go')
+
+produces the required plot.
+
+{{{ Pause here and try out the following exercises }}}
+
+%% 3 %% Produce a plot of tangent curve with red dashed line and linewidth 3
+
+{{{ continue from paused state }}}
+
+Now that we know how to produce a bare minimum plot with colour, style and
+thickness of our interest, we shall look at decorating the plot.
+
+Let us start with a plot of the function -x^2 + 4x - 5.
+::
+
+    plot(x, -x*x + 4*x - 5, 'r', linewidth=2)
+
+{{{ Show the plot window and switch back to terminal }}}
+
+We now have the plot in a colour and linewidth of our interest. As you can see,
+the figure does have any description describing the plot.
+
+We will now add a title to the plot by using the =title= command.
+::
+
+    title("Parabolic function -x^2+4x-5") 
+
+{{{ Show the plot window and point to the title }}}
+The figure now has a title which describes what the plot is.
+The =title= command as you can see, takes a string as argument and set the
+title accordingly.
+
+The formatting in title is messed and it does not look clean. You can imagine
+what would be the situation if there were fractions and more complex functions
+like log and exp. Wouldn't it be good if there was LaTex like formatting.
+
+That is also possible by adding a $ sign before and after the part of the 
+string that should be LaTex style.
+
+for instance, we can use
+::
+
+    title("Parabolic function $-x^2+4x-5$")
+
+and we get the polynomial formatted properly.
+
+#[Nishanth]: Unsure if I have to give this exercise since enclosing the whole
+             string in LaTex style is not good
+
+{{{ Pause here and try out the following exercises }}}
+
+%% 4 %% Change the title of the figure such that the whole title is formatted
+        in LaTex style
+
+{{{ continue from the paused state }}}
+
+The solution is to enclose the whole string in between $. Hence,
+::
+
+    title("$Parabolic function -x^2+4x-5$")
+
+gives a title that looks neatly formatted.
+
+Although we have title, the plot is not complete without labelling x and y
+axes. Hence we shall label x-axis to "x" and y-axis to "f(x)"
+::
+
+    xlabel("x")
+
+{{{ Switch to plot window and show the xlabel }}}
+
+As you can see, =xlabel= command takes a string as argument, similar to the
+=title= command and sets it to x-axis.
+
+Similarly,
+::
+
+    ylabel("f(x)")
+
+sets the name of y-axis as "f(x)"
+
+{{{ Show the plot window and point to ylabel and switch back to terminal }}}
+
+{{{ Pause here and try out the following exercises }}}
+
+%% 5 %% Set the x and y labels as "x" and "f(x)" in LaTex style.
+
+{{{ continue from paused state }}}
+
+Since we need LaTex style formatting, all we have to do is enclose the string
+in between two $. Hence,
+::
+
+    xlabel("$x$")
+    yalbel("$f(x)$")
+
+does the job for us.
+
+{{{ Show the plot window with clean labels }}}
+
+The plot is now almost complete. Except that we have still not seen how to 
+name the points. For example the point (2, -1) is the local maxima. We would
+like to name the point accordingly. We can do this by using
+::
+
+    annotate("local maxima", xy=(2, -1))
+
+{{{ Show the annotation that has appeared on the plot }}}
+As you can see, the first argument to =annotate= command is the name we would
+like to mark the point as and the argument after xy= is the point at which the
+name should appear.
+
+{{{ Pause here and try out the following exercises }}}
+
+%% 6 %% Make an annotation called "root" at the point (-4, 0)
+        What happens to the first annotation ?
+
+{{{ continue from paused state }}}
+
+As we can see, every annotate command makes a new annotation on the figure.
+
+{{{ Show summary slide }}}
+
+we have looked at 
+
+ * Modifying the attributes of plot by passing additional arguments
+ * How to add title
+ * How to incorporate LaTex style formatting
+ * How to label x and y axes
+ * How to add annotations
+
+{{{ Show the "sponsored by FOSSEE" slide }}}
+
+#[Nishanth]: Will add this line after all of us fix on one.
+This tutorial was created as a part of FOSSEE project, NME ICT, MHRD India
+
+Hope you have enjoyed and found it useful.
+Thankyou
+ 
+.. Author              : Nishanth
+   Internal Reviewer 1 : 
+   Internal Reviewer 2 : 
+   External Reviewer   :
diff -r 60a4616dbf55 -r b9ae88095ade getting-started-files.rst
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/getting-started-files.rst	Thu Sep 16 19:40:33 2010 +0530
@@ -0,0 +1,147 @@
+========
+ Script
+========
+
+Welcome to the tutorial on getting started with files. 
+
+{{{ Screen shows welcome slide }}}
+
+{{{ Show the outline for this tutorial }}} 
+
+In this tutorial we shall learn to read files, and do some basic
+actions on the file, like opening and reading a file, closing a
+file, iterating through the file line-by-line, and appending the
+lines of a file to a list. 
+
+{{{ switch back to the terminal }}}
+
+As usual, we start IPython, using 
+::
+
+  ipython -pylab 
+
+Let us first open the file, ``pendulum.txt`` present in
+``/home/fossee/``. 
+::
+
+  f = open('/home/fossee/pendulum.txt')
+
+``f`` is called a file object. Let us type ``f`` on the terminal to
+see what it is. 
+::
+
+  f
+
+The file object shows, the file which is open and the mode (read
+or write) in which it is open. 
+
+We shall first learn to read the whole file into a single
+variable. Later, we shall look at reading it line-by-line. We use
+the ``read`` method of ``f`` to read, all the contents of the file
+into the variable ``pend``. 
+::
+
+  pend = f.read()
+
+Now, let us see what is in ``pend``, by typing 
+::
+
+  print pend
+
+We can see that ``pend`` has all the data of file. Type just ``pend``
+to see more explicitly, what it contains. 
+::
+
+  pend
+
+%%1%% Pause the video here and split the variable into a list,
+``pend_list``, of the lines in the file and then resume the
+video. Hint, use the tab command to see what methods the string
+variable has. 
+
+#[punch: should this even be put? add dependency to strings LO,
+where we mention that strings have methods for manipulation. hint:
+use splitlines()]
+::
+
+  pend_list = pend.splitlines()
+
+  pend_list
+
+Now, let us learn to read the file line-by-line. But, before that
+we will have to close the file, since the file has already been
+read till the end. 
+#[punch: should we mention file-pointer?]
+
+Let us close the file opened into f.
+::
+
+  f.close()
+
+Let us again type ``f`` on the prompt to see what it shows. 
+::
+
+  f
+
+Notice, that it now says the file has been closed. It is a good
+programming practice to close any file objects that we have
+opened, after their job is done.
+
+Let us, now move on to reading files line-by-line. 
+
+%%1%% Pause the video here and re-open the file ``pendulum.txt``
+with ``f`` as the file object, and then resume the video.
+
+We just use the up arrow until we reach the open command and issue
+it again. 
+::
+
+  f = open('/home/fossee/pendulum.txt')
+
+Now, to read the file line-by-line, we iterate over the file
+object line-by-line, using the ``for`` command. Let us iterate over
+the file line-wise and print each of the lines. 
+::
+
+  for line in f:
+      print line
+
+As we already know, ``line`` is just a dummy variable, and not a
+keyword. We could have used any other variable name, but ``line``
+seems meaningful enough.
+
+Instead of just printing the lines, let us append them to a list,
+``line_list``. We first initialize an empty list, ``line_list``. 
+::
+
+  line_list = [ ]
+
+Let us then read the file line-by-line and then append each of the
+lines, to the list. We could, as usual close the file using
+``f.close`` and re-open it. But, this time, let's leave alone the
+file object ``f`` and directly open the file within the for
+statement. This will save us the trouble of closing the file, each
+time we open it. 
+
+for line in open('/home/fossee/pendulum.txt'):
+line_list.append(line)
+
+Let us see what ``line_list`` contains. 
+::
+
+  line_list
+
+Notice that ``line_list`` is a list of the lines in the file, along
+with the newline characters. If you noticed, ``pend_list`` did not
+contain the newline characters, because the string ``pend`` was
+split on the newline characters. 
+
+{{{ show the summary slide }}}
+
+That brings us to the end of this tutorial. In this tutorial we
+have learnt to open and close files, read the data in the files as
+a whole, using the read command or reading it line by line by
+iterating over the file object. 
+
+Thank you!   
+
diff -r 60a4616dbf55 -r b9ae88095ade getting-started-ipython.rst
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/getting-started-ipython.rst	Thu Sep 16 19:40:33 2010 +0530
@@ -0,0 +1,174 @@
+========
+ Script
+========
+
+Welcome to so and so..
+
+
+This tutorial will cover the basic usage of the ``ipython``
+interpreter. The following topics would be covered.
+
+{{{ Show slide with outline of the session. }}}
+
+IPython is an enhanced Python interpreter that provides features like
+tabcompletion, easier access to help and many other functionalities
+which are not available in the vannila Python interpreter.
+
+First let us see how to invoke the ``ipython`` interpreter.
+
+We type
+::
+
+  ipython
+
+at the terminal prompt to invoke the ipython interpreter.
+
+We get a prompt with ``In [1]:`` after getting some information about
+the version of Python installed and some help commands.   
+
+If you get an error saying something like ``ipython is not
+installed``, refer to the tutorial on how to install the packages
+required for this course.
+
+Now, to quit the ipython interpreter, type Ctrl-D.  You are prompted
+asking if you really want to exit, type y to say yes and quit ipython.
+
+Start ipython again, as you did before.
+
+The prompt that you have says ``In [1]``. ``In`` stands for input and the
+ipython interpreter is ready to accept input from you.
+
+Now let us see, how we can type some commands into the interpreter.
+
+Start with the simplest thing, addition.
+
+Let's type 
+::
+  1+2 
+
+at the prompt. IPython promptly gives back the output as 3.  Notice
+that the output is displayed with an ``Out[1]`` indication.
+
+Let's try out few other mathematical operations.
+::
+
+  5 - 3
+  7 - 4
+  6 * 5
+
+Now let's ``print 1+2``. Instead of typing the whole thing, we make
+use of the fact that IPython remembers the history of the commands
+that you have already used. We use the up arrow key to go back the
+command ``1+2``. We then use the left-arrow key to navigate to the
+beginning of the line and add the word ``print`` and a space. Then hit
+enter and observe that the interpreter prints out the value as 3,
+without the Out[] indication.
+
+Now, let's change the previous command ``print 1+2`` to ``print
+10*2``.  We use the up arrow again to navigate to the previous command
+and use the left arrow key to move the cursor on to the + symbol and
+then use the delete key to remove it and type 0 and * to change the
+expression to the required one.  We hit enter to see the output of
+``print``. 
+
+Now, let's say we want to use the function ``round``. We type ``ro``
+at the prompt and hit the tab key. As you can see, the IPython
+completes the command. This feature is called the tab-completion.
+
+Now, we remove all the characters and just type ``r`` and then hit
+tab. IPython does not complete the command since there are many
+possibilities. It just lists out all the possible completions.
+
+%% %% Pause the video here and type ``ab`` and hit tab to see what
+happens. Next, jut type ``a`` and hit tab to see what happens. 
+
+``ab`` tab completes to ``abs`` and ``a<tab>`` gives us a list of all
+the commands starting with a. 
+
+Now, let's see what these functions are used for.  We will use the
+help features of ipython to find this out.
+
+To get the help of any function, we first type the function, ``abs``
+in our case and then add a ? at the end and hit enter.
+
+As the documentation says, ``abs`` accepts a number as an input and
+returns it's absolute value.
+
+We say, 
+::
+
+  abs(-19)
+
+  abs(19)
+
+We get 19, as expected, in both the cases.  
+
+Does it work for decimals (or floats)?  Let's try typing abs(-10.5)
+and we do get back 10.5.
+
+%% %% Pause the video here, and look-up the documentation of ``round``
+and see how to use it. 
+
+::
+
+ round?
+
+If you notice, there are extra square brackets around the ``ndigits``.
+This means that ``ndigits`` is optional and 0 is the default value.
+Optional parameters are shown in square brackets anywhere in Python
+documentation.
+
+The function ``round``, rounds a number to a given precision.
+
+%% %% Pause the video here and check the output of
+round(2.48)
+round(2.48, 1)
+round(2.48, 2)
+and then resume the video. 
+
+::
+  round(2.484)
+  round(2.484, 1)
+  round(2.484, 2)
+
+We get 2.0, 2.5 and 2.48, which are what we expect. 
+
+Let's now see how to correct typing errors that we make when typing at
+the terminal. As already shown, if we haven't hit the enter key
+already, we could navigate using the arrow keys and make deletions
+using delete or backspace key and correct the errors. 
+
+Let's now type round(2.484 and hit enter, without closing the
+parenthesis. We get a prompt with dots.  This prompt is the
+continuation prompt of ``ipython``.  It appears, the previous line is
+incomplete in some way.  We now complete the command by typing, the
+closing parenthesis and hitting enter.  We get the expected output of
+2.5. 
+
+In other instances, if we commit a typing error with a longer and more
+complex expression and end up with the continuation prompt, we can
+type Ctrl-C to interrupt the command and get back the ``ipython`` input
+prompt.
+
+%% %% Pause the video here. 
+Try typing round(2.484, and hit enter. and then cancel the command
+using Ctrl-C. Then, type the command, round(2.484, 2) and resume the
+video. 
+
+::
+  
+  round(2.484 
+  ^C
+
+  round(2.484, 2)
+  
+This brings us to the end of the tutorial on getting started with
+``ipython``.
+
+In this tutorial we have seen 
+{{{ show the outline/summary slide. }}}
+
+Thank you!
+
+
+
diff -r 60a4616dbf55 -r b9ae88095ade input_output.rst
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/input_output.rst	Thu Sep 16 19:40:33 2010 +0530
@@ -0,0 +1,182 @@
+Hello friends and welcome to the tutorial on Input/Output
+
+{{{ Show the slide containing title }}}
+
+{{{ Show the slide containing the outline slide }}}
+
+Input and Output are used in almost every program we use.
+In this tutorial, we shall learn
+
+ * Outputting data
+ * Taking input from the user
+
+type
+::
+ 
+    a = "This is a string"
+    a
+    print a
+     
+print a prints the value of a which is obvious.
+As you can see, even when you type just a, the value of a is shown.
+But there is a difference.
+
+Typing a shows the value of a while print a prints the string. This difference
+becomes more evident when we use strings with newlines in them.
+type
+::
+
+    b = "A line \n New line"
+    b
+    print b
+
+As you can see, just typing b shows that b contains a newline character.
+While typing print b prints the string and hence the newline.
+
+Moreover when we type just a, the value a is shown only in interactive mode and
+does not have any effect on the program while running it as a script.
+
+We shall look at different ways of outputting the data.
+
+print statement also accepts the syntax of C's printf statement.
+Various arguments can be passed to print using modifiers.
+type
+::
+
+    x = 1.5
+    y = 2
+    z = "zed"
+    print "x is %2.1f y is %d z is %s"%(x,y)
+
+As you can see, the values of x and y are substituted in place of %2.1f and %d
+
+{{{ Pause here and try out the following exercises }}}
+
+%% 1 %% What happens when you do print "x is %d y is %f"%(x)
+
+{{{ continue from paused state }}}
+
+We see that the int value of x and float value of y are printed corresponding
+to the modifiers used in the print statement.
+
+We can also see that print statement prints a new line character at the end of
+line, everytime it is called. This can be suppressed by using a "," at the end
+print statement.
+
+Let us see this by typing out following code on an editor as print_example.py
+
+{{{ open an editor }}}
+type
+::
+
+    print "Hello"
+    print "World"
+
+    print "Hello",
+    print "World"
+
+Now we run the script using %run /home/fossee/print_example.py
+
+As we can see, the print statement when used with comma in the end, prints a
+space instead of a new line.
+
+Now we shall look at taking input from the user.
+We will use the ~~raw_input~~ for this.
+type
+::
+
+    ip = raw_input()
+
+The cursor is blinking indicating that it is waiting for input    
+type
+::
+
+    an input
+
+and hit enter.
+Now let us see what is the value of ip by typing.
+::
+
+    ip
+
+We can see that it contains the string "an input"
+
+{{{ Pause here and try out the following exercises }}}
+
+%% 2 %% enter the number 5.6 as input and store it in a variable called c.
+
+{{{ continue from paused state }}}
+
+We have to use the raw_input command with variable c.
+type
+::
+
+    c = raw_input()
+    5.6
+    c
+
+Now let us see the type of c.
+
+::
+
+    type(c)
+
+We see that c is a string. This implies that anything you enter as input, will
+be taken as a string no matter what you enter.
+
+{{{ Pause here and try out the following exercises }}}
+
+%% 3 %% What happens when you do not enter anything and hit enter
+
+{{{ continue from paused state }}}
+
+::
+
+    d = raw_input()
+    <RET>
+    d
+
+We see that when nothing is entered, an empty string is considered as input.
+
+raw_input also can display a prompt to assist the user.
+::
+
+    name = raw_input("Please enter your name: ")
+
+prints the string given as argument and then waits for the user input.
+
+{{{ Pause here and try out the following exercises }}}
+
+%% 4 %% How do you display a prompt and let the user enter input in a new line
+
+{{{ continue from paused state }}}
+
+The trick is to include a newline character at the end of the prompt string.
+::
+
+    ip = raw_input("Please enter a number in the next line\n> ")
+
+prints the newline character and hence the user enters input in the new line
+
+{{{ Show summary slide }}}
+
+This brings us to the end of the tutorial.
+we have learnt
+
+ * How to print some value
+ * How to print using modifiers
+ * How to take input from user
+ * How to display a prompt to the user before taking the input
+
+{{{ Show the "sponsored by FOSSEE" slide }}}
+
+#[Nishanth]: Will add this line after all of us fix on one.
+This tutorial was created as a part of FOSSEE project, NME ICT, MHRD India
+
+Hope you have enjoyed and found it useful.
+Thankyou
+ 
+.. Author              : Nishanth
+   Internal Reviewer 1 : 
+   Internal Reviewer 2 : 
+   External Reviewer   :
diff -r 60a4616dbf55 -r b9ae88095ade loading-data-from-files.rst
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/loading-data-from-files.rst	Thu Sep 16 19:40:33 2010 +0530
@@ -0,0 +1,137 @@
+========
+ Script
+========
+
+Welcome to this tutorial on loading data from files. 
+
+{{{ Screen shows welcome slide }}}
+
+Until now, all the plots we have made use analytic functions. We have
+been using analytic functions to generate a sequence of points and
+plotting them, against another sequence of points. But, this is not
+what we do most often. We often require to plot points obtained from
+experimental observations.
+
+#[punch: the initial part of the paragraph may be removed, to make
+this a more generic LO?]
+
+In this tutorial we shall learn to read data from files and save it
+into sequences that can later be used to plot.
+
+{{{ Show the outline for this tutorial }}} 
+
+We shall use the ``loadtxt`` command to load data from files. We will
+be looking at how to get multiple columns of data into multiple
+sequences.
+
+{{{ switch back to the terminal }}}
+
+As usual, let us start IPython, using 
+::
+
+  ipython -pylab 
+
+Now, Let us begin with reading the file primes.txt, which contains
+just a list of primes listed in a column, using the loadtxt command.
+The file, in our case, is present in ``/home/fossee/primes.txt``.
+
+#[punch: do we need a slide for showing the path?]
+
+We use the ``cat`` command to see the contents of this file. 
+
+#[punch: should we show the cat command here? seems like a good place
+to do it] ::
+
+  cat /home/fossee/primes.txt
+
+Now let us read this list into the variable ``primes``.
+::
+
+  primes = loadtxt('/home/fossee/primes.txt')
+
+``primes`` is now a sequence of primes, that was listed in the file,
+``primes.txt``.
+
+We now type, ``print primes`` to see the sequence printed.
+
+We observe that all of the numbers end with a period. This is so,
+because these numbers are actually read as ``floats``. We shall learn
+about them, later.
+
+Now, let us use the ``loadtxt`` command to read a file that contains
+two columns of data, ``pendulum.txt``. This file contains the length
+of the pendulum in the first column and the corresponding time period
+in the second.
+
+%%1%% Pause the video here, and use the ``cat`` command to view the
+contents of this file and then resume the video.
+
+This is how we look at the contents of the file, ``pendulum.txt``
+::
+
+  cat /home/fossee/pendulum.txt
+
+Let us, now, read the data into the variable ``pend``. Again, it is
+assumed that the file is in ``/home/fossee/``
+::
+
+  pend = loadtxt('/home/fossee/pendulum.txt')
+
+Let us now print the variable ``pend`` and see what's in it. 
+::
+
+  print pend
+
+Notice that ``pend`` is not a simple sequence like ``primes``. It has
+two sequences, containing both the columns of the data file. Let us
+use an additional argument of the ``loadtxt`` command, to read it into
+two separate, simple sequences.
+::
+
+  L, T = loadtxt('/home/fossee/pendulum.txt', unpack=True)
+
+Let us now, print the variables L and T, to see what they contain.
+::
+
+  print L
+  print T
+
+Notice, that L and T now contain the first and second columns of data
+from the data file, ``pendulum.txt``, and they are both simple
+sequences.
+
+{{{ show the slide with loadtxt --- other features }}}
+
+In this tutorial, we have learnt the basic use of the ``loadtxt``
+command, which is capable of doing a lot more than we have used it for
+until now, for example
+
+%%2%% Pause the video here, and read the file
+``pendulum_semicolon.txt`` which contains the same data as
+``pendulum.txt``, but the columns are separated by semi-colons instead
+of spaces. Use the IPython help to see how to do this. Once you have
+finished, resume the video to look at the solution.
+
+{{{ switch back to the terminal }}}
+::
+
+  L, T = loadtxt('/home/fossee/pendulum.txt', unpack``True, delimiter``';')
+
+  print L
+
+  print T
+
+This brings us to the end of this tutorial. 
+
+{{{ show the summary slide }}}
+
+You should now be able to do the following, comfortably. 
+
+  + Read data from files, containing a single column of data using the
+    ``loadtxt`` command.
+  + Read multiple columns of data, separated by spaces or other
+    delimiters.
+
+Thank you!   
+
+
diff -r 60a4616dbf55 -r b9ae88095ade loops.rst
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/loops.rst	Thu Sep 16 19:40:33 2010 +0530
@@ -0,0 +1,4 @@
+========
+ Script
+========
+
diff -r 60a4616dbf55 -r b9ae88095ade lstsq.rst
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/lstsq.rst	Thu Sep 16 19:40:33 2010 +0530
@@ -0,0 +1,128 @@
+Hello friends and welcome to the tutorial on Least Square Fit
+
+{{{ Show the slide containing title }}}
+
+{{{ Show the slide containing the outline slide }}}
+
+In this tutorial, we shall look at generating the least square fit line for a
+given set of points.
+
+First let us have a look at the problem.
+
+{{{ Show the slide containing problem statement. }}}
+
+We have an input file generated from a simple pendulum experiment.
+
+It contains two columns of data. The first column is the length of the
+pendulum and the second is the corresponding time period of the pendulum.
+
+As we know, the square of time period of a pendulum is directly proportional to
+its length, we shall plot l vs t^2 and verify if the proportionality is linear.
+
+If it is not linear, we shall generate a least square fit line.
+
+{{{ show the slide containing explanation on least square fit }}}
+
+As shown in the slide, we are first going to generate the two matrices tsq and
+A. Then we are going to use the =lstsq= function to find the values of m and c.
+
+To read the input file and parse the data, we are going to loadtxt function.
+Type
+::
+
+    data = loadtxt("/home/fossee/pendulum.txt")
+    data
+
+As you can see, data is a sequence containing 90 records. Each record contains
+two values. The first is length and second is time period. But what we need is 
+two sequences. One sequence containing all the length values and one containing
+all the time values.
+
+Hence we have to use the unpack option with loadtxt. It unpacks the data into
+ sequences depending on the structure of data.
+
+Type
+::
+
+    l, t = loadtxt("/home/fossee/pendulum.txt", unpack=True)
+    l
+    t
+
+We can see that l and t are two sequences containing length and time values
+correspondingly.
+
+Let us first plot l vs t^2. Type
+::
+
+    tsq = t * t
+    plot(l, tsq, 'bo')
+
+
+{{{ switch to the plot window }}}
+
+We can see that there is a visible linear trend.
+
+let us now generate the A matrix with l values.
+We shall first generate a 2 x 90 matrix with the first row as l values and the
+second row as ones. Then take the transpose of it. Type
+::
+
+    inter_mat = array((l, ones_like(l)))
+    inter_mat
+
+We see that we have intermediate matrix. Now we need the transpose.Type
+::
+
+    A = inter_mat.T
+    A
+
+Now we have both the matrices A and tsq. We only need to use the =lstsq=
+Type
+::
+
+    result = lstsq(A, tsq)
+
+The result is a sequence of values. The first item is the matrix p or in simple
+words, the values of m and c. Hence, 
+::
+
+    m, c = result[0]
+    m
+    c
+
+Now that we have m and c, we need to generate the fitted values of t^2. Type
+::
+
+    tsq_fit = m * l + c
+    plot(l, tsq, 'bo')
+    plot(l, tsq_fit, 'r')
+
+We get the least square fit of l vs t^2
+
+{{{ Pause here and try out the following exercises }}}
+
+%% 2 %% change the label on y-axis to "y" and save the lines of code
+        accordingly
+
+{{{ continue from paused state }}}
+
+{{{ Show summary slide }}}
+
+This brings us to the end of the tutorial.
+we have learnt
+
+ * how to use loadtxt to read files
+ * how to generate a least square fit
+
+{{{ Show the "sponsored by FOSSEE" slide }}}
+
+#[Nishanth]: Will add this line after all of us fix on one.
+This tutorial was created as a part of FOSSEE project, NME ICT, MHRD India
+
+Hope you have enjoyed and found it useful.
+Thankyou
+ 
+.. Author              : Nishanth
+   Internal Reviewer 1 : 
+   Internal Reviewer 2 : 
+   External Reviewer   :
diff -r 60a4616dbf55 -r b9ae88095ade manipulating-strings.rst
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/manipulating-strings.rst	Thu Sep 16 19:40:33 2010 +0530
@@ -0,0 +1,179 @@
+========
+ Script
+========
+
+{{{ show the welcome slide }}}
+
+Welcome to this tutorial on manipulating strings. 
+
+{{{ show the slide with outline }}} 
+
+In this tutorial we shall learn to manipulate strings, specifically
+slicing and reversing them, or replacing characters, converting from
+upper to lower case and vice-versa 
+
+#[punch: reversed returns an iterator. should we still teach it?]
+
+We have an ``ipython`` shell open, in which we are going to work,
+through out this session. 
+
+Let us consider a simple problem, and learn how to slice strings and
+get sub-strings. 
+
+Let's say the variable ``week`` has the list of the names of the days
+of the week. 
+
+::
+
+    week = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"]
+
+
+Now given a string ``s``, we should be able to check if the string is a
+valid name of a day of the week or not. 
+
+::
+
+    s = saturday
+
+
+``s`` could be in any of the forms --- sat, saturday, Sat, Saturday,
+SAT, SATURDAY. We shall now be solving the problem only for the forms,
+sat and saturday. We shall solve it for the other forms, at the end of
+the tutorial. 
+
+{{{ show these forms in a slide }}}
+
+So, we need to check if the first three characters of the given string
+exists in the variable ``week``. 
+
+As, with any of the string data-types, strings can be sliced into
+sub-strings. To get the first three characters of s, we say, 
+
+::
+
+    s[0:3]
+
+Note that, we are slicing the string from the index 0 to index 3, 3
+not included. 
+
+As we already know, the last element of the string can be accessed
+using ``s[-1]``.  
+
+%%1%% Pause the video here and obtain the sub-string excluding the
+first and last characters from the string. 
+
+::
+
+    s[1:-1]
+
+gives the a substring of s, without the first and the last
+characters. 
+
+::
+
+    s = saturday
+    s[:3]
+
+Now, we just check if that substring is present in the variable
+``week``. 
+
+::
+
+    s[:3] in week          
+
+Let us now consider the problem of finding out if a given string is
+palindromic or not. First of all, a palindromic string is a string
+that remains same even when it has been reversed.
+
+Let the string given be ``malayalam``.
+
+::
+
+    s = "malayalam"
+
+Now, we need to compare this string with it's reverse. 
+
+Again, we will use a technique common to all sequence data-types,
+[::-1]
+
+So, we obtain the reverse of s, by simply saying, 
+
+::
+
+    s[::-1]
+
+Now, to check if the string is ``s`` is palindromic, we say
+::
+
+    s == s[::-1]
+
+As, expected, we get ``True``. 
+
+Now, if the string we are given is ``Malayalam`` instead of
+``malayalam``, the above comparison would return a False. So, we will
+have to convert the string to all lower case or all upper case, before
+comparing. Python provides methods, ``s.lower`` and ``s.upper`` to
+achieve this. 
+
+Let's try it out. 
+::
+
+   s = "Malayalam"
+
+   s.upper()
+
+   s
+
+   s.lower()
+
+   s.lower() == s.lower()[::-1]
+   
+Note that these methods, do not change the original string, but return
+a new string.
+
+a%% %% Pause the video here, and finish the problem of checking if
+``s`` is a valid name of a day of the week and then resume the
+video. Change the solution to this problem, to include forms like,
+SAT, SATURDAY, Saturday and Sat. 
+
+::
+
+    s.lower()[:3] in week
+
+We just convert any input string to lower case and then check if it is
+present in the list ``week``. 
+
+Now, let us consider another problem. We often encounter e-mail id's
+which have @ and periods replaced with text, something like
+info[at]fossee[dot]in. We now wish to get back proper e-mail
+addresses.  
+
+Let's say the variable email has the email address. 
+::
+
+   email = "info[at]fossee[dot]in"
+
+Now, we first replace the ``[at]`` with the ``@``, using the replace
+method of strings. 
+::
+
+   email = email.replace("[at]", "@")
+   print email
+
+%%1%% Pause the video here and replace the ``[dot]`` with ``.`` and then
+resume the video. 
+
+::
+
+   email = email.replace("[dot]", ".")        
+   print email
+
+
+That brings us to the end of the tutorial. 
+
+{{{ show summary slide }}}
+
+In this tutorial, we have learnt how to get substrings, reverse
+strings and a few useful methods, namely upper, lower and replace. 
+
+Thank You!
diff -r 60a4616dbf55 -r b9ae88095ade module-assessment-arrays-matrices.rst
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/module-assessment-arrays-matrices.rst	Thu Sep 16 19:40:33 2010 +0530
@@ -0,0 +1,88 @@
+========
+ Script
+========
+
+Welcome. 
+
+This spoken tutorial is a self-assessment tutorial and you will be
+able to assess yourself on the concepts learnt in the Module on Arrays
+and Matrices. 
+
+
+As with all other assessments we will first start with a few short
+questions that will not take you more that 15 to 20 seconds to
+answer. Then we shall move on to a bigger problem, that you are
+expected to solve in less than 10 mins. 
+
+
+  * Given a list of marks::
+   
+      marks = [10, 20, 30, 50, 55, 75, 83]
+
+    How will you convert it to an array?
+
+  * What is the shape of the following array?::
+
+      x = array([[1,2,3,4],
+                 [3,4,2,5]])
+
+  * What is the resulting array::
+
+      a = array([[1, 2],
+                 [3, 4]])
+      
+      a[1,0] = 0
+ 
+  * What is the resulting array?::
+
+      x = array(([1,2,3,4],
+                 [2,3,4,5]))
+
+      x[-2][-3] = 4
+
+
+  * How do we change the array ``x = array([[1,2,3,4]])`` to
+    ``array([[1,2,0,4]])``?
+
+  * How do we get the slice::
+
+      array([[2,3],
+             [4,2]])
+
+    out of the array::
+
+      x = array([[1,2,3,4],
+                 [3,4,2,5]])
+
+
+  * What is the output of x[::3,::3], when x is::
+
+      x = array([[9,18,27],
+                 [30,60,90],
+                 [14,7,1]])
+
+  * How do you get the transpose of this array?::
+
+      a = array([[1, 2],
+                 [3, 4]])
+
+  * What is the output of the following?::
+
+      a = array([[1, 2],
+                 [3, 4]])
+
+      b = array([[1, 1],
+                 [2, 2]])
+
+      a*b
+
+
+{{{ show slides with solutions to these problems }}}
+
+Now, let us move on to a larger problem. From the image
+`tagore-einstein.png``
+
+  + extract the face of Einstein alone.
+  + extract the face of Tagore alone.
+  + get a smaller copy of the image, that is a fourth it's size. 
+                 
diff -r 60a4616dbf55 -r b9ae88095ade parsing_data.rst
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/parsing_data.rst	Thu Sep 16 19:40:33 2010 +0530
@@ -0,0 +1,192 @@
+Hello friends and welcome to the tutorial on Parsing Data
+
+{{{ Show the slide containing title }}}
+
+{{{ Show the slide containing the outline slide }}}
+
+In this tutorial, we shall learn
+
+ * What is parsing data
+ * the string operations required for parsing data
+ * datatype conversion
+
+ Lets us have a look at the problem
+
+{{{ Show the slide containing problem statement. }}}
+
+There is an input file containing huge no.of records. Each record corresponds
+to a student.
+
+{{{ show the slide explaining record structure }}}
+As you can see, each record consists of fields seperated by a ";". The first
+record is region code, then roll number, then name, marks of second language,
+first language, maths, science and social, total marks, pass/fail indicatd by P
+or F and finally W if with held and empty otherwise.
+
+Our job is to calculate the mean of all the maths marks in the region "B".
+
+#[Nishanth]: Please note that I am not telling anything about AA since they do
+             not know about any if/else yet.
+
+
+Now what is parsing data.
+
+From the input file, we can see that there is data in the form of text. Hence
+parsing data is all about reading the data and converting it into a form which
+can be used for computations. In our case, that is numbers.
+
+We can clearly see that the problem involves reading files and tokenizing.
+
+Let us learn about tokenizing strings. Let us define a string first. Type
+::
+
+    line = "parse this           string"
+
+We are now going to split this string on whitespace.
+::
+
+    line.split()
+
+As you can see, we get a list of strings. Which means, when split is called
+without any arguments, it splits on whitespace. In simple words, all the spaces
+are treated as one big space.
+
+split also can split on a string of our choice. This is acheived by passing
+that as an argument. But first lets define a sample record from the file.
+::
+
+    record = "A;015163;JOSEPH RAJ S;083;042;47;AA;72;244;;;"
+    record.split(';')
+
+We can see that the string is split on ';' and we get each field seperately.
+We can also observe that an empty string appears in the list since there are
+two semi colons without anything in between.
+
+Hence split splits on whitespace if called without an argument and splits on
+the given argument if it is called with an argument.
+
+{{{ Pause here and try out the following exercises }}}
+
+%% 1 %% split the variable line using a space as argument. Is it same as
+        splitting without an argument ?
+
+{{{ continue from paused state }}}
+
+We see that when we split on space, multiple whitespaces are not clubbed as one
+and there is an empty string everytime there are two consecutive spaces.
+
+Now that we know splitting a string, we can split the record and retreive each
+field seperately. But there is one problem. The region code "B" and a "B"
+surrounded by whitespace are treated as two different regions. We must find a
+way to remove all the whitespace around a string so that "B" and a "B" with
+white spaces are dealt as same.
+
+This is possible by using the =strip= method of strings. Let us define a
+string by typing
+::
+
+    unstripped = "     B    "
+    unstripped.strip()
+
+We can see that strip removes all the whitespace around the sentence
+
+{{{ Pause here and try out the following exercises }}}
+
+%% 2 %% What happens to the white space inside the sentence when it is stripped
+
+{{{ continue from paused state }}}
+
+Type
+::
+
+    a_str = "         white      space            "
+    a_str.strip()
+
+We see that the whitespace inside the sentence is only removed and anything
+inside remains unaffected.
+
+By now we know enough to seperate fields from the record and to strip out any
+white space. The only road block we now have is conversion of string to float.
+
+The splitting and stripping operations are done on a string and their result is
+also a string. hence the marks that we have are still strings and mathematical
+operations are not possible. We must convert them into integers or floats
+
+We shall look at converting strings into floats. We define an float string
+first. Type
+::
+
+    mark_str = "1.25"
+    mark = int(mark_str)
+    type(mark_str)
+    type(mark)
+
+We can see that string is converted to float. We can perform mathematical
+operations on them now.
+
+{{{ Pause here and try out the following exercises }}}
+
+%% 3 %% What happens if you do int("1.25")
+
+{{{ continue from paused state }}}
+
+It raises an error since converting a float string into integer directly is
+not possible. It involves an intermediate step of converting to float.
+::
+
+    dcml_str = "1.25"
+    flt = float(dcml_str)
+    flt
+    number = int(flt)
+    number
+
+Using =int= it is also possible to convert float into integers.
+
+Now that we have all the machinery required to parse the file, let us solve the
+problem. We first read the file line by line and parse each record. We see if
+the region code is B and store the marks accordingly.
+::
+
+    math_marks_B = [] # an empty list to store the marks
+    for line in open("/home/fossee/sslc1.txt"):
+        fields = line.split(";")
+
+        region_code = fields[0]
+        region_code_stripped = region_code.strip()
+
+        math_mark_str = fields[5]
+        math_mark = float(math_mark_str)
+
+        if region_code == "AA":
+            math_marks_B.append(math_mark)
+
+
+Now we have all the maths marks of region "B" in the list math_marks_B.
+To get the mean, we just have to sum the marks and divide by the length.
+::
+
+        math_marks_mean = sum(math_marks_B) / len(math_marks_B)
+        math_marks_mean
+
+{{{ Show summary slide }}}
+
+This brings us to the end of the tutorial.
+we have learnt
+
+ * how to tokenize a string using various delimiters
+ * how to get rid of extra white space around
+ * how to convert from one type to another
+ * how to parse input data and perform computations on it
+
+{{{ Show the "sponsored by FOSSEE" slide }}}
+
+#[Nishanth]: Will add this line after all of us fix on one.
+This tutorial was created as a part of FOSSEE project, NME ICT, MHRD India
+
+Hope you have enjoyed and found it useful.
+Thankyou
+ 
+.. Author              : Nishanth
+   Internal Reviewer 1 : 
+   Internal Reviewer 2 : 
+   External Reviewer   :
diff -r 60a4616dbf55 -r b9ae88095ade sets.rst
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/sets.rst	Thu Sep 16 19:40:33 2010 +0530
@@ -0,0 +1,149 @@
+Hello friends and welcome to the tutorial on Sets
+
+{{{ Show the slide containing title }}}
+
+{{{ Show the slide containing the outline slide }}}
+
+In this tutorial, we shall learn
+
+ * sets
+ * operations on sets
+
+Sets are data structures which contain unique elements. In other words,
+duplicates are not allowed in sets.
+
+Lets look at how to input sets.
+type
+::
+ 
+    a_list = [1, 2, 1, 4, 5, 6, 7]
+    a = set(a_list)
+    a
+     
+We can see that duplicates are removed and the set contains only unique
+elements. 
+::
+
+    f10 = set([1, 2, 3, 5, 8])
+    p10 = set([2, 3, 5, 7])
+
+f10 is the set of fibonacci numbers from 1 to 10.
+p10 is the set of prime numbers from 1 to 10.
+
+Various operations that we do on sets are possible here also.
+The | character stands for union
+::
+
+    f10 | p10
+
+gives us the union of f10 and p10
+
+The & character stands for intersection.
+::
+
+    f10 & p10
+
+gives the intersection
+
+similarly,
+::
+
+    f10 - p10
+
+gives all the elements that are in f10 but not in p10
+
+::
+
+    f10 ^ p10
+
+is all the elements in f10 union p10 but not in f10 intersection p10. In
+mathematical terms, it gives the symmectric difference.
+
+Sets also support checking of subsets.
+::
+
+    b = set([1, 2])
+    b < f10
+
+gives a True since b is a proper subset of f10.
+Similarly,
+::
+
+    f10 < f10
+
+gives a False since f10 is not a proper subset.
+hence the right way to do would be
+::
+
+    f10 <= f10
+
+and we get a True since every set is a subset of itself.
+
+Sets can be iterated upon just like lists and tuples. 
+::
+
+    for i in f10:
+        print i,
+
+prints the elements of f10.
+
+The length and containership check on sets is similar as in lists and tuples.
+::
+
+    len(f10)
+
+shows 5. And
+::
+    
+    1 in f10
+    2 in f10
+
+prints True and False respectively
+
+The order in which elements are organised in a set is not to be relied upon 
+since sets do not support indexing. Hence, slicing and striding are not valid
+on sets.
+
+{{{ Pause here and try out the following exercises }}}
+
+%% 1 %% Given a list of marks, marks = [20, 23, 22, 23, 20, 21, 23] 
+        list all the duplicates
+
+{{{ continue from paused state }}}
+
+Duplicates marks are the marks left out when we remove each element of the 
+list exactly one time.
+
+::
+
+    marks = [20, 23, 22, 23, 20, 21, 23] 
+    marks_set = set(marks)
+    for mark in marks_set:
+        marks.remove(mark)
+
+    # we are now left with only duplicates in the list marks
+    duplicates = set(marks)
+
+{{{ Show summary slide }}}
+
+This brings us to the end of the tutorial.
+we have learnt
+
+ * How to make sets from lists
+ * How to input sets
+ * How to perform union, intersection and symmectric difference operations
+ * How to check if a set is a subset of other
+ * The various similarities with lists like length and containership
+
+{{{ Show the "sponsored by FOSSEE" slide }}}
+
+#[Nishanth]: Will add this line after all of us fix on one.
+This tutorial was created as a part of FOSSEE project, NME ICT, MHRD India
+
+Hope you have enjoyed and found it useful.
+Thankyou
+ 
+.. Author              : Nishanth
+   Internal Reviewer 1 : 
+   Internal Reviewer 2 : 
+   External Reviewer   :
diff -r 60a4616dbf55 -r b9ae88095ade using-sage.rst
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/using-sage.rst	Thu Sep 16 19:40:33 2010 +0530
@@ -0,0 +1,119 @@
+========
+ Script
+========
+
+{{{ show the welcome slide }}}
+
+Welcome to this tutorial on using Sage.
+
+{{{ show the slide with outline }}} 
+
+In this tutorial we shall quickly look at a few examples of the areas
+(name the areas, here) in which Sage can be used and how it can be
+used.
+
+{{{ show the slide with Calculus outline }}} 
+
+Let us begin with Calculus. We shall be looking at limits,
+differentiation, integration, and Taylor polynomial.
+
+{{{ show sage notebook }}}
+
+We have our Sage notebook running. In case, you don't have it running,
+start is using the command, ``sage --notebook``.
+
+To find the limit of the function x*sin(1/x), at x=0, we say::
+
+   lim(x*sin(1/x), x=0)
+
+We get the limit to be 0, as expected. 
+
+It is also possible to the limit at a point from one direction. For
+example, let us find the limit of 1/x at x=0, when approaching from
+the positive side.::
+
+    lim(1/x, x=0, dir='above')
+
+To find the limit from the negative side, we say,::
+
+    lim(1/x, x=0, dir='above')   
+
+Let us now see how to differentiate, using Sage. We shall find the
+differential of the expression ``exp(sin(x^2))/x`` w.r.t ``x``. We
+shall first define the expression, and then use the ``diff`` function
+to obtain the differential of the expression.::
+
+    var('x')
+    f = exp(sin(x^2))/x
+
+    diff(f, x)
+
+We can also obtain the partial differentiation of an expression w.r.t
+one of the variables. Let us differentiate the expression
+``exp(sin(y - x^2))/x`` w.r.t x and y.::
+
+    var('x y')
+    f = exp(sin(y - x^2))/x
+
+    diff(f, x)
+
+    diff(f, y)
+
+Now, let us look at integration. We shall use the expression obtained
+from the differentiation that we did before, ``diff(f, y)`` ---
+``e^(sin(-x^2 + y))*cos(-x^2 + y)/x``. The ``integrate`` command is
+used to obtain the integral of an expression or function.::
+
+    integrate(e^(sin(-x^2 + y))*cos(-x^2 + y)/x, y)
+
+We get back the correct expression. The minus sign being inside or
+outside the ``sin`` function doesn't change much. 
+
+Now, let us find the value of the integral between the limits 0 and
+pi/2. ::
+
+    integral(e^(sin(-x^2 + y))*cos(-x^2 + y)/x, y, 0, pi/2)
+
+Let us now see how to obtain the Taylor expansion of an expression
+using sage. Let us obtain the Taylor expansion of ``(x + 1)^n`` up to
+degree 4 about 0.::
+
+    var('x n')
+    taylor((x+1)^n, x, 0, 4)
+
+This brings us to the end of the features of Sage for Calculus, that
+we will be looking at. For more, look at the Calculus quick-ref from
+the Sage Wiki. 
+
+Next let us move on to Matrix Algebra. 
+
+{{{ show the equation on the slides }}}
+
+Let us begin with solving the equation ``Ax = v``, where A is the
+matrix ``matrix([[1,2],[3,4]])`` and v is the vector
+``vector([1,2])``. 
+
+To solve the equation, ``Ax = v`` we simply say::
+
+    x = solve_right(A, v)
+
+To solve the equation, ``xA = v`` we simply say::
+
+    x = solve_left(A, v)
+
+The left and right here, denote the position of ``A``, relative to x. 
+
+
+
+Now, let us look at Graph Theory in Sage. 
+
+Graph: G = Graph({0:[1,2,3], 2:[4]})
+Directed Graph: DiGraph(dictionary)
+Graph families: graphs. tab
+Invariants: G.chromatic polynomial(), G.is planar()
+Paths: G.shortest path()
+Visualize: G.plot(), G.plot3d()
+Automorphisms: G.automorphism group(), G1.is isomorphic(G2), G1.is subgraph(G2)
+
+Now let us look at bits and pieces of Number theory, combinatorics, 
+