merged.
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/accessing-pieces-arrays.rst Fri Sep 17 18:39:24 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!
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/advanced-features-functions.rst Fri Sep 17 18:39:24 2010 +0530
@@ -0,0 +1,203 @@
+========
+ Script
+========
+
+{{{ show the welcome slide }}}
+
+Welcome to the tutorial on advanced feature of functions.
+
+{{{ show the outline slide }}}
+
+In this tutorial we shall be looking at specifying default arguments
+to functions when defining them and calling functions using keyword
+arguments. We shall also, look at some of the built-in functions
+available in the standard library of Python.
+
+{{{ switch to terminal }}}
+
+We have an ``ipython`` terminal open, which we shall be using through
+out this session.
+
+Let's use the ``round`` function as an example to understand what a
+default value of an argument means. Let's type the following
+expressions in the terminal.
+
+::
+
+ round(2.484)
+
+ round(2.484, 2)
+
+Both the first expression and the second are calls to the ``round``
+function, but the first calls it with only one argument and the second
+calls it with two arguments. By observing the output, we can guess
+that the first one is equivalent to call with the second argument
+being 0. 0 is the default value of the argument.
+
+{{{ show a slide with examples of functions showing default values }}}
+::
+
+ s.strip() # strips on spaces.
+ s.strip('@') # strips the string of '@' symbols.
+
+ plot(x, y) # plots with x vs. y using default line style.
+ plot(x, y, 'o') # plots x vs. y with circle markers.
+
+ linspace(0, 2*pi, 100) # returns 100 points between 0 and 2pi
+ linspace(0, 2*pi) # returns 50 points between 0 and 2pi
+
+#[punch: all above content goes on to a slide]
+
+{{{ switch back to ipython }}}
+
+Let's now define a simple function that uses default arguments. We
+define a simple function that prints a welcome message to a person,
+given a greeting and his/her name.
+
+::
+
+ def welcome(greet, name="World"):
+ print greet, name
+
+Let us first call the function with two arguments, one for ``greet``
+and other for ``name``.
+
+::
+
+ welcome("Hi", "Guido")
+
+We get the expected welcome message, "Hi Guido".
+
+Now let us call the function with just one argument "Hello".
+::
+
+ welcome("Hello")
+
+"Hello" is treated as the ``greet`` and we get "Hello World" as
+the output. "World" is the default value for the argument ``name``.
+
+E%% %% Pause the video here and redefine the function ``welcome``, by
+interchanging it's arguments. Place the ``name`` argument with it's
+default value of "Hello" before the ``greet`` argument. Then, resume
+the video.
+
+::
+
+ def welcome(name="World", greet):
+ print greet, name
+
+We get an error that reads ``SyntaxError: non-default argument follows
+default argument``. When defining a function all the argument with
+default values should come at the end.
+
+E%% %% Pause the video here and type ``linspace?`` to see the
+definition of the command and notice how all the arguments with
+default values are towards the end.
+
+::
+
+ linspace?
+
+E%% %% Pause the video here and redefine the function ``welcome`` with
+a default value of "Hello" to the ``greet`` argument. Then, call the
+function without any arguments. Then, resume the video.
+
+::
+
+ def welcome(greet="Hello", name="World"):
+ print greet, name
+
+
+ welcome()
+
+
+Let us now learn what keyword arguments are.
+
+{{{ show a slide with examples using keyword arguments. }}}
+::
+
+ legend(['sin(2y)'], loc = 'center')
+
+ plot(y, sin(y), 'g', linewidth = 2)
+
+ annotate('local max', xy = (1.5, 1))
+
+ pie(science.values(), labels = science.keys())
+
+When you are calling functions in Python, you don't need to remember
+the order in which to pass the arguments. Instead, you can use the
+name of the argument to pass it a value. This slide shows a few
+function calls that use keyword arguments. ``loc``, ``linewidth``,
+``xy`` and ``labels`` are being called with keyword arguments.
+
+{{{ switch to ipython terminal }}}
+
+Let us try and understand this better using the ``welcome`` function
+that we have been using all along. Let us call it in different ways
+and observe the output to see how keyword arguments work.
+
+::
+
+ welcome()
+
+ welcome("Hello", "James")
+
+ welcome("Hi", name="Guido")
+
+When no keyword is specified, the arguments are allotted based on
+their position. So, "Hi" is the value of the argument ``greet`` and
+name is passed the value "Guido".
+::
+
+ welcome(name="Guido", greet="Hey! ")
+
+When keyword arguments are used, the arguments can be called in any
+order.
+
+::
+
+ welcome(name="Guido", "Hey")
+
+This call returns an error that reads, ``non keyword arg after keyword
+arg``. Python expects all the keyword to be present towards the end.
+
+That brings us to the end of what we wanted to learn about ``keyword``
+arguments.
+
+{{{ switch to a slide showing variety of functions with uses }}}
+
+Before defining a function of your own, make sure that you check the
+standard library, for a similar function. Python is popularly called a
+"Batteries included" language, for the huge library that comes along
+with it.
+
+::
+
+ Math functions - abs, sin, ....
+
+#[punch: Need to decide, exactly what to put here. Reviewer comments
+ welcome.]
+
+
+{{{ switch to slide showing classes of functions in pylab, scipy }}}
+
+Apart from the standard library there are other libraries like ``pylab``,
+``scipy``, etc which have a huge collection of functions for scientific
+purposes.
+::
+
+ pylab
+ plot, bar, contour, boxplot, errorbar, log, polar, quiver, semilog
+
+ scipy (modules)
+ fftpack, stats, linalg, ndimage, signal, optimize, integrate
+
+{{{ switch slide to summary slide }}}
+
+That brings us to the end of this tutorial. In this tutorial we have
+learnt how to use functions with default values and keyword
+arguments. We also looked at the range of functions available in the
+Python standard library and the Scientific Computing related
+packages.
+
+Thank You!
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/arrays.txt Fri Sep 17 18:39:24 2010 +0530
@@ -0,0 +1,27 @@
+Hello friends and welcome to the second tutorial in the series of spoken tutorials on Python for Scientific computing.
+
+In the previous tutorial we learnt about arrays and we told you that numpy arrays are faster and more efficient . In this tutorial we shall look at creating arrays, accessing elements and changing them.
+
+
+Let's start with creating simple arrays. We've already seen how to convert lists to arrays. Inputting a new array is similarto that.
+
+On your Ipython terminal type a = array open parenthesis and then open square brackets 5,8,10,13 ,close square brackets and close parenthesis . This create an array a . You can see what a is by typing a on the terminal .
+Now we will try to create a multi-dimensional array type in your ipython terminal
+c= array open parenthesis , then open square brackets 11,12,13 close square bracket 'comma' start square bracket 21 , 22 ,23close square bracket 'comma' open 31,32,33 close square bracket another close square bracket which closes the first sqaure bracket and parenthesis which closes the first parenthesis . Now to see the dimensions of the array c we will do c.shape . We can see that c is a 3 by 3 matrix .
+
+There are other special methods of creating arrays as well we will now look at them .
+The first one is the command arange which is similar to range except that it returns an array.
+We will type on our Ipython interpreter a = arange(10). We will see what a is now . Type a . As we can see This returns us an array of one dimension and has 10 elements .
+Ones can be use to get all entries as ones . We can pass it the shape of the array as required .
+type b=ones open parenthesis , another open parenthesis , 3,4 , close second parenthesis and close first parenthesis . Look at b , by printing it out .
+To create an array with all entries as ones, with it's shape similar to an already existing array, we use the ones_like
+command. type b= ones_like in parenthesis a .
+
+
+
+
+
+
+
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/getting-started-files.rst Fri Sep 17 18:39:24 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!
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/getting-started-ipython.rst Fri Sep 17 18:39:24 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!
+
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/getting_started_with_for.rst Fri Sep 17 18:39:24 2010 +0530
@@ -0,0 +1,217 @@
+.. 3.2 LO: getting started with =for= (2) [anoop]
+.. -----------------------------------------------
+.. * blocks in python
+.. + (indentation)
+.. * blocks in ipython
+.. + ... prompt
+.. + hitting enter
+.. * =for= with a list
+.. * =range= function
+
+=============================
+Getting started with for loop
+=============================
+
+{{{ show welcome slide }}}
+
+Hello and welcome to the tutorial getting started with ``for`` loop.
+
+{{{ switch to next slide, outline slide }}}
+
+In this tutorial we will see ``for`` loops in python, and also cover
+the basics of indenting code in python.
+
+{{{ switch to next slide, about whitespaces }}}
+
+In Python whitespace is significant, and the blocks are visually
+separated rather than using braces or any other mechanisms for
+defining blocks. And by this method Python forces the programmers to
+stick on to one way of writing or beautifying the code rather than
+debating over where to place the braces. This way it produces uniform
+code than obscure or unreadable code.
+
+A block may be defined by a suitable indentation level which can be
+either be a tab or few spaces. And the best practice is to indent the
+code using four spaces.
+
+Now let us move straight into ``for`` loop.
+
+{{{ switch to next slide, problem statement of exercise 1 }}}
+
+Write a for loop which iterates through a list of numbers and find the
+square root of each number. Also make a new list with the square roots
+and print it at the end.
+::
+
+ numbers are 1369, 7225, 3364, 7056, 5625, 729, 7056, 576, 2916
+
+For the problem, first we need to create a ``list`` of numbers and
+then iterate over the list and find the square root of each element in
+it. And let us create a script, rather than typing it out in the
+interpreter itself. Create a script called list_roots.py and type the
+following.
+
+{{{ open the text editor and paste the following code there }}}
+::
+
+ numbers = [1369, 7225, 3364, 7056, 5625, 729, 7056, 576, 2916]
+ square_roots = []
+ for each in numbers:
+ sq_root = sqrt(each)
+ print "Square root of", each, "is", sq_root
+ square_roots.append(sq_root)
+ print
+ print square_roots
+
+{{{ save the script }}}
+
+Now save the script, and run it from your IPython interpreter. I
+assume that you have started your IPython interpreter using ``-pylab``
+option.
+
+Run the script as,
+::
+
+ %run -i list_roots.py
+
+{{{ run the script }}}
+
+So that was easy! We didn't have to find the length of the string nor
+address of each element of the list one by one. All what we did was
+iterate over the list element by element and then use the element for
+calculation. Note that here we used three variables. One the variable
+``numbers``, which is a list, another one ``each``, which is the
+element of list under consideration in each cycle of the ``for`` loop,
+and then a variable ``sq_root`` for storing the square root in each
+cycle of the ``for`` loop. The variable names can be chosen by you.
+
+{{{ show the script which was created }}}
+
+Note that three lines after ``for`` statement, are indented using four
+spaces.
+
+{{{ highlight the threee lines after for statement }}}
+
+It means that those three lines are part of the for loop. And it is
+called a block of statements. And the seventh line or the immediate
+line after the third line in the ``for`` loop is not indented,
+
+{{{ highlight the seventh line - the line just after for loop }}}
+
+it means that it is not part of the ``for`` loop and the lines after
+that doesn't fall in the scope of the ``for`` loop. Thus each block is
+separated by the indentation level. Thus marking the importance of
+white-spaces in Python.
+
+{{{ switch to the slide which shows the problem statement of the first
+problem to be tried out }}}
+
+Now a question for you to try, from the given numbers make a list of
+perfect squares and a list of those which are not. The numbers are,
+::
+
+ 7225, 3268, 3364, 2966, 7056, 5625, 729, 5547, 7056, 576, 2916
+
+{{{ switch to next slide, problem statement of second problem in
+solved exercie}}}
+
+Now let us try a simple one, to print the square root of numbers in
+the list. And this time let us do it right in the IPython
+interpreter.
+
+{{{ switch focus to the IPython interpreter }}}
+
+So let us start with making a list. Type the following
+::
+
+ numbers = [1369, 7225, 3364, 7056, 5625, 729, 7056, 576, 2916]
+ for each in numbers:
+
+and now you will notice that, as soon as you press the return key
+after for statement, the prompt changes to four dots and the cursor is
+not right after the four dots but there are four spaces from the
+dots. The four dots tell you that you are inside a block. Now type the
+rest of the ``for`` loop,
+::
+
+ sq_root = sqrt(each)
+ print "Square root of", each, "is", sq_root
+
+Now we have finished the statements in the block, and still the
+interpreter is showing four dots, which means you are still inside the
+block. To exit from the block press return key or the enter key twice
+without entering anything else. It printed the square root of each
+number in the list, and that is executed in a ``for`` loop.
+
+Now, let us generate the multiplication table of 10 from one to
+ten. But this time let us try it in the vanilla version of Python
+interpreter.
+
+Start the vanilla version of Python interpreter by issuing the command
+``python`` in your terminal.
+
+{{{ open the python interpreter in the terminal using the command
+python to start the vanilla Python interpreter }}}
+
+Start with,
+::
+
+ for i in range(1,11):
+
+and press enter once, and we will see that this time it shows four
+dots, but the cursor is close to the dots, so we have to intend the
+block. So enter four spaces there and then type the following
+::
+
+
+ print "10 *",i,"=",i*10
+
+Now when we hit enter, we still see the four dots, to get out of the
+block type enter once.
+
+Okay! so the main thing here we learned is how to use Python
+interpreter and IPython interpreter to specify blocks. But while we
+were generating the multiplication table we used something new,
+``range()`` function. ``range()`` is an inbuilt function in Python
+which can be used to generate a ``list`` of integers from a starting
+range to an ending range. Note that the ending number that you specify
+will not be included in the ``list``.
+
+Now, let us print all the odd numbers from 1 to 50. Let us do it in
+our IPython interpreter for ease of use.
+
+{{{ switch focus to ipython interpreter }}}
+
+{{{ switch to next slide, problem statement of the next problem in
+solved exercises }}}
+
+Print the list of odd numbers from 1 to 50. It will be better if
+you can try it out yourself.
+
+It is a very trivial problem and can be solved as,
+::
+
+ print range(1,51,2)
+
+This time we passed three parameters to ``range()`` function unlike
+the previous case where we passed only two parameters. The first two
+parameters are the same in both the cases. The first parameter is the
+starting number of the sequence and the second parameter is the end of
+the range. Note that the sequence doesn't include the ending
+number. The third parameter is for stepping through the sequence. Here
+we gave two which means we are skipping every alternate element.
+
+{{{ switch to next slide, recap slide }}}
+
+Thus we come to the end of this tutorial. We learned about blocks in
+Python, indentation, blocks in IPython, for loop, iterating over a
+list and then the ``range()`` function.
+
+{{{ switch to next slide, thank you slide }}}
+
+Thank you!
+
+.. Author: Anoop Jacob Thomas <anoop@fossee.in>
+ Reviewer 1:
+ Reviewer 2:
+ External reviewer:
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/loading-data-from-files.rst Fri Sep 17 18:39:24 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!
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/loops.rst Fri Sep 17 18:39:24 2010 +0530
@@ -0,0 +1,124 @@
+========
+ Script
+========
+
+{{{ show the welcome slide }}}
+
+Welcome this tutorial on loops in Python.
+
+{{{ show the outline slide }}}
+
+In this tutorial, we shall look at ``while`` and ``for`` loops. We
+shall then look at the ``break``, ``continue`` and ``pass`` keywords
+and how to use them.
+
+{{{ switch to the ipython terminal }}}
+
+We have an ``ipython`` terminal, that we shall use through out this
+tutorial.
+
+We shall first begin with the ``while`` loop. The ``while`` loop is
+used for repeated execution as long as a condition is ``True``.
+
+Let us print the squares of all the odd numbers less than 10, using
+the ``while`` loop.
+
+::
+
+ i = 1
+
+ while i<10:
+ print i*i
+ i += 2
+
+This loop prints the squares of the odd numbers below 10.
+
+The ``while`` loop, repeatedly checks if the condition is true and
+executes the block of code within the loop, if it is. As with any
+other block in Python, the code within the ``while`` block is indented
+to the right by 4 spaces.
+
+E%% %% Pause the video here and write a ``while`` loop to print the
+squares of all the even numbers below 10. Then, return to the video.
+
+::
+
+ i = 2
+
+ while i<10:
+ print i*i
+ i += 2
+
+Let us now solve the same problem of printing the squares of all odd
+numbers less than 10, using the ``for`` loop. As we know, the ``for``
+loop iterates over a list or any other sequential data type. So, we
+use the ``range`` function to get a list of odd numbers below 10, and
+then iterate over it and print the required stuff.
+
+::
+
+ for n in range(1, 10, 2):
+ print n*n
+
+E%% %% Pause the video here and write a ``for`` loop to print the
+squares of all the even numbers below 10. Then, return to the video.
+
+::
+
+ for n in range(2, 10, 2):
+ print n*n
+
+Let us now look at how to use the keywords, ``pass``, ``break`` and
+``continue``.
+
+As we already know, ``pass`` is just a syntactic filler. It is used
+for the sake of completion of blocks, that do not have any code within
+them.
+
+::
+
+ for n in range(2, 10, 2):
+ pass
+
+``break`` is used to break out of the innermost loop. The ``while``
+loop to print the squares of all the odd numbers below 10, can be
+modified using the ``break`` statement, as follows
+::
+
+ i = 1
+
+ while True:
+ print i*i
+ i += 2
+ if i<10:
+ break
+
+``continue`` is used to skip execution of the rest of the loop on this
+iteration and continue to the end of this iteration.
+
+Say, we wish to print the squares of all the odd numbers below 10,
+which are not multiples of 3, we would modify the for loop as follows.
+::
+
+ for n in range(1, 10, 2):
+ if n%3 == 0:
+ continue
+ print n*n
+
+
+E%% %%Pause the video here and using the ``continue`` keyword modify
+the ``for`` loop to print the squares of even numbers below 10, to
+print the squares of only multiples of 4. (Do not modify the range
+function call.) Then, resume the video.
+::
+
+ for n in range(2, 10, 2):
+ if n%4:
+ continue
+ print n*n
+
+That brings us to the end of this tutorial. In this tutorial, we have
+learnt about looping structures in Python and the use of the keywords
+``pass``, ``break`` and ``continue``.
+
+Thank You!
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/manipulating-strings.rst Fri Sep 17 18:39:24 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!
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/module-assessment-arrays-matrices.rst Fri Sep 17 18:39:24 2010 +0530
@@ -0,0 +1,92 @@
+========
+ 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.
+
+
+{{{ show slide with solutions to the problem }}}
+
+Thank You!
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/module_assesment_plotting_exp_data.rst Fri Sep 17 18:39:24 2010 +0530
@@ -0,0 +1,35 @@
+Hello friends.
+
+This tutorial is a self-assessment tutorial and you will be able to assess
+yourself on the concepts learnt in the Module "Plotting Expetimental data"
+
+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 problems that should take you about 5 mins.
+
+{{{ Always show slide and explain the problem }}}
+
+ * What is the shape of plot resulting from the following piece of code::
+
+ x = linspace(0, 2*pi, 4)
+ plot(x, sin(x))
+
+ * #[Nishanth]: Hav to add a simple question on scatter plot
+
+ * #[Nishanth]: Hav to add a simple question on pie chart
+
+ * Input file contains 25 lines of data, each containing 5 values seperated by
+ spaces. What is the shape of the resulting matrix from the command::
+
+ loadtxt("input-file.txt", unpack=True)
+
+{{{ Big problem - 5 mins }}}
+
+The input file ``pos.txt`` contains two columns of data. The first column
+contains x position and second column contains y position of a particle in
+flight. Plot the trajectory of the particle. What kind of motion is it?
+
+.. Author : Nishanth
+ Internal Reviewer 1 :
+ Internal Reviewer 2 :
+ External Reviewer :
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/other_type_of_plots.rst Fri Sep 17 18:39:24 2010 +0530
@@ -0,0 +1,220 @@
+.. 2.4 LO: other types of plots (3) [anoop]
+.. -----------------------------------------
+.. * scatter
+.. * pie chart
+.. * bar chart
+.. * log
+.. * illustration of other plots, matplotlib help
+
+===================
+Other type of plots
+===================
+
+{{{ show the first slide }}}
+
+Hello and welcome to the tutorial other type of plots.
+
+{{{ show the outline slide }}}
+
+In this tutorial we will cover scatter plot, pie chart, bar chart and
+log plot. We will also see few other plots and also introduce you to
+the matplotlib help.
+
+
+Let us start with scatter plot.
+
+{{{ switch to the next slide }}}
+
+In a scatter plot, the data is displayed as a collection of points,
+each having the value of one variable determining the position on the
+horizontal axis and the value of the other variable determining the
+position on the vertical axis. This kind of plot is also called a
+scatter chart, scatter diagram and scatter graph.
+
+Before we proceed further get your IPython interpreter running with
+the ``-pylab`` option. Start your IPython interpreter as
+::
+
+ ipython -pylab
+
+{{{ open the ipython interpreter in the terminal using the command
+ipython -pylab }}}
+
+{{{ switch to the next slide having the problem statement of first
+exercise }}}
+
+Now, let us plot a scatter plot showing the percentage profit of company A
+from the year 2000-2010. The data for the same is available in the
+file ``company-a-data.txt``.
+
+{{{ open the file company-a-data.txt and show the content }}}
+
+The data file has two lines with a set of values in each line, the
+first line representing years and the second line representing the
+profit percentages.
+
+{{{ close the file and switch to the terminal }}}
+
+To product the scatter plot first we need to load the data from the
+file using ``loadtxt``. We learned in one of the previous sessions,
+and it can be done as ::
+
+ year,profit = loadtxt('/home/fossee/other-plot/company-a-data.txt',dtype=type(int()))
+
+Now in-order to generate the scatter graph we will use the function
+``scatter()``
+::
+
+ scatter(year,profit)
+
+Notice that we passed two arguments to ``scatter()`` function, first
+one the values in x-coordinate, year, and the other the values in
+y-coordinate, the profit percentage.
+
+{{{ switch to the next slide which has the problem statement of
+problem to be tried out }}}
+
+Now here is a question for you to try out, plot the same data with red
+diamonds.
+
+**Clue** - *try scatter? in your ipython interpreter*
+
+.. scatter(year,profit,color='r',marker='d')
+
+Now let us move on to pie chart.
+
+{{{ switch to the slide which says about pie chart }}}
+
+A pie chart or a circle graph is a circular chart divided into
+sectors, illustrating proportion.
+
+{{{ switch to the slide showing the problem statement of second
+exercise question }}}
+
+Plot a pie chart representing the profit percentage of company A, with
+the same data from file ``company-a-data.txt``. So let us reuse the
+data we have loaded from the file previously.
+
+We can plot the pie chart using the function ``pie()``.
+::
+
+ pie(profit,labels=year)
+
+Notice that we passed two arguments to the function ``pie()``. The
+first one the values and the next one the set of labels to be used in
+the pie chart.
+
+{{{ switch to the next slide which has the problem statement of
+problem to be tried out }}}
+
+Now here is a question for you to try out, plot a pie chart with the
+same data with colors for each wedges as white, red, black, magenta,
+yellow, blue, green, cyan, yellow, magenta and blue respectively.
+
+**Clue** - *try pie? in your ipython interpreter*
+
+.. pie(t,labels=s,colors=('w','r','k','m','y','b','g','c','y','m','b'))
+
+{{{ switch to the slide which says about bar chart }}}
+
+Now let us move on to bar chart. A bar chart or bar graph is a chart
+with rectangular bars with lengths proportional to the values that
+they represent.
+
+{{{ switch to the slide showing the problem statement of third
+exercise question }}}
+
+Plot a bar chart representing the profit percentage of company A, with
+the same data from file ``company-a-data.txt``.
+
+So let us reuse the data we have loaded from the file previously.
+
+We can plot the bar chart using the function ``bar()``.
+::
+
+ bar(year,profit)
+
+Note that the function ``bar()`` needs at least two arguments one the
+values in x-coordinate and the other values in y-coordinate which is
+used to determine the height of the bars.
+
+{{{ switch to the next slide which has the problem statement of
+problem to be tried out }}}
+
+Now here is a question for you to try, plot a bar chart which is not
+filled and which is hatched with 45\ :sup:`o` slanting lines as shown
+in the image in the slide.
+
+**Clue** - *try bar? in your ipython interpreter*
+
+.. bar(year,profit,fill=False,hatch='/')
+
+{{{ switch to the slide which says about bar chart }}}
+
+Now let us move on to log-log plot. A log-log graph or log-log plot is
+a two-dimensional graph of numerical data that uses logarithmic scales
+on both the horizontal and vertical axes. Because of the nonlinear
+scaling of the axes, a function of the form y = ax\ :sup:`b` will
+appear as a straight line on a log-log graph
+
+{{{ switch to the slide showing the problem statement of fourth
+exercise question }}}
+
+
+Plot a `log-log` chart of y=5*x\ :sup:`3` for x from 1-20.
+
+Before we actually plot let us calculate the points needed for
+that. And it could be done as,
+::
+
+ x = linspace(1,20,100)
+ y = 5*x**3
+
+Now we can plot the log-log chart using ``loglog()`` function,
+::
+
+ loglog(x,y)
+
+To understand the difference between a normal ``plot`` and a ``log-log
+plot`` let us create another plot using the function ``plot``.
+::
+
+ figure(2)
+ plot(x,y)
+
+{{{ show both the plots side by side }}}
+
+So that was ``log-log() plot``.
+
+{{{ switch to the next slide which says: "How to get help on
+matplotlib online"}}}
+
+Now we will see few more plots and also see how to access help of
+matplotlib over the internet.
+
+Help about matplotlib can be obtained from
+matplotlib.sourceforge.net/contents.html
+
+.. #[[Anoop: I am not so sure how to do the rest of it, so I guess we
+ can just browse through the side and tell them few. What is your
+ opinion??]]
+
+Now let us see few plots from
+matplotlib.sourceforge.net/users/screenshots.html
+
+{{{ browse through the site quickly }}}
+
+{{{ switch to recap slide }}}
+
+Now we have come to the end of this tutorial. We have covered scatter
+plot, pie chart, bar chart, log-log plot and also saw few other plots
+and covered how to access the matplotlib online help.
+
+{{{ switch to the thank you slide }}}
+
+Thank you!
+
+.. Author: Anoop Jacob Thomas <anoop@fossee.in>
+ Reviewer 1:
+ Reviewer 2:
+ External reviewer:
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/plotting-data.rst Fri Sep 17 18:39:24 2010 +0530
@@ -0,0 +1,137 @@
+Plotting Experimental Data
+=============================
+Hello and welcome , this tutorial on Plotting Experimental data is
+presented by the fossee team.
+
+{{{ Show the slide containing title }}}
+
+
+{{{ Show the Outline Slide }}}
+
+Here we will discuss plotting Experimental data.
+
+1.We will see how we can represent a sequence of numbers in Python.
+
+2.We will also become fimiliar with elementwise squaring of such a
+sequence.
+
+3. We will also see how we can use our graph to indicate Error.
+
+One needs to be fimiliar with the concepts of plotting
+mathematical functions in Python.
+
+We will use data from a Simple Pendulum Experiment to illustrate our
+points.
+
+{{{ Simple Pendulum data Slide }}}
+
+
+
+
+As we know for a simple pendulum length,L is directly proportional to
+the square of time,T. We shall be plotting L and T^2 values.
+
+
+First we will have to initiate L and T values. We initiate them as sequence
+of values. To tell ipython a sequence of values we write the sequence in
+comma seperated values inside two square brackets. This is also called List
+so to create two sequences
+
+L,t type in ipython shell. ::
+
+ In []: L = [0.1, 0.2, 0.3, 0.4, 0.5,0.6, 0.7, 0.8, 0.9]
+
+ In []: t= [0.69, 0.90, 1.19,1.30, 1.47, 1.58, 1.77, 1.83, 1.94]
+
+
+
+To obtain the square of sequence t we will use the function square
+with argument t.This is saved into the variable tsquare.::
+
+ In []: tsquare=square(t)
+
+ array([ 0.4761, 0.81 , 1.4161, 1.69 , 2.1609, 2.4964, 3.1329,
+ 3.3489, 3.7636])
+
+
+Now to plot L vs T^2 we will simply type ::
+
+ In []: plot(L,t,.)
+
+'.' here represents to plot use small dots for the point. ::
+
+ In []: clf()
+
+You can also specify 'o' for big dots.::
+
+ In []: plot(L,t,o)
+
+ In []: clf()
+
+
+{{{ Slide with Error data included }}}
+
+
+Now we shall try and take into account error into our plots . The
+Error values for L and T are on your screen.We shall again intialize
+the sequence values in the same manner as we did for L and t ::
+
+ In []: delta_L= [0.08,0.09,0.07,0.05,0.06,0.00,0.06,0.06,0.01]
+
+ In []: delta_T= [0.04,0.08,0.11,0.05,0.03,0.03,0.01,0.07,0.01]
+
+
+
+Now to plot L vs T^2 with an error bar we use the function errorbar()
+
+The syntax of the command is as given on the screen. ::
+
+
+ In []: errorbar(L,tsquare,xerr=delta_L, yerr=delta_T, fmt='b.')
+
+This gives a plot with error bar for x and y axis. The dots are of
+blue color.
+
+
+similarly we can draw the same error bar with big red dots just change
+the parameters to fmt to 'ro'. ::
+
+ In []: clf()
+ In []: errorbar(L,tsquare,xerr=delta_L, yerr=delta_T, fmt='ro')
+
+
+
+thats it. you can explore other options to errorbar using the documentation
+of errorbar.::
+
+ In []: errorbar?
+
+
+{{{ Summary Slides }}}
+
+In this tutorial we have learnt :
+
+1. How to declare a sequence of number , specifically the kind of sequence we learned was a list.
+
+2. Plotting experimental data extending our knowledge from mathematical functions.
+
+3. The various options available for plotting dots instead of lines.
+
+4. Plotting experimental data such that we can also represent error. We did this using the errorbar() function.
+
+
+ {{{ Show the "sponsored by FOSSEE" slide }}}
+
+
+
+This tutorial was created as a part of FOSSEE project.
+
+Hope you have enjoyed and found it useful.
+
+ Thankyou
+
+
+
+Author : Amit Sethi
+Internal Reviewer :
+Internal Reviewer 2 :
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/plotui.rst Fri Sep 17 18:39:24 2010 +0530
@@ -0,0 +1,177 @@
+Hello and welcome to the tutorial on creating simple plots using
+Python.This tutorial is presented by the Fossee group.
+{{{ Show the Title Slide }}}
+
+I hope you have IPython running on your computer.
+
+In this tutorial we will look at plot command and also how to study
+the plot using the UI.
+
+{{{ Show Outline Slide }}}
+
+Lets start ipython on your shell, type ::
+
+ $ipython -pylab
+
+
+Pylab is a python library which provides plotting functionality.It
+also provides many other important mathematical and scientific
+functions. After running IPython -pylab in your shell if at the top of
+the result of this command, you see something like ::
+
+
+ `ERROR: matplotlib could NOT be imported! Starting normal
+ IPython.`
+
+
+{{{ Slide with Error written on it }}}
+
+Then you have to install matplotlib and run this command again.
+
+Now type in your ipython shell ::
+
+ In[]: linpace?
+
+
+
+as the documentation says, it returns `num` evenly spaced samples,
+calculated over the interval start and stop. To illustrate this, lets
+do it form 1 to 100 and try 100 points. ::
+
+ In[]: linspace(1,100,100)
+
+As you can see a sequence of numbers from 1 to 100 appears.
+
+Now lets try 200 points between 0 and 1 you do this by typing ::
+
+
+ In[]: linspace(0,1,200)
+
+0 for start , 1 for stop and 200 for no of points. In linspace
+the start and stop points can be integers, decimals , or
+constants. Let's try and get 100 points between -pi to pi. Type ::
+
+ In[]: p = linspace(-pi,pi,100)
+
+
+'pi' here is constant defined by pylab. Save this to the variable, p
+.
+
+If you now ::
+
+ In[]: len(p)
+
+You will get the no. of points. len function gives the no of elements
+of a sequence.
+
+
+Let's try and plot a cosine curve between -pi and pi using these
+points. Simply type ::
+
+
+ In[]: plot(p,cos(points))
+
+Here cos(points) gets the cosine value at every corresponding point to
+p.
+
+
+We can also save cos(points) to variable cosine and plot it using
+plot.::
+
+ In[]: cosine=cos(points)
+
+ In[]: plot(p,cosine)
+
+
+
+Now do ::
+
+ In[]: clf()
+
+this will clear the plot.
+
+This is done because any other plot we try to make shall come on the
+same drawing area. As we do not wish to clutter the area with
+overlaid plots , we just clear it with clf(). Now lets try a sine
+plot. ::
+
+
+ In []: plot(p,sin(p))
+
+
+
+
+The Window on which the plot appears can be used to study it better.
+
+First of all moving the mouse around gives us the point where mouse
+points at.
+
+Also we have some buttons the right most among them is
+for saving the file.
+
+Just click on it specifying the name of the file. We will save the plot
+by the name sin_curve in pdf format.
+
+{{{ Action corelating with the words }}}
+
+As you can see I can specify format of file.
+Left to the save button is the slider button to specify the margins.
+
+{{{ Action corelating with the words }}}
+
+Left to this is zoom button to zoom into the plot. Just specify the
+region to zoom into.
+The button left to it can be used to move the axes of the plot.
+
+{{{ Action corelating with the words }}}
+
+The next two buttons with a left and right arrow icons change the state of the
+plot and take it to the previous state it was in. It more or less acts like a
+back and forward button in the browser.
+
+{{{ Action corelating with the words }}}
+
+The last one is 'home' referring to the initial plot.
+
+{{{ Action corelating with the words}}}
+
+
+
+{{{ Summary Slide }}}
+
+
+In this tutorial we have looked at
+
+1. Starting Ipython with pylab
+
+2. Using linspace function to create `num` equaly spaced points in a region.
+
+3. Finding length of sequnces using len.
+
+4. Plotting mathematical functions using plot.
+
+4. Clearing drawing area using clf
+
+5. Using the UI of plot for studying it better . Using functionalities like save , zoom , moving the plots on x and y axis
+
+etc ..
+
+
+
+{{{ Show the "sponsored by FOSSEE" slide }}}
+
+
+
+This tutorial was created as a part of FOSSEE project, NME ICT, MHRD India
+
+
+
+ Hope you have enjoyed and found it useful.
+
+ Thankyou
+
+
+
+Author : Amit Sethi
+Internal Reviewer :
+Internal Reviewer 2 :
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/symbolics.rst Fri Sep 17 18:39:24 2010 +0530
@@ -0,0 +1,248 @@
+Symbolics with Sage
+-------------------
+
+This tutorial on using Sage for symbolic calculation is brought to you
+by Fossee group.
+
+{{{ Part of Notebook with title }}}
+
+We would be using simple mathematical functions on the sage notebook
+for this tutorial .
+
+During the course of the tutorial we will learn
+
+
+{{{ Part of Notebook with outline }}}
+
+To define symbolic expressions in sage . Use built-in costants and
+function. Integration , differentiation using sage . Defining
+matrices. Defining Symbolic functions . Simplifying and solving
+symbolic expressions and functions
+
+
+
+Using sage we can perform mathematical operations on symbols .
+
+On the sage notebook type::
+
+ sin(y)
+
+It raises a name error saying that y is not defined . But in sage we
+can declare y as a symbol using var function. ::
+
+ var('y')
+
+Now if you type::
+
+ sin(y)
+
+ sage simply returns the expression .
+
+thus now sage treats sin(y) as a symbolic expression . You can use
+this to do a lot of symbolic maths using sage's built-in constants and
+expressions .
+
+Try out ::
+
+ var('x,alpha,y,beta') x^2/alpha^2+y^2/beta^2
+
+Similarly , we can define many algebraic and trigonometric expressions
+using sage .
+
+
+
+Sage also provides a few built-in constants which are commonly used in
+mathematics .
+
+example : pi,e,oo , Function n gives the numerical values of all these
+ constants.
+
+For instance::
+
+ n(e)
+
+ 2.71828182845905
+
+gives numerical value of e.
+
+If you look into the documentation of n by doing ::
+
+ n(<Tab>
+
+You will see what all arguments it can take etc .. It will be very
+helpful if you look at the documentation of all functions introduced
+
+
+Also we can define the no of digits we wish to use in the numerical
+value . For this we have to pass an argument digits. Type::
+
+ n(pi, digits = 10)
+
+Apart from the constants sage also has a lot of builtin functions like
+sin,cos,sinh,cosh,log,factorial,gamma,exp,arcsin,arccos,arctan etc ...
+lets try some out on the sage notebook. ::
+
+ sin(pi/2)
+
+ arctan(oo)
+
+ log(e,e)
+
+
+Given that we have defined variables like x,y etc .. , We can define
+an arbitrary function with desired name in the following way.::
+
+ var('x') function(<tab> {{{ Just to show the documentation
+ extend this line }}} function('f',x)
+
+Here f is the name of the function and x is the independent variable .
+Now we can define f(x) to be ::
+
+ f(x) = x/2 + sin(x)
+
+Evaluating this function f for the value x=pi returns pi/2.::
+
+ f(pi)
+
+We can also define function that are not continuous but defined
+piecewise. We will be using a function which is a parabola between 0
+to 1 and a constant from 1 to 2 . type the following as given on the
+screen::
+
+
+ var('x') h(x)=x^2 g(x)=1 f=Piecewise(<Tab> {{{ Just to show the
+ documentation extend this line }}}
+ f=Piecewise([[(0,1),h(x)],[(1,2),g(x)]],x) f
+
+Checking f at 0.4, 1.4 and 3 :: f(0.4) f(1.4) f(3)
+
+for f(3) it raises a value not defined in domain error .
+
+
+Apart from operations on expressions and functions one can also use
+them for series .
+
+We first define a function f(n) in the way discussed above.::
+
+ var('n') function('f', n)
+
+
+To sum the function for a range of discrete values of n, we use the
+sage function sum.
+
+ For a convergent series , f(n)=1/n^2 we can say ::
+
+ var('n') function('f', n)
+
+ f(n) = 1/n^2
+
+ sum(f(n), n, 1, oo)
+
+For the famous Madhava series :: var('n') function('f', n)
+
+ f(n) = (-1)^(n-1)*1/(2*n - 1)
+
+This series converges to pi/4. It was used by ancient Indians to
+interpret pi.
+
+For a divergent series, sum would raise a an error 'Sum is
+divergent' ::
+
+ var('n')
+ function('f', n)
+ f(n) = 1/n sum(f(n), n,1, oo)
+
+
+
+
+We can perform simple calculus operation using sage
+
+For example lets try an expression first ::
+
+ diff(x**2+sin(x),x) 2x+cos(x)
+
+The diff function differentiates an expression or a function . Its
+first argument is expression or function and second argument is the
+independent variable .
+
+We have already tried an expression now lets try a function ::
+
+ f=exp(x^2)+arcsin(x) diff(f(x),x)
+
+To get a higher order differentiation we need to add an extra argument
+for order ::
+
+ diff(<tab> diff(f(x),x,3)
+
+
+in this case it is 3.
+
+
+Just like differentiation of expression you can also integrate them ::
+
+ x = var('x') s = integral(1/(1 + (tan(x))**2),x) s
+
+
+
+To find factors of an expression use the function factor
+
+ factor(<tab> y = (x^100 - x^70)*(cos(x)^2 + cos(x)^2*tan(x)^2) f =
+ factor(y)
+
+One can also simplify complicated expression using sage ::
+ f.simplify_full()
+
+This simplifies the expression fully . You can also do simplification
+of just the algebraic part and the trigonometric part ::
+
+ f.simplify_exp() f.simplify_trig()
+
+
+One can also find roots of an equation by using find_root function::
+
+ phi = var('phi') find_root(cos(phi)==sin(phi),0,pi/2)
+
+Lets substitute this solution into the equation and see we were
+correct ::
+
+ var('phi') f(phi)=cos(phi)-sin(phi)
+ root=find_root(f(phi)==0,0,pi/2) f.substitute(phi=root)
+
+
+as we can see the solution is almost equal to zero .
+
+
+We can also define symbolic matrices ::
+
+
+
+ var('a,b,c,d') A=matrix([[a,1,0],[0,b,0],[0,c,d]]) A
+
+
+Now lets do some of the matrix operations on this matrix ::
+
+
+ A.det() A.inverse()
+
+You can do ::
+
+ A.<Tab>
+
+To see what all operations are available
+
+
+{{{ Part of the notebook with summary }}}
+
+So in this tutorial we learnt how to
+
+
+We learnt about defining symbolic expression and functions .
+And some built-in constants and functions .
+Getting value of built-in constants using n function.
+Using Tab to see the documentation.
+Also we learnt how to sum a series using sum function.
+diff() and integrate() for calculus operations .
+Finding roots , factors and simplifying expression using find_root(),
+factor() , simplify_full, simplify_exp , simplify_trig .
+Substituting values in expression using substitute function.
+And finally creating symbolic matrices and performing operation on them .
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tuples.rst Fri Sep 17 18:39:24 2010 +0530
@@ -0,0 +1,150 @@
+Hello friends and welcome to the tutorial on Tuples
+
+{{{ Show the slide containing title }}}
+
+{{{ Show the slide containing the outline slide }}}
+
+In this tutorial, we shall learn
+
+ * what are tuples
+ * their similarities and dissimilarities with lists
+ * why are they needed
+
+Let`s get started by defining a tuple. A tuple is defined by enclosing
+parantheses around a sequence of items seperated by commas. It is similar to
+defining a list except that parantheses are used instead of square brackets.
+::
+
+ t = (1, 2.5, "hello", -4, "world", 1.24, 5)
+ t
+
+defines a tuple. The items in the tuple are indexed using numbers and can be
+accessed by using their position.
+::
+
+ t[3]
+
+prints -4 which is the fourth item of the tuple.
+
+::
+
+ t[1:5:2]
+
+prints the corresponding slice
+
+This is the behaviour similar as to lists. But the difference can be seen when
+we try to change an element in the tuple.
+::
+
+ t[2] = "Hello"
+
+We can see that, it raises an error saying tuple does not support item
+assignment. It only implies that tuples are immutable or in simple words,
+tuples cannot be changed.
+
+But what is the use of tuples!!!
+
+We shall understand that soon. But let us look at a simple problem of swapping
+values.
+
+{{{ Pause here and try out the following exercises }}}
+
+%% 1 %% a = 5 and b = 7. swap the values of a and b
+
+{{{ continue from paused state }}}
+::
+
+ a = 5
+ b = 7
+
+ a
+ b
+
+We define the two values
+::
+
+ temp = a
+ a = b
+ b = temp
+
+ a
+ b
+
+This is the traditional approach
+
+Now let us do it the python way
+::
+
+ a
+ b
+
+ a, b = b, a
+
+ a
+ b
+
+We see that the values are swapped.
+This idiom works for different datatypes also.
+::
+
+ a = 2.5
+ b = "hello"
+
+ a
+ b
+
+Moreover this type of behaviour is straight forward and what you would expect
+should happen naturally.
+
+This is possible because of the immutability of tuples. This process is called
+tuple packing and unpacking.
+
+Let us first see what is tuple packing. Type
+::
+
+ 5,
+
+What we see is a tuple with one element.
+::
+
+ 5, "hello", 2.5
+
+Now it is a tuple with two elements.
+
+So when we are actually typing two or more elements seperated by commas, those
+elements are packed and a tuple is made from them.
+
+When you type
+::
+
+ a, b = b, a
+
+First the values of b and a are packed into a tuple on the right side and then
+unpacked into the variables a and b.
+
+Immutability of tuples ensures that the values are not changed during the
+packing and unpacking.
+
+{{{ Show summary slide }}}
+
+This brings us to the end of the tutorial.
+we have learnt
+
+ * How to define tuples
+ * The similarities of tuples with lists, like indexing and iterability
+ * The immutability of tuples
+ * The value swapping idiom in Python
+ * packing and unpacking of tuples
+
+{{{ 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 :
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/using-sage.rst Fri Sep 17 18:39:24 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,
+