#LyX 1.5.5 created this file. For more info see http://www.lyx.org/
\lyxformat 276
\begin_document
\begin_header
\textclass book
\language american
\inputencoding auto
\font_roman default
\font_sans default
\font_typewriter default
\font_default_family default
\font_sc false
\font_osf false
\font_sf_scale 100
\font_tt_scale 100
\graphics default
\paperfontsize default
\spacing single
\papersize custom
\use_geometry true
\use_amsmath 1
\use_esint 0
\cite_engine basic
\use_bibtopic false
\paperorientation portrait
\paperwidth 21cm
\paperheight 24cm
\leftmargin 3cm
\topmargin 1.5cm
\rightmargin 3cm
\bottommargin 1.5cm
\secnumdepth 3
\tocdepth 3
\paragraph_separation indent
\defskip medskip
\quotes_language english
\papercolumns 1
\papersides 1
\paperpagestyle default
\tracking_changes false
\output_changes false
\author "" 
\author "" 
\end_header

\begin_body

\begin_layout Standard

\lang english
\begin_inset ERT
status open

\begin_layout Standard


\backslash
thispagestyle{empty}
\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset VSpace 0.5in*
\end_inset

 
\end_layout

\begin_layout Standard
\align center

\size huge
Python for Education
\end_layout

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/ylm20.png
	width 8cm

\end_inset


\end_layout

\begin_layout Standard
\align center

\shape italic
\size large
Learning Maths & Science using Python 
\end_layout

\begin_layout Standard
\align center

\shape italic
\size large
and 
\end_layout

\begin_layout Standard
\align center

\shape italic
\size large
writing them in LaTeX
\end_layout

\begin_layout Standard
\begin_inset VSpace 0.5in
\end_inset


\end_layout

\begin_layout Standard
\align center

\size large
Ajith Kumar B.P.
\end_layout

\begin_layout Standard
\align center

\size large
Inter University Accelerator Centre
\end_layout

\begin_layout Standard
\align center

\size large
New Delhi 110067
\end_layout

\begin_layout Standard
\align center

\size large
www.iuac.res.in
\end_layout

\begin_layout Standard
\align center
\begin_inset VSpace 0.3in
\end_inset


\end_layout

\begin_layout Standard
\align center
June 2010
\end_layout

\begin_layout Standard

\newpage

\end_layout

\begin_layout Standard
\align center
Preface
\end_layout

\begin_layout Standard
\begin_inset Quotes eld
\end_inset

Mathematics, rightly viewed, possesses not only truth, but supreme beauty
 -- a beauty cold and austere, like that of sculpture, without appeal to
 any part of our weaker nature, without the gorgeous trappings of painting
 or music, yet sublimely pure, and capable of a stern perfection such as
 only the greatest art can show
\begin_inset Quotes erd
\end_inset

, wrote Bertrand Russell about the beauty of mathematics.
 All of us may not reach such higher planes, probably reserved for Russels
 and Ramanujans, but we also have beautiful curves and nice geometrical
 figures with intricate symmetries, like fractals, generated by seemingly
 dull equations.
 This book attempts to explore it using a simple tool, the Python programming
 language.
\end_layout

\begin_layout Standard
I started using Python for the Phoenix project (www.iuac.res.in).
 Phoenix was driven in to Python by Pramode CE (pramode.net) and I followed.
 Writing this document was triggered by some of my friends who are teaching
 mathematics at Calicut University.
 
\end_layout

\begin_layout Standard
In the first chapter, a general introduction about computers and high level
 programming languages is given.
 Basics of Python language, Python modules for array and matrix manipulation,
 2D and 3D data visualization, type-setting mathematical equations using
 latex and numerical methods in Python are covered in the subsequent chapters.
 Example programs are given for every topic discussed.
 This document is meant for those who want to try out these examples and
 modify them for better understanding.
 Huge amount of material is already available online on the topics covered,
 and the references to many resources on the Internet are given for the
 benefit of the serious reader.
\end_layout

\begin_layout Standard
This book comes with a live CD, containing a modified version of Ubuntu
 GNU/Linux operating system.
 You can boot any PC from this CD and practice Python.
 Click on the 'Learn by Coding' icon on the desktop to browse through a
 collection of Python programs, run any of them with a single click.
 You can practice Python very easily by modifying and running these example
 programs.
 
\end_layout

\begin_layout Standard
This document is prepared using LyX, a LaTeX front-end.
 It is distributed under the GNU Free Documentation License (www.gnu.org).
 Feel free to make verbatim copies of this document and distribute through
 any media.
 For the LyX source files please contact the author.
\end_layout

\begin_layout Standard
Ajith Kumar
\end_layout

\begin_layout Standard
IUAC , New Delhi
\end_layout

\begin_layout Standard
ajith at iuac.res.in
\end_layout

\begin_layout Standard

\newpage

\end_layout

\begin_layout Standard
\begin_inset LatexCommand tableofcontents

\end_inset

 
\end_layout

\begin_layout Chapter
Introduction
\end_layout

\begin_layout Standard
Primary objective of this book is to explore the possibilities of using
 Python language as a tool for learning mathematics and science.
 The reader is not assumed to be familiar with computer programming.
 Ability to think logically is enough.
 Before getting into Python programming, we will briefly explain some basic
 concepts and tools required.
\end_layout

\begin_layout Standard
Computer is essentially an electronic device like a radio or a television.
 What makes it different from a radio or a TV is its ability to perform
 different kinds of tasks using the same electronic and mechanical components.
 This is achieved by making the electronic circuits flexible enough to work
 according to a set of instructions.
 The electronic and mechanical parts of a computer are called the Hardware
 and the set of instructions is called Software (or computer program).
 Just by changing the Software, computer can perform vastly different kind
 of tasks.
 The instructions are stored in binary format using electronic switches.
\end_layout

\begin_layout Section
Hardware Components
\end_layout

\begin_layout Standard
Central Processing Unit (CPU), Memory and Input/Output units are the main
 hardware components of a computer.
 CPU
\begin_inset Foot
status collapsed

\begin_layout Standard
The cabinet that encloses most of the hardware is called CPU by some, mainly
 the computer vendors.
 They are not referring to the actual CPU chip.
\end_layout

\end_inset

 can be called the brain of the computer.
 It contains a Control Unit and an Arithmetic and Logic Unit, ALU.
 The control unit brings the instructions stored in the main memory one
 by one and acts according to it.
 It also controls the movement of data between memory and input/output units.
 The ALU can perform arithmetic operations like addition, multiplication
 and logical operations like comparing two numbers.
\end_layout

\begin_layout Standard
Memory stores the instructions and data, that is processed by the CPU.
 All types of information are stored as binary numbers.
 The smallest unit of memory is called a binary digit or Bit.
 It can have a value of zero or one.
 A group of eight bits are called a Byte.
 A computer has Main and Secondary types of memory.
 Before processing, data and instructions are moved into the main memory.
 Main memory is organized into words of one byte size.
 CPU can select any memory location by using it's address.
 Main memory is made of semiconductor switches and is very fast.
 There are two types of Main Memory.
 Read Only Memory and Read/Write Memory.
 Read/Write Memory is also called Random Access Memory.
 All computers contains some programs in ROM which start running when you
 switch on the machine.
 Data and programs to be stored for future use are saved to Secondary memory,
 mainly devices like Hard disks, floppy disks, CDROM or magnetic tapes.
\end_layout

\begin_layout Standard
The Input devices are for feeding the input data into the computer.
 Keyboard is the most common input device.
 Mouse, scanner etc.
 are other input devices.
 The processed data is displayed or printed using the output devices.
 The monitor screen and printer are the most common output devices.
\end_layout

\begin_layout Section
Software components
\end_layout

\begin_layout Standard
An ordinary user expects an easy and comfortable interaction with a computer,
 and most of them are least inclined to learn even the basic concepts.
 To use modern computers for common applications like browsing and word
 processing, all you need to do is to click on some icons and type on the
 keyboard.
 However, to write your own computer programs, you need to learn some basic
 concepts, like the operating system, editors, compilers, different types
 of user interfaces etc.
 This section describes the basics from that point of view.
\end_layout

\begin_layout Subsection
The Operating System
\end_layout

\begin_layout Standard
Operating system (OS) is the software that interacts with the user and makes
 the hardware resources available to the user.
 It starts running when you switch on the computer and remains in control.
 On user request, operating system loads other application programs from
 disk to the main memory and executes them.
 OS also provides a file system, a facility to store information on devices
 like floppy disk and hard disk.
 In fact the OS is responsible for managing all the hardware resources.
\end_layout

\begin_layout Standard
GNU/Linux and MS Windows are two popular operating systems.
 Based on certain features, operating systems can be classified as:
\end_layout

\begin_layout Itemize
Single user, single process systems like MS DOS.
 Only one process can run at a time.
 Such operating systems do not have much control over the application programs.
\end_layout

\begin_layout Itemize
Multi-tasking systems like MS Windows, where more than one processe can
 run at a time.
\end_layout

\begin_layout Itemize
Multi-user, multi-tasking systems like GNU/Linux, Unix etc.
 More than one person can use the computer at the same time.
\end_layout

\begin_layout Itemize
Real-time systems, mostly used in control applications, where the response
 time to any external input is maintained under specified limits.
 
\end_layout

\begin_layout Subsection
The User Interface
\end_layout

\begin_layout Standard
Interacting with a computer involves, starting various application programs
 and managing them on the computer screen.
 The software that manages these actions is called the user interface.
 The two most common forms of user interface have historically been the
 Command-line Interface, where computer commands are typed out line-by-line,
 and the Graphical User Interface (GUI), where a visual environment (consisting
 of windows, menus, buttons, icons, etc.) is present.
 
\end_layout

\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/terminal.png
	width 12cm

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Caption

\begin_layout Standard
A GNU/Linux Terminal
\begin_inset LatexCommand label
name "fig:The-command-terminal"

\end_inset

.
\end_layout

\end_inset


\end_layout

\begin_layout Standard

\end_layout

\end_inset


\end_layout

\begin_layout Subsubsection
The Command Terminal
\end_layout

\begin_layout Standard
To run any particular program, we need to request the operating system to
 do so.
 Under a Graphical User Interface, we do this by choosing the desired applicatio
n from a menu.
 It is possible only because someone has added it to the menu earlier.
 When you start writing your own programs, obviously they will not appear
 in any menu.
 Another way to request the operating system to execute a program is to
 enter the name of the program (more precisely, the name of the file containing
 it) at the Command Terminal.
 On an Ubuntu GNU/Linux system, you can start a Terminal from the menu names
 Applications->Accessories->Terminal.
 Figure 
\begin_inset LatexCommand ref
reference "fig:The-command-terminal"

\end_inset

 shows a Terminal displaying the list of files in a directory (output of
 the command 'ls -l' , the -l option is for long listing).
\end_layout

\begin_layout Standard
The command processor offers a host of features to make the interaction
 more comfortable.
 It keeps track of the history of commands and we can recall previous commands,
 modify and reuse them using the cursor keys.
 There is also a completion feature implemented using the Tab key that reduces
 typing.
 Use the tab key to complete command and filenames.
 To run 
\shape italic
hello.py
\shape default
 from our test directory, type 
\shape italic
python h
\shape default
 and then press the tab key to complete it.
 If there are more than one file starting with 'h', you need to type more
 characters until the ambiguity is removed.
 Always use the up-cursor key to recall the previous commands and re-issue
 it.
\end_layout

\begin_layout Standard
The commands given at the terminal are processed by a program called the
 
\shape italic
shell
\shape default
.
 (The version now popular under GNU/Linux is called bash, the Bourne again
 shell).
 Some of the GNU/Linux commands are listed below.
\end_layout

\begin_layout Itemize
top : Shows the CPU and memory usage of all the processes started.
\end_layout

\begin_layout Itemize
cp filename filename : copies a file to another.
\end_layout

\begin_layout Itemize
mv : moves files from one folder to another, or rename a file.
\end_layout

\begin_layout Itemize
rm : deletes files or directories.
 
\end_layout

\begin_layout Itemize
man : display manual pages for a program.
 For example 'man bash' will give help on the bash shell.
 Press 'q' to come out of the help screen.
\end_layout

\begin_layout Itemize
info : A menu driven information system on various topics.
\end_layout

\begin_layout Standard
See the manual pages of 'mv', cp, 'rm' etc.
 to know more about them.
 Most of these commands are application programs, stored inside the folders
 /bin or /sbin, that the shell starts for you and displays their output
 inside the terminal window.
\end_layout

\begin_layout Subsection
The File-system
\end_layout

\begin_layout Standard
Before the advent of computers, people used to keep documents in files and
 folders.
 The designers of the Operating System have implemented the electronic counterpa
rts of the same.
 The storage space is made to appear as files arranged inside folders (directory
 is another term for folder).
 A simplified schematic of the GNU/Linux file system is shown in figure
  
\begin_inset LatexCommand ref
reference "fig:The-GNU/Linux-file"

\end_inset

.
 The outermost directory is called 'root' directory and represented using
 the forward slash character.
 Inside that we have folders named bin, usr, home, tmp etc., containing different
 type of files.
\end_layout

\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/linux-tree.png
	width 6cm

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Caption

\begin_layout Standard
The GNU/Linux file system tree
\begin_inset LatexCommand label
name "fig:The-GNU/Linux-file"

\end_inset

.
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsubsection
Ownership & permissions
\end_layout

\begin_layout Standard
On a multi-user operating system, application programs and document files
 must be protected against any misuse.
 This is achieved by defining a scheme of ownerships and permissions.
 Each and every file on the system will be owned by a specific user.
 The read, write and execute permissions can be assigned to them, to control
 the usage.
 The concept of 
\shape italic
group
\shape default
 is introduced to share files between a selected group of users.
 
\end_layout

\begin_layout Standard
There is one special user named 
\shape italic
root
\shape default
 (also called the system administrator or the super user) , who has permission
 to use all the resources.
 Ordinary user accounts, with a username and password, are created for everyone
 who wants to use the computer.
 In a multi-user operating system, like GNU/Linux, every user will have
 one directory inside which he can create sub-directories and files.
 This is called the 'home directory' of that user.
 Home directory of one user cannot be modified by another user.
 
\end_layout

\begin_layout Standard
The operating system files are owned by 
\shape italic
root
\shape default
.
 The /home directory contains subdirectories named after every ordinary
 user, for example, the user 
\shape italic
fred
\shape default
 owns the directory 
\shape italic
/home/fred
\shape default
 (fig 
\begin_inset LatexCommand ref
reference "fig:The-GNU/Linux-file"

\end_inset

) and its contents.
 That is also called the user's home directory.
 Every file and directory has three types of permissions : read, write and
 execute.
 To view them use the 'ls -l ' command.
 The first character of output line tells the type of the file.
 The next three characters show the 
\shape italic
rwx
\shape default
 (read, write, execute) permissions for the owner of that file.
 Next three for the users belonging to the same group and the next three
 for other users.
 A hyphen character (-) means the permission corresponding to that field
 is not granted.
 For example, the figure 
\begin_inset LatexCommand ref
reference "fig:The-command-terminal"

\end_inset

 shows a listing of five files:
\end_layout

\begin_layout Enumerate
asecret.dat : read & write for the owner.
 No one else can even see it.
\end_layout

\begin_layout Enumerate
foo.png : rw for owner, but others can view the file.
\end_layout

\begin_layout Enumerate
hello.py : rwx for owner, others can view and execute.
\end_layout

\begin_layout Enumerate
share.tex : rw for owner and other members of the same group.
\end_layout

\begin_layout Enumerate
xdata is a directory.
 Note that execute permission is required to view contents of a directory.
\end_layout

\begin_layout Standard
The system of ownerships and permissions also protects the system from virus
 attacks
\begin_inset Foot
status collapsed

\begin_layout Standard
Do not expect this from the MS Windows system.
 Even though it allows to create users, any user ( by running programs or
 viruses) is allowed to modify the system files.
 This may be because it grew from a single process system like MSDOS and
 still keeps that legacy.
\end_layout

\end_inset

.
 The virus programs damage the system by modifying some application program.
 On a true multi-user system, for example GNU/Linux, the application program
 and other system files are owned by the root user and ordinary users have
 no permission to modify them.
 When a virus attempts to modify an application, it fails due to this permission
 and ownership scheme.
\end_layout

\begin_layout Subsubsection
Current Directory
\end_layout

\begin_layout Standard
There is a working directory for every user.
 You can create subdirectories inside that and change your current working
 directory to any of them.
 While using the command-line interface, you can use the 'cd' command to
 change the current working directory.
 Figure 
\begin_inset LatexCommand ref
reference "fig:The-command-terminal"

\end_inset

 shows how to change the directory and come back to the parent directory
 by using double dots.
 We also used the command 'pwd' to print the name of the current working
 directory.
 
\end_layout

\begin_layout Section
Text Editors
\end_layout

\begin_layout Standard
To create and modify files, we use different application programs depending
 on the type of document contained in that file.
 Text editors are used for creating and modifying plain text matter, without
 any formatting information embedded inside.
 Computer programs are plain text files and to write computer programs,
 we need a text editor.
 
\shape italic
'gedit'
\shape default
 is a simple, easy to use text editor available on GNU/Linux, which provides
 syntax high-lighting for several programming languages.
\end_layout

\begin_layout Section
High Level Languages
\end_layout

\begin_layout Standard
In order to solve a problem using a computer, it is necessary to evolve
 a detailed and precise step by step method of solution.
 A set of these precise and unambiguous steps is called an Algorithm.
 It should begin with steps accepting input data and should have steps which
 gives output data.
 For implementing any algorithm on a computer, each of it's steps must be
 converted into proper machine language instructions.
 Doing this process manually is called Machine Language Programming.
 Writing machine language programs need great care and a deep understanding
 about the internal structure of the computer hardware.
 High level languages are designed to overcome these difficulties.
 Using them one can create a program without knowing much about the computer
 hardware.
\end_layout

\begin_layout Standard
We already learned that to solve a problem we require an algorithm and it
 has to be executed step by step.
 It is possible to express the algorithm using a set of precise and unambiguous
 notations.
 The notations selected must be suitable for the problems to be solved.

\shape italic
 A high level programming language is a set of well defined notations which
 is capable of expressing algorithms.
\end_layout

\begin_layout Standard
In general a high level language should have the following features.
\end_layout

\begin_layout Enumerate
Ability to represent different data types like characters, integers and
 real numbers.
 In addition to this it should also support a collection of similar objects
 like character strings, arrays etc.
\end_layout

\begin_layout Enumerate
Arithmetic and Logical operators that acts on the supported data types.
 
\end_layout

\begin_layout Enumerate
Control flow structures for decision making, branching, looping etc.
\end_layout

\begin_layout Enumerate
A set of syntax rules that precisely specify the combination of words and
 symbols permissible in the language.
\end_layout

\begin_layout Enumerate
A set of semantic rules that assigns a single, precise and unambiguous meaning
 to each syntactically correct statement.
\end_layout

\begin_layout Standard
Program text written in a high level language is often called the Source
 Code.
 It is then translated into the machine language by using translator programs.
 There are two types of translator programs, the Interpreter and the Compiler.
 
\shape italic
\size small
Interpreter reads the high level language program line by line, translates
 and executes it.
 Compilers convert the entire program in to machine language and stores
 it to a file which can be executed.
\end_layout

\begin_layout Standard
High level languages make the programming job easier.
 We can write programs that are machine independent.
 For the same program different compilers can produce machine language code
 to run on different types of computers and operating systems.
 BASIC, COBOL, FORTRAN, C, C++, Python etc.
 are some of the popular high level languages, each of them having advantages
 in different fields.
 
\end_layout

\begin_layout Standard
To write any useful program for solving a problem, one has to develop an
 algorithm.
 The algorithm can be expressed in any suitable high level language.
 
\shape italic
Learning how to develop an algorithm is different from learning a programming
 language.

\color black
 Learning a programming language means learning the notations, syntax and
 semantic rules of that language
\color inherit
.

\shape default
 Best way to do this is by writing small programs with very simple algorithms.
 After becoming familiar with the notations and rules of the language one
 can start writing programs to implement more complicated algorithms.
\end_layout

\begin_layout Section
On Free Software
\end_layout

\begin_layout Standard
Software that can be used, studied, modified and redistributed in modified
 or unmodified form without restriction is called Free Software.
 In practice, for software to be distributed as free software, the human-readabl
e form of the program (the source code) must be made available to the recipient
 along with a notice granting the above permissions.
\end_layout

\begin_layout Standard
The free software movement was conceived in 1983 by Richard Stallman to
 give the benefit of "software freedom" to computer users.
 Stallman founded the Free Software Foundation in 1985 to provide the organizati
onal structure to advance his Free Software ideas.
 Later on, alternative movements like Open Source Software came.
\end_layout

\begin_layout Standard
Software for almost all applications is currently available under the pool
 of Free Software.
 GNU/Linux operating system, OpenOffice.org office suite, LaTeX typesetting
 system, Apache web server, GIMP image editor, GNU compiler collection,
 Python interpreter etc.
 are some of the popular examples.
 For more information refer to www.gnu.org website.
\end_layout

\begin_layout Section
Exercises
\end_layout

\begin_layout Enumerate
What are the basic hardware components of a computer.
\end_layout

\begin_layout Enumerate
Name the working directory of a user named 'ramu' under GNU/Linux.
\end_layout

\begin_layout Enumerate
What is the command to list the file names inside a directory (folder).
\end_layout

\begin_layout Enumerate
What is the command under GNU/Linux to create a new folder.
\end_layout

\begin_layout Enumerate
What is the command to change the working directory.
\end_layout

\begin_layout Enumerate
Can we install more than one operating systems on a single hard disk.
\end_layout

\begin_layout Enumerate
Name two most popular Desktop Environments for GNU/Linux.
\end_layout

\begin_layout Enumerate
How to open a command window from the main menu of Ubuntu GNU/Linux.
\end_layout

\begin_layout Enumerate
Explain the file ownership and permission scheme of GNU/Linux.
\end_layout

\begin_layout Chapter
Programming in Python
\end_layout

\begin_layout Standard
Python is a simple, high level language with a clean syntax.
 It offers strong support for integration with other languages and tools,
 comes with extensive standard libraries, and can be learned in a few days.
 Many Python programmers report substantial productivity gains and feel
 the language encourages the development of higher quality, more maintainable
 code.
 To know more visit the Python website.
\begin_inset Foot
status collapsed

\begin_layout Standard
http://www.python.org/
\end_layout

\begin_layout Standard
http://docs.python.org/tutorial/
\end_layout

\begin_layout Standard
This document, example programs and a GUI program to browse through them
 are at
\end_layout

\begin_layout Standard
http://www.iuac.res.in/phoenix
\end_layout

\end_inset


\end_layout

\begin_layout Section
Getting started with Python
\end_layout

\begin_layout Standard
To start programming in Python, we have to learn how to type the source
 code and save it to a file, using a text editor program.
 We also need to know how to open a Command Terminal and start the Python
 Interpreter.
 The details of this process may vary from one system to another.
 On an Ubuntu GNU/Linux system, you can open the 
\shape italic
Text Editor
\shape default
 and the 
\shape italic
Terminal
\shape default
 from the Applications->Accessories menu.
\end_layout

\begin_layout Subsection
Two modes of using Python Interpreter
\end_layout

\begin_layout Standard
If you issue the command 'python', without any argument, from the command
 terminal, the Python interpreter will start and display a
\shape italic
 '>>>'
\shape default
 prompt where you can type Python statements.
 Use this method only for viewing the results of single Python statements,
 for example to use Python as a calculator.
 It could be confusing when you start writing larger programs, having looping
 and conditional statements.
 The preferred way is to enter your source code in a text editor, save it
 to a file (with .py extension) and execute it from the command terminal
 using Python.
 A screen-shot of the Desktop with Text Editor and Terminal is shown in
 figure 
\begin_inset LatexCommand ref
reference "fig:Text-Editor-and"

\end_inset

.
\end_layout

\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/python_edit.png
	lyxscale 50
	width 12cm

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Caption

\begin_layout Standard
Text Editor and Terminal Windows.
\begin_inset LatexCommand label
name "fig:Text-Editor-and"

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard

\end_layout

\end_inset


\end_layout

\begin_layout Standard
In this document, we will start writing small programs showing the essential
 elements of the language without going into the details.
 The reader is expected to run these example programs and also to modify
 them in different ways.It is like learning to drive a car, you master it
 by practicing.
\end_layout

\begin_layout Standard
Let us start with a program to display the words 
\emph on
\color black
Hello World
\emph default
\color inherit
 on the computer screen.
 This is the customary 'hello world' program.
 There is another version that prints 'Goodbye cruel world', probably invented
 by those who give up at this point.
 The Python 'hello world' program is shown below.
\end_layout

\begin_layout Standard
\align left

\emph on
\color black
Example.
 hello.py
\end_layout

\begin_layout LyX-Code

\shape italic
\emph on
\color black
print 'Hello World'
\end_layout

\begin_layout Standard
This should be entered into a text file using any text editor.
 On a GNU/Linux system you may use the text editor like 'gedit' to create
 the source file, save it as 
\shape italic
\color black
hello.py
\shape default
\color inherit
 .
 The next step is to call the Python Interpreter to execute the new program.
 For that, open a command terminal and (at the $ prompt) type: 
\begin_inset Foot
status collapsed

\begin_layout Standard
For quick practicing, boot from the CD provided with this book and click
 on the learn-by-coding icon to browse through the example programs given
 in this book.
 The browser allows you to run any of them with a single click, modify and
 save the modified versions.
 
\end_layout

\end_inset

 
\end_layout

\begin_layout Standard
$ python hello.py
\end_layout

\begin_layout Section
Variables and Data Types
\end_layout

\begin_layout Standard
As mentioned earlier, any high level programming language should support
 several data types.
 The problem to be solved is represented using variables belonging to the
 supported data types.
 Python supports numeric data types like integers, floating point numbers
 and complex numbers.
 To handle character strings, it uses the String data type.
 Python also supports other compound data types like lists, tuples, dictionaries
 etc.
\end_layout

\begin_layout Standard
In languages like C, C++ and Java, we need to explicitly declare the type
 of a variable.
 This is not required in Python.
 The data type of a variable is decided by the value assigned to it.
 This is called dynamic data typing.
 The type of a particular variable can change during the execution of the
 program.
 If required, one type of variable can be converted in to another type by
 explicit type casting, like 
\begin_inset Formula $y=float(3)$
\end_inset

.
 Strings are enclosed within single quotes or double quotes.
 
\end_layout

\begin_layout Standard
The program 
\shape italic
first.py
\shape default
 shows how to define variables of different data types.
 It also shows how to embed comments inside a program.
\end_layout

\begin_layout Standard
\align left

\emph on
\color black
Example:  first.py
\end_layout

\begin_layout LyX-Code
'''
\end_layout

\begin_layout LyX-Code
A multi-line comment, within a pair of three single quotes.
\end_layout

\begin_layout LyX-Code
In a line, anything after a # sign is also a comment 
\end_layout

\begin_layout LyX-Code
'''
\end_layout

\begin_layout LyX-Code
x = 10 
\end_layout

\begin_layout LyX-Code
print x, type(x)        # print x and its type
\end_layout

\begin_layout LyX-Code
x = 10.4
\end_layout

\begin_layout LyX-Code
print x, type(x)
\end_layout

\begin_layout LyX-Code
x = 3 + 4j
\end_layout

\begin_layout LyX-Code
print x, type(x)
\end_layout

\begin_layout LyX-Code
x = 'I am a String '
\end_layout

\begin_layout LyX-Code
print x,  type(x)
\end_layout

\begin_layout Standard
The output of the program is shown below.
 Note that the type of the variable 
\shape italic
x
\shape default
 changes during the execution of the program, depending on the value assigned
 to it.
\end_layout

\begin_layout LyX-Code
10 <type 'int'>
\end_layout

\begin_layout LyX-Code
10.4 <type 'float'>
\end_layout

\begin_layout LyX-Code
(3+4j) <type 'complex'>
\end_layout

\begin_layout LyX-Code
I am a String  <type 'str'> 
\end_layout

\begin_layout Standard
\align block
The program treats the variables like humans treat labelled envelopes.
 We can pick an envelope, write some name on it and keep something inside
 it for future use.
 In a similar manner the program creates a variable, gives it a name and
 keeps some value inside it, to be used in subsequent steps.
 So far we have used four data types of Python: int, float, complex and
 str.
 To become familiar with them, you may write simple programs performing
 arithmetic and logical operations using them.
 
\end_layout

\begin_layout Standard
\align left

\emph on
\color black
Example: oper.py
\end_layout

\begin_layout LyX-Code
x = 2
\end_layout

\begin_layout LyX-Code
y = 4
\end_layout

\begin_layout LyX-Code
print x + y * 2
\end_layout

\begin_layout LyX-Code
s = 'Hello '
\end_layout

\begin_layout LyX-Code
print s + s
\end_layout

\begin_layout LyX-Code
print 3 * s
\end_layout

\begin_layout LyX-Code
print x == y
\end_layout

\begin_layout LyX-Code
print y == 2 * x 
\end_layout

\begin_layout Standard
Running the program 
\shape italic
oper.py
\shape default
 will generate the following output.
\end_layout

\begin_layout LyX-Code
10
\end_layout

\begin_layout LyX-Code
Hello Hello
\end_layout

\begin_layout LyX-Code
Hello Hello Hello
\end_layout

\begin_layout LyX-Code
False
\end_layout

\begin_layout LyX-Code
True 
\end_layout

\begin_layout Standard
Note that a String can be added to another string and it can be multiplied
 by an integer.
 Try to understand the logic behind that and also try adding a String to
 an Integer to see what is the error message you will get.
 We have used the logical operator 
\begin_inset Formula $==$
\end_inset

 for comparing two variables.
 
\end_layout

\begin_layout Section
Operators and their Precedence
\end_layout

\begin_layout Standard
Python supports a large number of arithmetic and logical operators.
 They are summarized in the table 
\begin_inset LatexCommand ref
reference "tab:Operators-in-Python"

\end_inset

.
 An important thing to remember is their precedence.
 In the expression 
\shape italic
2+3*4
\shape default
, is the addition done first or the multiplication? According to elementary
 arithmetics, the multiplication should be done first.
 It means that the multiplication operator has higher precedence than the
 addition operator.
 If you want the addition to be done first, enforce it by using parenthesis
 like 
\begin_inset Formula $(2+3)*4$
\end_inset

.
 Whenever there is ambiguity in evaluation, use parenthesis to clarify the
 order of evaluation.
\end_layout

\begin_layout Standard
\begin_inset Float table
wide false
sideways false
status collapsed

\begin_layout Standard
\align center
\begin_inset Tabular
<lyxtabular version="3" rows="16" columns="4">
<features>
<column alignment="center" valignment="top" leftline="true" width="0">
<column alignment="center" valignment="top" leftline="true" width="0">
<column alignment="center" valignment="top" leftline="true" width="0">
<column alignment="center" valignment="top" leftline="true" rightline="true" width="0">
<row topline="true">
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
Operator
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
Description
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
Expression
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" rightline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
Result
\end_layout

\end_inset
</cell>
</row>
<row topline="true" bottomline="true">
<cell alignment="center" valignment="top" topline="true" bottomline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
or
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" bottomline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
Boolean OR
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" bottomline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
0 or 4
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" bottomline="true" leftline="true" rightline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
4
\end_layout

\end_inset
</cell>
</row>
<row bottomline="true">
<cell alignment="center" valignment="top" bottomline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
and
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" bottomline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
Boolean AND
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" bottomline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
3 and 0
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" bottomline="true" leftline="true" rightline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
0
\end_layout

\end_inset
</cell>
</row>
<row bottomline="true">
<cell alignment="center" valignment="top" bottomline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
not x
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" bottomline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
Boolean NOT
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" bottomline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
not 0
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" bottomline="true" leftline="true" rightline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
True
\end_layout

\end_inset
</cell>
</row>
<row>
<cell alignment="center" valignment="top" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
in, not in
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
Membership tests
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
3 in [2.2,3,12]
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" leftline="true" rightline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
True
\end_layout

\end_inset
</cell>
</row>
<row topline="true">
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
<, <=, >, >=, !=, ==
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
Comparisons
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
2 > 3
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" rightline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
False
\end_layout

\end_inset
</cell>
</row>
<row topline="true">
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
|
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
Bitwise OR
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
1 | 2
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" rightline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
3
\end_layout

\end_inset
</cell>
</row>
<row topline="true">
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
^
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
Bitwise XOR
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
1 ^ 5
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" rightline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
4
\end_layout

\end_inset
</cell>
</row>
<row topline="true">
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
&
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
Bitwise AND
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
1 & 3
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" rightline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
1
\end_layout

\end_inset
</cell>
</row>
<row topline="true">
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
<<, >>
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
Bitwise Shifting
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
1 << 3
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" rightline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
8
\end_layout

\end_inset
</cell>
</row>
<row topline="true">
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
+ , -
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
Add, Subtract
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
6 - 4
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" rightline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
2
\end_layout

\end_inset
</cell>
</row>
<row topline="true">
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
*, /, %
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
Multiply, divide, reminder
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
5 % 2
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" rightline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
1
\end_layout

\end_inset
</cell>
</row>
<row topline="true">
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
+x , -x
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
Positive, Negative
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
-5*2
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" rightline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
-10
\end_layout

\end_inset
</cell>
</row>
<row topline="true">
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
~
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
Bitwise NOT
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
~1
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" rightline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
-2
\end_layout

\end_inset
</cell>
</row>
<row topline="true">
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
**
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
Exponentiation
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
2 ** 3
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" rightline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
8
\end_layout

\end_inset
</cell>
</row>
<row topline="true" bottomline="true">
<cell alignment="center" valignment="top" topline="true" bottomline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
x[index]
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" bottomline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
Subscription
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" bottomline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
a='abcd' ; a[1]
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" bottomline="true" leftline="true" rightline="true" usebox="none">
\begin_inset Text

\begin_layout Standard

\shape italic
\size small
'b'
\end_layout

\end_inset
</cell>
</row>
</lyxtabular>

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Caption

\begin_layout Standard
Operators in Python listed according to their precedence.
 
\begin_inset LatexCommand label
name "tab:Operators-in-Python"

\end_inset


\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Section
Python Strings
\end_layout

\begin_layout Standard
So far we have come across four data types: Integer, Float, Complex and
 String.
 Out of which, String is somewhat different from the other three.
 It is a collection of same kind of elements, characters.
 The individual elements of a String can be accessed by indexing as shown
 in 
\shape italic
string.py
\shape default
.
 String is a compound, or collection, data type.
\end_layout

\begin_layout Standard
\align left

\emph on
\color black
Example: string.py
\end_layout

\begin_layout LyX-Code
s = 'hello world'
\end_layout

\begin_layout LyX-Code
print s[0]             # print first element, h
\end_layout

\begin_layout LyX-Code
print s[1]             # print e
\end_layout

\begin_layout LyX-Code
print s[-1]            # will print the last character
\end_layout

\begin_layout Standard
Addition and multiplication is defined for Strings, as demonstrated by string2.py.
 
\end_layout

\begin_layout Standard
\align left

\emph on
\color black
Example: string2.py
\end_layout

\begin_layout LyX-Code
a = 'hello'+'world'
\end_layout

\begin_layout LyX-Code
print a
\end_layout

\begin_layout LyX-Code
b = 'ha' * 3
\end_layout

\begin_layout LyX-Code
print b
\end_layout

\begin_layout LyX-Code
print a[-1] + b[0]
\end_layout

\begin_layout Standard
\align left
will give the output
\end_layout

\begin_layout Standard
helloworld
\end_layout

\begin_layout Standard
hahaha
\end_layout

\begin_layout Standard
dh
\end_layout

\begin_layout Standard
\align left
The last element of 
\shape italic
a
\shape default
 and first element of 
\shape italic
b
\shape default
 are added, resulting in the string 'dh'
\end_layout

\begin_layout Subsection
Slicing
\end_layout

\begin_layout Standard
Part of a String can be extracted using the slicing operation.
 It can be considered as a modified form of indexing a single character.
 Indexing using 
\begin_inset Formula $s[a:b]$
\end_inset

 extracts elements 
\begin_inset Formula $s[a]$
\end_inset

 to 
\begin_inset Formula $s[b-1]$
\end_inset

.
 We can skip one of the indices.
 If the index on the left side of the colon is skipped, slicing starts from
 the first element and if the index on right side is skipped, slicing ends
 with the last element.
 
\end_layout

\begin_layout Standard
\align left

\emph on
\color black
Example: slice.py
\end_layout

\begin_layout Standard
a = 'hello world'
\end_layout

\begin_layout Standard
print a[3:5]
\end_layout

\begin_layout Standard
print a[6:]
\end_layout

\begin_layout Standard
print a[:5]
\end_layout

\begin_layout Standard
\align left
The reader can guess the nature of slicing operation from the output of
 this code, shown below.
\end_layout

\begin_layout LyX-Code
'lo'
\end_layout

\begin_layout LyX-Code
'world' 
\end_layout

\begin_layout LyX-Code
'hello'
\end_layout

\begin_layout Standard
Please note that specifying a right side index more than the length of the
 string is equivalent to skipping it.
 Modify 
\shape italic
slice.py
\shape default
 to print the result of 
\begin_inset Formula $a[6:20]$
\end_inset

 to demonstrate it.
\end_layout

\begin_layout Section
Python Lists
\end_layout

\begin_layout Standard
List is an important data type of Python.
 It is much more flexible than String.
 The individual elements can be of any type, even another list.
 Lists are defined by enclosing the elements inside a pair of square brackets,
 separated by commas.
 The program 
\shape italic
list1.py
\shape default
 defines a list and print its elements.
\end_layout

\begin_layout Standard
\align left

\emph on
\color black
Example: list1.py
\end_layout

\begin_layout LyX-Code
a = [2.3, 3.5, 234]   # make a list
\end_layout

\begin_layout LyX-Code
print a[0]
\end_layout

\begin_layout LyX-Code
a[1] = 'haha'       # Change an element
\end_layout

\begin_layout LyX-Code
print a
\end_layout

\begin_layout Standard
The output is shown below 
\begin_inset Foot
status collapsed

\begin_layout Standard
The floating point number 2.3 showing as 2.2999999999999998 is interesting.
 This is the very nature of floting point representation of numbers, nothing
 to do with Python.
 With the precision we are using, the error in representing 2.3 is around
 2.0e-16.
 This becomes a concern in operations like inversion of big matrices.
\end_layout

\end_inset

.
\end_layout

\begin_layout Standard
2.3 
\end_layout

\begin_layout Standard
[2.2999999999999998, 'haha', 234] 
\end_layout

\begin_layout Standard
Lists can be sliced in a manner similar to that if Strings.
 List addition and multiplication are demonstrated by the following example.
 We can also have another list as an element of a list.
\end_layout

\begin_layout Standard
\align left

\emph on
\color black
Example: list2.py
\end_layout

\begin_layout LyX-Code
a = [1,2]
\end_layout

\begin_layout LyX-Code
print a * 2
\end_layout

\begin_layout LyX-Code
print a + [3,4]
\end_layout

\begin_layout LyX-Code
b = [10, 20, a]
\end_layout

\begin_layout LyX-Code
print b
\end_layout

\begin_layout Standard
The output of this program is shown below.
\end_layout

\begin_layout Standard
[1, 2, 1, 2] 
\end_layout

\begin_layout Standard
[1, 2, 3, 4] 
\end_layout

\begin_layout Standard
[10, 20, [1, 2] ] 
\end_layout

\begin_layout Section
Mutable and Immutable Types
\end_layout

\begin_layout Standard
There is one major difference between String and List types, List is mutable
 but String is not.
 
\shape italic
We can change the value of an element in a list, add new elements to it
 and remove any existing element.
 This is not possible with String type
\shape default
.
 Uncomment the last line of 
\shape italic
third.py
\shape default
 and run it to clarify this point.
\end_layout

\begin_layout Standard
\align left

\emph on
\color black
Example: third.py
\end_layout

\begin_layout LyX-Code
s = [3, 3.5, 234]   # make a list
\end_layout

\begin_layout LyX-Code
s[2] = 'haha'       # Change an element
\end_layout

\begin_layout LyX-Code
print s
\end_layout

\begin_layout LyX-Code
x = 'myname'        # String type
\end_layout

\begin_layout LyX-Code
#x[1] = 2           # uncomment to get ERROR
\end_layout

\begin_layout Standard
The List data type is very flexible, an element of a list can be another
 list.
 We will be using lists extensively in the coming chapters.
 Tuple is another data type similar to List, except that it is immutable.
 List is defined inside square brackets, tuple is defined in a similar manner
 but inside parenthesis, like 
\begin_inset Formula $(3,3.5,234)$
\end_inset

.
\end_layout

\begin_layout Section
Input from the Keyboard
\end_layout

\begin_layout Standard
Since most of the programs require some input from the user, let us introduce
 this feature before proceeding further.
 There are mainly two functions used for this purpose, 
\emph on
\color black
input()
\emph default
\color inherit
 for numeric type data and 
\emph on
\color black
raw_input()
\emph default
\color inherit
 for String type data.
 A message to be displayed can be given as an argument while calling these
 functions.
\begin_inset Foot
status collapsed

\begin_layout Standard
Functions will be introduced later.
 For the time being, understand that it is an isolated piece of code, called
 from the main program with some input arguments and returns some output.
\end_layout

\end_inset

 
\end_layout

\begin_layout Standard
\align left

\emph on
\color black
Example: kin1.py
\end_layout

\begin_layout LyX-Code
x = input('Enter an integer ')
\end_layout

\begin_layout LyX-Code
y = input('Enter one more ')
\end_layout

\begin_layout LyX-Code
print 'The sum is ', x + y
\end_layout

\begin_layout LyX-Code
s = raw_input('Enter a String ')
\end_layout

\begin_layout LyX-Code
print 'You entered ', s
\end_layout

\begin_layout Standard
It is also possible to read more than one variable using a single input()
 statement.
 
\emph on
\color black
String
\emph default
\color inherit
 type data read using raw_input() may be converted into 
\emph on
\color black
integer
\emph default
\color inherit
 or
\emph on
\color black
 float
\emph default
\color inherit
 type if they contain only the valid characters.
 In order to show the effect of conversion explicitly, we multiply the variables
 by 2 before printing.
 Multiplying a String by 2 prints it twice.
 If the String contains any other characters than 
\shape italic
0..9, .
 and e
\shape default
, the conversion to float will give an error.
\end_layout

\begin_layout Standard
\align left

\emph on
\color black
Example: kin2.py
\end_layout

\begin_layout LyX-Code
x,y = input('Enter x and y separated by comma ')
\end_layout

\begin_layout LyX-Code
print 'The sum is ', x + y
\end_layout

\begin_layout LyX-Code
s = raw_input('Enter a decimal number ')
\end_layout

\begin_layout LyX-Code
a = float(s)
\end_layout

\begin_layout LyX-Code
print s * 2    # prints string twice
\end_layout

\begin_layout LyX-Code
print a * 2    # converted value times 2
\end_layout

\begin_layout Standard
We have learned about the basic data types of Python and how to get input
 data from the keyboard.
 This is enough to try some simple problems and algorithms to solve them.
\end_layout

\begin_layout Standard
\align left

\emph on
\color black
Example:
\emph default
\color inherit
 area.py
\end_layout

\begin_layout LyX-Code
pi = 3.1416
\end_layout

\begin_layout LyX-Code
r = input('Enter Radius ')
\end_layout

\begin_layout LyX-Code
a = pi * r ** 2       # 
\begin_inset Formula $A=\pi r^{2}$
\end_inset


\end_layout

\begin_layout LyX-Code
print 'Area = ', a
\end_layout

\begin_layout Standard
\align block
The above example calculates the area of a circle.
 Line three calculates 
\begin_inset Formula $r^{2}$
\end_inset

\InsetSpace ~
using the exponentiation operator 
\begin_inset Formula $**$
\end_inset

, and multiply it with 
\begin_inset Formula $\pi$
\end_inset

 using the multiplication operator 
\begin_inset Formula $*$
\end_inset

.
 
\begin_inset Formula $r^{2}$
\end_inset

 is evaluated first because ** has higher precedence than *, otherwise the
 result would be 
\begin_inset Formula $(\pi r)^{2}$
\end_inset

.
\end_layout

\begin_layout Section
Iteration: while and for loops
\end_layout

\begin_layout Standard
If programs can only execute from the first line to the last in that order,
 as shown in the previous examples, it would be impossible to write any
 useful program.
 For example, we need to print the multiplication table of eight.
 Using our present knowledge, it would look like the following
\end_layout

\begin_layout Standard
\align left

\emph on
\color black
Example:
\emph default
\color inherit
 badtable.py
\end_layout

\begin_layout LyX-Code
print 1 * 8
\end_layout

\begin_layout LyX-Code
print 2 * 8
\end_layout

\begin_layout LyX-Code
print 3 * 8
\end_layout

\begin_layout LyX-Code
print 4 * 8
\end_layout

\begin_layout LyX-Code
print 5 * 8
\end_layout

\begin_layout Standard
Well, we are stopping here and looking for a better way to do this job.
 
\end_layout

\begin_layout Standard
The solution is to use the 
\emph on
\color black
while
\emph default
\color inherit
 loop of Python.
 The logical expression in front of 
\shape italic
while
\shape default
 is evaluated, and if it is True, the body of the while loop (the indented
 lines below the while statement) is executed.
 The process is repeated until the condition becomes false.
 We should have some statement inside the body of the loop that will make
 this condition false after few iterations.
 Otherwise the program will run in an infinite loop and you will have to
 press Control-C to terminate it.
 
\end_layout

\begin_layout Standard
The program
\shape italic
 table.py
\shape default
, defines a variable 
\begin_inset Formula $x$
\end_inset

 and assigns it an initial value of 1.
 Inside the while loop 
\begin_inset Formula $x*8$
\end_inset

 is printed and the value of 
\begin_inset Formula $x$
\end_inset

 is incremented.
 This process will be repeated until the value of 
\begin_inset Formula $x$
\end_inset

 becomes greater than 10.
\end_layout

\begin_layout Standard
\align left

\emph on
\color black
Example:
\emph default
\color inherit
 table.py
\end_layout

\begin_layout LyX-Code
x = 1
\end_layout

\begin_layout LyX-Code
while x <= 10:
\end_layout

\begin_layout LyX-Code
    print x * 8
\end_layout

\begin_layout LyX-Code
    x = x + 1
\end_layout

\begin_layout Standard
As per the Python syntax, the while statement ends with a colon and the
 code inside the 
\emph on
\color black
while
\emph default
\color inherit
 loop is indented.
 Indentation can be done using tab or few spaces.
 In this example, we have demonstrated a simple algorithm.
\end_layout

\begin_layout Subsection
Python Syntax, Colon & Indentation
\end_layout

\begin_layout Standard
Python was designed to be a highly readable language.
 It has a relatively uncluttered visual layout, uses English keywords frequently
 where other languages use punctuation, and has notably fewer syntactic
 constructions than other popular structured languages.
 
\end_layout

\begin_layout Standard
There are mainly two things to remember about Python syntax: 
\shape italic
indentation and colon
\shape default
.
 
\shape italic
Python uses indentation to delimit blocks of code
\shape default
.
 Both space characters and tab characters are currently accepted as forms
 of indentation in Python.
 Mixing spaces and tabs can create bugs that are hard to find, since the
 text editor does not show the difference.
 There should not be any extra white spaces in the beginning of any line.
 
\end_layout

\begin_layout Standard

\shape italic
The line before any indented block must end with a colon character
\shape default
.
 
\end_layout

\begin_layout Subsection
Syntax of 'for loops'
\end_layout

\begin_layout Standard
Python 
\shape italic
for
\shape default
 loops are slightly different from the for loops of other languages.
 Python 
\shape italic
for
\shape default
 loop iterates over a compound data type like a String, List or Tuple.
 During each iteration, one member of the compound data is assigned to the
 loop variable.
 The flexibility of this can be seen from the examples below.
\end_layout

\begin_layout Standard
\align left

\emph on
\color black
Example:
\emph default
\color inherit
 forloop.py
\end_layout

\begin_layout LyX-Code
a = 'Hello'
\end_layout

\begin_layout LyX-Code
for ch in a:  # ch is the loop variable
\end_layout

\begin_layout LyX-Code
    print ch
\end_layout

\begin_layout LyX-Code
b = ['haha', 3.4, 2345, 3+5j]
\end_layout

\begin_layout LyX-Code
for item in b:
\end_layout

\begin_layout LyX-Code
    print item
\end_layout

\begin_layout Standard
which gives the output :
\end_layout

\begin_layout Standard
H
\end_layout

\begin_layout Standard
e
\end_layout

\begin_layout Standard
l
\end_layout

\begin_layout Standard
l
\end_layout

\begin_layout Standard
o
\end_layout

\begin_layout Standard
haha
\end_layout

\begin_layout Standard
3.4
\end_layout

\begin_layout Standard
2345
\end_layout

\begin_layout Standard
(3+5j) 
\end_layout

\begin_layout Standard
For constructing for loops that executes a fixed number of times, we can
 create a list using the range() function and run the for loop over that.
\end_layout

\begin_layout Standard
\align left

\emph on
\color black
Example:
\emph default
\color inherit
 forloop2.py
\end_layout

\begin_layout LyX-Code
mylist = range(5)
\end_layout

\begin_layout LyX-Code
print mylist
\end_layout

\begin_layout LyX-Code
for item in mylist:
\end_layout

\begin_layout LyX-Code
    print item
\end_layout

\begin_layout Standard
The output will look like :
\end_layout

\begin_layout Standard
[0, 1, 2, 3, 4]
\end_layout

\begin_layout Standard
0
\end_layout

\begin_layout Standard
1
\end_layout

\begin_layout Standard
2
\end_layout

\begin_layout Standard
3
\end_layout

\begin_layout Standard
4 
\end_layout

\begin_layout Standard
The range function in the above example generates the list 
\begin_inset Formula $[0,1,2,3,4]$
\end_inset

 and the for loop walks thorugh it printing each member.
 It is possible to specify the starting point and increment as arguments
 in the form range(start, end+1, step).
 The following example prints the table of 5 using this feature.
\end_layout

\begin_layout Standard
\align left

\emph on
\color black
Example:
\emph default
\color inherit
 forloop3.py
\end_layout

\begin_layout LyX-Code
mylist = range(5,51,5)
\end_layout

\begin_layout LyX-Code
for item in mylist:
\end_layout

\begin_layout LyX-Code
    print item ,
\end_layout

\begin_layout Standard
The output is shown below.
 
\end_layout

\begin_layout Standard
5 10 15 20 25 30 35 40 45 50 
\end_layout

\begin_layout Standard
The print statement inserts a newline at the end by default.
 We can suppress this behaviour by adding a comma character at the end as
 done in the previous example.
\end_layout

\begin_layout Standard
In some cases, we may need to traverse the list to modify some or all of
 the elements.
 This can be done by looping over a list of indices generated by the range()
 function.For example, the program
\emph on
 
\emph default
forloop4.py
\size large
\emph on
 
\size default
\emph default
zeros all the elements of the list.
\end_layout

\begin_layout Standard
\align left

\emph on
\color black
Example:
\emph default
\color inherit
 forloop4.py
\end_layout

\begin_layout LyX-Code
a = [2, 5, 3, 4, 12]
\end_layout

\begin_layout LyX-Code
size = len(a)
\end_layout

\begin_layout LyX-Code
for k in range(size):
\end_layout

\begin_layout LyX-Code
    a[k] = 0
\end_layout

\begin_layout LyX-Code
print a
\end_layout

\begin_layout Section
Conditional Execution: if, elif and else
\end_layout

\begin_layout Standard
In some cases, we may need to execute some section of the code only if certain
 conditions are true.
 Python implements this feature using the 
\emph on
\color black
if, elif
\emph default
\color inherit
 and 
\emph on
\color black
else
\emph default
\color inherit
 keywords, as shown in the next example.
 The indentation levels of 
\shape italic
if
\shape default
 and the corresponding 
\shape italic
elif
\shape default
 and 
\shape italic
else
\shape default
 must be kept the same.
\end_layout

\begin_layout Standard
\align left

\emph on
\color black
Example:
\emph default
\color inherit
 compare.py
\end_layout

\begin_layout LyX-Code
x = raw_input('Enter a string ')
\end_layout

\begin_layout LyX-Code
if x == 'hello':
\end_layout

\begin_layout LyX-Code
    print 'You typed ', x
\end_layout

\begin_layout Standard
\align left

\emph on
\color black
Example:
\emph default
\color inherit
 big.py
\end_layout

\begin_layout LyX-Code
x = input('Enter a number ')
\end_layout

\begin_layout LyX-Code
if x > 10:
\end_layout

\begin_layout LyX-Code
    print 'Bigger Number'
\end_layout

\begin_layout LyX-Code
elif x < 10:
\end_layout

\begin_layout LyX-Code
    print 'Smaller Number'
\end_layout

\begin_layout LyX-Code
else:
\end_layout

\begin_layout LyX-Code
    print 'Same Number'
\end_layout

\begin_layout Standard
The statement 
\shape italic
x > 10 and x < 15
\shape default
 can be expressed in a short form, like 
\shape italic
10 < x < 15
\shape default
.
\end_layout

\begin_layout Standard
The next example uses
\emph on
\color black
 while
\emph default
\color inherit
 and
\emph on
\color black
 if 
\emph default
\color inherit
keywords in the same program.
 Note the level of indentation when the if statement comes inside the while
 loop.
 Remember that, the 
\shape italic
if
\shape default
 statement must be aligned with the corresponding 
\shape italic
elif and else.
\end_layout

\begin_layout Standard
\align left

\emph on
\color black
Example:
\emph default
\color inherit
 big2.py
\end_layout

\begin_layout LyX-Code
x = 1
\end_layout

\begin_layout LyX-Code
while x < 11:
\end_layout

\begin_layout LyX-Code
    if x < 5:
\end_layout

\begin_layout LyX-Code
        print 'Small ', x
\end_layout

\begin_layout LyX-Code
    else:
\end_layout

\begin_layout LyX-Code
        print 'Big ', x
\end_layout

\begin_layout LyX-Code
    x = x + 1
\end_layout

\begin_layout LyX-Code
print 'Done'
\end_layout

\begin_layout Section
Modify loops : break and continue
\end_layout

\begin_layout Standard
We can use the 
\emph on
\color black
break
\emph default
\color inherit
 statement to terminate a loop, if some condition is met.
 The 
\shape italic
continue
\shape default
 statement is used to skip the rest of the block and go to the beginning
 again.
 Both are demonstrated in the program 
\shape italic
big3.py
\shape default
 shown below.
\end_layout

\begin_layout Standard
\align left

\emph on
\color black
Example:
\emph default
\color inherit
 big3.py
\end_layout

\begin_layout LyX-Code
x = 1
\end_layout

\begin_layout LyX-Code
while x < 10:
\end_layout

\begin_layout LyX-Code
   if x < 3:
\end_layout

\begin_layout LyX-Code
       print 'skipping work', x
\end_layout

\begin_layout LyX-Code
       x = x + 1
\end_layout

\begin_layout LyX-Code
       continue
\end_layout

\begin_layout LyX-Code
   print x
\end_layout

\begin_layout LyX-Code
   if x == 4:
\end_layout

\begin_layout LyX-Code
      print 'Enough of work'
\end_layout

\begin_layout LyX-Code
      break
\end_layout

\begin_layout LyX-Code
   x = x  + 1
\end_layout

\begin_layout LyX-Code
print 'Done'
\end_layout

\begin_layout Standard
The output of big3.py is listed below.
\end_layout

\begin_layout Standard
skipping work 1
\end_layout

\begin_layout Standard
skipping work 2
\end_layout

\begin_layout Standard
3
\end_layout

\begin_layout Standard
4
\end_layout

\begin_layout Standard
Enough of work
\end_layout

\begin_layout Standard
Done 
\end_layout

\begin_layout Standard
\align block
Now let us write a program to find out the largest positive number entered
 by the user.
 The algorithm works in the following manner.
 To start with, we assume that the largest number is zero.
 After reading a number, the program checks whether it is bigger than the
 current value of the largest number.
 If so the value of the largest number is replaced with the current number.
 The program terminates when the user enters zero.
 Modify max.py to work with negative numbers also.
\end_layout

\begin_layout Standard
\align left
Example: max.py
\end_layout

\begin_layout LyX-Code
max = 0
\end_layout

\begin_layout LyX-Code
while True:     # Infinite loop
\end_layout

\begin_layout LyX-Code
   x = input('Enter a number ')
\end_layout

\begin_layout LyX-Code
   if x > max:
\end_layout

\begin_layout LyX-Code
      max = x
\end_layout

\begin_layout LyX-Code
   if x == 0:
\end_layout

\begin_layout LyX-Code
      print max
\end_layout

\begin_layout LyX-Code
      break
\end_layout

\begin_layout Section
Line joining
\end_layout

\begin_layout Standard
Python interpreter processes the code line by line.
 A program may have a long line of code that may not physically fit in the
 width of the text editor.
 In such cases, we can split a logical line of code into more than one physical
 lines, using backslash characters (
\backslash
), in other words multiple physical lines are joined to form a logical line
 before interpreting it.
\end_layout

\begin_layout LyX-Code
if 1900 < year < 2100 and 1 <= month <= 12 :
\end_layout

\begin_layout Standard
can be split like
\end_layout

\begin_layout LyX-Code
if 1900 < year < 2100 
\backslash

\end_layout

\begin_layout LyX-Code
    and 1 <= month <= 12 :
\end_layout

\begin_layout Standard
Do not split in the middle of words except for Strings.
 A long String can be split as shown below.
\end_layout

\begin_layout LyX-Code
longname = 'I am so long and will 
\backslash

\end_layout

\begin_layout LyX-Code
not fit in a single line'
\end_layout

\begin_layout LyX-Code
print longname
\end_layout

\begin_layout Section
Exercises
\end_layout

\begin_layout Standard
We have now covered the minimum essentials of Python; defining variables,
 performing arithmetic and logical operations on them and the control flow
 statements.
 These are sufficient for handling most of the programming tasks.
 It would be better to get a grip of it before proceeding further, by writing
 some code.
\end_layout

\begin_layout Enumerate
Modify the expression 
\shape italic
print 5+3*2
\shape default
 to get a result of 16
\end_layout

\begin_layout Enumerate
What will be the output of 
\shape italic
print type(4.5)
\end_layout

\begin_layout Enumerate
Print all even numbers upto 30, suffixed by a * if the number is a multiple
 of 6.
 (hint: use % operator)
\end_layout

\begin_layout Enumerate
Write Python code to remove the last two characters of 'I am a long string'
 by slicing, without counting the characters.
 (hint: use negative indexing)
\end_layout

\begin_layout Enumerate
s = '012345' .
 (a) Slice it to remove last two elements (b) remove first two element.
\end_layout

\begin_layout Enumerate
a = [1,2,3,4,5].
 Use Slicing and multiplication to generate [2,3,4,2,3,4] from it.
\end_layout

\begin_layout Enumerate
Compare the results of 5/2, 5.0/2 and 2.0/3.
\end_layout

\begin_layout Enumerate
Print the following pattern using a while loop
\newline
+
\newline
++
\newline
+++
\newline
++++
\end_layout

\begin_layout Enumerate
Write a program to read inputs like 8A, 10C etc.
 and print the integer and alphabet parts separately.
\end_layout

\begin_layout Enumerate
Write code to print a number in the binary format (for example 5 will be
 printed as 101)
\end_layout

\begin_layout Enumerate
Write code to print all perfect cubes upto 2000.
\end_layout

\begin_layout Enumerate
Write a Python program to print the multiplication table of 5.
\end_layout

\begin_layout Enumerate
Write a program to find the volume of a box with sides 3,4 and 5 inches
 in 
\begin_inset Formula $cm^{3}$
\end_inset

( 1 inch = 2.54 cm)
\end_layout

\begin_layout Enumerate
Write a program to find the percentage of volume occupied by a sphere of
 diameter 
\begin_inset Formula $r$
\end_inset

 fitted in a cube of side 
\begin_inset Formula $r$
\end_inset

.
 Read 
\begin_inset Formula $r$
\end_inset

 from the keyboard.
\end_layout

\begin_layout Enumerate
Write a Python program to calculate the area of a circle.
\end_layout

\begin_layout Enumerate
Write a program to divide an integer by another without using the / operator.
 (hint: use - operator)
\end_layout

\begin_layout Enumerate
Count the number of times the character 'a' appears in a String read from
 the keyboard.
 Keep on prompting for the string until there is no 'a' in the input.
\end_layout

\begin_layout Enumerate
Create an integer division machine that will ask the user for two numbers
 then divide and give the result.
 The program should give the result in two parts: the whole number result
 and the remainder.
 Example: If a user enters 11 / 4, the computer should give the result 2
 and remainder 3.
\end_layout

\begin_layout Enumerate
Modify the previous program to avoid division by zero error.
\end_layout

\begin_layout Enumerate
Create an adding machine that will keep on asking the user for numbers,
 add them together and show the total after each step.
 Terminate when user enters a zero.
\end_layout

\begin_layout Enumerate
Modify the adding machine to use raw_input() and check for errors like user
 entering invalid characters.
\end_layout

\begin_layout Enumerate
Create a script that will convert Celsius to Fahrenheit.
 The program should ask the users to enter the temperature in Celsius and
 should print out the temperature in Fahrenheit, using 
\begin_inset Formula $f=\frac{9}{5}c+32$
\end_inset

.
 
\end_layout

\begin_layout Enumerate
Write a program to convert Fahrenheit to Celsius.
\end_layout

\begin_layout Enumerate
Create a script that uses a variable and will write 20 times "I will not
 talk in class." Make each sentence on a separate line.
 
\end_layout

\begin_layout Enumerate
Define 
\begin_inset Formula $2+5j$
\end_inset

 and 
\begin_inset Formula $2-5j$
\end_inset

 as complex numbers , and find their product.
 Verify the result by defining the real and imaginary parts separately and
 using the multiplication formula.
\end_layout

\begin_layout Enumerate
Write the multiplication table of 12 using while loop.
\end_layout

\begin_layout Enumerate
Write the multiplication table of a number, from the user, using for loop.
\end_layout

\begin_layout Enumerate
Print the powers of 2 up to 1024 using a for loop.
 (only two lines of code)
\end_layout

\begin_layout Enumerate
Define the list a = [123, 12.4, 'haha', 3.4]
\newline
a) print all members using a for
 loop
\newline
b) print the float type members ( use type() function)
\newline
c) insert a member
 after 12.4
\newline
d) append more members
\end_layout

\begin_layout Enumerate
Make a list containing 10 members using a for loop.
\end_layout

\begin_layout Enumerate
Generate multiplication table of 5 with two lines of Python code.
 (hint: range function)
\end_layout

\begin_layout Enumerate
Write a program to find the sum of five numbers read from the keyboard.
\end_layout

\begin_layout Enumerate
Write a program to read numbers from the keyboard until their sum exceeds
 200.
 Modify the program to ignore numbers greater than 99.
\end_layout

\begin_layout Enumerate
Write a Python function to calculate the GCD of two numbers
\end_layout

\begin_layout Enumerate
Write a Python program to find annual compound interest.
 Get P,N and R from user
\end_layout

\begin_layout Section
Functions
\end_layout

\begin_layout Standard
Large programs need to be divided into small logical units.
 A function is generally an isolated unit of code that has a name and does
 a well defined job.
 A function groups a number of program statements into a unit and gives
 it a name.
 This unit can be invoked from other parts of a program.
 Python allows you to define functions using the 
\shape italic
def
\shape default
 keyword.
 A function may have one or more variables as arguments, which receive their
 values from the calling program.
 
\end_layout

\begin_layout Standard
In the example shown below, function arguments (a and b) get the values
 3 and 4 respectively from the caller.
 One can specify more than one variables in the return statement, separated
 by commas.
 The function will return a tuple containing those variables.
 Some functions may not have any arguments, but while calling them we need
 to use an empty parenthesis, otherwise the function will not be invoked.
 If there is no return statement, a None is returned to the caller.
\end_layout

\begin_layout Standard
\align left

\emph on
Example func.py
\end_layout

\begin_layout LyX-Code
def sum(a,b):    # a trivial function
\end_layout

\begin_layout LyX-Code
    return a + b
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
print sum(3, 4)
\end_layout

\begin_layout Standard
The function 
\shape italic
factorial.py
\shape default
 calls itself recursively.
 The value of argument is decremented before each call.
 Try to understand the working of this by inserting print statements inside
 the function.
\end_layout

\begin_layout Standard
\align left

\emph on
Example factor.py
\end_layout

\begin_layout LyX-Code
def factorial(n): # a recursive function
\end_layout

\begin_layout LyX-Code
    if n == 0: 
\end_layout

\begin_layout LyX-Code
         return 1 
\end_layout

\begin_layout LyX-Code
    else: 
\end_layout

\begin_layout LyX-Code
         return n * factorial(n-1) 
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
print factorial(10)
\end_layout

\begin_layout Standard
\align left

\emph on
Example fibanocci.py
\end_layout

\begin_layout LyX-Code
def fib(n): # print Fibonacci series up to n
\end_layout

\begin_layout LyX-Code
   a, b = 0, 1
\end_layout

\begin_layout LyX-Code
   while b < n:
\end_layout

\begin_layout LyX-Code
      print b
\end_layout

\begin_layout LyX-Code
      a, b = b, a+b
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
print fib(30)
\end_layout

\begin_layout Standard
Runing 
\shape italic
fibanocci.py
\shape default
 will print
\end_layout

\begin_layout Quotation
1 1 2 3 5 8 13 21
\end_layout

\begin_layout Standard
Modify it to replace 
\begin_inset Formula $a,b=b,a+b$
\end_inset

 by two separate assignment statements, if required introduce a third variable.
\end_layout

\begin_layout Subsection
Scope of variables
\end_layout

\begin_layout Standard
The variables defined inside a function are not known outside the function.
 There could be two variables, one inside and one outside, with the same
 name.
 The program 
\shape italic
scope.py
\shape default
 demonstrates this feature.
\end_layout

\begin_layout Standard
\align left

\emph on
Example scope.py
\end_layout

\begin_layout LyX-Code
def change(x):
\end_layout

\begin_layout LyX-Code
   counter = x
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
counter = 10
\end_layout

\begin_layout LyX-Code
change(5)
\end_layout

\begin_layout LyX-Code
print counter
\end_layout

\begin_layout Standard
The program will print 10 and not 5.
 The two variables, both named counter, are not related to each other.
 In some cases, it may be desirable to allow the function to change some
 external variable.
 This can be achieved by using the 
\shape italic
global
\shape default
 keyword, as shown in 
\shape italic
global.py
\shape default
.
\end_layout

\begin_layout Standard
\align left

\emph on
Example global.py
\end_layout

\begin_layout LyX-Code
def change(x):
\end_layout

\begin_layout LyX-Code
   global counter  # use the global variable
\end_layout

\begin_layout LyX-Code
   counter = x
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
counter = 10
\end_layout

\begin_layout LyX-Code
change(5)
\end_layout

\begin_layout LyX-Code
print counter
\end_layout

\begin_layout Standard
The program will now print 5.
 Functions with global variables should be used carefully to avoid inadvertent
 side effects.
\end_layout

\begin_layout Subsection
Optional and Named Arguments
\end_layout

\begin_layout Standard
Python allows function arguments to have default values; if the function
 is called without a particular argument, its default value will be taken.
 Due to this feature, the same function can be called with different number
 of arguments.
 The arguments without default values must appear first in the argument
 list and they cannot be omitted while invoking the function.
 The following example shows a function named power() that does exponentiation,
 but the default value of exponent is set to 2.
\end_layout

\begin_layout Standard
\align left

\emph on
Example power.py
\end_layout

\begin_layout LyX-Code
def power(mant, exp = 2.0):
\end_layout

\begin_layout LyX-Code
    return mant ** exp 
\end_layout

\begin_layout LyX-Code
  
\end_layout

\begin_layout LyX-Code
print power(5., 3)
\end_layout

\begin_layout LyX-Code
print power(4.)      # prints 16
\end_layout

\begin_layout LyX-Code
print power()        # Gives Error
\end_layout

\begin_layout Standard
Arguments can be specified in any order by using named arguments.
 
\end_layout

\begin_layout Standard
\align left

\emph on
Example named.py
\end_layout

\begin_layout LyX-Code
def power(mant = 10.0, exp = 2.0):
\end_layout

\begin_layout LyX-Code
    return mant ** exp   
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
print power(5., 3)
\end_layout

\begin_layout LyX-Code
print power(4.)      # prints 16
\end_layout

\begin_layout LyX-Code
print power(exp=3)   # mant gets 10.0, prints 1000
\end_layout

\begin_layout Section
More on Strings and Lists
\end_layout

\begin_layout Standard
Before proceeding further, we will explore some of the functions provided
 for manipulating strings and lists.
 Python strings can be manipulated in many ways.
 The following program prints the length of a string, makes an upper case
 version for printing and prints a help message on the String class.
 
\end_layout

\begin_layout Standard
\align left

\emph on
\color black
Example: stringhelp.py
\end_layout

\begin_layout LyX-Code
s = 'hello world'
\end_layout

\begin_layout LyX-Code
print len(s)
\end_layout

\begin_layout LyX-Code
print s.upper()
\end_layout

\begin_layout LyX-Code
help(str)          # press q to exit help
\end_layout

\begin_layout Standard
Python is an object oriented language and all variables are objects belonging
 to various classes.
 The method upper() (a function belonging to a class is called a method)
 is invoked using the dot operator.
 All we need to know at this stage is that there are several methods that
 can be used for manipulating objects and they can be invoked like: 
\shape italic
variable_name.method_name()
\shape default
.
 
\end_layout

\begin_layout Subsection
split and join
\end_layout

\begin_layout Standard
\align left
Splitting a String will result in a list of smaller strings.
 If you do not specify the separator, the space character is assumed by
 default.
 To demonstrate the working of these functions, few lines of code and its
 output are listed below.
\end_layout

\begin_layout Standard
\align left

\emph on
\color black
Example: split.py
\end_layout

\begin_layout LyX-Code
s = 'I am a long string'
\end_layout

\begin_layout LyX-Code
print s.split()
\end_layout

\begin_layout LyX-Code
a = 'abc.abc.abc'
\end_layout

\begin_layout LyX-Code
aa = a.split('.')
\end_layout

\begin_layout LyX-Code
print aa
\end_layout

\begin_layout LyX-Code
mm = '+'.join(aa)
\end_layout

\begin_layout LyX-Code
print mm
\end_layout

\begin_layout Standard
\align left
The result is shown below
\end_layout

\begin_layout Standard
['I', 'am', 'a', 'long', 'string']
\end_layout

\begin_layout Standard
['abc', 'abc', 'abc']
\end_layout

\begin_layout Standard
'abc+abc+abc' 
\end_layout

\begin_layout Standard
\align left
The List of strings generated by split is joined using '+' character, resulting
 in the last line of the output.
\end_layout

\begin_layout Subsection
Manipulating Lists
\end_layout

\begin_layout Standard
Python lists are very flexible, we can append, insert, delete and modify
 elements of a list.
 The program 
\shape italic
list3.py
\shape default
 demonstrates some of them.
\end_layout

\begin_layout Standard
\align left

\emph on
\color black
Example: list3.py
\end_layout

\begin_layout LyX-Code
a = []          # make an empty list
\end_layout

\begin_layout LyX-Code
a.append(3)     # Add an element
\end_layout

\begin_layout LyX-Code
a.insert(0,2.5) # insert 2.5 as first element
\end_layout

\begin_layout LyX-Code
print a, a[0]
\end_layout

\begin_layout LyX-Code
print len(a)
\end_layout

\begin_layout Standard
The output is shown below.
\end_layout

\begin_layout Standard
[2.5, 3] 2.5 
\end_layout

\begin_layout Standard
2
\end_layout

\begin_layout Subsection
Copying Lists
\end_layout

\begin_layout Standard
Lists cannot be copied like numeric data types.
 The statement 
\begin_inset Formula $b=a$
\end_inset

 will not create a new list b from list a, it just make a reference to a.
 The following example will clarify this point.
 To make a duplicate copy of a list, we need to use the 
\shape italic
copy
\shape default
 module.
\end_layout

\begin_layout Standard
\align left

\emph on
\color black
Example: list_copy.py
\end_layout

\begin_layout LyX-Code
a = [1,2,3,4]
\end_layout

\begin_layout LyX-Code
print a
\end_layout

\begin_layout LyX-Code
b = a        # b refers to a
\end_layout

\begin_layout LyX-Code
print a == b # True
\end_layout

\begin_layout LyX-Code
b[0] = 5     # Modifies a[0]
\end_layout

\begin_layout LyX-Code
print a
\end_layout

\begin_layout LyX-Code
import copy
\end_layout

\begin_layout LyX-Code
c = copy.copy(a)
\end_layout

\begin_layout LyX-Code
c[1] = 100
\end_layout

\begin_layout LyX-Code
print a is c # is False
\end_layout

\begin_layout LyX-Code
print a, c
\end_layout

\begin_layout Standard
The output is shown below.
\end_layout

\begin_layout Standard
[1, 2, 3, 4]
\end_layout

\begin_layout Standard
True
\end_layout

\begin_layout Standard
[5, 2, 3, 4]
\end_layout

\begin_layout Standard
False
\end_layout

\begin_layout Standard
[5, 2, 3, 4] [5, 100, 3, 4] 
\end_layout

\begin_layout Section
Python Modules and Packages
\begin_inset Foot
status collapsed

\begin_layout Standard
While giving names to your Python programs, make sure that you are not directly
 or indirectly importing any Python module having same name.
 For example, if you create a program named 
\emph on
math.py
\emph default
 and keep it in your working directory, the 
\emph on
import math
\emph default
 statement from any other program started from that directory will try to
 import your file named 
\emph on
math.py
\emph default
 and give error.
 If you ever do that by mistake, delete all the files with .pyc extension
 from your directory.
\end_layout

\end_inset


\end_layout

\begin_layout Standard
One of the major advantages of Python is the availability of libraries for
 various applications like graphics, networking and scientific computation.
 The standard library distributed with Python itself has a large number
 of modules: time, random, pickle, system etc.
 are some of them.
 The site http://docs.python.org/library/ has the complete reference.
 
\end_layout

\begin_layout Standard
Modules are loaded by using the 
\shape italic
import
\shape default
 keyword.
 Several ways of using 
\shape italic
import
\shape default
 is explained below, using the math (containing mathematical functions)
 module as an example.
\end_layout

\begin_layout Subsection
Different ways to import
\end_layout

\begin_layout Standard
simplest way to use import is shown in 
\shape italic
mathsin.py
\shape default
, where the function is invoked using the form 
\shape italic
module_name.function_name()
\shape default
.
 In the next example, we use an alias for the module name.
 
\end_layout

\begin_layout Standard
\align left

\emph on
Example mathsin.py
\end_layout

\begin_layout LyX-Code
import math
\end_layout

\begin_layout LyX-Code
print math.sin(0.5) # module_name.method_name 
\end_layout

\begin_layout Standard
\align left

\emph on
Example mathsin2.py
\end_layout

\begin_layout LyX-Code
import math as m   # Give another name for math
\end_layout

\begin_layout LyX-Code
print m.sin(0.5)   # Refer by the new name
\end_layout

\begin_layout Standard
We can also import the functions to behave like local (like the ones within
 our source file) function, as shown below.
 The character * is a wild card for importing all the functions.
\end_layout

\begin_layout Standard
\align left

\emph on
Example mathlocal.py
\end_layout

\begin_layout LyX-Code
from math import sin  # sin is imported as local
\end_layout

\begin_layout LyX-Code
print sin(0.5)     
\end_layout

\begin_layout Standard
\align left

\emph on
Example mathlocal2.py
\end_layout

\begin_layout LyX-Code
from math import *   # import everything from math
\end_layout

\begin_layout LyX-Code
print sin(0.5)
\end_layout

\begin_layout Standard
In the third and fourth cases, we need not type the module name every time.
 But there could be trouble if two modules imported contains a function
 with same name.
 In the program 
\emph on
conflict.py
\emph default
, the 
\begin_inset Formula $\sin()$
\end_inset

 from 
\emph on
numpy
\emph default
 is capable of handling a list argument.
 After importing 
\shape italic
math.py
\shape default
, line 4, the 
\begin_inset Formula $\sin$
\end_inset

 function from 
\shape italic
math
\shape default
 module replaces the one from 
\emph on
numpy
\emph default
.
 The error occurs because the 
\begin_inset Formula $\sin()$
\end_inset

 from 
\emph on
math
\emph default
 can accept only a numeric type argument.
\end_layout

\begin_layout Standard
\align left

\emph on
Example conflict.py
\end_layout

\begin_layout LyX-Code
from numpy import *
\end_layout

\begin_layout LyX-Code
x = [0.1, 0.2, 0.3]
\end_layout

\begin_layout LyX-Code
print sin(x)           # numpy's sin can handle lists
\end_layout

\begin_layout LyX-Code
from math import *     # sin of math becomes effective
\end_layout

\begin_layout LyX-Code
print sin(x)           # will give ERROR
\end_layout

\begin_layout Subsection
Packages
\end_layout

\begin_layout Standard
Packages are used for organizing multiple modules.
 The module name A.B designates a submodule named B in a package named A.
 The concept is demonstrated using the packages Numpy
\begin_inset Foot
status collapsed

\begin_layout Standard
NumPy will be discusssed later in chapter 
\begin_inset LatexCommand ref
reference "sec:Arrays-and-Matrices"

\end_inset

.
\end_layout

\end_inset

 and Scipy.
 
\end_layout

\begin_layout Standard
\align left

\emph on
Example submodule.py
\end_layout

\begin_layout LyX-Code
import numpy
\end_layout

\begin_layout LyX-Code
print numpy.random.normal()
\end_layout

\begin_layout LyX-Code

\end_layout

\begin_layout LyX-Code
import scipy.special 
\end_layout

\begin_layout LyX-Code
print scipy.special.j0(.1)
\end_layout

\begin_layout Standard
In this example 
\shape italic
random
\shape default
 is a module inside the package 
\shape italic
NumPy
\shape default
.
 Similarly 
\shape italic
special
\shape default
 is a module inside the package 
\shape italic
Scipy.
 
\shape default
We use both of them in the package.module.function() format.
 But there is some difference.
 In the case of Numpy, the random module is loaded by default, importing
 scipy does not import the module special by default.
 This behavior can be defined while writing the Package and it is upto the
 package author.
\end_layout

\begin_layout Section
File Input/Output
\end_layout

\begin_layout Standard
Disk files can be opened using the function named open() that returns a
 File object.
 Files can be opened for reading or writing.
 There are several methods belonging to the File class that can be used
 for reading and writing data.
\end_layout

\begin_layout Standard
\align left

\emph on
Example wfile.py
\end_layout

\begin_layout LyX-Code
f = open('test.dat' , 'w')
\end_layout

\begin_layout LyX-Code
f.write ('This is a test file')
\end_layout

\begin_layout LyX-Code
f.close()
\end_layout

\begin_layout Standard
Above program creates a new file named 'test.dat' (any existing file with
 the same name will be deleted) and writes a String to it.
 The following program opens this file for reading the data.
\end_layout

\begin_layout Standard
\align left

\emph on
Example rfile.py
\end_layout

\begin_layout LyX-Code
f = open('test.dat' , 'r')
\end_layout

\begin_layout LyX-Code
print f.read()
\end_layout

\begin_layout LyX-Code
f.close()
\end_layout

\begin_layout Standard
Note that the data written/read are character strings.
 read() function can also be used to read a fixed number of characters,
 as shown below.
\end_layout

\begin_layout Standard
\align left

\emph on
Example rfile2.py
\end_layout

\begin_layout LyX-Code
f = open('test.dat' , 'r')
\end_layout

\begin_layout LyX-Code
print f.read(7)      # get first seven characters
\end_layout

\begin_layout LyX-Code
print f.read()       # get the remaining ones
\end_layout

\begin_layout LyX-Code
f.close()
\end_layout

\begin_layout Standard
Now we will examine how to read a text data from a file and convert it into
 numeric type.
 First we will create a file with a column of numbers.
\end_layout

\begin_layout Standard
\align left

\emph on
Example wfile2.py
\end_layout

\begin_layout LyX-Code
f = open('data.dat' , 'w')
\end_layout

\begin_layout LyX-Code
for k in range(1,4):
\end_layout

\begin_layout LyX-Code
      s = '%3d
\backslash
n' %(k)
\end_layout

\begin_layout LyX-Code
      f.write(s) 
\end_layout

\begin_layout LyX-Code
f.close()
\end_layout

\begin_layout Standard
The contents of the file created will look like this.
\end_layout

\begin_layout Standard
1 
\end_layout

\begin_layout Standard
2 
\end_layout

\begin_layout Standard
3 
\end_layout

\begin_layout Standard
\align left
Now we write a program to read this file, line by line, and convert the
 string type data to integer type, and print the numbers.
\begin_inset Foot
status collapsed

\begin_layout Standard
This will give error if there is a blank line in the data file.
 This can be corrected by changing the comparison statement to if 
\shape italic
len(s) < 1:
\shape default
 , so that the processing stops at a blank line.
 Modify the code to skip a blank line instead of exiting (hint: use continue
 ).
\end_layout

\end_inset


\end_layout

\begin_layout Standard
\align left

\emph on
Example rfile3.py
\end_layout

\begin_layout LyX-Code
f = open('data.dat' , 'r')
\end_layout

\begin_layout LyX-Code
while 1: # infinite loop
\end_layout

\begin_layout LyX-Code
    s = f.readline()
\end_layout

\begin_layout LyX-Code
    if s == '' :    # Empty string means end of file
\end_layout

\begin_layout LyX-Code
         break      # terminate the loop
\end_layout

\begin_layout LyX-Code
    m = int(s)      # Convert to integer
\end_layout

\begin_layout LyX-Code
    print m * 5     
\end_layout

\begin_layout LyX-Code
f.close()
\end_layout

\begin_layout Subsection
The pickle module
\end_layout

\begin_layout Standard
Strings can easily be written to and read from a file.
 Numbers take a bit more effort, since the read() method only returns Strings,
 which will have to be converted in to a number explicitly.
 However, when you want to save and restore data types like lists, dictionaries,
 or class instances, things get a lot more complicated.
 Rather than have the users constantly writing and debugging code to save
 complicated data types, Python provides a standard module called pickle.
\end_layout

\begin_layout Standard
\align left

\emph on
Example pickledump.py
\end_layout

\begin_layout LyX-Code
import pickle
\end_layout

\begin_layout LyX-Code
f = open('test.pck' , 'w')
\end_layout

\begin_layout LyX-Code
pickle.dump(12.3, f) # write a float type
\end_layout

\begin_layout LyX-Code
f.close()
\end_layout

\begin_layout Standard
\align left
Now write another program to read it back from the file and check the data
 type.
\end_layout

\begin_layout Standard
\align left

\emph on
Example pickleload.py
\end_layout

\begin_layout LyX-Code
import pickle
\end_layout

\begin_layout LyX-Code
f = open('test.pck' , 'r')
\end_layout

\begin_layout LyX-Code
x = pickle.load(f)
\end_layout

\begin_layout LyX-Code
print x , type(x)        # check the type of data read
\end_layout

\begin_layout LyX-Code
f.close()
\end_layout

\begin_layout Section
Formatted Printing
\end_layout

\begin_layout Standard
Formatted printing is done by using a format string followed by the % operator
 and the values to be printed.
 If format requires a single argument, values may be a single variable.
 Otherwise, values must be a tuple (just place them inside parenthesis,
 separated by commas) with exactly the number of items specified by the
 format string.
\end_layout

\begin_layout Standard
\align left

\emph on
Example: format.py
\end_layout

\begin_layout LyX-Code
a = 2.0 /3  # 2/3 will print zero
\end_layout

\begin_layout LyX-Code
print a
\end_layout

\begin_layout LyX-Code
print 'a = %5.3f' %(a) # upto 3 decimal places
\end_layout

\begin_layout Standard
Data can be printed in various formats.
 The conversion types are summarized in the following table.
 There are several flags that can be used to modify the formatting, like
 justification, filling etc.
\end_layout

\begin_layout Standard
\begin_inset Float table
wide false
sideways false
status open

\begin_layout Standard
\align center
\begin_inset Tabular
<lyxtabular version="3" rows="8" columns="4">
<features>
<column alignment="center" valignment="top" leftline="true" width="0">
<column alignment="center" valignment="top" leftline="true" width="0">
<column alignment="center" valignment="top" leftline="true" width="0">
<column alignment="center" valignment="top" leftline="true" rightline="true" width="0">
<row topline="true" bottomline="true">
<cell alignment="center" valignment="top" topline="true" bottomline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard
Conversion
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" bottomline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard
Conversion
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" bottomline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard
Example
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" bottomline="true" leftline="true" rightline="true" usebox="none">
\begin_inset Text

\begin_layout Standard
Result
\end_layout

\end_inset
</cell>
</row>
<row topline="true">
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard
d , i
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard
signed Integer
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard
'%6d'%(12)
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" rightline="true" usebox="none">
\begin_inset Text

\begin_layout Standard
'\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
12'
\end_layout

\end_inset
</cell>
</row>
<row topline="true">
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard
f
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard
floating point decimal
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard
'%6.4f'%(2.0/3)
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" rightline="true" usebox="none">
\begin_inset Text

\begin_layout Standard
0.667
\end_layout

\end_inset
</cell>
</row>
<row topline="true">
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard
e
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard
floating point exponential
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard
'%6.2e'%(2.0/3)
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" rightline="true" usebox="none">
\begin_inset Text

\begin_layout Standard
6.67e-01
\end_layout

\end_inset
</cell>
</row>
<row topline="true">
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard
x
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard
hexadecimal
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard
'%x'%(16)
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" rightline="true" usebox="none">
\begin_inset Text

\begin_layout Standard
10
\end_layout

\end_inset
</cell>
</row>
<row topline="true">
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard
o
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard
octal
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard
'%o'%(8)
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" rightline="true" usebox="none">
\begin_inset Text

\begin_layout Standard
10
\end_layout

\end_inset
</cell>
</row>
<row topline="true">
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard
s
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard
string
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard
'%s'%('abcd')
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" leftline="true" rightline="true" usebox="none">
\begin_inset Text

\begin_layout Standard
abcd
\end_layout

\end_inset
</cell>
</row>
<row topline="true" bottomline="true">
<cell alignment="center" valignment="top" topline="true" bottomline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard
0d
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" bottomline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard
modified 'd'
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" bottomline="true" leftline="true" usebox="none">
\begin_inset Text

\begin_layout Standard
'%05d'%(12)
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" topline="true" bottomline="true" leftline="true" rightline="true" usebox="none">
\begin_inset Text

\begin_layout Standard
00012
\end_layout

\end_inset
</cell>
</row>
</lyxtabular>

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Caption

\begin_layout Standard
Formatted Printing in Python
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\align left
The following example shows some of the features available with formatted
 printing.
\end_layout

\begin_layout Standard
\align left

\emph on
Example: format2.py
\end_layout

\begin_layout LyX-Code
a = 'justify as you like'
\end_layout

\begin_layout LyX-Code
print '%30s'%a         # right justified
\end_layout

\begin_layout LyX-Code
print '%-30s'%a        # minus sign for left justification
\end_layout

\begin_layout LyX-Code
for k in range(1,11):   # A good looking table
\end_layout

\begin_layout LyX-Code
    print '5 x %2d = %2d' %(k, k*5)
\end_layout

\begin_layout Standard
The output of 
\emph on
format2.py 
\emph default
is given below.
\end_layout

\begin_layout LyX-Code
           justify as you like
\end_layout

\begin_layout LyX-Code
justify as you like           
\end_layout

\begin_layout LyX-Code
5 x  1 =  5
\end_layout

\begin_layout LyX-Code
5 x  2 = 10
\end_layout

\begin_layout LyX-Code
5 x  3 = 15
\end_layout

\begin_layout LyX-Code
5 x  4 = 20
\end_layout

\begin_layout LyX-Code
5 x  5 = 25
\end_layout

\begin_layout LyX-Code
5 x  6 = 30
\end_layout

\begin_layout LyX-Code
5 x  7 = 35
\end_layout

\begin_layout LyX-Code
5 x  8 = 40
\end_layout

\begin_layout LyX-Code
5 x  9 = 45
\end_layout

\begin_layout LyX-Code
5 x 10 = 50
\end_layout

\begin_layout Section
Exception Handling
\end_layout

\begin_layout Standard
Errors detected during execution are called exceptions, like divide by zero.
 If the program does not handle exceptions, the Python Interpreter reports
 the exception and terminates the program.
 We will demonstrate handling exceptions using 
\shape italic
try
\shape default
 and 
\shape italic
except
\shape default
 keywords, in the example except.py.
\end_layout

\begin_layout Standard
\align left

\emph on
Example: except.py
\end_layout

\begin_layout LyX-Code
x = input('Enter a number ')
\end_layout

\begin_layout LyX-Code
try:
\end_layout

\begin_layout LyX-Code
    print 10.0/x
\end_layout

\begin_layout LyX-Code
except:
\end_layout

\begin_layout LyX-Code
    print 'Division by zero not allowed'
\end_layout

\begin_layout Standard
If any exception occurs while running the code inside the try block, the
 code inside the except block is executed.
 The following program implements error checking on input using exceptions.
\end_layout

\begin_layout Standard
\align left

\emph on
Example: except2.py
\end_layout

\begin_layout LyX-Code
def get_number():
\end_layout

\begin_layout LyX-Code
   while 1:
\end_layout

\begin_layout LyX-Code
      try:
\end_layout

\begin_layout LyX-Code
         a = raw_input('Enter a number ')
\end_layout

\begin_layout LyX-Code
         x = atof(a)
\end_layout

\begin_layout LyX-Code
         return x
\end_layout

\begin_layout LyX-Code
      except:
\end_layout

\begin_layout LyX-Code
         print 'Enter a valid number'
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
print get_number()
\end_layout

\begin_layout Section
Turtle Graphics
\end_layout

\begin_layout Standard
Turtle Graphics have been noted by many psychologists and educators to be
 a powerful aid in teaching geometry, spatial perception, logic skills,
 computer programming, and art.
 The language LOGO was specifically designed to introduce children to programmin
g, using turtle graphics.
 An abstract drawing device, called the Turtle, is used to make programming
 attractive for children by concentrating on doing turtle graphics.
 It has been used with children as young as 3 and has a track record of
 30 years of success in education.
 
\end_layout

\begin_layout Standard
We will use the Turtle module of Python to play with Turtle Graphics and
 practice the logic required for writing computer programs.
 Using this module, we will move a 
\shape italic
Pen
\shape default
 on a two dimensional screen to generate graphical patterns.
 The Pen can be controlled using functions like forward(distance), backward(dist
ance), right(angle), left(angle) etc.
\begin_inset Foot
status collapsed

\begin_layout Standard
http://docs.python.org/library/turtle.html
\end_layout

\end_inset

.
 Run the program turtle1.py to understand the functions.
 This section is included only for those who want to practice programming
 in a more interesting manner.
\end_layout

\begin_layout Standard
\align left

\emph on
Example turtle1.py
\end_layout

\begin_layout LyX-Code
from turtle import *
\end_layout

\begin_layout LyX-Code
a = Pen()    # Creates a turtle in a window
\end_layout

\begin_layout LyX-Code
a.forward(50)
\end_layout

\begin_layout LyX-Code
a.left(45)
\end_layout

\begin_layout LyX-Code
a.backward(50)
\end_layout

\begin_layout LyX-Code
a.right(45)
\end_layout

\begin_layout LyX-Code
a.forward(50)
\end_layout

\begin_layout LyX-Code
a.circle(10)
\end_layout

\begin_layout LyX-Code
a.up()
\end_layout

\begin_layout LyX-Code
a.forward(50)
\end_layout

\begin_layout LyX-Code
a.down()
\end_layout

\begin_layout LyX-Code
a.color('red')
\end_layout

\begin_layout LyX-Code
a.right(90)
\end_layout

\begin_layout LyX-Code
a.forward(50)
\end_layout

\begin_layout LyX-Code
raw_input('Press Enter') 
\end_layout

\begin_layout Standard
\align left

\emph on
Example turtle2.py
\end_layout

\begin_layout LyX-Code
from turtle import *
\end_layout

\begin_layout LyX-Code
a = Pen()      
\end_layout

\begin_layout LyX-Code
for k in range(4):
\end_layout

\begin_layout LyX-Code
  a.forward(50)
\end_layout

\begin_layout LyX-Code
  a.left(90)
\end_layout

\begin_layout LyX-Code
  a.circle(25)
\end_layout

\begin_layout LyX-Code
raw_input()  # Wait for Key press
\end_layout

\begin_layout Standard
Outputs of the program turtle2.py and turtle3.py are shown in figure 
\begin_inset LatexCommand ref
reference "fig:turtle2 and 3 outputs"

\end_inset

.
 Try to write more programs like this to generate more complex patterns.
\end_layout

\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/turtle2.png
	width 3cm

\end_inset


\begin_inset Graphics
	filename pics/turtle3.png
	width 3cm

\end_inset


\begin_inset Graphics
	filename pics/turtle4.png
	width 6cm

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Caption

\begin_layout Standard
Output of turtle2.py (b) turtle3.py (c) turtle4.py
\begin_inset LatexCommand label
name "fig:turtle2 and 3 outputs"

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard

\end_layout

\end_inset


\end_layout

\begin_layout Standard
\align left

\emph on
Example turtle3.py
\end_layout

\begin_layout LyX-Code
from turtle import *
\end_layout

\begin_layout LyX-Code

\end_layout

\begin_layout LyX-Code
def draw_rectangle():
\end_layout

\begin_layout LyX-Code
    for k in range(4):
\end_layout

\begin_layout LyX-Code
        a.forward(50)
\end_layout

\begin_layout LyX-Code
        a.left(90)
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
a = Pen()
\end_layout

\begin_layout LyX-Code
for k in range(36):
\end_layout

\begin_layout LyX-Code
  draw_rectangle()
\end_layout

\begin_layout LyX-Code
  a.left(10)   
\end_layout

\begin_layout LyX-Code
raw_input()  
\end_layout

\begin_layout Standard
The program turtle3.py creates a pattern by drwaing 36 squares, each drawn
 tilted by 
\begin_inset Formula $10^{\circ}$
\end_inset

 from the previous one.
 The program turtle4.py generates the fractal image as shown in figure
\begin_inset LatexCommand ref
reference "fig:turtle2 and 3 outputs"

\end_inset

(c).
 
\end_layout

\begin_layout Standard
\align left

\emph on
Example turtle4.py
\end_layout

\begin_layout LyX-Code
from turtle import *
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
def f(length, depth):
\end_layout

\begin_layout LyX-Code
  if depth == 0: 
\end_layout

\begin_layout LyX-Code
    forward(length)
\end_layout

\begin_layout LyX-Code
  else:   
\end_layout

\begin_layout LyX-Code
    f(length/3, depth-1)
\end_layout

\begin_layout LyX-Code
    right(60)
\end_layout

\begin_layout LyX-Code
    f(length/3, depth-1)
\end_layout

\begin_layout LyX-Code
    left(120)
\end_layout

\begin_layout LyX-Code
    f(length/3, depth-1)
\end_layout

\begin_layout LyX-Code
    right(60)
\end_layout

\begin_layout LyX-Code
    f(length/3, depth-1)
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
f(500, 4) 
\end_layout

\begin_layout LyX-Code
raw_input('Press any Key')
\end_layout

\begin_layout Section
Writing GUI Programs
\end_layout

\begin_layout Standard
Python has several modules that can be used for creating Graphical User
 Interfaces.
 The intention of this chapter is just to show the ease of making GUI in
 Python and we have selected Tkinter
\begin_inset Foot
status collapsed

\begin_layout Standard
http://www.pythonware.com/library/an-introduction-to-tkinter.htm
\end_layout

\begin_layout Standard
http://infohost.nmt.edu/tcc/help/pubs/tkinter/
\end_layout

\begin_layout Standard
http://wiki.python.org/moin/TkInter
\end_layout

\end_inset

, one of the easiest to learn.
 The GUI programs are event driven (movement of mouse, clicking a mouse
 button, pressing and releasing a key on the keyboard etc.
 are called events).
 The execution sequence of the program is decided by the events, generated
 mostly by the user.
 For example, when the user clicks on a Button, the code associated with
 that Button is executed.
 GUI Programming is about creating Widgets like Button, Label, Canvas etc.
 on the screen and executing selected functions in response to events.
 After creating all the necessary widgets and displaying them on the screen,
 the control is passed on to Tkinter by calling a function named 
\shape italic
mainloop
\shape default
.
 After that the program flow is decided by the events and associated callback
 functions.
\end_layout

\begin_layout Standard
For writing GUI programs, the first step is to create a main graphics window
 by calling the function Tk().
 After that we create various Widgets and pack them inside the main window.
 The example programs given below demonstrate the usage of some of the Tkinter
 widgets.The program 
\shape italic
tkmain.py
\shape default
 is the smallest GUI program one can write using Tkinter.
 The output of tkmain.py is shown in figure
\begin_inset LatexCommand ref
reference "fig:tkmain and tklabel outputs"

\end_inset

(a).
\end_layout

\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status open

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/tkmain.png
	width 4cm

\end_inset

\InsetSpace ~
\InsetSpace ~
\InsetSpace ~

\begin_inset Graphics
	filename pics/tklabel.png
	width 4cm

\end_inset

 
\end_layout

\begin_layout Standard
\begin_inset Caption

\begin_layout Standard
Outputs of (a)tkmain.py (b)tklabel.py
\begin_inset LatexCommand label
name "fig:tkmain and tklabel outputs"

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard

\end_layout

\end_inset


\end_layout

\begin_layout Standard
\align left

\emph on
Example tkmain.py
\end_layout

\begin_layout LyX-Code
from Tkinter import *
\end_layout

\begin_layout LyX-Code
root = Tk()
\end_layout

\begin_layout LyX-Code
root.mainloop() 
\end_layout

\begin_layout Standard
\align left

\emph on
Example tklabel.py
\end_layout

\begin_layout LyX-Code
from Tkinter import *
\end_layout

\begin_layout LyX-Code
root = Tk()
\end_layout

\begin_layout LyX-Code
w = Label(root, text="Hello, world")
\end_layout

\begin_layout LyX-Code
w.pack()
\end_layout

\begin_layout LyX-Code
root.mainloop() 
\end_layout

\begin_layout Standard
The program tklabel.py will generate the output as shown in figure 
\begin_inset LatexCommand ref
reference "fig:tkmain and tklabel outputs"

\end_inset

(b).
 Terminate the program by clicking on the x displayed at the top right corner.
 In this example, we used a Label widget to display some text.
 The next example will show how to use a Button widget.
 
\end_layout

\begin_layout Standard
A Button widget can have a callback function, hello() in this case, that
 gets executed when the user clicks on the Button.
 The program will display a Button on the screen.
 Every time you click on it, the function 
\shape italic
hello
\shape default
 will be executed.
 The output of the program is shown in figure 
\begin_inset LatexCommand ref
reference "fig:tkbutton and canvas"

\end_inset

(a).
\end_layout

\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/tkbutton.png
	width 4cm

\end_inset

\InsetSpace ~
\InsetSpace ~
\InsetSpace ~

\begin_inset Graphics
	filename pics/tkcanvas.png
	width 6cm

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Caption

\begin_layout Standard
Outputs of (a) tkbutton.py (b)tkcanvas.py
\begin_inset LatexCommand label
name "fig:tkbutton and canvas"

\end_inset


\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\align left

\emph on
Example tkbutton.py
\end_layout

\begin_layout LyX-Code
from Tkinter import *
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
def hello():
\end_layout

\begin_layout LyX-Code
    print 'hello world'    
\end_layout

\begin_layout LyX-Code
            
\end_layout

\begin_layout LyX-Code
w = Tk()   # Creates the main Graphics window
\end_layout

\begin_layout LyX-Code
b = Button(w, text = 'Click Me', command = hello)
\end_layout

\begin_layout LyX-Code
b.pack()
\end_layout

\begin_layout LyX-Code
w.mainloop()
\end_layout

\begin_layout Standard
Canvas is another commonly used widget.
 Canvas is a drawing area on which we can draw elements like line, arc,
 rectangle, text etc.
 The program tkcanvas.py creates a Canvas widget and binds the <Button-1>
 event to the function draw().
 When left mouse button is pressed, a small rectangle are drawn at the cursor
 position.
 The output of the program is shown in figure 
\begin_inset LatexCommand ref
reference "fig:tkbutton and canvas"

\end_inset

(b).
\end_layout

\begin_layout Standard
\align left

\emph on
Example tkcanvas.py
\end_layout

\begin_layout LyX-Code
from Tkinter import *
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
def draw(event):
\end_layout

\begin_layout LyX-Code
   c.create_rectangle(event.x, 
\backslash

\end_layout

\begin_layout LyX-Code
         event.y, event.x+5, event.y+5)
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
w = Tk()
\end_layout

\begin_layout LyX-Code
c = Canvas(w, width = 300, height = 200)
\end_layout

\begin_layout LyX-Code
c.pack()
\end_layout

\begin_layout LyX-Code
c.bind("<Button-1>", draw)
\end_layout

\begin_layout LyX-Code
w.mainloop() 
\end_layout

\begin_layout Standard
The next program is a modification of tkcanvas.py.
 The right mouse-button is bound to remove().
 Every time a rectangle is drawn, its return value is added to a list, a
 global variable, and this list is used for removing the rectangles when
 right button is pressed.
\end_layout

\begin_layout Standard
\align left

\emph on
Example tkcanvas2.py
\end_layout

\begin_layout LyX-Code
from Tkinter import *
\end_layout

\begin_layout LyX-Code
recs = []    # List keeping track of the rectangles
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
def remove(event):
\end_layout

\begin_layout LyX-Code
   global recs
\end_layout

\begin_layout LyX-Code
   if len(recs) > 0:
\end_layout

\begin_layout LyX-Code
      c.delete(recs[0]) # delete from Canvas
\end_layout

\begin_layout LyX-Code
      recs.pop(0)       # delete first item from list
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
def draw(event):
\end_layout

\begin_layout LyX-Code
   global recs
\end_layout

\begin_layout LyX-Code
   r = c.create_rectangle(event.x, 
\backslash

\end_layout

\begin_layout LyX-Code
           event.y, event.x+5, event.y+5)
\end_layout

\begin_layout LyX-Code
   recs.append(r)
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
w = Tk()
\end_layout

\begin_layout LyX-Code
c = Canvas(w, width = 300, height = 200)
\end_layout

\begin_layout LyX-Code
c.pack()
\end_layout

\begin_layout LyX-Code
c.bind("<Button-1>", draw)
\end_layout

\begin_layout LyX-Code
c.bind("<Button-3>", remove)
\end_layout

\begin_layout LyX-Code
w.mainloop() 
\end_layout

\begin_layout Section
Object Oriented Programming in Python
\end_layout

\begin_layout Standard
OOP is a programming paradigm that uses 
\emph on
objects
\emph default
 (Structures consisting of variables and methods) and their interactions
 to design computer programs.
 Python is an object oriented language but it does not force you to make
 all programs object oriented and there is no advantage in making small
 programs object oriented.
 In this section, we will discuss some features of OOP.
\end_layout

\begin_layout Standard
Before going to the new concepts, let us recollect some of the things we
 have learned.
 We have seen that the effect of operators on different data types is predefined.
 For example 
\begin_inset Formula $2*3$
\end_inset

 results in 
\begin_inset Formula $6$
\end_inset

 and 
\begin_inset Formula $2*'abc'$
\end_inset

 results in 
\begin_inset Formula $'abcabc'$
\end_inset

.
 This behavior has been decided beforehand, based on some logic, by the
 language designers.
 One of the key features of OOP is the ability to create user defined data
 types.
 The user will specify, how the new data type will behave under the existing
 operators like add, subtract etc.
 and also define methods that will belong to the new data type.
 
\end_layout

\begin_layout Standard
We will design a new data type using the class keyword and define the behavior
 of it.
 In the program point.py, we define a class named Point.
 The variables xpos and ypos are members of Point.
 The __init__() function is executed whenever we create an instance of this
 class, the member variables are initialized by this function.
 The way in which an object belonging to this class is printed is decided
 by the __str__ function.
 We also have defined the behavior of add (+) and subtract (-) operators
 for this class.
 The + operator returns a new Point by adding the x and y coordinates of
 two Points.
 Subtracting a Point from another gives the distance between the two.
 The method dist() returns the distance of a Point object from the origin.
 We have not defined the behavior of Point under copy operation.
 We can use the copy module of Python to copy objects.
\end_layout

\begin_layout Standard
\align left

\emph on
Example point.py
\end_layout

\begin_layout LyX-Code
class Point:
\end_layout

\begin_layout LyX-Code
  '''
\end_layout

\begin_layout LyX-Code
  This is documentation comment.
 
\end_layout

\begin_layout LyX-Code
  help(Point) will display this.
\end_layout

\begin_layout LyX-Code
  '''
\end_layout

\begin_layout LyX-Code
  def __init__(self, x=0, y=0):
\end_layout

\begin_layout LyX-Code
    self.xpos = x
\end_layout

\begin_layout LyX-Code
    self.ypos = y
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
  def __str__(self): # overloads print
\end_layout

\begin_layout LyX-Code
   return 'Point at (%f,%f)'%(self.xpos, self.ypos)
\end_layout

\begin_layout LyX-Code
  
\end_layout

\begin_layout LyX-Code
  def __add__(self, other):  #overloads +
\end_layout

\begin_layout LyX-Code
    xpos = self.xpos + other.xpos
\end_layout

\begin_layout LyX-Code
    ypos = self.ypos + other.ypos
\end_layout

\begin_layout LyX-Code
    return Point(xpos,ypos)
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
  def __sub__(self, other):  #overloads -
\end_layout

\begin_layout LyX-Code
    import math 
\end_layout

\begin_layout LyX-Code
    dx = self.xpos - other.xpos
\end_layout

\begin_layout LyX-Code
    dy = self.ypos - other.ypos 
\end_layout

\begin_layout LyX-Code
    return math.sqrt(dx**2+dy**2) 
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
  def dist(self):
\end_layout

\begin_layout LyX-Code
    import math
\end_layout

\begin_layout LyX-Code
    return math.sqrt(self.xpos**2 + self.ypos**2) 
\end_layout

\begin_layout Standard
The program point1.py imports the file point.py to use the class Point defined
 inside it to demonstrate the properties of the class.
 A self.
 is prefixed when a method refers to member of the same object.
 It refers to the variable used for invoking the method.
\end_layout

\begin_layout Standard
\align left

\emph on
Example point1.py
\end_layout

\begin_layout LyX-Code
from point import *
\end_layout

\begin_layout LyX-Code
origin = Point()
\end_layout

\begin_layout LyX-Code
print origin
\end_layout

\begin_layout LyX-Code
p1 = Point(4,4)
\end_layout

\begin_layout LyX-Code
p2 = Point(8,7)
\end_layout

\begin_layout LyX-Code
print p1
\end_layout

\begin_layout LyX-Code
print p2
\end_layout

\begin_layout LyX-Code
print p1 + p2
\end_layout

\begin_layout LyX-Code
print p1 - p2 
\end_layout

\begin_layout LyX-Code
print p1.dist()
\end_layout

\begin_layout Standard
Output of program point1.py is shown below.
\end_layout

\begin_layout Quotation
Point at (0.000000,0.000000)
\end_layout

\begin_layout Quotation
Point at (4.000000,4.000000)
\end_layout

\begin_layout Quotation
Point at (8.000000,7.000000)
\end_layout

\begin_layout Quotation
Point at (12.000000,11.000000)
\end_layout

\begin_layout Quotation
5.0 
\end_layout

\begin_layout Quotation
5.65685424949 
\end_layout

\begin_layout Standard
In this section, we have demonstrated the OO concepts like class, object
 and operator overloading.
\end_layout

\begin_layout Subsection
Inheritance, reusing code
\end_layout

\begin_layout Standard
\align left
Reuse of code is one of the main advantages of object oriented programming.
 We can define another class that inherits all the properties of the Point
 class, as shown below.
 The __init__ function of colPoint calls the __init__ function of Point,
 to get all work except initilization of color done.
 All other methods and operator overloading defined for Point is inherited
 by colPoint.
\end_layout

\begin_layout Standard
\align left

\emph on
Example cpoint.py
\end_layout

\begin_layout LyX-Code
class colPoint(Point):  #colPoint inherits Point
\end_layout

\begin_layout LyX-Code
  color = 'black'
\end_layout

\begin_layout LyX-Code
  def __init__(self,x=0,y=0,col='black'):
\end_layout

\begin_layout LyX-Code
    Point.__init__(self,x,y)
\end_layout

\begin_layout LyX-Code
    self.color = col
\end_layout

\begin_layout LyX-Code
  
\end_layout

\begin_layout LyX-Code
  def __str__(self):
\end_layout

\begin_layout LyX-Code
    return '%s colored Point at (%f,%f)'% 
\backslash

\end_layout

\begin_layout LyX-Code
       (self.color,self.xpos, self.ypos) 
\end_layout

\begin_layout Standard
\align left

\emph on
Example point2.py
\end_layout

\begin_layout LyX-Code
from cpoint import *
\end_layout

\begin_layout LyX-Code
p1 = Point(5,5) 
\end_layout

\begin_layout LyX-Code
rp1 = colPoint(2,2,'red')
\end_layout

\begin_layout LyX-Code
print p1 
\end_layout

\begin_layout LyX-Code
print rp1 
\end_layout

\begin_layout LyX-Code
print rp1 + p1 
\end_layout

\begin_layout LyX-Code
print rp1.dist() 
\end_layout

\begin_layout Standard
The output of point2.py is listed below.
\end_layout

\begin_layout Standard
Point at (5.000000,5.000000)
\end_layout

\begin_layout Standard
red colored Point at (2.000000,2.000000)
\end_layout

\begin_layout Standard
Point at (7.000000,7.000000) 
\end_layout

\begin_layout Standard
2.82842712475 
\end_layout

\begin_layout Standard
\align left
For a detailed explanation on the object oriented features of Python, refer
 to chapters 13, 14 and 15 of the online book http://openbookproject.net//thinkCS
py/
\end_layout

\begin_layout Subsection
A graphics example program
\end_layout

\begin_layout Standard
Object Oriented programming allows us to write Classes with a well defined
 external interface hiding all the internal details.
 This example shows a Class named 'disp', for drawing curves, providing
 the xy coordinates within an arbitrary range .
 The the world-to-screen coordinate conversion is performed internally.
 The method named line() accepts a list of xy coordinates.
 The file 
\shape italic
tkplot_class.py
\shape default
 defines the 'disp' class and is listed below.
\end_layout

\begin_layout Standard
\align left

\emph on
Example tkplot_class.py
\end_layout

\begin_layout LyX-Code
from Tkinter import * 
\end_layout

\begin_layout LyX-Code
from math import *
\end_layout

\begin_layout LyX-Code
class disp:
\end_layout

\begin_layout LyX-Code
    def __init__(self, parent, width=400., height=200.):
\end_layout

\begin_layout LyX-Code
       self.parent = parent
\end_layout

\begin_layout LyX-Code
       self.SCX = width
\end_layout

\begin_layout LyX-Code
       self.SCY = height
\end_layout

\begin_layout LyX-Code
       self.border = 1
\end_layout

\begin_layout LyX-Code
       self.canvas = Canvas(parent, width=width, height=height)
\end_layout

\begin_layout LyX-Code
       self.canvas.pack(side = LEFT)
\end_layout

\begin_layout LyX-Code
       self.setWorld(0 , 0, self.SCX, self.SCY)  # scale factors 
\end_layout

\begin_layout LyX-Code
   
\end_layout

\begin_layout LyX-Code
    def setWorld(self, x1, y1, x2, y2):   
\end_layout

\begin_layout LyX-Code
       self.xmin = float(x1) 
\end_layout

\begin_layout LyX-Code
       self.ymin = float(y1)
\end_layout

\begin_layout LyX-Code
       self.xmax = float(x2)
\end_layout

\begin_layout LyX-Code
       self.ymax = float(y2)
\end_layout

\begin_layout LyX-Code
       self.xscale = (self.xmax - self.xmin) / (self.SCX)
\end_layout

\begin_layout LyX-Code
       self.yscale = (self.ymax - self.ymin) / (self.SCY) 
\end_layout

\begin_layout LyX-Code
   
\end_layout

\begin_layout LyX-Code
    def w2s(self, p): #world-to-screen before plotting
\end_layout

\begin_layout LyX-Code
       ip = []
\end_layout

\begin_layout LyX-Code
       for xy in p:
\end_layout

\begin_layout LyX-Code
          ix = self.border + int( (xy[0] - self.xmin) / self.xscale)
\end_layout

\begin_layout LyX-Code
          iy = self.border + int( (xy[1] - self.ymin) / self.yscale)
\end_layout

\begin_layout LyX-Code
          iy = self.SCY - iy 
\end_layout

\begin_layout LyX-Code
          ip.append((ix,iy))
\end_layout

\begin_layout LyX-Code
       return ip
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
    def line(self, points, col='blue'):
\end_layout

\begin_layout LyX-Code
       ip = self.w2s(points)
\end_layout

\begin_layout LyX-Code
       t = self.canvas.create_line(ip, fill=col)
\end_layout

\begin_layout Standard
The program 
\shape italic
tkplot.py
\shape default
 imports tkplot_class.py and plots two graphs.
 The advantage of code reuse is evident from this example.
 
\begin_inset Foot
status collapsed

\begin_layout Standard
A more sophisticated version of the 
\shape italic
disp
\shape default
 class program (draw.py) is included in the package 'learn-by-coding', available
 on the CD.
 
\end_layout

\end_inset

.
 Output of 
\shape italic
tkplot.py
\shape default
 is shown in figure 
\begin_inset LatexCommand ref
reference "fig:Output-of-tkplot.py"

\end_inset

.
\end_layout

\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/tkplot.png
	width 10cm

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Caption

\begin_layout Standard
Output of tkplot.py
\begin_inset LatexCommand label
name "fig:Output-of-tkplot.py"

\end_inset


\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\align left

\emph on
Example tkplot.py
\end_layout

\begin_layout LyX-Code
from tkplot_class import *
\end_layout

\begin_layout LyX-Code
from math import *
\end_layout

\begin_layout LyX-Code
w = Tk()
\end_layout

\begin_layout LyX-Code
gw1 = disp(w)
\end_layout

\begin_layout LyX-Code
xy = []
\end_layout

\begin_layout LyX-Code
for k in range(200):
\end_layout

\begin_layout LyX-Code
    x = 2 * pi * k/200
\end_layout

\begin_layout LyX-Code
    y = sin(x)
\end_layout

\begin_layout LyX-Code
    xy.append((x,y))
\end_layout

\begin_layout LyX-Code
gw1.setWorld(0, -1.0, 2*pi, 1.0)
\end_layout

\begin_layout LyX-Code
gw1.line(xy)
\end_layout

\begin_layout LyX-Code
gw2 = disp(w)
\end_layout

\begin_layout LyX-Code
gw2.line([(10,10),(100,100),(350,50)], 'red')
\end_layout

\begin_layout LyX-Code
w.mainloop()
\end_layout

\begin_layout Section
Exercises
\end_layout

\begin_layout Enumerate
Generate multiplication table of eight and write it to a file.
\end_layout

\begin_layout Enumerate
Make a list and write it to a file using the pickle module.
\end_layout

\begin_layout Enumerate
Write a Python program to open a file and write 'hello world' to it.
\end_layout

\begin_layout Enumerate
Write a Python program to open a text file and read all lines from it.
\end_layout

\begin_layout Enumerate
Write a program to generate the multiplication table of a number from the
 user.
 The output should be formatted as shown below
\newline
\InsetSpace ~
\InsetSpace ~
1 x 5 = \InsetSpace ~
\InsetSpace ~
\InsetSpace ~
5
\newline
\InsetSpace ~
\InsetSpace ~
2 x 5 = \InsetSpace ~
10
\end_layout

\begin_layout Enumerate
Define the list [1,2,3,4,5,6] using the range function.
 Write code to insert a 10 after 2, delete 4, add 0 at the end and sort
 it in the ascending order.
\end_layout

\begin_layout Enumerate
Write Python code to generate the sequence of numbers 
\newline
25 20 15 10 5
\newline
using
 range function .
 Delete 15 from the result and sort it.
 Print it using a for loop.
\end_layout

\begin_layout Enumerate
Define a string 
\shape italic
s = 'mary had a little lamb'.
 
\newline

\shape default
a) print it in reverse order
\newline
b) split it using space character as sepatator
\end_layout

\begin_layout Enumerate
Join the elements of the list ['I', 'am', 'in', 'pieces'] using + character.
 Do the same using a for loop also.
\end_layout

\begin_layout Enumerate
Create a window with five buttons.
 Make each button a different color.
 Each button should have some text on it.
 
\end_layout

\begin_layout Enumerate
Create a program that will put words in alphabetical order.
 The program should allow the user to enter as many words as he wants to.
 
\end_layout

\begin_layout Enumerate
Create a program that will check a sentence to see if it is a palindrome.
 A palindrome is a sentence that reads the same backwards and forwards ('malayal
am').
 
\end_layout

\begin_layout Enumerate
A text file contains two columns of numbers.
 Write a program to read them and print the sum of numbers in each row.
\end_layout

\begin_layout Enumerate
Read a String from the keyboard.
 Multiply it by an integer to make its length more than 50.
 How do you find out the smallest number that does the job.
\end_layout

\begin_layout Enumerate
Write a program to find the length of the hypotenuse of a right triangle
 from the length of other two sides, get the input from the user.
\end_layout

\begin_layout Enumerate
Write a program displaying 2 labels and 2 buttons.
 It should print two different messages when clicked on the two buttons.
\end_layout

\begin_layout Enumerate
Write a program with a Canvas and a circle drawn on it.
\end_layout

\begin_layout Enumerate
Write a program using for loop to reverse a string.
 
\end_layout

\begin_layout Enumerate
Write a Python function to calculate the GCD of two numbers
\end_layout

\begin_layout Enumerate
Write a program to print the values of sine function from 
\begin_inset Formula $0$
\end_inset

 to 
\begin_inset Formula $2\pi$
\end_inset

 with 0.1 increments.
 Find the mean value of them.
\end_layout

\begin_layout Enumerate
Generate N random numbers using random.random() and find out howmay are below
 0.5 .
 Repeat the same for different values of N to draw some conclusions.
\end_layout

\begin_layout Enumerate
Use the equation 
\begin_inset Formula $x=(-b\pm\sqrt{b^{2}-4ac})/2a$
\end_inset

 to find the roots of 
\begin_inset Formula $3x^{2}+6x+12=0$
\end_inset


\end_layout

\begin_layout Enumerate
Write a program to calculate the distance between points (x1,y1) and (x2,y2)
 in a Cartesian plane.
 Get the coordinates from the user.
\end_layout

\begin_layout Enumerate
Write a program to evaluate 
\begin_inset Formula $y$
\end_inset

= 
\begin_inset Formula $\sqrt{2.3a}+a^{2}+34.5$
\end_inset

 for a = 1, 2 and 3.
\end_layout

\begin_layout Enumerate
Print Fibanocci numbers upto 100, without using multiple assignment statement.
\end_layout

\begin_layout Enumerate
Draw a chess board pattern using turtle graphics.
\end_layout

\begin_layout Enumerate
Find the syntax error in the following code and correct it.
\newline
x=1
\newline
while x <=
 10:
\newline
print x * 5
\end_layout

\begin_layout Chapter
Arrays and Matrices 
\begin_inset LatexCommand label
name "sec:Arrays-and-Matrices"

\end_inset


\end_layout

\begin_layout Standard
In the previous chapter, we have learned the essential features of Python
 language.
 We also used the 
\shape italic
math
\shape default
 module to calculate trigonometric functions.
 Using the tools introduced so far, let us generate the data points to plot
 a sine wave.
 The program sine.py generates the coordinates to plot a sine wave.
\end_layout

\begin_layout Standard
\align left

\emph on
Example sine.py
\end_layout

\begin_layout LyX-Code
import math
\end_layout

\begin_layout LyX-Code
x = 0.0
\end_layout

\begin_layout LyX-Code
while x < 2 * math.pi:
\end_layout

\begin_layout LyX-Code
    print x , math.sin(x)
\end_layout

\begin_layout LyX-Code
    x = x + 0.1
\end_layout

\begin_layout Standard
The output to the screen can be redirected to a file as shown below, from
 the command prompt.
 You can plot the data using some program like xmgrace.
\end_layout

\begin_layout Standard
$ python sine.py > sine.dat
\end_layout

\begin_layout Standard
$ xmgrace sine.dat 
\end_layout

\begin_layout Standard
It would be better if we could write such programs without using loops explicitl
y.
 Serious scientific computing requires manipulating of large data structures
 like matrices.
 The 
\shape italic
list
\shape default
 data type of Python is very flexible but the performance is not acceptable
 for large scale computing.
 The need of special tools is evident even from the simple example shown
 above.
 
\shape italic
NumPy
\shape default
 is a package widely used for scientific computing with Python.
\begin_inset Foot
status collapsed

\begin_layout Standard
http://numpy.scipy.org/
\end_layout

\begin_layout Standard
http://www.scipy.org/Tentative_NumPy_Tutorial
\end_layout

\begin_layout Standard
http://www.scipy.org/Numpy_Functions_by_Category
\end_layout

\begin_layout Standard
http://www.scipy.org/Numpy_Example_List_With_Doc
\end_layout

\end_inset

 
\end_layout

\begin_layout Section
The NumPy Module
\end_layout

\begin_layout Standard
The 
\shape italic
\color black
numpy
\shape default
\color inherit
 module supports operations on compound data types like arrays and matrices.

\shape italic
\color black
 First thing to learn is how to create arrays and matrices using the numpy
 package.

\shape default
\color inherit
 Python lists can be converted into multi-dimensional arrays.
 There are several other functions that can be used for creating matrices.
 The mathematical functions like sine, cosine etc.
 of numpy accepts array objects as arguments and return the results as arrays
 objects.
 NumPy arrays can be indexed, sliced and copied like Python Lists.
\end_layout

\begin_layout Standard
In the examples below, we will import numpy functions as local (using the
 syntax 
\shape italic
from numpy import *
\shape default
).
 Since it is the only package used there is no possibility of any function
 name conflicts.
\end_layout

\begin_layout Standard
\align left

\emph on
Example numpy1.py
\end_layout

\begin_layout LyX-Code
from numpy import *
\end_layout

\begin_layout LyX-Code
x = array( [1, 2, 3] )   # Make array from list
\end_layout

\begin_layout LyX-Code
print x , type(x)
\end_layout

\begin_layout Standard
In the above example, we have created an array from a list.
\end_layout

\begin_layout Subsection
Creating Arrays and Matrices
\end_layout

\begin_layout Standard
We can also make multi-dimensional arrays.
 Remember that a member of a list can be another list.
 The following example shows how to make a two dimensional array.
\end_layout

\begin_layout Standard
\align left

\emph on
Example numpy3.py
\end_layout

\begin_layout LyX-Code
from numpy import *
\end_layout

\begin_layout LyX-Code
a = [ [1,2] , [3,4] ] # make a list of lists
\end_layout

\begin_layout LyX-Code
x = array(a)    # and convert to an array
\end_layout

\begin_layout LyX-Code
print a
\end_layout

\begin_layout Standard
Other than than 
\shape italic
array(),
\shape default
 there are several other functions that can be used for creating different
 types of arrays and matrices.
 Some of them are described below.
\end_layout

\begin_layout Subsubsection
arange(start, stop, step, dtype = None)
\end_layout

\begin_layout Standard
Creates an evenly spaced one-dimensional array.
 Start, stop, stepsize and datatype are the arguments.
 If datatype is not given, it is deduced from the other arguments.
 Note that, the values are generated within the interval, including start
 but excluding stop.
 
\end_layout

\begin_layout Standard
arange(2.0, 3.0, .1) makes the array([ 2.
 , 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9])
\end_layout

\begin_layout Subsubsection
linspace(start, stop, number of elements)
\end_layout

\begin_layout Standard
Similar to arange().
 Start, stop and number of samples are the arguments.
 
\end_layout

\begin_layout Standard
linspace(1, 2, 11) is equivalent to array([ 1.
 , 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.
 ])
\end_layout

\begin_layout Subsubsection
zeros(shape, datatype) 
\end_layout

\begin_layout Standard
Returns a new array of given shape and type, filled zeros.
 The arguments are shape and datatype.
 For example
\emph on
\color black
 zeros( [3,2], 'float')
\emph default
\color inherit
 generates a 3 x 2 array filled with zeros as shown below.
 If not specified, the type of elements defaults to int.
\end_layout

\begin_layout Standard
\begin_inset Formula $\begin{array}{ccc}
0.0 & 0.0 & 0.0\\
0.0 & 0.0 & 0.0\end{array}$
\end_inset


\end_layout

\begin_layout Subsubsection
ones(shape, datatype)
\end_layout

\begin_layout Standard
Similar to zeros() except that the values are initialized to 1.
\end_layout

\begin_layout Subsubsection
random.random(shape)
\end_layout

\begin_layout Standard
Similar to the functions above, but the matrix is filled with random numbers
 ranging from 0 to 1, of 
\emph on
\color black
float
\emph default
\color inherit
 type.
 For example, random.random([3,3]) will generate the 3x3 matrix;
\end_layout

\begin_layout LyX-Code
array([[ 0.3759652 , 0.58443562, 0.41632997],
\end_layout

\begin_layout LyX-Code
       [ 0.88497654, 0.79518478, 0.60402514],
\end_layout

\begin_layout LyX-Code
       [ 0.65468458, 0.05818105, 0.55621826]])
\end_layout

\begin_layout Subsubsection
reshape(array, newshape)
\end_layout

\begin_layout Standard
We can also make multi-dimensions arrays by reshaping a one-dimensional
 array.
 The function 
\shape italic
reshape()
\shape default
 changes dimensions of an array.
 The total number of elements must be preserved.
 Working of 
\shape italic
reshape()
\shape default
 can be understood by looking at 
\emph on
\color black
reshape.py
\emph default
\color inherit
 and its result.
\end_layout

\begin_layout Standard
\align left

\emph on
Example reshape.py
\end_layout

\begin_layout LyX-Code
from numpy import *
\end_layout

\begin_layout LyX-Code
a = arange(20)
\end_layout

\begin_layout LyX-Code
b = reshape(a, [4,5])
\end_layout

\begin_layout LyX-Code
print b
\end_layout

\begin_layout Standard
The result is shown below.
\end_layout

\begin_layout LyX-Code
array([[ 0,  1,  2,  3,  4],
\end_layout

\begin_layout LyX-Code
       [ 5,  6,  7,  8,  9],
\end_layout

\begin_layout LyX-Code
       [10, 11, 12, 13, 14],
\end_layout

\begin_layout LyX-Code
       [15, 16, 17, 18, 19]])
\end_layout

\begin_layout Standard
The program 
\shape italic
numpy2.py
\shape default
 demonstrates most of the functions discussed so far.
\end_layout

\begin_layout Standard
\align left

\emph on
Example numpy2.py
\end_layout

\begin_layout LyX-Code
from numpy import *
\end_layout

\begin_layout LyX-Code
a = arange(1.0, 2.0, 0.1)
\end_layout

\begin_layout LyX-Code
print a
\end_layout

\begin_layout LyX-Code
b = linspace(1,2,11) 
\end_layout

\begin_layout LyX-Code
print b
\end_layout

\begin_layout LyX-Code
c = ones(5,'float')         
\end_layout

\begin_layout LyX-Code
print c
\end_layout

\begin_layout LyX-Code
d = zeros(5, 'int')
\end_layout

\begin_layout LyX-Code
print d
\end_layout

\begin_layout LyX-Code
e = random.rand(5)
\end_layout

\begin_layout LyX-Code
print e
\end_layout

\begin_layout Standard
Output of this program will look like;
\end_layout

\begin_layout Standard
[ 1.
 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9]
\end_layout

\begin_layout Standard
[ 1.
 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 2.
 ]
\end_layout

\begin_layout Standard
[ 1.
 1.
 1.
 1.
 1.]
\end_layout

\begin_layout Standard
[ 0.
 0.
 0.
 0.
 0.]
\end_layout

\begin_layout Standard
[ 0.89039193 0.55640332 0.38962117 0.17238343 0.01297415]
\end_layout

\begin_layout Subsection
Copying
\end_layout

\begin_layout Standard
Numpy arrays can be copied using the copy method, as shown below.
\end_layout

\begin_layout Standard
\align left

\emph on
Example array_copy.py
\end_layout

\begin_layout LyX-Code
from mumpy import *
\end_layout

\begin_layout LyX-Code
a = zeros(5)
\end_layout

\begin_layout LyX-Code
print a
\end_layout

\begin_layout LyX-Code
b = a
\end_layout

\begin_layout LyX-Code
c = a.copy()
\end_layout

\begin_layout LyX-Code
c[0] = 10
\end_layout

\begin_layout LyX-Code
print a, c
\end_layout

\begin_layout LyX-Code
b[0] = 10
\end_layout

\begin_layout LyX-Code
print a,c
\end_layout

\begin_layout Standard
The output of the program is shown below.
 The statement 
\begin_inset Formula $b=a$
\end_inset

 does not make a copy of a.
 Modifying b affects a, but c is a separate entity.
\end_layout

\begin_layout Standard
[ 0.
 0.
 0.]
\end_layout

\begin_layout Standard
[ 0.
 0.
 0.] [ 10.
 0.
 0.]
\end_layout

\begin_layout Standard
[ 10.
 0.
 0.] [ 10.
 0.
 0.] 
\end_layout

\begin_layout Subsection
Arithmetic Operations
\end_layout

\begin_layout Standard
Arithmetic operations performed on an array is carried out on all individual
 elements.
 Adding or multiplying an array object with a number will multiply all the
 elements by that number.
 However, adding or multiplying two arrays having identical shapes will
 result in performing that operation with the corresponding elements.
 To clarify the idea, have a look at 
\emph on
\color black
aroper.py
\emph default
\color inherit
 and its results.
\end_layout

\begin_layout Standard
\align left

\emph on
Example aroper.py
\end_layout

\begin_layout LyX-Code
from numpy import *
\end_layout

\begin_layout LyX-Code
a = array([[2,3], [4,5]])
\end_layout

\begin_layout LyX-Code
b = array([[1,2], [3,0]])
\end_layout

\begin_layout LyX-Code
print a + b
\end_layout

\begin_layout LyX-Code
print a * b
\end_layout

\begin_layout Standard
The output will be as shown below
\end_layout

\begin_layout LyX-Code
array([[3, 5],
\end_layout

\begin_layout LyX-Code
       [7, 5]])
\end_layout

\begin_layout LyX-Code
array([[ 2, 6],
\end_layout

\begin_layout LyX-Code
       [12, 0]])
\end_layout

\begin_layout Standard
Modifying this program for more operations is left as an exercise to the
 reader.
\end_layout

\begin_layout Subsection
cross product
\end_layout

\begin_layout Standard
Returns the cross product of two vectors, defined by
\end_layout

\begin_layout Standard
\begin_inset Formula \begin{equation}
A\times B=\left|\begin{array}{clc}
i & j & k\\
A_{1} & A_{2} & A_{3}\\
B_{1} & B_{2} & B_{3}\end{array}\right|=i(A_{2}B_{3}-A_{3}B_{2})+j(A_{1}B_{3}-A_{3}B_{1})+k(A_{1}B_{2}-A_{2}B_{1})\label{eq:cross product}\end{equation}

\end_inset


\end_layout

\begin_layout Standard
It can be evaluated using the function cross((array1, array2).
 The program 
\shape italic
cross.py
\shape default
 prints [-3, 6, -3]
\end_layout

\begin_layout Standard
\align left

\emph on
Example cross.py
\end_layout

\begin_layout LyX-Code
from numpy import *
\end_layout

\begin_layout LyX-Code
a = array([1,2,3])
\end_layout

\begin_layout LyX-Code
b = array([4,5,6])
\end_layout

\begin_layout LyX-Code
c = cross(a,b)
\end_layout

\begin_layout LyX-Code
print c
\end_layout

\begin_layout Subsection
dot product
\end_layout

\begin_layout Standard
Returns the dot product of two vectors defined by 
\begin_inset Formula $A.B=A_{1}B_{1}+A_{2}B_{2}+A_{3}B_{3}$
\end_inset

 .
 If you change the fourth line of 
\emph on
\color black
cross.py
\emph default
\color inherit
 to 
\begin_inset Formula $c=dot(a,b)$
\end_inset

, the result will be 32.
\end_layout

\begin_layout Subsection
Saving and Restoring
\end_layout

\begin_layout Standard
An array can be saved to text file using 
\shape italic
array.tofile(filename)
\shape default
 and it can be read back using 
\shape italic
array=fromfile()
\shape default
 methods, as shown by the code fileio.py
\end_layout

\begin_layout Standard
\align left

\emph on
Example fileio.py
\end_layout

\begin_layout LyX-Code
from numpy import *
\end_layout

\begin_layout LyX-Code
a = arange(10)
\end_layout

\begin_layout LyX-Code
a.tofile('myfile.dat')
\end_layout

\begin_layout LyX-Code
b = fromfile('myfile.dat',dtype = 'int')
\end_layout

\begin_layout LyX-Code
print b
\end_layout

\begin_layout Standard
The function fromfile() sets dtype='float' by default.
 In this case we have saved an integer array and need to specify that while
 reading the file.
 We could have saved it as float the the statement a.tofile('myfile.dat',
 'float').
\end_layout

\begin_layout Subsection
Matrix inversion
\end_layout

\begin_layout Standard
The function 
\shape italic
linalg.inv(matrix)
\shape default
 computes the inverse of a square matrix, if it exists.
 We can verify the result by multiplying the original matrix with the inverse.
 Giving a singular matrix as the argument should normally result in an error
 message.
 In some cases, you may get a result whose elements are having very high
 values, and it indicates an error.
\end_layout

\begin_layout Standard
\align left

\emph on
Example inv.py
\end_layout

\begin_layout LyX-Code
from numpy import *
\end_layout

\begin_layout LyX-Code
a = array([ [4,1,-2], [2,-3,3], [-6,-2,1] ], dtype='float')
\end_layout

\begin_layout LyX-Code
ainv = linalg.inv(a)
\end_layout

\begin_layout LyX-Code
print ainv
\end_layout

\begin_layout LyX-Code
print dot(a,ainv)
\end_layout

\begin_layout Standard
Result of this program is printed below.
\end_layout

\begin_layout LyX-Code
[[ 0.08333333  0.08333333 -0.08333333]
\end_layout

\begin_layout LyX-Code
 [-0.55555556 -0.22222222 -0.44444444]
\end_layout

\begin_layout LyX-Code
 [-0.61111111  0.05555556 -0.38888889]]
\end_layout

\begin_layout LyX-Code
[[ 1.00000000e+00 -1.38777878e-17 0.00000000e+00]
\end_layout

\begin_layout LyX-Code
 [-1.11022302e-16  1.00000000e+00 0.00000000e+00]
\end_layout

\begin_layout LyX-Code
 [ 0.00000000e+00  2.08166817e-17 1.00000000e+00]]
\end_layout

\begin_layout Section
Vectorized Functions
\end_layout

\begin_layout Standard
The functions like sine, log etc.
 from NumPy are capable of accepting arrays as arguments.
 This eliminates the need of writing loops in our Python code.
 
\end_layout

\begin_layout Standard
\align left

\emph on
Example vfunc.py
\end_layout

\begin_layout LyX-Code
from numpy import *
\end_layout

\begin_layout LyX-Code
a = array([1,10,100,1000])
\end_layout

\begin_layout LyX-Code
print log10(a)
\end_layout

\begin_layout Standard
The output of the program is [ 0.
 1.
 2.
 3.] , where the log of each element is calculated and returned in an array.
 This feature simplifies the programs a lot.
 Numpy also provides a function to vectorize functions written by the user.
 
\end_layout

\begin_layout Standard
\align left

\emph on
Example vectorize.py
\end_layout

\begin_layout LyX-Code
from numpy import *
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
def spf(x):
\end_layout

\begin_layout LyX-Code
    return 3*x 
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
vspf = vectorize(spf)
\end_layout

\begin_layout LyX-Code
a = array([1,2,3,4])
\end_layout

\begin_layout LyX-Code
print vspf(a)
\end_layout

\begin_layout Standard
The output will be [ 3 6 9 12] .
\end_layout

\begin_layout Section
Exercises
\end_layout

\begin_layout Enumerate
Write code to make a one dimensional matrix with elements 5,10,15,20 and
 25.
 make another matrix by slicing the first three elements from it.
\end_layout

\begin_layout Enumerate
Create a 
\begin_inset Formula $3\times2$
\end_inset

 matrix and print the sum of its elements using for loops.
\end_layout

\begin_layout Enumerate
Create a 
\begin_inset Formula $2\times3$
\end_inset

 matrix and fill it with random numbers.
\end_layout

\begin_layout Enumerate
Use linspace to make an array from 0 to 10, with stepsize of 0.1
\end_layout

\begin_layout Enumerate
Use arange to make an 100 element array ranging from 0 to 10
\end_layout

\begin_layout Enumerate
Make an array a = [2,3,4,5] and copy it to 
\shape italic
b
\shape default
.
 change one element of 
\shape italic
b
\shape default
 and print both.
\end_layout

\begin_layout Enumerate
Make a 3x3 matrix and multipy it by 5.
\end_layout

\begin_layout Enumerate
Create two 3x3 matrices and add them.
\end_layout

\begin_layout Enumerate
Write programs to demonstrate the dot and cross products.
\end_layout

\begin_layout Enumerate
Using matrix inversion, solve the system of equations
\newline
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
4x1 − 2x2 + \InsetSpace ~
\InsetSpace ~
x3 = 11
\newline
−2x1
 + 4x2 − 2x3 = −16 
\newline
 \InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
x1 − 2x2 + 4x3 = 17 
\end_layout

\begin_layout Enumerate
Find the new values of the coordinate (10,10) under a rotation by angle
 
\begin_inset Formula $\pi/4$
\end_inset

.
\end_layout

\begin_layout Enumerate
Write a vectorized function to evaluate 
\begin_inset Formula $y=x^{2}$
\end_inset

 and print the result for x=[1,2,3].
\end_layout

\begin_layout Chapter
Data visualization
\end_layout

\begin_layout Standard
A graph or chart is used to present numerical data in visual form.
 A graph is one of the easiest ways to compare numbers.
 They should be used to make facts clearer and more understandable.
 Results of mathematical computations are often presented in graphical format.
 In this chapter, we will explore the Python modules used for generating
 two and three dimensional graphs of various types.
\end_layout

\begin_layout Section
The Matplotlib Module
\end_layout

\begin_layout Standard
Matplotlib is a python package that produces publication quality figures
 in a variety of hardcopy formats.
 It also provides many functions for matrix manipulation.
 You can generate plots, histograms, power spectra, bar charts, error-charts,
 scatter-plots, etc, with just a few lines of code and have full control
 of line styles, font properties, axes properties, etc.
 The data points to the plotting functions are supplied as Python lists
 or Numpy arrays.
\end_layout

\begin_layout Standard
If you import matplotlib as 
\emph on
\color black
pylab,
\emph default
\color inherit
 the plotting functions from the submodules
\emph on
\color black
 pyplot
\emph default
\color inherit
 and matrix manipulation functions from the submodule 
\emph on
\color black
mlab
\emph default
\color inherit
 will be available as local functions.
 Pylab also imports Numpy for you.
 Let us start with some simple plots to become familiar with matplotlib.
\begin_inset Foot
status collapsed

\begin_layout Standard
http://matplotlib.sourceforge.net/
\end_layout

\begin_layout Standard
http://matplotlib.sourceforge.net/users/pyplot_tutorial.html
\end_layout

\begin_layout Standard
http://matplotlib.sourceforge.net/examples/index.html
\end_layout

\begin_layout Standard
http://matplotlib.sourceforge.net/api/axes_api.html
\end_layout

\end_inset


\end_layout

\begin_layout Standard
\align left

\emph on
Example plot1.py
\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
data = [1,2,5]
\end_layout

\begin_layout LyX-Code
plot(data)
\end_layout

\begin_layout LyX-Code
show()
\end_layout

\begin_layout Standard
In the above example, the x-axis of the three points is taken from 0 to
 2.
 We can specify both the axes as shown below.
\end_layout

\begin_layout Standard
\align left

\emph on
Example plot2.py
\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
x = [1,2,5]
\end_layout

\begin_layout LyX-Code
y = [4,5,6]
\end_layout

\begin_layout LyX-Code
plot(x,y)
\end_layout

\begin_layout LyX-Code
show()
\end_layout

\begin_layout Standard
By default, the color is blue and the line style is continuous.
 This can be changed by an optional argument after the coordinate data,
 which is the format string that indicates the color and line type of the
 plot.
 The default format string is ‘b-‘ (blue, continuous line).
 Let us rewrite the above example to plot using red circles.
 We will also set the ranges for x and y axes and label them.
\end_layout

\begin_layout Standard
\align left

\emph on
Example plot3.py
\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
x = [1,2,5]
\end_layout

\begin_layout LyX-Code
y = [4,5,6]
\end_layout

\begin_layout LyX-Code
plot(x,y,'ro')
\end_layout

\begin_layout LyX-Code
xlabel('x-axis')
\end_layout

\begin_layout LyX-Code
ylabel('y-axis')
\end_layout

\begin_layout LyX-Code
axis([0,6,1,7])
\end_layout

\begin_layout LyX-Code
show()
\end_layout

\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/plot4.png
	lyxscale 40
	width 4cm

\end_inset


\begin_inset Graphics
	filename pics/subplot1.png
	lyxscale 40
	width 4cm

\end_inset


\begin_inset Graphics
	filename pics/piechart.png
	lyxscale 40
	width 4cm

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Caption

\begin_layout Standard
Output of (a) plot4.py (b) subplot1.py (c) piechart.py
\begin_inset LatexCommand label
name "fig:Output-of-plot4.py"

\end_inset


\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
The figure 
\begin_inset LatexCommand ref
reference "fig:Output-of-plot4.py"

\end_inset

 shows two different plots in the same window, using different markers and
 colors.
 
\end_layout

\begin_layout Standard
\align left

\emph on
Example plot4.py
\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
t = arange(0.0, 5.0, 0.2)
\end_layout

\begin_layout LyX-Code
plot(t, t**2,'x')      # 
\begin_inset Formula $t^{2}$
\end_inset


\end_layout

\begin_layout LyX-Code
plot(t, t**3,'ro')     # 
\begin_inset Formula $t^{3}$
\end_inset


\end_layout

\begin_layout LyX-Code
show()
\end_layout

\begin_layout Standard
We have just learned how to draw a simple plot using the pylab interface
 of matplotlib.
\end_layout

\begin_layout Subsection
Multiple plots
\end_layout

\begin_layout Standard
Matplotlib allows you to have multiple plots in the same window, using the
 subplot() command as shown in the example subplot1.py, whose output is shown
 in figure 
\begin_inset LatexCommand ref
reference "fig:Output-of-plot4.py"

\end_inset

(b).
\end_layout

\begin_layout Standard
\align left

\emph on
Example subplot1.py
\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
subplot(2,1,1)             # the first subplot
\end_layout

\begin_layout LyX-Code
plot([1,2,3,4])
\end_layout

\begin_layout LyX-Code
subplot(2,1,2)             # the second subplot
\end_layout

\begin_layout LyX-Code
plot([4,2,3,1])
\end_layout

\begin_layout LyX-Code
show()
\end_layout

\begin_layout Standard
The arguments to subplot function are NR (number of rows) , NC (number of
 columns) and a figure number, that ranges from 1 to 
\begin_inset Formula $NR*NC$
\end_inset

.
 The commas between the arguments are optional if 
\begin_inset Formula $NR*NC<10$
\end_inset

, ie.
 subplot(2,1,1) can be written as subplot(211).
 
\end_layout

\begin_layout Standard
Another example of subplot is given is 
\shape italic
subplot2.py
\shape default
.
 You can modify the variable NR and NC to watch the results.
 Please note that the % character has different meanings.
 In 
\shape italic
(pn+1)%5
\shape default
, it is the reminder operator resulting in a number less than 5.
 The % character also appears in the String formatting.
 
\end_layout

\begin_layout Standard
\align left

\emph on
Example subplot2.py
\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
mark = ['x','o','^','+','>']
\end_layout

\begin_layout LyX-Code
NR = 2  # number of rows 
\end_layout

\begin_layout LyX-Code
NC = 3  # number of columns 
\end_layout

\begin_layout LyX-Code
pn = 1 
\end_layout

\begin_layout LyX-Code
for row in range(NR):
\end_layout

\begin_layout LyX-Code
   for col in range(NC):  
\end_layout

\begin_layout LyX-Code
      subplot(NR, NC, pn)
\end_layout

\begin_layout LyX-Code
      a = rand(10) * pn
\end_layout

\begin_layout LyX-Code
      plot(a, marker = mark[(pn+1)%5])
\end_layout

\begin_layout LyX-Code
      xlabel('plot %d X'%pn)
\end_layout

\begin_layout LyX-Code
      ylabel('plot %d Y'%pn)
\end_layout

\begin_layout LyX-Code
      pn = pn + 1
\end_layout

\begin_layout LyX-Code
show()
\end_layout

\begin_layout Subsection
Polar plots 
\end_layout

\begin_layout Standard
Polar coordinates locate a point on a plane with one distance and one angle.
 The distance ‘r’ is measured from the origin.
 The angle 
\begin_inset Formula $\theta$
\end_inset

 is measured from some agreed starting point.
 Use the positive part of the 
\begin_inset Formula $x-axis$
\end_inset

 as the starting point for measuring angles.
 Measure positive angles anti-clockwise from the positive 
\begin_inset Formula $x-axis$
\end_inset

 and negative angles clockwise from it.
\end_layout

\begin_layout Standard
Matplotlib supports polar plots, using the polar(
\begin_inset Formula $\theta,r$
\end_inset

) function.
 Let us plot a circle using polar().
 For every point on the circle, the value of 
\begin_inset Formula $radius$
\end_inset

 is the same but the polar angle 
\begin_inset Formula $\theta$
\end_inset

 changes from 
\begin_inset Formula $0$
\end_inset

to 
\begin_inset Formula $2\pi$
\end_inset

.
 Both the coordinate arguments must be arrays of equal size.
 Since 
\begin_inset Formula $\theta$
\end_inset

 is having 100 points , 
\begin_inset Formula $r$
\end_inset

 also must have the same number.
 This array can be generated using the 
\begin_inset Formula $ones()$
\end_inset

 function.
 The axis([
\begin_inset Formula $\theta_{min},\theta_{max},r_{min},r_{max}$
\end_inset

) function can be used for setting the scale.
\end_layout

\begin_layout Standard
\align left

\emph on
Example polar.py
\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
th = linspace(0,2*pi,100)
\end_layout

\begin_layout LyX-Code
r = 5 * ones(100)  # radius = 5
\end_layout

\begin_layout LyX-Code
polar(th,r)
\end_layout

\begin_layout LyX-Code
show()
\end_layout

\begin_layout Subsection
Pie Charts
\end_layout

\begin_layout Standard
An example of a pie chart is given below.
 The percentage of different items and their names are given as arguments.
 The output is shown in figure 
\begin_inset LatexCommand ref
reference "fig:Output-of-plot4.py"

\end_inset

(c).
\end_layout

\begin_layout Standard
\align left

\emph on
Example piechart.py
\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
labels = 'Frogs', 'Hogs', 'Dogs', 'Logs' 
\end_layout

\begin_layout LyX-Code
fracs = [25, 25, 30, 20] 
\end_layout

\begin_layout LyX-Code
pie(fracs, labels=labels) 
\end_layout

\begin_layout LyX-Code
show() 
\end_layout

\begin_layout Section
Plotting mathematical functions
\end_layout

\begin_layout Standard
One of our objectives is to understand different mathematical functions
 better, by plotting them graphically.
 We will use the 
\shape italic
arange
\shape default
, 
\shape italic
linspace
\shape default
 and 
\shape italic
logspace
\shape default
 functions from 
\shape italic
numpy
\shape default
 to generate the input data and also the vectorized versions of the mathematical
 functions.
 For arange(), the third argument is the stepsize.
 The total number of elements is calculated from start, stop and stepsize.
 In the case of linspace(), we provide start, stop and the total number
 of points.
 The step size is calculated from these three parameters.
 Please note that to create a data set ranging from 0 to 1 (including both)
 with a stepsize of 0.1, we need to specify linspace(0,1,11) and not linspace(0,1
,10).
 
\end_layout

\begin_layout Subsection
Sine function and friends
\end_layout

\begin_layout Standard
Let the first example be the familiar sine function.
 The input data is from 
\begin_inset Formula $-\pi$
\end_inset

 to 
\begin_inset Formula $+\pi$
\end_inset

 radians
\begin_inset Foot
status collapsed

\begin_layout Standard
Why do we need to give the angles in radians and not in degrees.
 Angle in radian is the length of the arc defined by the given angle, with
 unit radius.
 Degree is just an arbitrary unit.
\end_layout

\end_inset

.
 To make it a bit more interesting we are plotting 
\begin_inset Formula $\sin x^{2}$
\end_inset

 also.
 The objective is to explain the concept of odd and even functions.
 Mathematically, we say that a function 
\begin_inset Formula $f(x)$
\end_inset

 is even if 
\begin_inset Formula $f(x)=f(-x)$
\end_inset

 and is odd if 
\begin_inset Formula $f(-x)=-f(x)$
\end_inset

.
 Even functions are functions for which the left half of the plane looks
 like the mirror image of the right half of the plane.
 From the figure 
\begin_inset LatexCommand ref
reference "fig:Sine and Circ"

\end_inset

(a) you can see that 
\begin_inset Formula $\sin x$
\end_inset

 is odd and 
\begin_inset Formula $\sin x^{2}$
\end_inset

 is even.
 
\end_layout

\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/npsin.png
	lyxscale 50
	width 6cm

\end_inset


\begin_inset Graphics
	filename pics/circ.png
	lyxscale 50
	width 6cm

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Caption

\begin_layout Standard
(a) Output of npsin.py (b) Output of circ.py 
\begin_inset LatexCommand label
name "fig:Sine and Circ"

\end_inset

.
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\align left

\emph on
Example npsin.py
\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
x = linspace(-pi, pi , 200)
\end_layout

\begin_layout LyX-Code
y = sin(x)
\end_layout

\begin_layout LyX-Code
y1 = sin(x*x)
\end_layout

\begin_layout LyX-Code
plot(x,y)
\end_layout

\begin_layout LyX-Code
plot(x,y1,'r')    
\end_layout

\begin_layout LyX-Code
show()
\end_layout

\begin_layout Standard
Exercise: Modify the program 
\emph on
\color black
npsin.py
\emph default
\color inherit
 to plot 
\begin_inset Formula $\sin^{2}x$
\end_inset

 , 
\begin_inset Formula $\cos x$
\end_inset

, 
\begin_inset Formula $\sin x^{3}$
\end_inset

 etc.
\end_layout

\begin_layout Subsection
Trouble with Circle 
\end_layout

\begin_layout Standard
Equation of a circle is 
\begin_inset Formula $x^{2}+y^{2}=a^{2}$
\end_inset

 , where a is the radius and the circle is located at the origin of the
 coordinate system.
 In order to plot it using Cartesian coordinates, we need to express 
\begin_inset Formula $y$
\end_inset

 in terms of 
\begin_inset Formula $x$
\end_inset

, and is given by 
\begin_inset Formula \[
y=\sqrt{a^{2}-x^{2}}\]

\end_inset


\end_layout

\begin_layout Standard
We will create the x-coordinates ranging from 
\begin_inset Formula $-a$
\end_inset

 to 
\begin_inset Formula $+a$
\end_inset

 and calculate the corresponding values of y.
 This will give us only half of the circle, since for each value of x, there
 are two values of y (+y and -y).
 The following program 
\emph on
\color black
circ.py
\emph default
\color inherit
 creates both to make the complete circle as shown in figure 
\begin_inset LatexCommand ref
reference "fig:Sine and Circ"

\end_inset

(b).
 Any multi-valued function will have this problem while plotting.
 Such functions can be plotted better using parametric equations or using
 the polar plot options, as explained in the coming sections.
 
\end_layout

\begin_layout Standard
\align left

\emph on
Example circ.py
\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
a = 10.0
\end_layout

\begin_layout LyX-Code
x = linspace(-a, a , 200)
\end_layout

\begin_layout LyX-Code
yupper = sqrt(a**2 - x**2)
\end_layout

\begin_layout LyX-Code
ylower = -sqrt(a**2 - x**2)
\end_layout

\begin_layout LyX-Code
plot(x,yupper)
\end_layout

\begin_layout LyX-Code
plot(x,ylower)
\end_layout

\begin_layout LyX-Code
show()
\end_layout

\begin_layout Subsection
Parametric plots
\end_layout

\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status open

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/circpar.png
	lyxscale 50
	width 6cm

\end_inset

 
\begin_inset Graphics
	filename pics/arcs.png
	lyxscale 50
	width 6cm

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Caption

\begin_layout Standard
(a)Output of circpar.py.
 (b)Output of arcs.py
\begin_inset LatexCommand label
name "fig:(a)Circpar and Arc"

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard

\end_layout

\end_inset


\end_layout

\begin_layout Standard
The circle can be represented using the equations 
\begin_inset Formula $x=a\cos\theta$
\end_inset

 and 
\begin_inset Formula $y=a\sin\theta$
\end_inset

 .
 To get the complete circle 
\begin_inset Formula $\theta$
\end_inset

 should vary from zero to 
\begin_inset Formula $2\pi$
\end_inset

 radians.
 The output of circpar.py is shown in figure 
\begin_inset LatexCommand ref
reference "fig:(a)Circpar and Arc"

\end_inset

(a).
\end_layout

\begin_layout Standard
\align left

\emph on
Example circpar.py
\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
a = 10.0
\end_layout

\begin_layout LyX-Code
th = linspace(0, 2*pi, 200)
\end_layout

\begin_layout LyX-Code
x = a * cos(th)
\end_layout

\begin_layout LyX-Code
y = a * sin(th)
\end_layout

\begin_layout LyX-Code
plot(x,y)
\end_layout

\begin_layout LyX-Code
show()
\end_layout

\begin_layout Standard
Changing the range of 
\begin_inset Formula $\theta$
\end_inset

 to less than 
\begin_inset Formula $2\pi$
\end_inset

 radians will result in an arc.
 The following example plots several arcs with different radii.
 The 
\emph on
\color black
for
\emph default
\color inherit
 loop will execute four times with the values of radius 5,10,15 and 20.
 The range of 
\begin_inset Formula $\theta$
\end_inset

 also depends on the loop variable.
 For the next three values it will be 
\begin_inset Formula $\pi,1.5\pi and2\pi$
\end_inset

 respectively.
 The output is shown in figure 
\begin_inset LatexCommand ref
reference "fig:(a)Circpar and Arc"

\end_inset

(b).
 
\end_layout

\begin_layout Standard
\align left

\emph on
Example arcs.py
\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
a = 10.0
\end_layout

\begin_layout LyX-Code
for a in range(5,21,5):
\end_layout

\begin_layout LyX-Code
    th = linspace(0, pi * a/10, 200)
\end_layout

\begin_layout LyX-Code
    x = a * cos(th)
\end_layout

\begin_layout LyX-Code
    y = a * sin(th)
\end_layout

\begin_layout LyX-Code
    plot(x,y)
\end_layout

\begin_layout LyX-Code
show()
\end_layout

\begin_layout Section
Famous Curves
\end_layout

\begin_layout Standard
Connection between different branches of mathematics like trigonometry,
 algebra and geometry can be understood by geometrically representing the
 equations.
 You will find a large number of equations generating geometric patterns
 having interesting symmetries.
 A collection of them is available on the Internet 
\begin_inset LatexCommand cite
key "wikipedia"

\end_inset


\begin_inset LatexCommand cite
key "gap-system"

\end_inset

.
 We will select some of them and plot here.
 Exploring them further is left as an exercise to the reader.
\end_layout

\begin_layout Subsection
Astroid
\end_layout

\begin_layout Standard
The astroid was first discussed by Johann Bernoulli in 1691-92.
 It also appears in Leibniz's correspondence of 1715.
 It is sometimes called the tetracuspid for the obvious reason that it has
 four cusps.
 A circle of radius 1/4 rolls around inside a circle of radius 1 and a point
 on its circumference traces an astroid.
 The Cartesian equation is
\begin_inset Formula \begin{equation}
x^{\frac{2}{3}}+y^{\frac{2}{3}}=a^{\frac{2}{3}}\label{eq:Astroid-cart}\end{equation}

\end_inset


\end_layout

\begin_layout Standard
The parametric equations are
\end_layout

\begin_layout Standard
\begin_inset Formula \begin{equation}
x=a\cos^{3}(t),y=a\sin^{3}(t)\label{eq:Astroid-Par}\end{equation}

\end_inset


\end_layout

\begin_layout Standard
In order to plot the curve in the Cartesian system, we rewrite equation
 
\begin_inset LatexCommand ref
reference "eq:Astroid-cart"

\end_inset

 as 
\end_layout

\begin_layout Standard
\begin_inset Formula \[
y=(a^{\frac{2}{3}}-x^{\frac{2}{3}})^{\frac{3}{2}}\]

\end_inset


\end_layout

\begin_layout Standard
The program 
\emph on
\color black
astro.py
\emph default
\color inherit
 plots the part of the curve in the first quadrant.
 The program 
\emph on
\color black
astropar.py
\emph default
\color inherit
 uses the parametric equation and plots the complete curve.
 Both are shown in figure 
\begin_inset LatexCommand ref
reference "fig:(a)Astro.py"

\end_inset


\end_layout

\begin_layout Standard
\align left

\emph on
Example astro.py
\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
a = 2
\end_layout

\begin_layout LyX-Code
x = linspace(0,a,100)
\end_layout

\begin_layout LyX-Code
y = ( a**(2.0/3) - x**(2.0/3) )**(3.0/2)
\end_layout

\begin_layout LyX-Code
plot(x,y)
\end_layout

\begin_layout LyX-Code
show()
\end_layout

\begin_layout Standard
\align left

\emph on
Example astropar.py
\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
a = 2
\end_layout

\begin_layout LyX-Code
t = linspace(-2*a,2*a,101)
\end_layout

\begin_layout LyX-Code
x = a * cos(t)**3
\end_layout

\begin_layout LyX-Code
y = a * sin(t)**3
\end_layout

\begin_layout LyX-Code
plot(x,y)
\end_layout

\begin_layout LyX-Code
show()
\end_layout

\begin_layout Subsection
Ellipse
\end_layout

\begin_layout Standard
The ellipse was first studied by Menaechmus 
\begin_inset LatexCommand cite
key "ellipse"

\end_inset

 .
 Euclid wrote about the ellipse and it was given its present name by Apollonius.
 The focus and directrix of an ellipse were considered by Pappus.
 Kepler, in 1602, said he believed that the orbit of Mars was oval, then
 he later discovered that it was an ellipse with the sun at one focus.
 In fact Kepler introduced the word 
\emph on
\color black
focus
\emph default
\color inherit
 and published his discovery in 1609.
\end_layout

\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/astro.png
	lyxscale 30
	width 4cm

\end_inset

 
\begin_inset Graphics
	filename pics/astropar.png
	lyxscale 40
	width 4cm

\end_inset


\begin_inset Graphics
	filename pics/lissa.png
	lyxscale 40
	width 4cm

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Caption

\begin_layout Standard
(a)Output of astro.py (b) astropar.py (c) lissa.py
\begin_inset LatexCommand label
name "fig:(a)Astro.py"

\end_inset


\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
The Cartesian equation is
\begin_inset Formula \begin{equation}
\frac{x^{2}}{a^{2}}+\frac{y^{2}}{b^{2}}=1\label{eq:Ellipse-cart}\end{equation}

\end_inset


\end_layout

\begin_layout Standard
The parametric equations are
\end_layout

\begin_layout Standard
\begin_inset Formula \begin{equation}
x=a\cos(t),y=b\sin(t)\label{eq:Ellipse-Par}\end{equation}

\end_inset


\end_layout

\begin_layout Standard
The program 
\emph on
\color black
ellipse.py
\emph default
\color inherit
 uses the parametric equation to plot the curve.
 Modifying the parametric equations will result in Lissajous figures.
 The output of lissa.py are shown in figure 
\begin_inset LatexCommand ref
reference "fig:(a)Astro.py"

\end_inset

(c).
\end_layout

\begin_layout Standard
\align left

\emph on
Example ellipse.py
\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
a = 2
\end_layout

\begin_layout LyX-Code
b = 3
\end_layout

\begin_layout LyX-Code
t = linspace(0, 2 * pi, 100)
\end_layout

\begin_layout LyX-Code
x = a * sin(t)       
\end_layout

\begin_layout LyX-Code
y = b * cos(t)
\end_layout

\begin_layout LyX-Code
plot(x,y)
\end_layout

\begin_layout LyX-Code
show()
\end_layout

\begin_layout Standard
\align left

\emph on
Example lissa.py
\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
a = 2
\end_layout

\begin_layout LyX-Code
b = 3
\end_layout

\begin_layout LyX-Code
t= linspace(0, 2*pi,100)
\end_layout

\begin_layout LyX-Code
x = a * sin(2*t)       
\end_layout

\begin_layout LyX-Code
y = b * cos(t)
\end_layout

\begin_layout LyX-Code
plot(x,y)
\end_layout

\begin_layout LyX-Code
x = a * sin(3*t)
\end_layout

\begin_layout LyX-Code
y = b * cos(2*t)
\end_layout

\begin_layout LyX-Code
plot(x,y)
\end_layout

\begin_layout LyX-Code
show()
\end_layout

\begin_layout Standard
The Lissajous curves are closed if the ratio of the arguments for sine and
 cosine functions is an integer.
 Otherwise open curves will result, both are shown in figure 
\begin_inset LatexCommand ref
reference "fig:(a)Astro.py"

\end_inset

(c).
 
\end_layout

\begin_layout Subsection
Spirals of Archimedes and Fermat
\end_layout

\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/archi.png
	lyxscale 50
	width 6cm

\end_inset


\begin_inset Graphics
	filename pics/fermat.png
	lyxscale 50
	width 6cm

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Caption

\begin_layout Standard
(a)Archimedes Spiral (b)Fermat's Spiral (c)Polar Rose
\begin_inset LatexCommand label
name "fig:(a)Archimedes-Fermat"

\end_inset


\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
The spiral of Archimedes is represented by the equation 
\begin_inset Formula $r=a\theta$
\end_inset

.
 Fermat's Spiral is given by 
\begin_inset Formula $r^{2}=a^{2}\theta$
\end_inset

.
 The output of archi.py and fermat.py are shown in figure 
\begin_inset LatexCommand ref
reference "fig:(a)Archimedes-Fermat"

\end_inset

.
\end_layout

\begin_layout Standard
\align left

\emph on
Example archi.py
\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
a = 2
\end_layout

\begin_layout LyX-Code
th= linspace(0, 10*pi,200)
\end_layout

\begin_layout LyX-Code
r = a*th
\end_layout

\begin_layout LyX-Code
polar(th,r)
\end_layout

\begin_layout LyX-Code
axis([0, 2*pi, 0, 70])
\end_layout

\begin_layout LyX-Code
show()
\end_layout

\begin_layout Standard
\align left

\emph on
Example fermat.py
\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
a = 2
\end_layout

\begin_layout LyX-Code
th= linspace(0, 10*pi,200)
\end_layout

\begin_layout LyX-Code
r = sqrt(a**2 * th)
\end_layout

\begin_layout LyX-Code
polar(th,r)
\end_layout

\begin_layout LyX-Code
polar(th, -r)
\end_layout

\begin_layout LyX-Code
show()
\end_layout

\begin_layout Subsection
Polar Rose
\end_layout

\begin_layout Standard
A rose or rhodonea curve is a sinusoid 
\begin_inset Formula $r=\cos(k\theta)$
\end_inset

 plotted in polar coordinates.
 If k is an even integer, the curve will have 
\begin_inset Formula $2k$
\end_inset

 petals and 
\begin_inset Formula $k$
\end_inset

 petals if it is odd.
 If k is rational, then the curve is closed and has finite length.
 If k is irrational, then it is not closed and has infinite length.
\end_layout

\begin_layout Standard
\align left

\emph on
Example rose.py
\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
k = 4
\end_layout

\begin_layout LyX-Code
th = linspace(0, 10*pi,1000)
\end_layout

\begin_layout LyX-Code
r = cos(k*th)
\end_layout

\begin_layout LyX-Code
polar(th,r)
\end_layout

\begin_layout LyX-Code
show()
\end_layout

\begin_layout Standard
There are dozens of other famous curves whose details are available on the
 Internet.
 It may be an interesting exercise for the reader.
 For more details refer to 
\begin_inset LatexCommand cite
key "gap-system,wikipedia,wolfram"

\end_inset

on the Internet.
\end_layout

\begin_layout Section
Power Series
\begin_inset LatexCommand label
name "sec:Power-Series"

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/series_sin.png
	lyxscale 50
	width 6cm

\end_inset


\begin_inset Graphics
	filename pics/rose.png
	lyxscale 50
	width 6cm

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Caption

\begin_layout Standard
Outputs of (a)series_sin.py (b) rose.py
\begin_inset LatexCommand label
name "fig:Functions-Series"

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard

\end_layout

\end_inset


\end_layout

\begin_layout Standard
Trigonometric functions like sine and cosine sounds very familiar to all
 of us, due to our interaction with them since high school days.
 However most of us would find it difficult to obtain the numerical values
 of , say 
\begin_inset Formula $\sin5^{0}$
\end_inset

, without trigonometric tables or a calculator.
 We know that differentiating a sine function twice will give you the original
 function, with a sign reversal, which implies
\end_layout

\begin_layout Standard
\begin_inset Formula \[
\frac{d^{2}y}{dx^{2}}+y=0\]

\end_inset


\end_layout

\begin_layout Standard
which has a series solution of the form
\end_layout

\begin_layout Standard
\begin_inset Formula \begin{equation}
y=a_{0}\sum_{n=0}^{\infty}\left(-1\right)^{n}\frac{x^{2n}}{(2n)!}+a_{1}\sum_{n=0}^{\infty}\left(-1\right)^{n}\frac{x^{2n+1}}{(2n+1)!}\label{eq:Trig Series}\end{equation}

\end_inset


\end_layout

\begin_layout Standard
These are the Maclaurin series for sine and cosine functions.
 The following code plots several terms of the sine series and their sum.
 
\end_layout

\begin_layout Standard
\align left

\emph on
Example series_sin.py
\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
from scipy import factorial
\end_layout

\begin_layout LyX-Code
x = linspace(-pi, pi, 50)
\end_layout

\begin_layout LyX-Code
y = zeros(50)
\end_layout

\begin_layout LyX-Code
for n in range(5):
\end_layout

\begin_layout LyX-Code
        term = (-1)**(n) * (x**(2*n+1)) / factorial(2*n+1)
\end_layout

\begin_layout LyX-Code
        y = y + term
\end_layout

\begin_layout LyX-Code
        #plot(x,term) #uncomment to see each term
\end_layout

\begin_layout LyX-Code
plot(x, y, '+b')
\end_layout

\begin_layout LyX-Code
plot(x, sin(x),'r') # compare with the real one
\end_layout

\begin_layout LyX-Code
show()
\end_layout

\begin_layout Standard
The output of 
\emph on
\color black
series_sin.py
\emph default
\color inherit
 is shown in figure 
\begin_inset LatexCommand ref
reference "fig:Functions-Series"

\end_inset

(a).
 For comparison the 
\begin_inset Formula $\sin$
\end_inset

 function from the library is plotted.
 The values calculated by using the series becomes closer to the actual
 value with more and more number of terms.
 The error can be obtained by adding the following lines to 
\emph on
series_sin.py 
\emph default
and the effect of number of terms on the error can be studied.
\end_layout

\begin_layout LyX-Code
err = y - sin(x)
\end_layout

\begin_layout LyX-Code
plot(x,err)
\end_layout

\begin_layout LyX-Code
for k in err:
\end_layout

\begin_layout LyX-Code
    print k
\end_layout

\begin_layout Section
Fourier Series
\end_layout

\begin_layout Standard
A Fourier series is an expansion of a periodic function 
\begin_inset Formula $f(x)$
\end_inset

 in terms of an infinite sum of sines and cosines.
 The computation and study of Fourier series is known as harmonic analysis
 and is extremely useful as a way to break up an arbitrary periodic function
 into a set of simple terms that can be plugged in, solved individually,
 and then recombined to obtain the solution to the original problem or an
 approximation to it to whatever accuracy is desired or practical.
 
\end_layout

\begin_layout Standard
The examples below shows how to generate a square wave and sawtooth wave
 using this technique.
 To make the output better, increase the number of terms by changing the
 argument of the range() function, used in the for loop.
 The output of the programs are shown in figure 
\begin_inset LatexCommand ref
reference "fig:Square-and-Sawtooth"

\end_inset

.
\end_layout

\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/sawtooth.png
	lyxscale 50
	width 6cm

\end_inset

 
\begin_inset Graphics
	filename pics/square.png
	lyxscale 50
	width 6cm

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Caption

\begin_layout Standard
Sawtooth and Square waveforms generated using Fourier series
\begin_inset LatexCommand label
name "fig:Square-and-Sawtooth"

\end_inset

.
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\align left

\emph on
Example fourier_square.py
\end_layout

\begin_layout LyX-Code
from pylab import * 
\end_layout

\begin_layout LyX-Code
N = 100    # number of points
\end_layout

\begin_layout LyX-Code
x = linspace(0.0, 2 * pi, N)
\end_layout

\begin_layout LyX-Code
y = zeros(N)
\end_layout

\begin_layout LyX-Code
for n in range(5): 
\end_layout

\begin_layout LyX-Code
    term = sin((2*n+1)*x) / (2*n+1)
\end_layout

\begin_layout LyX-Code
    y = y + term
\end_layout

\begin_layout LyX-Code
    plot(x,y)
\end_layout

\begin_layout LyX-Code
show()
\end_layout

\begin_layout Standard
\align left

\emph on
Example fourier_sawtooth.py
\end_layout

\begin_layout LyX-Code
from pylab import * 
\end_layout

\begin_layout LyX-Code
N = 100    # number of points
\end_layout

\begin_layout LyX-Code
x = linspace(-pi, pi, N)
\end_layout

\begin_layout LyX-Code
y = zeros(N)
\end_layout

\begin_layout LyX-Code
for n in range(1,10): 
\end_layout

\begin_layout LyX-Code
    term = (-1)**(n+1) * sin(n*x) / n
\end_layout

\begin_layout LyX-Code
    y = y + term
\end_layout

\begin_layout LyX-Code
plot(x,y)
\end_layout

\begin_layout LyX-Code
show()
\end_layout

\begin_layout Section
2D plot using colors
\end_layout

\begin_layout Standard
A two dimensional matrix can be represented graphically by assigning a color
 to each point proportional to the value of that element.
 The program imshow1.py makes a 
\begin_inset Formula $50\times50$
\end_inset

 matrix filled with random numbers and uses 
\shape italic
imshow()
\shape default
 to plot it.
 The result is shown in figure 
\begin_inset LatexCommand ref
reference "fig:Output-of-imshow1.py"

\end_inset

(a).
\end_layout

\begin_layout Standard
\align left

\emph on
Example imshow1.py
\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
m = random([50,50])
\end_layout

\begin_layout LyX-Code
imshow(m)
\end_layout

\begin_layout LyX-Code
show()
\end_layout

\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/imshow.png
	lyxscale 70
	width 4cm

\end_inset


\begin_inset Graphics
	filename pics/julia.png
	lyxscale 40
	width 4cm

\end_inset


\begin_inset Graphics
	filename pics/mgrid2.png
	lyxscale 70
	width 4cm

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Caption

\begin_layout Standard
Outputs of (a) imshow1.py (b) julia.py (c) mgrid2.py
\begin_inset LatexCommand label
name "fig:Output-of-imshow1.py"

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard

\end_layout

\end_inset


\end_layout

\begin_layout Section
Fractals
\end_layout

\begin_layout Standard
Fractals
\begin_inset Foot
status collapsed

\begin_layout Standard
http://en.wikipedia.org/wiki/Fractal
\end_layout

\end_inset

 are a part of fractal geometry, which is a branch of mathematics concerned
 with irregular patterns made of parts that are in some way similar to the
 whole (e.g.: twigs and tree branches).
 A fractal is a design of infinite details.
 It is created using a mathematical formula.
 No matter how closely you look at a fractal, it never loses its detail.
 It is infinitely detailed, yet it can be contained in a finite space.
 Fractals are generally self-similar and independent of scale.
 The theory of fractals was developed from Benoit Mandelbrot's study of
 complexity and chaos.
 Complex numbers are required to compute the Mandelbrot and Julia Set fractals
 and it is assumed that the reader is familiar with the basics of complex
 numbers.
\end_layout

\begin_layout Standard
To compute the basic Mandelbrot (or Julia) set one uses the equation 
\begin_inset Formula $f(z)\rightarrow z^{2}+c$
\end_inset

 , where both z and c are complex numbers.
 The function is evaluated in an iterative manner, ie.
 the result is assigned to 
\begin_inset Formula $z$
\end_inset

 and the process is repeated.
 The purpose of the iteration is to determine the behavior of the values
 that are put into the function.
 If the value of the function goes to infinity (practically to some fixed
 value, like 1 or 2) after few iterations for a particular value of 
\begin_inset Formula $z$
\end_inset

 , that point is considered to be outside the Set.
 A Julia set can be defined as the set of all the complex numbers 
\begin_inset Formula $(z)$
\end_inset

 such that the iteration of 
\begin_inset Formula $f(z)\rightarrow z^{2}+c$
\end_inset

 is bounded for a particular value of c.
 
\end_layout

\begin_layout Standard
To generate the fractal the number of iterations required to diverge is
 calculated for a set of points in the selected region in the complex plane.
 The number of iterations taken for diverging decides the color of each
 point.
 The points that did not diverge, belonging to the set, are plotted with
 the same color.
 The program 
\emph on
julia.py
\emph default
 generates a fractal using a julia set.
 The program creates a 2D array (200 x 200 elements).
 For our calculations, this array represents a rectangular region on the
 complex plane centered at the origin whose lower left corner is (-1,-j)
 and the upper right corner is (1+j).
 For 200x200 equidistant points in this plane the number of iterations are
 calculated and that value is given to the corresponding element of the
 2D matrix.
 The plotting is taken care by the imshow function.
 The output is shown in figure 
\begin_inset LatexCommand ref
reference "fig:Output-of-imshow1.py"

\end_inset

(b).
 Change the value of 
\begin_inset Formula $c$
\end_inset

 and run the program to generate more patterns.
 The equation also may be changed.
\end_layout

\begin_layout Standard
\align left

\emph on
Example julia.py
\end_layout

\begin_layout LyX-Code
'''
\end_layout

\begin_layout LyX-Code
Region of a complex plane ranging from -1 to +1 in both real
\end_layout

\begin_layout LyX-Code
and imaginary axes is represented using a 2D  matrix
\end_layout

\begin_layout LyX-Code
having X x Y elements.For X and Y equal to 200,the stepsize
\end_layout

\begin_layout LyX-Code
in the complex plane is 2.0/200 = 0.01.
\end_layout

\begin_layout LyX-Code
The nature of the pattern depends much on the value of c.
\end_layout

\begin_layout LyX-Code
'''
\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
X = 200
\end_layout

\begin_layout LyX-Code
Y = 200
\end_layout

\begin_layout LyX-Code
MAXIT = 100
\end_layout

\begin_layout LyX-Code
MAXABS = 2.0
\end_layout

\begin_layout LyX-Code
c = 0.02 - 0.8j   # The constant in equation z**2 + c
\end_layout

\begin_layout LyX-Code
m = zeros([X,Y])  # A two dimensional array
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
def numit(x,y):       # number of iterations to diverge
\end_layout

\begin_layout LyX-Code
     z = complex(x,y)
\end_layout

\begin_layout LyX-Code
     for k in range(MAXIT):
\end_layout

\begin_layout LyX-Code
            if abs(z) <= MAXABS:
\end_layout

\begin_layout LyX-Code
                z = z**2 + c         
\end_layout

\begin_layout LyX-Code
            else:
\end_layout

\begin_layout LyX-Code
                return k     # diverged after k trials
\end_layout

\begin_layout LyX-Code
     return MAXIT            # did not diverge,
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
for x in range(X):
\end_layout

\begin_layout LyX-Code
    for y in range(Y):
\end_layout

\begin_layout LyX-Code
        re = 0.01 * x - 1.0     # complex number for
\end_layout

\begin_layout LyX-Code
        im = 0.01 * y - 1.0     # this (x,y) coordinate
\end_layout

\begin_layout LyX-Code
        m[x][y] = numit(re,im)  # get the color for (x,y)
\end_layout

\begin_layout LyX-Code
imshow(m)  # Colored plot using the 2D matrix
\end_layout

\begin_layout LyX-Code
show()
\end_layout

\begin_layout Section
Meshgrids
\end_layout

\begin_layout Standard
in order to make contour and 3D plots, we need to understand the meshgrid.
 Consider a rectangular area on the X-Y plane.
 Assume there are m divisions in the X direction and n divisions in the
 Y direction.
 We now have a 
\begin_inset Formula $m\times n$
\end_inset

 mesh.
 A meshgrid is the coordinates of a grid in a 2D plane, x coordinates of
 each mesh point is held in one matrix and y coordinates are held in another.
 
\end_layout

\begin_layout Standard
The NumPy function meshgrid() creates two 2x2 matrices from two 1D arrays,
 as shown in the example below.
 This can be used for plotting surfaces and contours, by assigning a Z coordinat
e to every mesh point.
\end_layout

\begin_layout Standard
\align left

\emph on
Example mgrid1.py
\end_layout

\begin_layout LyX-Code
from numpy import *
\end_layout

\begin_layout LyX-Code
x = arange(0, 3, 1)
\end_layout

\begin_layout LyX-Code
y = arange(0, 3, 1)
\end_layout

\begin_layout LyX-Code
gx, gy = meshgrid(x, y)
\end_layout

\begin_layout LyX-Code
print gx
\end_layout

\begin_layout LyX-Code
print gy
\end_layout

\begin_layout Standard
\align block
The outputs are as shown below, gx(i,j) contains the x-coordinate and gx(i,j)
 contains the y-coordinate of the point (i,j).
\end_layout

\begin_layout Standard
[[0 1 2] 
\end_layout

\begin_layout Standard
[0 1 2]
\end_layout

\begin_layout Standard
[0 1 2]]
\end_layout

\begin_layout Standard
[[0 0 0] 
\end_layout

\begin_layout Standard
[1 1 1]
\end_layout

\begin_layout Standard
[2 2 2]] 
\end_layout

\begin_layout Standard
\align block
We can evaluate a function at all points of the meshgrid by passing the
 meshgrid as an argument.
 The program mgrid2.py plots the sum of sines of the x and y coordinates,
 using imshow to get a result as shown in figure 
\begin_inset LatexCommand ref
reference "fig:Output-of-imshow1.py"

\end_inset

(c).
\end_layout

\begin_layout Standard
\align left

\emph on
Example mgrid2.py
\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
x = arange(-3*pi, 3*pi, 0.1)
\end_layout

\begin_layout LyX-Code
y = arange(-3*pi, 3*pi, 0.1)
\end_layout

\begin_layout LyX-Code
xx, yy = meshgrid(x, y)
\end_layout

\begin_layout LyX-Code
z = sin(xx) + sin(yy) 
\end_layout

\begin_layout LyX-Code
imshow(z)
\end_layout

\begin_layout LyX-Code
show() 
\end_layout

\begin_layout Section
3D Plots
\end_layout

\begin_layout Standard
Matplotlib supports several types of 3D plots, using the Axes3D class.
 The following three lines of code are required in every program making
 3D plots using matplotlib.
\end_layout

\begin_layout LyX-Code
from pylab import * 
\end_layout

\begin_layout LyX-Code
from mpl_toolkits.mplot3d import Axes3D
\end_layout

\begin_layout LyX-Code
ax = Axes3D(figure())
\end_layout

\begin_layout Subsection
Surface Plots
\end_layout

\begin_layout Standard
The example mgrid2.py is re-written to make a surface plot using the same
 equation in surface3d.py and the result is shown in figure 
\begin_inset LatexCommand ref
reference "fig:Suface3d and Line3d"

\end_inset

(a).
\end_layout

\begin_layout Standard
\align left

\emph on
Example sufrace3d.py
\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
from mpl_toolkits.mplot3d import Axes3D
\end_layout

\begin_layout LyX-Code
ax = Axes3D(figure())
\end_layout

\begin_layout LyX-Code
x = arange(-3*pi, 3*pi, 0.1)
\end_layout

\begin_layout LyX-Code
y = arange(-3*pi, 3*pi, 0.1)
\end_layout

\begin_layout LyX-Code
xx, yy = meshgrid(x, y)
\end_layout

\begin_layout LyX-Code
z = sin(xx) + sin(yy) 
\end_layout

\begin_layout LyX-Code
ax.plot_surface(xx, yy, z, cmap=cm.jet, cstride=1)
\end_layout

\begin_layout LyX-Code
show() 
\end_layout

\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/surface3d.png
	width 5cm

\end_inset


\begin_inset Graphics
	filename pics/line3d.png
	width 5cm

\end_inset


\end_layout

\begin_layout Standard
Output of (a)surface3d.py (b)line3d.py
\begin_inset LatexCommand label
name "fig:Suface3d and Line3d"

\end_inset


\end_layout

\begin_layout Standard

\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Line Plots
\end_layout

\begin_layout Standard
Example of a line plot is shown in line3d.py along with the output in figure
 
\begin_inset LatexCommand ref
reference "fig:Suface3d and Line3d"

\end_inset

(b).
\end_layout

\begin_layout Standard
\align left

\emph on
Example line3d.py
\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
from mpl_toolkits.mplot3d import Axes3D
\end_layout

\begin_layout LyX-Code
ax = Axes3D(figure())
\end_layout

\begin_layout LyX-Code

\end_layout

\begin_layout LyX-Code
phi = linspace(0, 2*pi, 400)
\end_layout

\begin_layout LyX-Code
x = cos(phi)
\end_layout

\begin_layout LyX-Code
y = sin(phi)
\end_layout

\begin_layout LyX-Code
z = 0
\end_layout

\begin_layout LyX-Code
ax.plot(x, y, z, label = 'x')# circle
\end_layout

\begin_layout LyX-Code

\end_layout

\begin_layout LyX-Code
z = sin(4*phi)  # modulated in z plane 
\end_layout

\begin_layout LyX-Code
ax.plot(x, y, z, label = 'x')  
\end_layout

\begin_layout LyX-Code
ax.set_xlabel('X')
\end_layout

\begin_layout LyX-Code
ax.set_ylabel('Y')
\end_layout

\begin_layout LyX-Code
ax.set_zlabel('Z')
\end_layout

\begin_layout LyX-Code
show()
\end_layout

\begin_layout Standard
Modify the code to make x = sin(2*phi) to observe Lissajous figures
\end_layout

\begin_layout Subsection
Wire-frame Plots
\end_layout

\begin_layout Standard
Data for a sphere is generated using the outer product of matrices and plotted,
 by sphere.py.
\end_layout

\begin_layout LyX-Code
from pylab import * 
\end_layout

\begin_layout LyX-Code
from mpl_toolkits.mplot3d import Axes3D 
\end_layout

\begin_layout LyX-Code
ax = Axes3D(figure())
\end_layout

\begin_layout LyX-Code
phi = linspace(0, 2 * pi, 100) 
\end_layout

\begin_layout LyX-Code
theta = linspace(0, pi, 100)
\end_layout

\begin_layout LyX-Code
x = 10 * outer(cos(phi), sin(theta))
\end_layout

\begin_layout LyX-Code
y = 10 * outer(sin(phi), sin(theta))
\end_layout

\begin_layout LyX-Code
z = 10 * outer(ones(size(phi)), cos(theta))
\end_layout

\begin_layout LyX-Code
ax.plot_wireframe(x,y,z, rstride=2, cstride=2)
\end_layout

\begin_layout LyX-Code
show()
\end_layout

\begin_layout Section
Mayavi, 3D visualization
\end_layout

\begin_layout Standard
For more efficient and advanced 3D visualization, use Mayavi that is available
 on most of the GNU/Linux platforms.
 Program ylm20.py plots the spherical harmonics 
\begin_inset Formula $Y_{m}^{l}$
\end_inset

 for 
\begin_inset Formula $l=2,m=0$
\end_inset

, using mayavi.
 The plot of 
\begin_inset Formula $Y_{2}^{0}=\frac{1}{4}\sqrt{\frac{5}{\pi}}(3\cos^{2}\phi-1)$
\end_inset

 is shown in figure
\begin_inset LatexCommand ref
reference "fig:Output-of-ylm20.py"

\end_inset

.
\end_layout

\begin_layout Standard
\align left

\emph on
Example ylm20.py
\end_layout

\begin_layout LyX-Code
from numpy import * 
\end_layout

\begin_layout LyX-Code
from enthought.mayavi import mlab
\end_layout

\begin_layout LyX-Code
polar = linspace(0,pi,100) 
\end_layout

\begin_layout LyX-Code
azimuth = linspace(0, 2*pi,100) 
\end_layout

\begin_layout LyX-Code
phi,th = meshgrid(polar, azimuth)
\end_layout

\begin_layout LyX-Code
r = 0.25 * sqrt(5.0/pi) * (3*cos(phi)**2 - 1)
\end_layout

\begin_layout LyX-Code
x = r*sin(phi)*cos(th) 
\end_layout

\begin_layout LyX-Code
y = r*cos(phi) 
\end_layout

\begin_layout LyX-Code
z = r*sin(phi)*sin(th) 
\end_layout

\begin_layout LyX-Code
mlab.mesh(x, y, z)
\end_layout

\begin_layout LyX-Code
mlab.show()
\end_layout

\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/ylm20.png
	width 6cm

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Caption

\begin_layout Standard
Output of ylm20.py
\begin_inset LatexCommand label
name "fig:Output-of-ylm20.py"

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard

\end_layout

\end_inset


\end_layout

\begin_layout Section
Exercises
\end_layout

\begin_layout Enumerate
Plot a sine wave using markers +, o and x using three different colors.
\end_layout

\begin_layout Enumerate
Plot 
\begin_inset Formula $\tan\theta$
\end_inset

 from 
\begin_inset Formula $\theta$
\end_inset

 from 
\begin_inset Formula $-2\pi$
\end_inset

 to 
\begin_inset Formula $2\pi$
\end_inset

, watch for singular points.
\end_layout

\begin_layout Enumerate
Plot a circle using the polar() function.
\end_layout

\begin_layout Enumerate
Plot the following from the list of Famous curves at reference 
\begin_inset LatexCommand cite
key "gap-system"

\end_inset


\newline
a) 
\begin_inset Formula $r^{2}=a^{2}\cos2\theta$
\end_inset

 , Lemniscate of Bernoulli
\newline
b) 
\begin_inset Formula $y=\sqrt{2\pi}e^{-x^{2}/2}$
\end_inset

 Frequency curve
\newline
c) 
\begin_inset Formula $a\cosh(x/a)$
\end_inset

 catenary
\newline
d) 
\begin_inset Formula $\sin(a\theta)$
\end_inset

 for a = 2, 3, and 4.
 Rhodonea curves
\end_layout

\begin_layout Enumerate
Generate a triangular wave using Fourier series.
\end_layout

\begin_layout Enumerate
Evaluate 
\begin_inset Formula $y=\sum_{n=1}^{n=\infty}\frac{(-1)^{n}x^{2n+1}}{(2n+1)!}$
\end_inset

 for 10 terms.
\end_layout

\begin_layout Enumerate
Write a Python program to calculate sine function using series expansion
 and plot it.
\end_layout

\begin_layout Enumerate
Write a Python program to plot 
\begin_inset Formula $y=5x^{2}+3x+2$
\end_inset

 (for x from 0 to 5, 20 points),using pylab, with axes and title.
 Use red colored circles to mark the points.
 
\end_layout

\begin_layout Enumerate
Write a Python program to plot a Square wave using Fourier series, number
 of terms should be a variable.
\end_layout

\begin_layout Enumerate
Write a Python program to read the x and y coordinates from a file, in a
 two column format, and plot them.
 
\end_layout

\begin_layout Enumerate
Plot 
\begin_inset Formula $x^{2}+y^{2}+z^{2}=25$
\end_inset

 using mayavi.
\end_layout

\begin_layout Enumerate
Make a plot z = sin(x) + sin(y) using imshow() , from 
\begin_inset Formula $-4\pi to4\pi$
\end_inset

 for both x and y.
\end_layout

\begin_layout Enumerate
Write Python code to plot 
\begin_inset Formula $y=x^{2}$
\end_inset

, with the axes labelled
\end_layout

\begin_layout Chapter
Type setting using LaTeX
\end_layout

\begin_layout Standard
LaTeX is a powerful typesetting system, used for producing scientific and
 mathematical documents of high typographic quality.
 LaTeX is not a word processor! Instead, LaTeX encourages authors not to
 worry too much about the appearance of their documents but to concentrate
 on getting the right content.
 You prepare your document using a plain text editor, and the formatting
 is specified by commands embedded in your document.
 The appearance of your document is decided by LaTeX, but you need to specify
 it using some commands.
 In this chapter, we will discuss some of these commands mainly to typeset
 mathematical equations.
 
\begin_inset Foot
status collapsed

\begin_layout Standard
http://www.latex-project.org/
\end_layout

\begin_layout Standard
http://mirror.ctan.org/info/lshort/english/lshort.pdf
\end_layout

\begin_layout Standard
http://en.wikibooks.org/wiki/LaTeX
\end_layout

\end_inset


\end_layout

\begin_layout Section
Document classes
\end_layout

\begin_layout Standard
LaTeX provides several predefined document classes (book, article, letter,
 report, etc.) with extensive sectioning and cross-referencing capabilities.
 Title, chapter, section, subsection, paragraph, subparagraph etc.
 are specified by commands and it is the job of LaTeX to format them properly.
 It does the numbering of sections automatically and can generate a table
 of contents if requested.
 Figures and tables are also numbered and placed without the user worrying
 about it.
\end_layout

\begin_layout Standard
The latex source document (the .tex file) is compiled by the latex program
 to generate a device independent (the .dvi file) output.
 From that you can generate postscript or PDF versions of the document.
 We will start with a simple example 
\shape italic
hello.tex
\shape default
 to demonstrate this process.
 In a line, anything after a % sign is taken as a comment.
\end_layout

\begin_layout Standard
\align left

\emph on
Example hello.tex
\end_layout

\begin_layout LyX-Code

\backslash
documentclass{article} 
\end_layout

\begin_layout LyX-Code

\backslash
begin{document} 
\end_layout

\begin_layout LyX-Code
Small is beautiful.
   % I am just a comment
\end_layout

\begin_layout LyX-Code

\backslash
end{document} 
\end_layout

\begin_layout Standard
Compile, view and make a PDF file using the following commands:
\end_layout

\begin_layout Standard
$ latex hello.tex
\end_layout

\begin_layout Standard
$ xdvi hello.dvi
\end_layout

\begin_layout Standard
$ dvipdf hello.dvi
\end_layout

\begin_layout Standard
\align left
The output will look like : Small is beautiful.
\end_layout

\begin_layout Section
Modifying Text
\end_layout

\begin_layout Standard
In the next example 
\shape italic
texts.tex
\shape default
 we will demonstrate different types of text.
 We will 
\backslash
newline or 
\backslash

\backslash
 to generate a line break.
 A blank line will start a new paragraph.
\end_layout

\begin_layout Standard
\align left

\emph on
Example texts.tex
\end_layout

\begin_layout Quotation

\backslash
documentclass{article} 
\end_layout

\begin_layout Quotation

\backslash
begin{document} 
\end_layout

\begin_layout Quotation
This is normal text.
 
\end_layout

\begin_layout Quotation

\backslash
newline 
\end_layout

\begin_layout Quotation

\backslash
textbf{This is bold face text.} 
\end_layout

\begin_layout Quotation

\backslash
textit{This is italic text.}
\backslash

\backslash

\end_layout

\begin_layout Quotation

\backslash
tiny{This is tiny text.} 
\end_layout

\begin_layout Quotation

\backslash
large{This is large text.} 
\end_layout

\begin_layout Quotation

\backslash
underline{This is underlined text.}
\end_layout

\begin_layout Quotation

\backslash
end{document} 
\end_layout

\begin_layout Standard
\align left
Compiling 
\shape italic
texts.tex,
\shape default
 as explained in the previous example, will genearte the following output.
\end_layout

\begin_layout Standard

\lyxline

\end_layout

\begin_layout Standard
\begin_inset ERT
status collapsed

\begin_layout Standard


\backslash
textnormal{This is normal text.}
\end_layout

\begin_layout Standard


\backslash
newline
\end_layout

\begin_layout Standard


\backslash
textbf{This is bold face text.} 
\end_layout

\begin_layout Standard


\backslash
textit{This is italic text.}
\backslash

\backslash

\end_layout

\begin_layout Standard


\backslash
tiny{This is tiny text.} 
\end_layout

\begin_layout Standard


\backslash
large{This is large text.} 
\end_layout

\begin_layout Standard


\backslash
underline{This is underlined text.}
\end_layout

\end_inset


\end_layout

\begin_layout Standard

\lyxline

\end_layout

\begin_layout Section
Dividing the document
\end_layout

\begin_layout Standard
A document is generally organized in to sections, subsections, paragraphs
 etc.
 and Latex allows us to do this by inserting commands like section subsection
 etc.
 If the document class is book, you can have chapters also.
 There is a command to generate the table of contents from the sectioning
 information.
\begin_inset Foot
status collapsed

\begin_layout Standard
To generate the table of contents, you may have to compile the document
 two times.
\end_layout

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/sections.png
	width 12cm

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Caption

\begin_layout Standard
Output of sections.tex
\begin_inset LatexCommand label
name "fig:Output-of-sections.tex"

\end_inset


\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\align left

\emph on
Example sections.tex
\end_layout

\begin_layout Quotation

\backslash
documentclass{article}
\end_layout

\begin_layout Quotation

\backslash
begin{document}
\end_layout

\begin_layout Quotation

\backslash
tableofcontents
\end_layout

\begin_layout Quotation

\backslash
section{Animals}
\end_layout

\begin_layout Quotation
This document defines sections.
 
\end_layout

\begin_layout Quotation

\backslash
subsection{Domestic}
\end_layout

\begin_layout Quotation
This document also defines subsections.
 
\end_layout

\begin_layout Quotation

\backslash
subsubsection{cats and dogs}
\end_layout

\begin_layout Quotation
Cats and dogs are Domestic animals.
 
\end_layout

\begin_layout Quotation

\backslash
end{document}
\end_layout

\begin_layout Standard
The output of sections.tex is shown in figure 
\begin_inset LatexCommand ref
reference "fig:Output-of-sections.tex"

\end_inset

.
\end_layout

\begin_layout Section
Environments
\end_layout

\begin_layout Standard
Environments decide the way in which your text is formatted : numbered lists,
 tables, equations, quotations, justifications, figure, etc.
 are some of the environments.
 Environments are defined like :
\end_layout

\begin_layout Standard

\backslash
begin{environment_name} your text 
\backslash
end{environment_name}
\end_layout

\begin_layout Standard
\align block
The example program 
\shape italic
environ.tex
\shape default
 demonstrates some of the environments.
\end_layout

\begin_layout Standard
\align left

\emph on
Example environs.tex
\end_layout

\begin_layout Standard

\backslash
documentclass{article}
\end_layout

\begin_layout Standard

\backslash
begin{document}
\end_layout

\begin_layout Standard

\backslash
begin{flushleft} A bulleted list.
 
\backslash
end{flushleft}
\end_layout

\begin_layout Standard

\backslash
begin{itemize} 
\backslash
item dog 
\backslash
item cat 
\backslash
end{itemize}
\end_layout

\begin_layout Standard

\backslash
begin{center} A numbered List.
 
\backslash
end{center}
\end_layout

\begin_layout Standard

\backslash
begin{enumerate} 
\backslash
item dog 
\backslash
item cat 
\backslash
end{enumerate}
\end_layout

\begin_layout Standard

\backslash
begin{flushright} This text is right justified.
 
\backslash
end{flushright}
\end_layout

\begin_layout Standard

\backslash
begin{quote} 
\end_layout

\begin_layout Standard
Any text inside quote
\backslash

\backslash
 environment will appe-
\backslash

\backslash
 ar as typed.
\backslash

\backslash
 
\end_layout

\begin_layout Standard

\backslash
end{quote}
\end_layout

\begin_layout Standard

\backslash
begin{verbatim} 
\end_layout

\begin_layout Standard
x = 1 
\end_layout

\begin_layout Standard
while x <= 10:
\end_layout

\begin_layout Standard
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
print x * 5 
\end_layout

\begin_layout Standard
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
x = x + 1 
\end_layout

\begin_layout Standard

\backslash
end{verbatim}
\end_layout

\begin_layout Standard

\backslash
end{document}
\end_layout

\begin_layout Standard
\align block
The enumerate and itemize are used for making numbered and non-numbered
 lists.
 Flushleft, flushright and center are used for specifying text justification.
 Quote and verbatim are used for portions where we do not want LaTeX to
 do the formatting.
 The output of environs.tex is shown below.
\end_layout

\begin_layout Standard

\lyxline

\end_layout

\begin_layout Standard
\align block
\begin_inset ERT
status collapsed

\begin_layout Standard


\backslash
begin{flushleft} A bulleted list.
 
\backslash
end{flushleft}
\end_layout

\begin_layout Standard


\backslash
begin{itemize} 
\backslash
item dog 
\backslash
item cat 
\backslash
end{itemize}
\end_layout

\begin_layout Standard


\backslash
begin{center} A numbered List.
 
\backslash
end{center}
\end_layout

\begin_layout Standard


\backslash
begin{enumerate} 
\backslash
item dog 
\backslash
item cat 
\backslash
end{enumerate}
\end_layout

\begin_layout Standard


\backslash
begin{flushright} This text is right justified.
 
\backslash
end{flushright}
\end_layout

\begin_layout Standard


\backslash
begin{quote} 
\end_layout

\begin_layout Standard

Any text inside quote
\backslash

\backslash
 environment will appe-
\backslash

\backslash
 ar as typed.
\backslash

\backslash
 
\end_layout

\begin_layout Standard


\backslash
end{quote}
\end_layout

\begin_layout Standard


\backslash
begin{verbatim} 
\end_layout

\begin_layout Standard

x = 1    # a Python program
\end_layout

\begin_layout Standard

while x <= 10:
\end_layout

\begin_layout Standard

   print x * 5 
\end_layout

\begin_layout Standard

   x = x + 1 
\end_layout

\begin_layout Standard


\backslash
end{verbatim}
\end_layout

\end_inset


\end_layout

\begin_layout Standard

\lyxline

\end_layout

\begin_layout Section
Typesetting Equations 
\end_layout

\begin_layout Standard
There two ways to typeset mathematical formulae: in-line within a paragraph,
 or in a separate line.
 In-line equations are entered between 
\shape italic
two $ symbols
\shape default
.
 The equations in a separate line can be done within the 
\shape italic
equation
\shape default
 environment.
 Both are demonstrated in math1.tex.
 
\shape italic
We use the amsmath package in this example.
\end_layout

\begin_layout Standard
\align left

\emph on
Example math1.tex
\end_layout

\begin_layout Quotation

\backslash
documentclass{article} 
\end_layout

\begin_layout Quotation

\backslash
usepackage{amsmath} 
\end_layout

\begin_layout Quotation

\backslash
begin{document} 
\end_layout

\begin_layout Quotation
The equation $a^2 + b^2 = c^2$ is typeset as inline.
 
\end_layout

\begin_layout Quotation
The same can be done in a separate line using 
\end_layout

\begin_layout Quotation

\backslash
begin{equation} 
\end_layout

\begin_layout Quotation
a^2 + b^2 = c^2 
\end_layout

\begin_layout Quotation

\backslash
end{equation} 
\end_layout

\begin_layout Quotation

\backslash
end{document}
\end_layout

\begin_layout Standard
The output of this file is shown below.
\end_layout

\begin_layout Standard

\lyxline

\begin_inset ERT
status collapsed

\begin_layout Standard

The equation $a^2 + b^2 = c^2$ is typeset as inline.
 
\end_layout

\begin_layout Standard

The same can be done in a separate line using 
\end_layout

\begin_layout Standard


\backslash
begin{equation} 
\end_layout

\begin_layout Standard

a^2 + b^2 = c^2 
\end_layout

\begin_layout Standard


\backslash
end{equation} 
\end_layout

\end_inset


\lyxline

\end_layout

\begin_layout Standard
The equation number becomes 5.1 because this happens to be the first equation
 in chapter 5.
 
\end_layout

\begin_layout Subsection
Building blocks for typesetting equations
\end_layout

\begin_layout Standard
To typeset equations, we need to know the commands to make constructs like
 fraction, sqareroot, integral etc.
 The following list shows several commands and corresponding outputs.
 For each item, the output of the command, between the two $ signs, is shown
 on the right side.
 The reader is expected to insert then inside the body of a document, compile
 the file and view the output for practicing.
\end_layout

\begin_layout Enumerate
Extra space
\begin_inset Foot
status collapsed

\begin_layout Standard

\backslash
quad is for inserting space, the size of a 
\backslash
quad corresponds to the width of the character ‘M’ of the current font.
 Use 
\backslash
qquad for larger space.
\end_layout

\end_inset

 : $A 
\backslash
quad B
\backslash
qquad C$\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~

\begin_inset ERT
status collapsed

\begin_layout Standard

$A
\backslash
quad B
\backslash
qquad C$
\end_layout

\end_inset


\end_layout

\begin_layout Enumerate
Greek letters : $ 
\backslash
alpha 
\backslash
beta 
\backslash
gamma 
\backslash
pi$\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~

\begin_inset ERT
status collapsed

\begin_layout Standard

$ 
\backslash
alpha 
\backslash
beta 
\backslash
gamma 
\backslash
pi$
\end_layout

\end_inset


\end_layout

\begin_layout Enumerate
Subscript and Exponents : $A_n 
\backslash
quad A^m $\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~

\begin_inset ERT
status collapsed

\begin_layout Standard

$A_n 
\backslash
quad A^m$
\end_layout

\end_inset


\end_layout

\begin_layout Enumerate
Multiple Exponents : $a^b 
\backslash
quad a^{b^c}$\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~

\begin_inset ERT
status collapsed

\begin_layout Standard

$a^b 
\backslash
quad a^{b^c}$
\end_layout

\end_inset


\end_layout

\begin_layout Enumerate
Fractions : $
\backslash
frac{3}{5}$ \InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~

\begin_inset ERT
status collapsed

\begin_layout Standard

$
\backslash
frac{3}{5}$
\end_layout

\end_inset


\end_layout

\begin_layout Enumerate
Dots : $n! = 1 
\backslash
cdot 2 
\backslash
cdots (n-1) 
\backslash
cdot n$ \InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~

\begin_inset ERT
status collapsed

\begin_layout Standard

$n! = 1 
\backslash
cdot 2 
\backslash
cdots (n-1) 
\backslash
cdot n$
\end_layout

\end_inset


\end_layout

\begin_layout Enumerate
Under/over lines : $0.
\backslash
overline{3} = 
\backslash
underline{1/3}}$ \InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~

\begin_inset ERT
status collapsed

\begin_layout Standard

$0.
\backslash
overline{3} = 
\backslash
underline{1/3}$
\end_layout

\end_inset


\end_layout

\begin_layout Enumerate
Vectors : $
\backslash
vec{a}$\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~

\begin_inset ERT
status collapsed

\begin_layout Standard

$
\backslash
vec{a}$
\end_layout

\end_inset


\end_layout

\begin_layout Enumerate
Functions : $
\backslash
sin x + 
\backslash
arctan y$\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~

\begin_inset ERT
status collapsed

\begin_layout Standard

$
\backslash
sin x + 
\backslash
arctan y$
\end_layout

\end_inset


\end_layout

\begin_layout Enumerate
Square root : $
\backslash
sqrt{x^2+y^2}$\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~

\begin_inset ERT
status collapsed

\begin_layout Standard

$
\backslash
sqrt{x^2+y^2}$
\end_layout

\end_inset


\end_layout

\begin_layout Enumerate
Higher roots : $z=
\backslash
sqrt[3]{x^{2} + 
\backslash
sqrt{y}}$\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~

\begin_inset ERT
status collapsed

\begin_layout Standard

$z=
\backslash
sqrt[3]{x^{2} + 
\backslash
sqrt{y}}$
\end_layout

\end_inset


\end_layout

\begin_layout Enumerate
Equalities : $A 
\backslash
neq B 
\backslash
quad A 
\backslash
approx C$\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~

\begin_inset ERT
status collapsed

\begin_layout Standard

$A 
\backslash
neq B 
\backslash
quad A 
\backslash
approx C 
\backslash
quad $
\end_layout

\end_inset


\end_layout

\begin_layout Enumerate
Arrows : $
\backslash
Leftrightarrow
\backslash
quad
\backslash
Downarrow$\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
 
\begin_inset ERT
status collapsed

\begin_layout Standard

$
\backslash
Leftrightarrow
\backslash
quad
\backslash
Downarrow$
\end_layout

\end_inset


\end_layout

\begin_layout Enumerate
Partial derivative : $
\backslash
frac{
\backslash
partial ^2A}{
\backslash
partial x^2}$\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~

\begin_inset ERT
status collapsed

\begin_layout Standard

$
\backslash
frac{
\backslash
partial ^2A}{
\backslash
partial x^2}$
\end_layout

\end_inset


\end_layout

\begin_layout Enumerate
Summation : $
\backslash
sum_{i=1}^n$\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~

\begin_inset ERT
status collapsed

\begin_layout Standard

$
\backslash
sum_{i=1}^n$
\end_layout

\end_inset


\end_layout

\begin_layout Enumerate
Integration : $
\backslash
int_0^{
\backslash
frac{
\backslash
pi}{2} 
\backslash
sin x}$\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~

\begin_inset ERT
status collapsed

\begin_layout Standard

$
\backslash
int_0^{
\backslash
frac{
\backslash
pi}{2}} sin x$
\end_layout

\begin_layout Standard

\end_layout

\end_inset


\end_layout

\begin_layout Enumerate
Product : $
\backslash
prod_
\backslash
epsilon$\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~

\begin_inset ERT
status collapsed

\begin_layout Standard

$
\backslash
prod_
\backslash
epsilon$
\end_layout

\end_inset


\end_layout

\begin_layout Enumerate
Big brackets : $
\backslash
Big((x+1)(x-1)
\backslash
Big)^{2}$\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~

\begin_inset ERT
status collapsed

\begin_layout Standard

$
\backslash
Big((x+1)(x-1)
\backslash
Big)^{2}$
\end_layout

\end_inset


\end_layout

\begin_layout Enumerate
Integral : $
\backslash
int_a^b f(x) dx$\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~

\begin_inset ERT
status collapsed

\begin_layout Standard

$
\backslash
int _a^b f(x)dx$
\end_layout

\end_inset


\end_layout

\begin_layout Enumerate
Operators : $
\backslash
pm 
\backslash
div 
\backslash
times 
\backslash
cup 
\backslash
ast 
\backslash
$\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~
\InsetSpace ~

\begin_inset ERT
status collapsed

\begin_layout Standard

$
\backslash
pm 
\backslash
div 
\backslash
times 
\backslash
cup 
\backslash
ast $
\end_layout

\end_inset


\end_layout

\begin_layout Section
Arrays and matrices 
\end_layout

\begin_layout Standard
To typeset arrays, use the array environment, that is similar to the tabular
 environment.
 Within an array environment, & character separates columns, 
\backslash

\backslash
 starts a new line.
 The command 
\backslash
hline inserts a horizontal line.
 Alignment of the columns is shown inside braces using characters (lcr)
 and the | symbol is used for adding vertical lines.
 An example of making a table is shown below.
 
\end_layout

\begin_layout Quotation
$ 
\backslash
begin{array}{|l|cr|}
\backslash
hline
\end_layout

\begin_layout Quotation
person & sex & age 
\backslash

\backslash

\end_layout

\begin_layout Quotation
John & male & 20 
\backslash

\backslash
 
\end_layout

\begin_layout Quotation
Mary & female & 10 
\backslash

\backslash
 
\end_layout

\begin_layout Quotation
Gopal & male & 30 
\backslash

\backslash
 
\end_layout

\begin_layout Quotation

\backslash
hline
\end_layout

\begin_layout Quotation

\backslash
end{array} $
\end_layout

\begin_layout Standard
\begin_inset ERT
status collapsed

\begin_layout Standard

$
\end_layout

\begin_layout Standard


\backslash
begin{array}{|l|cr|}
\backslash
hline
\end_layout

\begin_layout Standard

person & sex & age 
\backslash

\backslash

\end_layout

\begin_layout Standard

John & male & 7 
\backslash

\backslash
 
\end_layout

\begin_layout Standard

Mary & female & 20 
\backslash

\backslash
 
\end_layout

\begin_layout Standard

Gopal & male & 30 
\backslash

\backslash
 
\end_layout

\begin_layout Standard


\backslash
hline
\end_layout

\begin_layout Standard


\backslash
end{array} 
\end_layout

\begin_layout Standard

$
\end_layout

\end_inset


\end_layout

\begin_layout Standard
The first column is left justified, second is centered and the third is
 right justified (decided by the {|l|cr|}).
 If you insert a | character between c and r, it will add a vertical line
 between second and third columns.
 
\end_layout

\begin_layout Standard
Let us make a matrix using the same command.
\end_layout

\begin_layout Quotation
$ A = 
\backslash
left( 
\end_layout

\begin_layout Quotation

\backslash
begin{array}{ccc} 
\end_layout

\begin_layout Quotation
x_1 & x_2 & 
\backslash
ldots 
\backslash

\backslash

\end_layout

\begin_layout Quotation
y_1 & y_2 & 
\backslash
ldots 
\backslash

\backslash
 
\end_layout

\begin_layout Quotation

\backslash
vdots & 
\backslash
vdots & 
\backslash
ddots 
\backslash

\backslash

\end_layout

\begin_layout Quotation

\backslash
end{array} 
\end_layout

\begin_layout Quotation

\backslash
right) $
\end_layout

\begin_layout Standard
The output is shown below.
 The 
\backslash
left( and 
\backslash
right) provides the enclosure.
 All the columns are centered.
 We have also used horizontal, vertical and diagonal dots in this example.
\end_layout

\begin_layout Standard
\begin_inset ERT
status collapsed

\begin_layout Standard

$
\end_layout

\begin_layout Standard

A = 
\backslash
left( 
\end_layout

\begin_layout Standard


\backslash
begin{array}{ccc} 
\end_layout

\begin_layout Standard

x_1 & x_2 & 
\backslash
ldots 
\backslash

\backslash

\end_layout

\begin_layout Standard

y_1 & y_2 & 
\backslash
ldots 
\backslash

\backslash
 
\end_layout

\begin_layout Standard


\backslash
vdots & 
\backslash
vdots & 
\backslash
ddots 
\backslash

\backslash

\end_layout

\begin_layout Standard


\backslash
end{array} 
\end_layout

\begin_layout Standard


\backslash
right) $
\end_layout

\end_inset


\end_layout

\begin_layout Section
Floating bodies, Inserting Images
\end_layout

\begin_layout Standard
Figures and tables need special treatment, because they cannot be broken
 across pages.
 One method would be to start a new page every time a figure or a table
 is too large to fit on the present page.
 This approach would leave pages partially empty, which looks very bad.
 The easiest solution is to 
\shape italic
float
\shape default
 them and let LaTeX decide the position.
 ( You can influence the placement of the floats using the arguments [htbp],
 here, top, bottom or special page).
 Any material enclosed in a figure or table environment will be treated
 as floating matter.
 The 
\shape italic
graphicsx
\shape default
 packages is required in this case.
\end_layout

\begin_layout Standard

\backslash
usepackage{graphicx} 
\end_layout

\begin_layout Standard

\backslash
text{Learn how to insert pictures with caption inside the figure environment.}
\end_layout

\begin_layout Standard

\backslash
begin{figure}[h]
\end_layout

\begin_layout Standard

\backslash
centering 
\end_layout

\begin_layout Standard

\backslash
includegraphics[width=0.2
\backslash
textwidth]{pics/arcs.png}
\end_layout

\begin_layout Standard

\backslash
includegraphics[width=0.2
\backslash
textwidth]{pics/sawtooth.png}
\end_layout

\begin_layout Standard

\backslash
caption{Picture of Arc and Sawtooth, inserted with [h] option.}
\end_layout

\begin_layout Standard

\backslash
end{figure} 
\end_layout

\begin_layout Standard
\align left
The result is shown below.
 
\lyxline

\end_layout

\begin_layout Standard
\begin_inset ERT
status open

\begin_layout Standard


\backslash
textit{Learn how to insert pictures with caption inside the figure environment.}
\end_layout

\begin_layout Standard


\backslash
begin{figure}[h]
\end_layout

\begin_layout Standard


\backslash
centering 
\end_layout

\begin_layout Standard


\backslash
includegraphics[width=0.2
\backslash
textwidth]{pics/arcs.png}
\end_layout

\begin_layout Standard


\backslash
includegraphics[width=0.2
\backslash
textwidth]{pics/sawtooth.png}
\end_layout

\begin_layout Standard


\backslash
caption{Picture of Arc and Sawtooth, inserted with [h] option.}
\end_layout

\begin_layout Standard


\backslash
end{figure} 
\end_layout

\end_inset


\lyxline

\end_layout

\begin_layout Section
Example Application
\end_layout

\begin_layout Standard
Latex source code for a simple question paper listed below.
\end_layout

\begin_layout Standard
\align left

\emph on
Example qpaper.tex
\end_layout

\begin_layout Quotation

\backslash
documentclass{article} 
\end_layout

\begin_layout Quotation

\backslash
usepackage{amsmath} 
\end_layout

\begin_layout Quotation
begin{document}
\end_layout

\begin_layout Quotation

\backslash
begin{center} 
\end_layout

\begin_layout Quotation

\backslash
large{
\backslash
textbf{Sample Question Paper
\backslash

\backslash
for
\backslash

\backslash

\end_layout

\begin_layout Quotation
Mathematics using Python}} 
\end_layout

\begin_layout Quotation

\backslash
end{center}
\end_layout

\begin_layout Quotation

\backslash
begin{tabular}{p{8cm}r} 
\end_layout

\begin_layout Quotation

\backslash
textbf{Duration:3 Hrs} & 
\backslash
textbf{30 weightage} 
\end_layout

\begin_layout Quotation

\backslash
end{tabular}
\backslash

\backslash

\end_layout

\begin_layout Quotation

\backslash
section{Answer all Questions.
 $4
\backslash
times 1
\backslash
frac{1}{2}$} 
\end_layout

\begin_layout Quotation

\backslash
begin{enumerate} 
\end_layout

\begin_layout Quotation

\backslash
item What are the main document classes in LaTeX.
 
\end_layout

\begin_layout Quotation

\backslash
item Typeset $
\backslash
sin^{2}x+
\backslash
cos^{2}x=1$ using LaTeX.
 
\end_layout

\begin_layout Quotation

\backslash
item Plot a circle using the polar() function.
 
\end_layout

\begin_layout Quotation

\backslash
item Write code to print all perfect cubes upto 2000.
\end_layout

\begin_layout Quotation

\backslash
end{enumerate} 
\end_layout

\begin_layout Quotation

\backslash
section{Answer any two Questions.
 $3
\backslash
times 5$} 
\end_layout

\begin_layout Quotation

\backslash
begin{enumerate} 
\end_layout

\begin_layout Quotation

\backslash
item Set a sample question paper using LaTeX.
 
\end_layout

\begin_layout Quotation

\backslash
item Using Python calculate the GCD of two numbers 
\end_layout

\begin_layout Quotation

\backslash
item Write a program with a Canvas and a circle.
 
\end_layout

\begin_layout Quotation

\backslash
end{enumerate} 
\end_layout

\begin_layout Quotation

\backslash
begin{center}
\backslash
text{End}
\backslash
end{center}
\end_layout

\begin_layout Quotation

\backslash
end{document}
\end_layout

\begin_layout Standard
The formatted output is shown below.
\end_layout

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/qpaper.png
	width 12cm

\end_inset


\end_layout

\begin_layout Section
Exercises
\end_layout

\begin_layout Enumerate
What are the main document classes supported by LaTeX.
\end_layout

\begin_layout Enumerate
How does Latex differ from other word processor programs.
\end_layout

\begin_layout Enumerate
Write a .tex file to typeset 'All types of Text Available' in tiny, large,
 underline and italic.
\end_layout

\begin_layout Enumerate
Rewrite the previous example to make the output a list of numbered lines.
\end_layout

\begin_layout Enumerate
Generate an article with section and subsections with table of contents.
\end_layout

\begin_layout Enumerate
Typeset 'All types of justifications' to print it three times; left, right
 and centered.
\end_layout

\begin_layout Enumerate
Write a .tex file that prints 12345 in five lines (one character per line).
\end_layout

\begin_layout Enumerate
Typeset a Python program to generate the multiplication table of 5, using
 verbatim.
\end_layout

\begin_layout Enumerate
Typeset 
\begin_inset Formula $\sin^{2}x+\cos^{2}x=1$
\end_inset


\end_layout

\begin_layout Enumerate
Typeset 
\begin_inset Formula $\left(\sqrt{x^{2}+y^{2}}\right)^{2}=x^{2}+y^{2}$
\end_inset


\end_layout

\begin_layout Enumerate
Typeset 
\begin_inset Formula $\sum_{n=1}^{\infty}\left(1+\frac{1}{n}\right)^{n}$
\end_inset


\end_layout

\begin_layout Enumerate
Typeset 
\begin_inset Formula $\frac{\partial A}{\partial x}=A$
\end_inset


\end_layout

\begin_layout Enumerate
Typeset 
\begin_inset Formula $\int_{0}^{\pi}\cos x.dx$
\end_inset


\end_layout

\begin_layout Enumerate
Typeset 
\begin_inset Formula $x=\frac{-b\pm\sqrt{b^{2}-4ac}}{2a}$
\end_inset


\end_layout

\begin_layout Enumerate
Typeset 
\begin_inset Formula $A=\left(\begin{array}{cc}
1 & 2\\
3 & 4\end{array}\right)$
\end_inset


\end_layout

\begin_layout Enumerate
Typeset 
\begin_inset Formula $R=\left(\begin{array}{cc}
\sin\theta & \cos\theta\\
\cos\theta & \sin\theta\end{array}\right)$
\end_inset


\end_layout

\begin_layout Chapter
Numerical methods 
\end_layout

\begin_layout Standard
Solving mathematical equations is an important requirement for various branches
 of science but many of them evade an analytic solution.
 The field of numerical analysis explores the techniques that give approximate
 but accurate solutions to such problems.
\begin_inset Foot
status collapsed

\begin_layout Standard
Introductory methods of numerical analysis by S.S.Sastry
\end_layout

\begin_layout Standard
http://ads.harvard.edu/books/1990fnmd.book/
\end_layout

\end_inset

 Even when they have a solution, for all practical purposes we need to evaluate
 the numeric value of the result, with the desired accuracy.
 We will focus on developing simple working programs rather than going into
 the theoretical details.
 The mathematical equations giving numerical solutions will be explored
 by changing various parameters and nature of input data.
\end_layout

\begin_layout Section
Derivative of a function
\end_layout

\begin_layout Standard
The mathematical definition of the derivative of a function 
\begin_inset Formula $f(x)$
\end_inset

 at point 
\begin_inset Formula $x$
\end_inset

 can be approximated by equation
\end_layout

\begin_layout Standard
\begin_inset Formula \begin{equation}
{lim\atop \Delta x\rightarrow0}\frac{f(x+\frac{\triangle x}{2})-f(x-\frac{\triangle x}{2})}{\triangle x}\label{eq:derivative}\end{equation}

\end_inset


\end_layout

\begin_layout Standard
neglecting the higher order terms.
 The accuracy of the derivative calculated using discrete values
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
 depends on the stepsize 
\begin_inset Formula $\triangle x$
\end_inset

.
 It will also depends on the number of higher order derivatives the function
 has.
 We will try to explore these aspects using the program 
\family default
\series default
\shape default
\size default
\emph on
\bar default
\noun default
\color black
diff.py
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
 , which evaluates the derivatives of few functions using two different
 stepsizes (0.1 ans 0.01).
 The input values to function deriv() are the function to be differentiated,
 the point at which the derivative is to be found and the stepsize 
\begin_inset Formula $\triangle x$
\end_inset

.
 
\end_layout

\begin_layout Standard
\align left

\emph on
Example diff.py
\end_layout

\begin_layout LyX-Code
def f1(x):
\end_layout

\begin_layout LyX-Code
        return x**2
\end_layout

\begin_layout LyX-Code
def f2(x):
\end_layout

\begin_layout LyX-Code
        return x**4
\end_layout

\begin_layout LyX-Code
def f3(x):
\end_layout

\begin_layout LyX-Code
        return x**10
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
def deriv(func, x, dx=0.1):
\end_layout

\begin_layout LyX-Code
        df = func(x+dx/2)-func(x-dx/2)
\end_layout

\begin_layout LyX-Code
        return df/dx
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
print deriv(f1, 1.0), deriv(f1, 1.0, 0.01)
\end_layout

\begin_layout LyX-Code
print deriv(f2, 1.0), deriv(f2, 1.0, 0.01)
\end_layout

\begin_layout LyX-Code
print deriv(f3, 1.0), deriv(f3, 1.0, 0.01)
\end_layout

\begin_layout Standard
The output of the program is shown below.
 Comparing the two numbers on the same line shows the effect of stepsize.
 Comparing the first number on each row shows the effect of the number of
 higher order derivatives the function has.
 For the same stepsize 
\begin_inset Formula $x^{4}$
\end_inset

 gives much less error than 
\begin_inset Formula $x^{10}$
\end_inset

.
 Second derivative of 
\begin_inset Formula $x^{2}$
\end_inset

 is constant and the result becomes exact, result on the first line.
\end_layout

\begin_layout Quotation
2.0 2.0 
\end_layout

\begin_layout Quotation
4.01 4.0001
\end_layout

\begin_layout Quotation
10.3015768754 10.0030001575
\end_layout

\begin_layout Standard
You may explore other functions by modifying the program.
 
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
It can be seen that the function deriv(), evaluates the function at two
 points to calculate the derivative.
 The higher order terms can be calculated by evaluating the function at
 more points.
 Techniques used for this will be discussed in section 
\begin_inset LatexCommand ref
reference "sec:Interpolation"

\end_inset

, on interpolation.
\end_layout

\begin_layout Subsection
Differentiate Sine to get Cosine
\end_layout

\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/vdiff.png
	lyxscale 50
	width 6cm

\end_inset

 
\begin_inset Graphics
	filename pics/vdiff_bigerror.png
	lyxscale 50
	width 6cm

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Caption

\begin_layout Standard
Outputs of vdiff.py (a)for 
\begin_inset Formula $\triangle x=0.005$
\end_inset

 (b) for 
\begin_inset Formula $\triangle x=1.0$
\end_inset


\begin_inset LatexCommand label
name "fig:Outputs-of-vdiff.py"

\end_inset


\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
The program 
\emph on
\color black
diff.py
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
 in the previous example can only calculate the value of the derivative
 at a given point.
 In the program 
\family default
\series default
\shape default
\size default
\emph on
\bar default
\noun default
\color black
vdiff.py
\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
, we use a vectorized version of our deriv() function.
 The defined function is sine and the derivative is calculated using the
 vectorized version of deriv().
 The actual cosine function also is plotted for comparison.
 The output of vdiff.py is shown in 
\begin_inset LatexCommand ref
reference "fig:Outputs-of-vdiff.py"

\end_inset

(a).
 
\end_layout

\begin_layout Standard

\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
The value of 
\begin_inset Formula $\triangle x$
\end_inset

 is increased to 1.0 
\family default
\series default
\shape default
\size default
\emph default
\bar default
\noun default
\color inherit
by changing one line of code as 
\begin_inset Formula $y=vecderiv(x,1.0)$
\end_inset

 and the result is shown in 
\begin_inset LatexCommand ref
reference "fig:Outputs-of-vdiff.py"

\end_inset

(b).
 The values calculated using our function is shown using 
\begin_inset Formula $+$
\end_inset

marker, while the continuous curve is the expected result , ie.
 the cosine curve.
\end_layout

\begin_layout Standard
\align left

\emph on
Example vdiff.py
\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
def f(x):
\end_layout

\begin_layout LyX-Code
        return sin(x)
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
def deriv(x,dx=0.005):
\end_layout

\begin_layout LyX-Code
        df = f(x+dx/2)-f(x-dx/2)
\end_layout

\begin_layout LyX-Code
        return df/dx
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
vecderiv = vectorize(deriv)
\end_layout

\begin_layout LyX-Code
x = linspace(-2*pi, 2*pi, 200)
\end_layout

\begin_layout LyX-Code
y = vecderiv(x)
\end_layout

\begin_layout LyX-Code
plot(x,y,'+')
\end_layout

\begin_layout LyX-Code
plot(x,cos(x))
\end_layout

\begin_layout LyX-Code
show()
\end_layout

\begin_layout Section
Numerical Integration
\end_layout

\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status open

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/integ1.png
	lyxscale 50
	width 5cm

\end_inset


\begin_inset Graphics
	filename pics/integ2.png
	lyxscale 50
	width 5cm

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Caption

\begin_layout Standard
Area under the curve is divided it in to a large number of intervals.
 Area of each of them is calculated by assuming them to be trapezoids.
\begin_inset LatexCommand label
name "fig:Integration"

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard

\end_layout

\end_inset


\end_layout

\begin_layout Standard
Numerical integration constitutes a broad family of algorithms for calculating
 the numerical value of a definite integral.
 The objective is to find the area under the curve as shown in figure 
\begin_inset LatexCommand ref
reference "fig:Integration"

\end_inset

.
 One method is to divide this area in to large number of sub-intervals and
 find the sum of their areas.
 The interval 
\begin_inset Formula $a\leq x\leq b$
\end_inset

 is divided in to 
\begin_inset Formula $n$
\end_inset

 sub-intervals, each of length 
\begin_inset Formula $h=(b-a)/n$
\end_inset

, and area of a sub-interval is approximated by
\begin_inset Formula \[
\int_{x_{n-1}}^{x_{n}}ydx=\frac{h}{2}(y_{n-1}+y_{n})\]

\end_inset

the integral is given by
\end_layout

\begin_layout Standard
\begin_inset Formula \begin{equation}
\int_{a}^{b}ydx=\frac{h}{2}\left[y_{0}+2(y_{1}+y_{2}+\ldots+y_{n-1})+y_{n}\right]\label{eq:Trapez}\end{equation}

\end_inset

 This is the sum of the areas of the individual trapezoids.
 The error in using the trapezoid rule is approximately proportional to
 
\begin_inset Formula $1/n^{2}$
\end_inset

.
 If the number of sub-intervals is doubled, the error is reduced by a factor
 of 4.
 The program 
\emph on
trapez.py
\emph default
 does integration of a given function using equation 
\begin_inset LatexCommand ref
reference "eq:Trapez"

\end_inset

.
 We will choose an example where the results can be cross checked easily,
 the value of 
\begin_inset Formula $\pi$
\end_inset

 is calculated by evaluating the area of a unit circle by integrating the
 equation of a circle.
\end_layout

\begin_layout Standard
\align left

\emph on
Example trapez.py
\end_layout

\begin_layout LyX-Code
from math import *
\end_layout

\begin_layout LyX-Code
def y(x): # equation of a circle
\end_layout

\begin_layout LyX-Code
    return sqrt(1.0 - x**2)
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
def trapez(f, a, b, n):
\end_layout

\begin_layout LyX-Code
    h = (b-a) / n
\end_layout

\begin_layout LyX-Code
    sum = 0
\end_layout

\begin_layout LyX-Code
    x = 0.5 * h   # f(x) at middle of the slice
\end_layout

\begin_layout LyX-Code
    for i in range (1,n):
\end_layout

\begin_layout LyX-Code
        sum = sum + h * f(x)
\end_layout

\begin_layout LyX-Code
        x = x + h
\end_layout

\begin_layout LyX-Code
    return sum
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
print 4 * trapez(y, 0.0, 1.0,1000)
\end_layout

\begin_layout LyX-Code
print 4 * trapez(y, 0.0, 1.0,10000)
\end_layout

\begin_layout LyX-Code
print trapez(sin,0,2,1000)   # Why the error ?
\end_layout

\begin_layout Standard
The output is shown below.
 The result gets better by increasing 
\begin_inset Formula $n$
\end_inset

 thus resulting in smaller 
\begin_inset Formula $h$
\end_inset

.
 The last line shows, how things can go wrong if the arguments are given
 in the integer format.
 Learn how to avoid such pitfalls while writing programs.
 It is left as an exercise to the reader to modify the function trapez()
 to accept integer arguments also.
\end_layout

\begin_layout Standard
3.14041703178
\end_layout

\begin_layout Standard
3.14155546691 
\end_layout

\begin_layout Standard
0.0
\end_layout

\begin_layout Section
Ordinary Differential Equations
\end_layout

\begin_layout Standard
Differential equations are one of the most important mathematical tools
 used in producing models for physical and biological processes.
 In this section, we will discuss the numerical methods for solving the
 initial value problem for first-order ordinary differential equations.
 Consider the equation,
\end_layout

\begin_layout Standard
\begin_inset Formula \begin{equation}
\frac{dy}{dx}=f(x,y);\,\,\,\, y(x_{0})=y_{0}\label{eq:ODE}\end{equation}

\end_inset


\end_layout

\begin_layout Standard
where the derivative of the function 
\begin_inset Formula $f(x,y)$
\end_inset

 is known and the value of the function at some value of 
\begin_inset Formula $x=x_{0}$
\end_inset

 also is known.
 The objective is to find out the value of the function for other values
 of 
\begin_inset Formula $x$
\end_inset

.
 The underlying idea of any routine for solving the initial value problem
 is to rewrite the 
\begin_inset Formula $dy$
\end_inset

 and 
\begin_inset Formula $dx$
\end_inset

 as finite steps 
\begin_inset Formula $\triangle y$
\end_inset

 and 
\begin_inset Formula $\triangle x$
\end_inset

, and multiply the equations by 
\begin_inset Formula $\triangle x$
\end_inset

.
 This gives algebraic formulas for the change in the value of 
\begin_inset Formula $y(x)$
\end_inset

 when 
\begin_inset Formula $x$
\end_inset

 is changed by one stepsize 
\begin_inset Formula $\triangle x$
\end_inset

 .
 In the limit of making the stepsize very small, a good approximation to
 the underlying differential equation is achieved.
 
\end_layout

\begin_layout Standard
Implementation of this procedure results in the Euler’s method, which is
 conceptually very important, but not recommended for any practical use.
 In this section we will discuss Euler's method and the Runge-Kutta method
 with the help of example programs.
 For detailed information refer to 
\begin_inset LatexCommand cite
key "numerical recepies,mathcs.emory"

\end_inset

.
\end_layout

\begin_layout Subsection
Euler method
\end_layout

\begin_layout Standard
The equations of Euler's method can be obtained as follows.
 By the definition of derivative,
\end_layout

\begin_layout Standard
\begin_inset Formula \begin{equation}
y^{'}(x_{n},y_{n})={lim\atop h\rightarrow0}\frac{y(x_{n}+h)-y(x_{n})}{h}\label{eq:Euler}\end{equation}

\end_inset


\end_layout

\begin_layout Standard
For sufficiently small values of 
\begin_inset Formula $h$
\end_inset

 , we can write,
\end_layout

\begin_layout Standard
\begin_inset Formula \begin{equation}
y(x_{n}+h)=y(x_{n},y_{n})+hy^{'}(x_{n})\label{eq:Euler2}\end{equation}

\end_inset


\end_layout

\begin_layout Standard
The above equations implies that, if the value of the function 
\begin_inset Formula $y(x)$
\end_inset

 is known to be 
\begin_inset Formula $y_{n}$
\end_inset

 at the point 
\begin_inset Formula $x_{n}$
\end_inset

, its value at a nearby point 
\begin_inset Formula $x_{n+1}$
\end_inset

 is given by 
\begin_inset Formula $y_{n}+h\times y^{'}.$
\end_inset

 The program 
\emph on
euler.py
\emph default
 calculates the value of sine function using its derivative, ie.
 the cosine function.
 We start from 
\begin_inset Formula $x=0$
\end_inset

 , where 
\begin_inset Formula $\sin(x)=0$
\end_inset

 and compute the subsequent values using the derivative, 
\begin_inset Formula $cos(x)$
\end_inset

, and compare the result with the actual sine function.
\end_layout

\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/euler.png
	lyxscale 50
	width 6cm

\end_inset


\begin_inset Graphics
	filename pics/rkmethod.png
	width 6cm

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Caption

\begin_layout Standard
(a)Output of euler.py (b)Four intermediate steps of RK4 method
\begin_inset LatexCommand label
name "fig:Output-of-euler.py"

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard

\end_layout

\end_inset


\end_layout

\begin_layout Standard
\align left

\emph on
Example euler.py
\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
h = 0.01    # stepsize 
\end_layout

\begin_layout LyX-Code
x = 0.0     # initial values 
\end_layout

\begin_layout LyX-Code
y = 0.0
\end_layout

\begin_layout LyX-Code
ax = []  # Lists to store x and y
\end_layout

\begin_layout LyX-Code
ay = []
\end_layout

\begin_layout LyX-Code
while x < 2*pi:
\end_layout

\begin_layout LyX-Code
     y = y + h * math.cos(x)   # Euler equation
\end_layout

\begin_layout LyX-Code
     x = x + h      
\end_layout

\begin_layout LyX-Code
     ax.append(x)
\end_layout

\begin_layout LyX-Code
     ay.append(y)
\end_layout

\begin_layout LyX-Code
plot(ax,ay) 
\end_layout

\begin_layout LyX-Code
show() 
\end_layout

\begin_layout Standard
The output of 
\emph on
euler.py
\emph default
 is shown in figure 
\begin_inset LatexCommand ref
reference "fig:Output-of-euler.py"

\end_inset

.
\end_layout

\begin_layout Subsection
Runge-Kutta method
\end_layout

\begin_layout Standard
The formula 
\begin_inset LatexCommand ref
reference "eq:Euler"

\end_inset

 used by Euler method which advances a solution from 
\begin_inset Formula $x_{n}tox_{n+1}$
\end_inset

 is not symmetric, it advances the solution through an interval 
\begin_inset Formula $h$
\end_inset

, but uses derivative information only at the beginning of that interval.
 Better results are obtained if we take 
\shape italic
trial
\shape default
 step to the midpoint of the interval and use the value of both 
\begin_inset Formula $x$
\end_inset

 and 
\begin_inset Formula $y$
\end_inset

 at that midpoint to compute the 
\shape italic
real
\shape default
 step across the whole interval.
 This is called the second-order Runge-Kutta or the midpoint method.
 This procedure can be further extended to higher orders.
 
\end_layout

\begin_layout Standard
The fourth order Runge-Kutta method is the most popular one and is commonly
 referred as the Runge-Kutta method.
 In each step the derivative is evaluated four times as shown in figure
 
\begin_inset LatexCommand ref
reference "fig:Outputs-of-(a)rk4.py"

\end_inset

(a).
 Once at the initial point, twice at trial midpoints, and once at a trial
 endpoint.
 Every trial evaluation uses the value of the function from the previous
 trial point, ie.
 
\begin_inset Formula $k_{2}$
\end_inset

 is evaluated using 
\begin_inset Formula $k_{1}$
\end_inset

 and not using 
\begin_inset Formula $y_{n}$
\end_inset

.
 From these derivatives the final function value is calculated, The calculation
 is done using the equations,
\end_layout

\begin_layout Standard
\align center
\begin_inset Formula $\begin{array}{c}
k_{1}=hf(x_{n},y_{n})\\
k_{2}=hf(x_{n}+\frac{h}{2},y_{n}+\frac{k_{1}}{2})\\
k_{3}=hf(x_{n}+\frac{h}{2},y_{n}+\frac{k_{2}}{2})\\
k_{4}=hf(x_{n}+h,y_{n}+k_{3})\end{array}$
\end_inset


\end_layout

\begin_layout Standard
\begin_inset Formula \begin{equation}
y_{n+1}=y_{n}+\frac{1}{6}\left(k_{1}+2k_{2}+2k_{3}+k_{4}\right)\label{eq:Runge-Kutta4}\end{equation}

\end_inset


\end_layout

\begin_layout Standard
The program rk4.py listed below uses the equations shown above to calculate
 the sine function, by integrating the cosine.
 The output is shown in figure 
\begin_inset LatexCommand ref
reference "fig:Outputs-of-(a)rk4.py"

\end_inset

(a).
\end_layout

\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/rk4.png
	lyxscale 50
	width 6cm

\end_inset

 
\begin_inset Graphics
	filename pics/eurk4.png
	lyxscale 50
	width 6cm

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Caption

\begin_layout Standard
Outputs of (a)rk4.py (b) compareEuRK4.py
\begin_inset LatexCommand label
name "fig:Outputs-of-(a)rk4.py"

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard

\end_layout

\end_inset


\end_layout

\begin_layout Standard
\align left

\emph on
Example rk4.py
\end_layout

\begin_layout LyX-Code
from pylab import * 
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
def rk4(x, y, fx, h = 0.1):   # x, y , f(x), stepsize
\end_layout

\begin_layout LyX-Code
    k1 = h * fx(x)
\end_layout

\begin_layout LyX-Code
    k2 = h * fx(x + h/2.0)
\end_layout

\begin_layout LyX-Code
    k3 = h * fx(x + h/2.0)
\end_layout

\begin_layout LyX-Code
    k4 = h * fx(x + h)
\end_layout

\begin_layout LyX-Code
    return y + ( k1/6 + k2/3 + k3/3 + k4/6 )
\end_layout

\begin_layout LyX-Code
  
\end_layout

\begin_layout LyX-Code
h = 0.01    # stepsize
\end_layout

\begin_layout LyX-Code
x = 0.0     # initial values
\end_layout

\begin_layout LyX-Code
y = 0.0
\end_layout

\begin_layout LyX-Code
ax = [x]
\end_layout

\begin_layout LyX-Code
ay = [y]
\end_layout

\begin_layout LyX-Code
while x < math.pi:
\end_layout

\begin_layout LyX-Code
     y = rk4(x,y,math.cos)       
\end_layout

\begin_layout LyX-Code
     x = x + h
\end_layout

\begin_layout LyX-Code
     ax.append(x)
\end_layout

\begin_layout LyX-Code
     ay.append(y)
\end_layout

\begin_layout LyX-Code
plot(ax,ay)
\end_layout

\begin_layout LyX-Code
show() 
\end_layout

\begin_layout Standard
The program compareEuRK4.py calculates the values of Sine by integrating
 Cosine.
 The errors in both cases are evaluated at every step, by comparing it with
 the sine function, and plotted as shown in figure 
\begin_inset LatexCommand ref
reference "fig:Outputs-of-(a)rk4.py"

\end_inset

(b).
 The accuracy of Runge-Kutta method is far superior to that of Euler's method,
 for the same step size.
 
\end_layout

\begin_layout Standard
\align left

\emph on
Example compareEuRK4.py
\end_layout

\begin_layout LyX-Code
from scipy import *
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
def rk4(x, y, fx, h = 0.1):   # x, y , f(x), stepsize
\end_layout

\begin_layout LyX-Code
    k1 = h * fx(x)
\end_layout

\begin_layout LyX-Code
    k2 = h * fx(x + h/2.0)
\end_layout

\begin_layout LyX-Code
    k3 = h * fx(x + h/2.0)
\end_layout

\begin_layout LyX-Code
    k4 = h * fx(x + h)
\end_layout

\begin_layout LyX-Code
    return y + ( k1/6 + k2/3 + k3/3 + k4/6 )
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
h = 0.1    # stepsize
\end_layout

\begin_layout LyX-Code
x = 0.0    # initial values
\end_layout

\begin_layout LyX-Code
ye = 0.0   # for Euler
\end_layout

\begin_layout LyX-Code
yr = 0.0   # for RK4
\end_layout

\begin_layout LyX-Code
ax = []    # Lists to store results 
\end_layout

\begin_layout LyX-Code
euerr = [] 
\end_layout

\begin_layout LyX-Code
rkerr = []
\end_layout

\begin_layout LyX-Code
while x < 2*pi:
\end_layout

\begin_layout LyX-Code
    ye = ye + h * math.cos(x)  # Euler method  
\end_layout

\begin_layout LyX-Code
    yr = rk4(x, yr, cos, h)    # RK4 method
\end_layout

\begin_layout LyX-Code
    x = x + h
\end_layout

\begin_layout LyX-Code
    ax.append(x)
\end_layout

\begin_layout LyX-Code
    euerr.append(ye - sin(x))
\end_layout

\begin_layout LyX-Code
    rkerr.append(yr - sin(x))
\end_layout

\begin_layout LyX-Code
plot(ax,euerr,'o')
\end_layout

\begin_layout LyX-Code
plot(ax, rkerr,'+')
\end_layout

\begin_layout LyX-Code
show()
\end_layout

\begin_layout Subsection
Function depending on the integral
\end_layout

\begin_layout Standard
In the previous section, the program 
\shape italic
rk4.py
\shape default
 implemented a simplified version of the Runge-Kutta method, the function
 was assumed to depend on the independent variable only.
 The program 
\shape italic
rk4_proper.py
\shape default
 listed below implements it properly.
 The functions 
\begin_inset Formula $f(x,y)=1+y^{2}$
\end_inset

 and 
\begin_inset Formula $f(x,y)=(y-x)/y+x)$
\end_inset

 are used for testing.
 Readers may verify the results by manual computing.
 
\end_layout

\begin_layout Standard
\align left

\emph on
Example rk4_proper.py
\end_layout

\begin_layout LyX-Code
def f1(x,y):
\end_layout

\begin_layout LyX-Code
   return 1 + y**2
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
def f2(x,y):
\end_layout

\begin_layout LyX-Code
   return (y-x)/(y+x)
\end_layout

\begin_layout LyX-Code
  
\end_layout

\begin_layout LyX-Code
def rk4(x, y, fxy, h):  # x, y , f(x,y), step
\end_layout

\begin_layout LyX-Code
   k1 = h * fxy(x, y)
\end_layout

\begin_layout LyX-Code
   k2 = h * fxy(x + h/2.0, y+k1/2) 
\end_layout

\begin_layout LyX-Code
   k3 = h * fxy(x + h/2.0, y+k2/2)
\end_layout

\begin_layout LyX-Code
   k4 = h * fxy(x + h, y+k3)
\end_layout

\begin_layout LyX-Code
   ny = y + ( k1/6 + k2/3 + k3/3 + k4/6 )
\end_layout

\begin_layout LyX-Code
   #print x,y,k1,k2,k3,k4, ny
\end_layout

\begin_layout LyX-Code
   return ny
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
h = 0.2   # stepsize 
\end_layout

\begin_layout LyX-Code
x = 0.0   # initial values
\end_layout

\begin_layout LyX-Code
y = 0.0 
\end_layout

\begin_layout LyX-Code
print rk4(x,y, f1, h)  
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
h = 1
\end_layout

\begin_layout LyX-Code
x = 0.0    # initial values
\end_layout

\begin_layout LyX-Code
y = 1.0 
\end_layout

\begin_layout LyX-Code
print rk4(x,y,f2,h)
\end_layout

\begin_layout Standard
The results are shown below.
\end_layout

\begin_layout Standard
0.202707408081
\end_layout

\begin_layout Standard
1.5056022409
\end_layout

\begin_layout Section
Polynomials
\begin_inset LatexCommand label
name "sec:Polynomials"

\end_inset


\end_layout

\begin_layout Standard
A polynomial is a mathematical expression involving a sum of powers in one
 or more variables multiplied by coefficients.
 A polynomial in one variable with constant coefficients is given by
\begin_inset Formula \begin{equation}
a_{n}x^{n}+...+a_{2}x^{2}+a_{1}x+a_{0}\label{eq:Polinomial}\end{equation}

\end_inset


\end_layout

\begin_layout Standard
The derivative of 
\begin_inset LatexCommand ref
reference "eq:Polinomial"

\end_inset

 is,
\end_layout

\begin_layout Standard
\begin_inset Formula \[
na_{n}x^{n-1}+...+2a_{2}x+a_{1}\]

\end_inset


\end_layout

\begin_layout Standard
It is easy to find the derivative of a polynomial.
 Complicated functions can be analyzed by approximating them with polynomials.
 Taylor's theorem states that any sufficiently smooth function can locally
 be approximated by a polynomial.
 Computers use this property to evaluate trigonometric, logarithmic and
 exponential functions.
 
\end_layout

\begin_layout Standard
One dimensional polynomials can be explored using the 
\begin_inset Formula $poly1d$
\end_inset

 function from Numpy.
 You can define a polynomial by supplying the coefficient as a list.
 For example , the statement p = poly1d([3,4,7]) constructs the polynomial
 
\begin_inset Formula $3x^{2}+4x+7$
\end_inset

.
 Numpy supports several polynomial operations.
 The following example demonstrates evaluation at a particular value, multiplica
tion, differentiation, integration and division of polynomials using 
\shape italic
poly1d
\shape default
.
\end_layout

\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/polyplot.png
	lyxscale 50
	width 6cm

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Caption

\begin_layout Standard
Output of polyplot.py
\begin_inset LatexCommand label
name "fig:Output-of-polyplot.py"

\end_inset


\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\align left

\emph on
Example poly.py
\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
a = poly1d([3,4,5])
\end_layout

\begin_layout LyX-Code
b = poly1d([6,7])
\end_layout

\begin_layout LyX-Code
c = a * b + 5
\end_layout

\begin_layout LyX-Code
d = c/a
\end_layout

\begin_layout LyX-Code
print a
\end_layout

\begin_layout LyX-Code
print a(0.5)
\end_layout

\begin_layout LyX-Code
print b
\end_layout

\begin_layout LyX-Code
print a * b
\end_layout

\begin_layout LyX-Code
print a.deriv()
\end_layout

\begin_layout LyX-Code
print a.integ()
\end_layout

\begin_layout LyX-Code
print d[0], d[1]
\end_layout

\begin_layout Standard
The output of 
\emph on
\color black
poly.py
\emph default
\color inherit
 is shown below.
\end_layout

\begin_layout Standard
\begin_inset Formula $\begin{array}[b]{l}
3x^{2}+4x+5\\
7.75\\
6x+7\\
18x^{3}+45x^{2}+58x+35\\
6x+4\\
1x^{3}+2x^{2}+5x\\
6x+7\\
5\end{array}$
\end_inset


\end_layout

\begin_layout Standard
The last two lines show the result of the polynomial division, quotient
 and reminder.
 Note that a polynomial can take an array argument for evaluation to return
 the results in an array.
 The program 
\emph on
\color black
polyplot.py
\emph default
\color inherit
 evaluates polynomial 
\begin_inset LatexCommand ref
reference "eq:polynomial of Sine"

\end_inset

 and its first derivative.
 
\begin_inset Formula \begin{equation}
x-\frac{x^{3}}{6}+\frac{x^{5}}{120}-\frac{x^{7}}{5040}\label{eq:polynomial of Sine}\end{equation}

\end_inset


\end_layout

\begin_layout Standard
The results are shown in figure 
\begin_inset LatexCommand ref
reference "fig:Output-of-polyplot.py"

\end_inset

.
 The equation 
\begin_inset LatexCommand ref
reference "eq:polynomial of Sine"

\end_inset

 is the first four terms of series representing sine wave (7! = 5040).
 The derivative looks like cosine as expected.
 Try adding more terms and change the limits to see the effects.
\end_layout

\begin_layout Standard
\align left

\emph on
Example polyplot.py
\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
x = linspace(-pi, pi, 100)
\end_layout

\begin_layout LyX-Code
a = poly1d([-1.0/5040,0,1.0/120,0,-1.0/6,0,1,0])
\end_layout

\begin_layout LyX-Code
da = a.deriv() 
\end_layout

\begin_layout LyX-Code
y = a(x)
\end_layout

\begin_layout LyX-Code
y1 = da(x) 
\end_layout

\begin_layout LyX-Code
plot(x,y)
\end_layout

\begin_layout LyX-Code
plot(x,y1) 
\end_layout

\begin_layout LyX-Code
show()
\end_layout

\begin_layout Subsection
Taylor's Series
\begin_inset LatexCommand label
name "sub:Taylor's-Series"

\end_inset


\end_layout

\begin_layout Standard
If a function and its derivatives are known at some point 
\begin_inset Formula $x=a$
\end_inset

, we can express 
\begin_inset Formula $f(x)$
\end_inset

 in the vicinity of that point using a polynomial.
 The Taylor series expansion is given by,
\end_layout

\begin_layout Standard
\begin_inset Formula \begin{equation}
f(x)=f(a)+(x-a)f^{'}(a)+\frac{(x-a)^{2}}{2!}f^{''}(a)+\cdots+\frac{(x-a)^{n}}{n!}f^{n}(a)\label{eq:Taylor's Series}\end{equation}

\end_inset


\end_layout

\begin_layout Standard
For example let us consider the equation 
\begin_inset Formula \begin{equation}
f(x)=x^{3}+x^{2}+x\label{eq:xcube}\end{equation}

\end_inset


\end_layout

\begin_layout Standard
We can see that 
\begin_inset Formula $f(0)=0$
\end_inset

 and the derivatives are
\begin_inset Formula \[
f'(x)=3x^{2}+2x+1;\,\,\,\,\,\,\,\,\,\,\, f''(x)=6x+2;\,\,\,\,\,\, f'''(x)=6\]

\end_inset


\end_layout

\begin_layout Standard
Using the values of the derivatives at 
\begin_inset Formula $x=0$
\end_inset

and equation 
\begin_inset LatexCommand ref
reference "eq:Taylor's Series"

\end_inset

, we evaluate the function at 
\begin_inset Formula $x=.5$
\end_inset

, using the polynomial expression,
\end_layout

\begin_layout Standard
\begin_inset Formula \[
f(0.5)=0+0.5\times1+\frac{0.5^{2}\times2}{2!}+\frac{0.5^{3}\times6}{3!}=.875\]

\end_inset


\end_layout

\begin_layout Standard
The result is same as 
\begin_inset Formula $0.5^{3}+0.5^{2}+0.5=.875$
\end_inset

.
 We have calculated it manually for 
\begin_inset Formula $x=.5$
\end_inset

 .
 We can also do this using Numpy as shown in the program taylor.py.
\end_layout

\begin_layout Standard
\align left

\emph on
Example taylor.py
\end_layout

\begin_layout LyX-Code
from numpy import *
\end_layout

\begin_layout LyX-Code
p = poly1d([1,1,1,0])
\end_layout

\begin_layout LyX-Code
dp = p.deriv()
\end_layout

\begin_layout LyX-Code
dp2 = dp.deriv()
\end_layout

\begin_layout LyX-Code
dp3 = dp2.deriv()
\end_layout

\begin_layout LyX-Code
a = 0  # The known point
\end_layout

\begin_layout LyX-Code
x = 0  # Evaluate at x
\end_layout

\begin_layout LyX-Code
while x < .5:
\end_layout

\begin_layout LyX-Code
    tay = p(a) + (x-a)* dp(a) + 
\backslash

\end_layout

\begin_layout LyX-Code
         (x-a)**2 * dp2(a) / 2 + (x-a)**3 * dp3(a)/6      
\end_layout

\begin_layout LyX-Code
    print '%5.1f  %8.5f
\backslash
t%8.5f'%(x, p(x), tay)
\end_layout

\begin_layout LyX-Code
    x = x + .1
\end_layout

\begin_layout Standard
The result is shown below.
\end_layout

\begin_layout Quotation
0.0 0.00000 0.00000
\end_layout

\begin_layout Quotation
0.1 0.11100 0.11100
\end_layout

\begin_layout Quotation
0.2 0.24800 0.24800
\end_layout

\begin_layout Quotation
0.3 0.41700 0.41700
\end_layout

\begin_layout Quotation
0.4 0.62400 0.62400
\end_layout

\begin_layout Subsection
Sine and Cosine Series
\end_layout

\begin_layout Standard
In the equation 
\begin_inset LatexCommand ref
reference "eq:Taylor's Series"

\end_inset

, let us choose 
\begin_inset Formula $f(x)=sin(x)$
\end_inset

 and 
\begin_inset Formula $a=0$
\end_inset

.
 If 
\begin_inset Formula $a=0$
\end_inset

, then the series is known as the Maclaurin Series.
 The first term will become 
\begin_inset Formula $sin(0)$
\end_inset

, which is just zero.
 The other terms involve the derivatives of 
\begin_inset Formula $sin(x)$
\end_inset

.
 The first, second and third derivatives of 
\begin_inset Formula $sin(x)$
\end_inset

 are 
\begin_inset Formula $cos(x)$
\end_inset

, 
\begin_inset Formula $-sin(x)$
\end_inset

 and 
\begin_inset Formula $-cos(x)$
\end_inset

, respectively.
 Evaluating each of these at zero, we get 1, 0 and -1 respectively.
 The terms with even powers vanish, resulting in,
\begin_inset Formula \begin{equation}
\sin(x)=x-\frac{x^{3}}{3!}+\frac{x^{5}}{5!}+\cdots\,\,\,\,\,=\sum_{n=0}^{\infty}\left(-1\right)^{n}\frac{x^{2n+1}}{(2n+1)!}\label{eq:Taylor Sine}\end{equation}

\end_inset


\end_layout

\begin_layout Standard
We can find the cosine series in a similar manner, to get
\end_layout

\begin_layout Standard
\begin_inset Formula \begin{equation}
\cos(x)=1-\frac{x^{2}}{2!}+\frac{x^{4}}{4!}+\cdots\,\,\,\,\,=\sum_{n=0}^{\infty}\left(-1\right)^{n}\frac{x^{2n}}{(2n)!}\label{eq:Taylor cosine}\end{equation}

\end_inset


\end_layout

\begin_layout Standard
The program series_sc.py evaluates the sine and cosine series.
 The output is shown in figure 
\begin_inset LatexCommand ref
reference "fig:Output-of-series_sc.py"

\end_inset

.
 Compare the output of polyplot.py from section 
\begin_inset LatexCommand ref
reference "sec:Polynomials"

\end_inset

 with this.
 In both cases, we have evaluated the polynomial of sine function.
 In the present case, we can easily modify the number of terms and the logic
 is simpler.
\end_layout

\begin_layout Standard
\align left

\emph on
Example series_sc.py
\end_layout

\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/series_sc.png
	lyxscale 50
	width 6cm

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Caption

\begin_layout Standard
Output of series_sc.py
\begin_inset LatexCommand label
name "fig:Output-of-series_sc.py"

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard

\end_layout

\end_inset


\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
def f(n):     # Factorial function
\end_layout

\begin_layout LyX-Code
    if n == 0: 
\end_layout

\begin_layout LyX-Code
        return 1
\end_layout

\begin_layout LyX-Code
    else:
\end_layout

\begin_layout LyX-Code
        return n * f(n-1)
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
NP = 100
\end_layout

\begin_layout LyX-Code
x = linspace(-pi, pi, NP)
\end_layout

\begin_layout LyX-Code
sinx = zeros(NP)
\end_layout

\begin_layout LyX-Code
cosx = zeros(NP)
\end_layout

\begin_layout LyX-Code
for n in range(10):
\end_layout

\begin_layout LyX-Code
   sinx += (-1)**(n) * (x**(2*n+1)) / f(2*n+1)
\end_layout

\begin_layout LyX-Code
   cosx += (-1)**(n) * (x**(2*n)) / f(2*n)
\end_layout

\begin_layout LyX-Code
plot(x, sinx)
\end_layout

\begin_layout LyX-Code
plot(x, cosx,'r')
\end_layout

\begin_layout LyX-Code
show()
\end_layout

\begin_layout Section
Finding roots of an equation
\end_layout

\begin_layout Standard
In general, an equation may have any number of roots, or no roots at all.
 For example 
\begin_inset Formula $f(x)=x^{2}$
\end_inset

 has a single root whereas 
\begin_inset Formula $f(x)=sin(x)$
\end_inset

 has an infinite number of roots.
 The roots can be located visually, by looking at the intersections with
 the x-axis.
 Another useful tool for detecting and bracketing roots is the incremental
 search method.
 The basic idea behind the incremental search method is simple: if 
\begin_inset Formula $f(x1)$
\end_inset

 and 
\begin_inset Formula $f(x2)$
\end_inset

 have opposite signs, then there is at least one root in the interval 
\begin_inset Formula $(x1,x2)$
\end_inset

.
 If the interval is small enough, it is likely to contain a single root.
 Thus the zeroes of 
\begin_inset Formula $f(x)$
\end_inset

 can be detected by evaluating the function at intervals of 
\begin_inset Formula $\Delta x$
\end_inset

 and looking for change in sign.
\end_layout

\begin_layout Standard
There are several potential problems with the incremental search method:
 It is possible to miss two closely spaced roots if the search increment
 
\begin_inset Formula $\Delta x$
\end_inset

 is larger than the spacing of the roots.
 Certain singularities of 
\begin_inset Formula $f(x)$
\end_inset

 can be mistaken for roots.
 For example, 
\begin_inset Formula $f(x)=tan(x)$
\end_inset

 changes sign at odd multiples of 
\begin_inset Formula $\pi/2$
\end_inset

, but these locations are not true zeroes as shown in figure 
\begin_inset LatexCommand ref
reference "fig:NRplot"

\end_inset

 (b).
\end_layout

\begin_layout Standard
Example 
\shape italic
rootsearch.py
\shape default
 implements the function 
\begin_inset Formula $root()$
\end_inset

 that searches the roots of a function 
\begin_inset Formula $f(x)$
\end_inset

 from 
\begin_inset Formula $x=a$
\end_inset

 to 
\begin_inset Formula $x=b$
\end_inset

, incrementing it by 
\begin_inset Formula $dx$
\end_inset

.
\end_layout

\begin_layout Standard
\align left

\emph on
Example rootsearch.py
\end_layout

\begin_layout LyX-Code
def func(x):
\end_layout

\begin_layout LyX-Code
   return x**3-10.0*x*x + 5
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
def root(f,a,b,dx):
\end_layout

\begin_layout LyX-Code
    x = a     
\end_layout

\begin_layout LyX-Code
    while True: 
\end_layout

\begin_layout LyX-Code
       f1 = f(x)
\end_layout

\begin_layout LyX-Code
       f2 = f(x+dx)
\end_layout

\begin_layout LyX-Code
       if f1*f2 < 0: 
\end_layout

\begin_layout LyX-Code
         return x, x + dx
\end_layout

\begin_layout LyX-Code
       x = x + dx
\end_layout

\begin_layout LyX-Code
       if x >=  b:
\end_layout

\begin_layout LyX-Code
           return (None,None)
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
x,y = root(func, 0.0, 1.0,.1) 
\end_layout

\begin_layout LyX-Code
print x,y
\end_layout

\begin_layout LyX-Code
x,y = root(math.cos, 0.0, 4,.1) 
\end_layout

\begin_layout LyX-Code
print x,y
\end_layout

\begin_layout Standard
The outputs are (0.7 , 0.8) and (1.5 , 1.6).
 The root of cosine,
\begin_inset Formula $\pi/2$
\end_inset

, is between 1.5 and 1.6.
 After the root has been located roughly, we can find the root with any
 specified accuracy, using bisection method, Newton-Raphson method etc.
 
\end_layout

\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/nrplot.png
	lyxscale 50
	width 6cm

\end_inset


\begin_inset Graphics
	filename pics/tanx.png
	lyxscale 50
	width 6cm

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Caption

\begin_layout Standard
(a)Function 
\begin_inset Formula $2x^{2}-3x-5$
\end_inset

 and its tangents at 
\begin_inset Formula $x=4$
\end_inset

 and 
\begin_inset Formula $x=4$
\end_inset

 (b) tan(x)
\begin_inset LatexCommand label
name "fig:NRplot"

\end_inset

.
\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Subsection
Method of Bisection
\end_layout

\begin_layout Standard
The method of bisection finds the root by successively halving the interval
 until it becomes sufficiently small.
 Bisection is not the fastest method available for computing roots, but
 it is the most reliable.
 Once a root has been bracketed, bisection will always find it.
 The method of bisection works in the following manner.
 If there is a root between 
\begin_inset Formula $x1$
\end_inset

 and 
\begin_inset Formula $x2$
\end_inset

, then 
\begin_inset Formula $f(x1)\times f(x2)<0$
\end_inset

.
 Next, we compute 
\begin_inset Formula $f(x3)$
\end_inset

, where 
\begin_inset Formula $x3=(x1+x2)/2$
\end_inset

.
 If 
\begin_inset Formula $f(x2)\times f(x3)<0$
\end_inset

, then the root must be in 
\begin_inset Formula $(x2,x3)$
\end_inset

 and we replace the original bound 
\begin_inset Formula $x1$
\end_inset

 by 
\begin_inset Formula $x3$
\end_inset

 .
 Otherwise, the root lies between 
\begin_inset Formula $x1$
\end_inset

 and 
\begin_inset Formula $x3$
\end_inset

, in that case 
\begin_inset Formula $x2$
\end_inset

 is replaced by 
\begin_inset Formula $x3$
\end_inset

.
 This process is repeated until the interval has been reduced to the specified
 value, say 
\begin_inset Formula $\varepsilon$
\end_inset

.
 
\end_layout

\begin_layout Standard
The number of bisections required to reach a prescribed limit, 
\begin_inset Formula $\varepsilon,$
\end_inset

 is given by equation 
\begin_inset LatexCommand ref
reference "eq:bisection"

\end_inset

.
\begin_inset Formula \begin{equation}
n=\frac{\ln(|\triangle x|)/\varepsilon}{\ln2}\label{eq:bisection}\end{equation}

\end_inset


\end_layout

\begin_layout Standard
The program 
\shape italic
bisection.py
\shape default
 finds the root of the equation 
\begin_inset Formula $x^{3}-10x^{2}+5$
\end_inset

.
 The starting values are found using the program 
\shape italic
rootsearch.py
\shape default
.
 The results are printed for two different accuracies.
 
\end_layout

\begin_layout Standard
\align left

\emph on
Example bisection.py
\end_layout

\begin_layout LyX-Code
import math def func(x):
\end_layout

\begin_layout LyX-Code
       return x**3 - 10.0* x*x + 5
\end_layout

\begin_layout LyX-Code
  
\end_layout

\begin_layout LyX-Code
def bisect(f, x1, x2, epsilon=1.0e-9):
\end_layout

\begin_layout LyX-Code
    f1 = f(x1) 
\end_layout

\begin_layout LyX-Code
    f2 = f(x2)
\end_layout

\begin_layout LyX-Code
    if f1*f2 > 0.0:
\end_layout

\begin_layout LyX-Code
       print 'x1 and x2 are on the same side of x-axis'
\end_layout

\begin_layout LyX-Code
       return
\end_layout

\begin_layout LyX-Code
    n = math.ceil(math.log(abs(x2 - x1)/epsilon)/math.log(2.0))     
\end_layout

\begin_layout LyX-Code
    n = int(n)
\end_layout

\begin_layout LyX-Code
    for i in range(n):
\end_layout

\begin_layout LyX-Code
        x3 = 0.5 * (x1 + x2)
\end_layout

\begin_layout LyX-Code
        f3 = f(x3)
\end_layout

\begin_layout LyX-Code
        if f3 == 0.0: return x3
\end_layout

\begin_layout LyX-Code
        if f2*f3 < 0.0:
\end_layout

\begin_layout LyX-Code
             x1 = x3
\end_layout

\begin_layout LyX-Code
             f1 = f3
\end_layout

\begin_layout LyX-Code
        else:              
\end_layout

\begin_layout LyX-Code
             x2 = x3
\end_layout

\begin_layout LyX-Code
             f2 = f3
\end_layout

\begin_layout LyX-Code
    return (x1 + x2)/2.0
\end_layout

\begin_layout LyX-Code
  
\end_layout

\begin_layout LyX-Code
print bisect(func, 0.70, 0.8, 1.0e-4)
\end_layout

\begin_layout LyX-Code
print bisect(func, 0.70, 0.8, 1.0e-9)
\end_layout

\begin_layout Subsection
Newton-Raphson Method
\end_layout

\begin_layout Standard
The Newton–Raphson algorithm requires the derivative of the function also
 to evaluate the roots.
 Therefore, it is usable only in problems where 
\begin_inset Formula $f'(x)$
\end_inset

 can be readily computed.
 It does not require the value at two points to start with.
 We start with an initial guess which is reasonably close to the true root.
 Then the function is approximated by its tangent line and the x-intercept
 of the tangent line is calculated.
 This value is taken as the next guess and the process is repeated.
 The Newton-Raphson formula is shown below.
 
\end_layout

\begin_layout Standard
\begin_inset Formula \begin{equation}
x_{i+1}=x_{i}-\frac{f(x_{i})}{f'(x_{i})}\label{eq:Newton-Raphson}\end{equation}

\end_inset


\end_layout

\begin_layout Standard
Figure 
\begin_inset LatexCommand ref
reference "fig:NRplot"

\end_inset

(a) shows the graph of the quadratic equation 
\begin_inset Formula $2x^{2}-3x-5=0$
\end_inset

 and its two tangents.
 It can be seen that the zeros are at x = -1 and x = 2.5, and we use the
 program newraph.py shown below to find the roots.
 The function nr() is called twice, and we get the roots nearer to the correspon
ding starting values.
\end_layout

\begin_layout Standard
\align left

\emph on
Example newraph.py
\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
def f(x):
\end_layout

\begin_layout LyX-Code
    return 2.0 * x**2 - 3*x - 5
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
def df(x):
\end_layout

\begin_layout LyX-Code
    return 4.0 * x - 3
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
def nr(x, tol = 1.0e-9):
\end_layout

\begin_layout LyX-Code
    for i in range(30):
\end_layout

\begin_layout LyX-Code
        dx = -f(x)/df(x)
\end_layout

\begin_layout LyX-Code
        #print x  
\end_layout

\begin_layout LyX-Code
        x = x + dx
\end_layout

\begin_layout LyX-Code
        if abs(dx) < tol:
\end_layout

\begin_layout LyX-Code
            return x
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
print nr(4)
\end_layout

\begin_layout LyX-Code
print nr(0)
\end_layout

\begin_layout Standard
The output is shown below.
\end_layout

\begin_layout Standard
2.5
\end_layout

\begin_layout Standard
-1.0 
\end_layout

\begin_layout Standard
\align block
Uncomment the print statement inside nr() to view how fast this method converges
, compared to the bisection method.
 The program newraph_plot.py, listed below is used for generating the figure
 
\begin_inset LatexCommand ref
reference "fig:NRplot"

\end_inset

.
\end_layout

\begin_layout Standard
\align left

\emph on
Example newraph_plot.py
\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
def f(x):
\end_layout

\begin_layout LyX-Code
      return 2.0 * x**2 - 3*x - 5
\end_layout

\begin_layout LyX-Code
  
\end_layout

\begin_layout LyX-Code
def df(x):
\end_layout

\begin_layout LyX-Code
     return 4.0 * x - 3
\end_layout

\begin_layout LyX-Code
  
\end_layout

\begin_layout LyX-Code
vf = vectorize(f)
\end_layout

\begin_layout LyX-Code
x = linspace(-2, 5, 100)
\end_layout

\begin_layout LyX-Code
y = vf(x)
\end_layout

\begin_layout LyX-Code
# Tangents at x=3 and 4, using one point slope formula
\end_layout

\begin_layout LyX-Code
x1 = 4  
\end_layout

\begin_layout LyX-Code
tg1 = df(x1)*(x-x1) + f(x1) 
\end_layout

\begin_layout LyX-Code
x1 = 3
\end_layout

\begin_layout LyX-Code
tg2 = df(x1)*(x-x1) + f(x1)
\end_layout

\begin_layout LyX-Code

\end_layout

\begin_layout LyX-Code
grid(True)
\end_layout

\begin_layout LyX-Code
plot(x,y)
\end_layout

\begin_layout LyX-Code
plot(x,tg1)
\end_layout

\begin_layout LyX-Code
plot(x,tg2)
\end_layout

\begin_layout LyX-Code
ylim([-20,40])
\end_layout

\begin_layout LyX-Code
show()
\end_layout

\begin_layout Standard
\align left
We have defined the function 
\begin_inset Formula $f(x)=2x^{2}-3x-5$
\end_inset

 and vectorized it.
 The derivative 
\begin_inset Formula $4x^{2}-3$
\end_inset

 also is defined by 
\begin_inset Formula $df(x)$
\end_inset

, which is the slope of 
\begin_inset Formula $f(x)$
\end_inset

.
 The tangents are drawn at 
\begin_inset Formula $x=4$
\end_inset

 and 
\begin_inset Formula $x=3$
\end_inset

, using the point slope formula for a line 
\begin_inset Formula $y=m(x-x1)+y1$
\end_inset

.
\end_layout

\begin_layout Section
System of Linear Equations
\end_layout

\begin_layout Standard
A system of 
\begin_inset Formula $m$
\end_inset

 linear equations with 
\begin_inset Formula $n$
\end_inset

 unknowns can be written in a matrix form and can be solved by using several
 standard techniques like Gaussian elimination.
 In this section, the matrix inversion method, using Numpy, is demonstrated.
 For more information see reference 
\begin_inset LatexCommand cite
key "Kiusalas"

\end_inset

.
\end_layout

\begin_layout Subsection
Equation solving using matrix inversion
\end_layout

\begin_layout Standard
Non-homogeneous matrix equations of the form 
\begin_inset Formula $Ax=b$
\end_inset

 can be solved by matrix inversion to obtain 
\begin_inset Formula $x=A^{-1}b$
\end_inset

 .
 The system of equations
\end_layout

\begin_layout Standard
\align center
\begin_inset Formula $\begin{array}[b]{r}
4x+y\,-2z=0\\
2x-3y+3z=9\\
-6x-2y\,+z=0\end{array}$
\end_inset


\end_layout

\begin_layout Standard
can be represented in the matrix form as
\end_layout

\begin_layout Standard
\align center
\begin_inset Formula \begin{eqnarray*}
\left(\begin{array}{rrr}
4 & 1 & -2\\
2 & -3 & 3\\
-6 & -2 & 1\end{array}\right)\left(\begin{array}{c}
x\\
y\\
z\end{array}\right) & = & \left(\begin{array}{c}
0\\
9\\
0\end{array}\right)\end{eqnarray*}

\end_inset


\end_layout

\begin_layout Standard
and can be solved by finding the inverse of the coefficient matrix.
\end_layout

\begin_layout Standard
\begin_inset Formula \[
\left(\begin{array}{c}
x\\
y\\
z\end{array}\right)=\left(\begin{array}{rrr}
4 & 1 & -2\\
2 & -3 & 3\\
-6 & -2 & 1\end{array}\right)^{-1}\left(\begin{array}{c}
0\\
9\\
0\end{array}\right)\]

\end_inset


\end_layout

\begin_layout Standard
Using numpy we can solve this as shown in solve_eqn.py
\end_layout

\begin_layout Standard
\align left
Example solve_eqn.py
\end_layout

\begin_layout LyX-Code
from numpy import * 
\end_layout

\begin_layout LyX-Code
b = array([0,9,0]) 
\end_layout

\begin_layout LyX-Code
A = array([ [4,1,-2], [2,-3,3],[-6,-2,1]]) 
\end_layout

\begin_layout LyX-Code
print dot(linalg.inv(A),b)
\end_layout

\begin_layout Standard
The result will be [ 0.75 -2.
 0.5 ], that means 
\begin_inset Formula $x=0.75,y=-2,z=0.5$
\end_inset

 .
 This can be verified by substituting them back in to the equations.
\end_layout

\begin_layout Standard
Exercise: solve x+y+3z = 6; 2x+3y-4z=6;3x+2y+7z=0
\end_layout

\begin_layout Section
Least Squares Fitting
\end_layout

\begin_layout Standard
A mathematical procedure for finding the best-fitting curve 
\begin_inset Formula $f(x)$
\end_inset

 for a given set of points 
\begin_inset Formula $(x_{n},y_{n})$
\end_inset

 by minimizing the sum of the squares of the vertical offsets of the points
 from the curve is called least squares fitting.
 The least square fit is obtained by minimizing the function,
\end_layout

\begin_layout Standard
\begin_inset Formula \begin{equation}
S(a_{0},a_{1},\ldots,a_{m})=\sum_{i=0}^{n}\left[y_{i}-f(x_{i})\right]^{2}\label{eq:Least square}\end{equation}

\end_inset


\end_layout

\begin_layout Standard
with respect to each 
\begin_inset Formula $a_{i}$
\end_inset

and the condition for that is
\end_layout

\begin_layout Standard
\begin_inset Formula \begin{equation}
\frac{\partial S}{\partial a_{i}}=0,\,\,\,\,\, i=0,1,\ldots m\label{eq:LS2}\end{equation}

\end_inset


\end_layout

\begin_layout Standard
For a linear fit, the equation is
\begin_inset Formula \[
f(a,b)=a+bx\]

\end_inset


\end_layout

\begin_layout Standard
Solving the equations 
\begin_inset Formula $\frac{\partial S}{\partial a}=0$
\end_inset

 and 
\begin_inset Formula $\frac{\partial S}{\partial b}=0$
\end_inset

 will give the result,
\begin_inset Formula \begin{equation}
b=\frac{\sum y_{i}(x-\overline{x})}{\sum x_{i}(x-\overline{x})},\,\,\,\, and\,\,\,\, a=\overline{y}-\overline{x}b\label{eq:LS3}\end{equation}

\end_inset


\end_layout

\begin_layout Standard
where 
\begin_inset Formula $\overline{x}$
\end_inset

 and 
\begin_inset Formula $\overline{y}$
\end_inset

 are the mean values defined by the equations,
\begin_inset Formula \begin{equation}
\overline{x}=\frac{1}{n+1}\sum_{i=0}^{n}x_{i},\,\,\,\,\,\,\overline{y}=\frac{1}{n+1}\sum_{i=0}^{n}y{}_{i}\label{eq:LS4}\end{equation}

\end_inset


\end_layout

\begin_layout Standard
The program lsfit.py demonstrates the usage of equations 
\begin_inset LatexCommand ref
reference "eq:LS3"

\end_inset

 and 
\begin_inset LatexCommand ref
reference "eq:LS4"

\end_inset

.
 
\end_layout

\begin_layout Standard
\align left
\begin_inset Float figure
wide false
sideways false
status collapsed

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/lsfit.png
	lyxscale 50
	width 7cm

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Caption

\begin_layout Standard
Output of lsfit.py
\begin_inset LatexCommand label
name "fig:Output-of-lsfit.py"

\end_inset


\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\align left

\emph on
Example lsfit.py
\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
NP = 50
\end_layout

\begin_layout LyX-Code
r = 2*ranf([NP]) - 0.5
\end_layout

\begin_layout LyX-Code
x = linspace(0,10,NP)
\end_layout

\begin_layout LyX-Code
data = 3 * x + 2 + r
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
xbar = mean(x)
\end_layout

\begin_layout LyX-Code
ybar = mean(data)
\end_layout

\begin_layout LyX-Code
b = sum(data*(x-xbar)) / sum(x*(x-xbar)) 
\end_layout

\begin_layout LyX-Code
a = ybar - xbar * b 
\end_layout

\begin_layout LyX-Code
print a,b
\end_layout

\begin_layout LyX-Code
y = a + b * x 
\end_layout

\begin_layout LyX-Code
plot(x,y) 
\end_layout

\begin_layout LyX-Code
plot(x,data,'ob') 
\end_layout

\begin_layout LyX-Code
show()
\end_layout

\begin_layout Standard
The raw data is made by adding random numbers (between -1 and 1) to the
 
\begin_inset Formula $y$
\end_inset

 coordinates generated by 
\begin_inset Formula $y=3*x+2$
\end_inset

 .
 The Numpy functions mean() and sum() are used.
 The output is shown in figure 
\begin_inset LatexCommand ref
reference "fig:Output-of-lsfit.py"

\end_inset

.
\end_layout

\begin_layout Section
Interpolation
\begin_inset LatexCommand label
name "sec:Interpolation"

\end_inset


\end_layout

\begin_layout Standard
Interpolation is the process of constructing a function 
\begin_inset Formula $f(x)$
\end_inset

 from a set of data points 
\begin_inset Formula $(x_{i},y_{i})$
\end_inset

, in the interval 
\begin_inset Formula $a<x<b$
\end_inset

 that will satisfy 
\begin_inset Formula $y_{i}=f(x_{i})$
\end_inset

 for any point in the same interval.
 The easiest way is to construct a polynomial of degree 
\begin_inset Formula $n$
\end_inset

 that passes through the 
\begin_inset Formula $n+1$
\end_inset

 distinct data points.
\end_layout

\begin_layout Subsection
Newton's polynomial
\end_layout

\begin_layout Standard
Suppose the the given set is 
\begin_inset Formula $(x_{i},y_{i}),i=0,1\ldots n-1$
\end_inset

 and the polynomial is 
\begin_inset Formula $P_{n}(x)$
\end_inset

.
 Since the polynomial passes through all the data points, the following
 condition will be satisfied.
\begin_inset Formula \begin{equation}
P_{n}(x_{i})=y_{i},\,\,\,\,\,\, i=0,1\ldots n-1\label{eq:NP one}\end{equation}

\end_inset


\end_layout

\begin_layout Standard
The Newton's interpolating polynomial is given by the equation,
\end_layout

\begin_layout Standard
\begin_inset Formula \begin{equation}
P_{n}(x)=a_{0}+(x-x_{0})a_{1}+\cdots+(x-x_{0})\cdots(x-x_{n-1})a_{n}\label{eq:NP 2}\end{equation}

\end_inset


\end_layout

\begin_layout Standard
The coefficients 
\begin_inset Formula $a_{i}$
\end_inset

 can be evaluated in the following manner.
 When 
\begin_inset Formula $x=x_{0}$
\end_inset

, all the terms in 
\begin_inset LatexCommand ref
reference "eq:NP 2"

\end_inset

 except 
\begin_inset Formula $a_{0}$
\end_inset

 will vanish due to the presence of 
\begin_inset Formula $(x-x_{0}$
\end_inset

) and we get
\end_layout

\begin_layout Standard
\begin_inset Formula \begin{equation}
y_{o}=a_{0}\label{eq:NP3}\end{equation}

\end_inset


\end_layout

\begin_layout Standard
For 
\begin_inset Formula $x=x_{1}$
\end_inset

, only the first two terms will be non-zero.
 
\end_layout

\begin_layout Standard
\begin_inset Formula \begin{equation}
y_{1}=a_{0}+a_{1}(x_{1}-x_{0})\label{eq:NP4}\end{equation}

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Formula \begin{equation}
a_{1}=\frac{(y_{1}-y_{0})}{(x_{1}-x_{0})}\label{eq:NP5}\end{equation}

\end_inset


\end_layout

\begin_layout Standard
Applying 
\begin_inset Formula $x=x_{2}$
\end_inset

, we get 
\end_layout

\begin_layout Standard
\begin_inset Formula \begin{equation}
y_{2}=a_{0}+a_{1}(x_{2}-x_{0})+a_{2}(x_{2}-x_{0})a_{1}(x_{2}-x_{1})\label{eq:NP6}\end{equation}

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Formula \begin{equation}
a_{2}=\frac{\frac{y_{2}-y_{1}}{x_{2}-x_{1}}-\frac{y_{1}-y_{0}}{x_{1}-x_{0}}}{x_{2}-x_{0}}\label{eq:NP7}\end{equation}

\end_inset


\end_layout

\begin_layout Standard
The other coefficients can be found in a similar manner.
 They can be expressed better using the divided difference notation as shown
 below.
\end_layout

\begin_layout Standard
\begin_inset Formula \[
\left[y_{0}\right]=y_{0}\]

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Formula \[
\left[y_{0},y_{1}\right]=\frac{(y_{1}-y_{0})}{(x_{1}-x_{0})}\]

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Formula \[
\left[y_{0},y_{1},y_{3}\right]=\frac{\frac{y_{2}-y_{1}}{x_{2}-x_{1}}-\frac{y_{1}-y_{0}}{x_{1}-x_{0}}}{x_{2}-x_{0}}=\frac{\left[y_{1},y_{2}\right]-\left[y_{0},y_{1}\right]}{(x_{2}-x_{0})}\]

\end_inset


\end_layout

\begin_layout Standard
Using these notation, the Newton's polynomial can be re-written as;
\end_layout

\begin_layout Standard
\begin_inset Formula \begin{eqnarray}
P(x) & = & \left[y_{0}\right]+\left[y_{0},y_{1}\right](x-x_{0})+\left[y_{0},y_{1},y_{2}\right](x-x_{0})(x-x_{1})+\nonumber \\
 &  & \cdots+\left[y_{0},\ldots,y_{n}\right](x-x_{0})\ldots(x-x_{n-1})\end{eqnarray}

\end_inset


\end_layout

\begin_layout Standard
The divided difference can be put in the tabular form as shown below.
 This will be useful while calculating the coefficients manually.
\end_layout

\begin_layout Standard
\align center
\begin_inset Tabular
<lyxtabular version="3" rows="4" columns="6">
<features>
<column alignment="center" valignment="top" width="0">
<column alignment="center" valignment="top" width="0">
<column alignment="center" valignment="top" width="0">
<column alignment="center" valignment="top" width="0">
<column alignment="center" valignment="top" width="0">
<column alignment="center" valignment="top" width="0">
<row>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard
\begin_inset Formula $x_{0}$
\end_inset


\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard
\begin_inset Formula $x_{0}$
\end_inset


\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard
\begin_inset Formula $\left[y_{0}\right]$
\end_inset


\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard

\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard

\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard

\end_layout

\end_inset
</cell>
</row>
<row>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard
\begin_inset Formula $x_{1}$
\end_inset


\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard
\begin_inset Formula $y{}_{1}$
\end_inset


\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard

\family roman
\series medium
\shape up
\size normal
\emph off
\bar no
\noun off
\color none
\begin_inset Formula $\left[y_{1}\right]$
\end_inset


\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard
\begin_inset Formula $\left[y_{0},y_{1}\right]$
\end_inset


\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard

\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard

\end_layout

\end_inset
</cell>
</row>
<row>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard
\begin_inset Formula $x_{2}$
\end_inset


\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard
\begin_inset Formula $y_{2}$
\end_inset


\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard
\begin_inset Formula $\left[y_{2}\right]$
\end_inset


\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard
\begin_inset Formula $\left[y_{1},y_{2}\right]$
\end_inset


\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard
\begin_inset Formula $\left[y_{0},y_{1},y_{2}\right]$
\end_inset


\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard

\end_layout

\end_inset
</cell>
</row>
<row>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard
\begin_inset Formula $x_{3}$
\end_inset


\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard
\begin_inset Formula $y_{3}$
\end_inset


\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard
\begin_inset Formula $\left[y_{3}\right]$
\end_inset


\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard
\begin_inset Formula $\left[y_{2},y_{3}\right]$
\end_inset


\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard
\begin_inset Formula $\left[y_{1},y_{2},y_{3}\right]$
\end_inset


\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard
\begin_inset Formula $\left[y_{0},y_{1},y_{2},y_{3}\right]$
\end_inset


\end_layout

\end_inset
</cell>
</row>
</lyxtabular>

\end_inset


\end_layout

\begin_layout Standard
\align center
\begin_inset Tabular
<lyxtabular version="3" rows="4" columns="5">
<features>
<column alignment="center" valignment="top" width="0">
<column alignment="center" valignment="top" width="0">
<column alignment="center" valignment="top" width="0">
<column alignment="center" valignment="top" width="0">
<column alignment="center" valignment="top" width="0">
<row>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard
0
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard
0
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard

\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard

\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard

\end_layout

\end_inset
</cell>
</row>
<row>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard
1
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard
3
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard
\begin_inset Formula $\frac{3-0}{1-0}=3$
\end_inset


\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard

\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard

\end_layout

\end_inset
</cell>
</row>
<row>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard
2
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard
14
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard
\begin_inset Formula $\frac{14-3}{2-1}=11$
\end_inset


\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard
\begin_inset Formula $\frac{11-3}{2-0}=4$
\end_inset


\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard

\end_layout

\end_inset
</cell>
</row>
<row>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard
3
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard
39
\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard
\begin_inset Formula $\frac{39-14}{3-2}=25$
\end_inset


\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard
\begin_inset Formula $\frac{25-11}{3-1}=7$
\end_inset


\end_layout

\end_inset
</cell>
<cell alignment="center" valignment="top" usebox="none">
\begin_inset Text

\begin_layout Standard
\begin_inset Formula $\frac{7-4}{3-0}=1$
\end_inset


\end_layout

\end_inset
</cell>
</row>
</lyxtabular>

\end_inset


\end_layout

\begin_layout Standard
The table given above shows the divided difference table for the data set
 x = [0,1,2,3] and y = [0,3,14,39], calculated manually.
 The program newpoly.py can be used for calculating the coefficients, which
 prints the output [0, 3, 4, 1].
\end_layout

\begin_layout Standard
\align left

\emph on
Example newpoly.py
\end_layout

\begin_layout LyX-Code
from copy import copy
\end_layout

\begin_layout LyX-Code
def coef(x,y):
\end_layout

\begin_layout LyX-Code
   a = copy(y)
\end_layout

\begin_layout LyX-Code
   m = len(x)
\end_layout

\begin_layout LyX-Code
   for k in range(1,m):
\end_layout

\begin_layout LyX-Code
       tmp = copy(a)
\end_layout

\begin_layout LyX-Code
       for i in range(k,m):
\end_layout

\begin_layout LyX-Code
           tmp[i] = (a[i] - a[i-1])/(x[i]-x[i-k])
\end_layout

\begin_layout LyX-Code
       a = copy(tmp)   
\end_layout

\begin_layout LyX-Code
   return a
\end_layout

\begin_layout LyX-Code
  
\end_layout

\begin_layout LyX-Code
x  = [0,1,2,3]
\end_layout

\begin_layout LyX-Code
y  = [0,3,14,39]
\end_layout

\begin_layout LyX-Code
print coef(x,y)
\end_layout

\begin_layout Standard
We start by copying the list 
\begin_inset Formula $y$
\end_inset

 to coefficient 
\begin_inset Formula $a$
\end_inset

, the first element 
\begin_inset Formula $a_{0}=y_{0}$
\end_inset

.
 While calculating the differences, we have used two loops and a temporary
 list.
 The same can be done in a better way using arrays of Numpy
\begin_inset Foot
status collapsed

\begin_layout Standard
This function is from reference 
\begin_inset LatexCommand cite
key "Kiusalas"

\end_inset

, some PDF versions of this book are available on the web.
\end_layout

\end_inset

, as shown in newpoly2.py.
\end_layout

\begin_layout Standard
\align left

\emph on
Example newpoly2.py
\end_layout

\begin_layout LyX-Code
from numpy import *
\end_layout

\begin_layout LyX-Code
def coef(x,y):
\end_layout

\begin_layout LyX-Code
    a = copy(y)
\end_layout

\begin_layout LyX-Code
    m = len(x)
\end_layout

\begin_layout LyX-Code
    for k in range(1,m):
\end_layout

\begin_layout LyX-Code
        a[k:m] = (a[k:m] - a[k-1])/(x[k:m]-x[k-1])
\end_layout

\begin_layout LyX-Code
    return a
\end_layout

\begin_layout LyX-Code
 
\end_layout

\begin_layout LyX-Code
x  = array([0,1,2,3])
\end_layout

\begin_layout LyX-Code
y  = array([0,3,14,39])
\end_layout

\begin_layout LyX-Code
print coef(x,y)
\end_layout

\begin_layout Standard
The next step is to calculate the value of 
\begin_inset Formula $y$
\end_inset

 for any given value of 
\begin_inset Formula $x$
\end_inset

, using the coefficients already calculated.
 The program 
\shape italic
newinterpol.py
\shape default
 calculates the coefficients using the four data points.
 The function eval() uses the recurrence relation
\end_layout

\begin_layout Standard
\begin_inset Formula \begin{equation}
P_{k}(x)=a_{n-k}+(x-x_{n-k})P_{k-1}(x),\,\,\,\, k=1,2,\ldots n\label{eq:NPrecur}\end{equation}

\end_inset


\end_layout

\begin_layout Standard
The program generates 20 new values of 
\begin_inset Formula $x$
\end_inset

, and calculate corresponding values of 
\begin_inset Formula $y$
\end_inset

 and plots them along with the original data points, as shown in figure
 
\begin_inset LatexCommand ref
reference "fig:Output-of-newton_in3.py"

\end_inset

.
\end_layout

\begin_layout Standard
\align left
\begin_inset Float figure
wide false
sideways false
status collapsed

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/newton_in3.png
	lyxscale 50
	width 8cm

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Caption

\begin_layout Standard
Output of newton_in3.py
\begin_inset LatexCommand label
name "fig:Output-of-newton_in3.py"

\end_inset


\end_layout

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard
\align left

\emph on
Example newinterpol.py
\end_layout

\begin_layout LyX-Code
from pylab import *
\end_layout

\begin_layout LyX-Code
def eval(a,xpoints,x):
\end_layout

\begin_layout LyX-Code
    n = len(xpoints) - 1
\end_layout

\begin_layout LyX-Code
    p = a[n]
\end_layout

\begin_layout LyX-Code
    for k in range(1,n+1):
\end_layout

\begin_layout LyX-Code
        p = a[n-k] + (x -xpoints[n-k]) * p
\end_layout

\begin_layout LyX-Code
    return p
\end_layout

\begin_layout LyX-Code
  
\end_layout

\begin_layout LyX-Code
def coef(x,y):
\end_layout

\begin_layout LyX-Code
    a = copy(y)
\end_layout

\begin_layout LyX-Code
    m = len(x)
\end_layout

\begin_layout LyX-Code
    for k in range(1,m):
\end_layout

\begin_layout LyX-Code
        a[k:m] = (a[k:m] - a[k-1])/(x[k:m]-x[k-1])
\end_layout

\begin_layout LyX-Code
    return a
\end_layout

\begin_layout LyX-Code
  
\end_layout

\begin_layout LyX-Code
x  = array([0,1,2,3])
\end_layout

\begin_layout LyX-Code
y  = array([0,3,14,39])
\end_layout

\begin_layout LyX-Code
coef = coef(x,y)
\end_layout

\begin_layout LyX-Code

\end_layout

\begin_layout LyX-Code
NP = 20
\end_layout

\begin_layout LyX-Code
newx = linspace(0,3, NP)  # New x-values
\end_layout

\begin_layout LyX-Code
newy = zeros(NP)
\end_layout

\begin_layout LyX-Code
for i in range(NP): # evaluate y-values
\end_layout

\begin_layout LyX-Code
    newy[i] = eval(coef, x, newx[i])
\end_layout

\begin_layout LyX-Code
plot(newx, newy,'-x')
\end_layout

\begin_layout LyX-Code
plot(x, y,'ro')
\end_layout

\begin_layout LyX-Code
show()
\end_layout

\begin_layout Standard
You may explore the results for new points outside the range by changing
 the second argument of line 
\shape italic
newx = linspace(0,3,NP)
\shape default
 to a higher value.
 
\end_layout

\begin_layout Standard
Look for similarities between Taylor's series discussed in section 
\begin_inset LatexCommand ref
reference "sub:Taylor's-Series"

\end_inset

 that and polynomial interpolation process.
 The derivative of a function represents an infinitesimal change in the
 function with respect to one of its variables.
 The finite difference is the discrete analog of the derivative.
 Using the divided difference method, we are in fact calculating the derivatives
 in the discrete form.
 
\end_layout

\begin_layout Section
Exercises
\end_layout

\begin_layout Enumerate
Differentiate 
\begin_inset Formula $5x^{2}+3x+5$
\end_inset

 numerically and evaluate at 
\begin_inset Formula $x=2$
\end_inset

 and 
\begin_inset Formula $x=-2$
\end_inset

.
\end_layout

\begin_layout Enumerate
Write code to numerically differentiate 
\begin_inset Formula $\sin(x^{2})$
\end_inset

 and plot it by vectorizing the function.
 Compare with the analytical result.
\end_layout

\begin_layout Enumerate
Integrate 
\begin_inset Formula $\ln x$
\end_inset

, 
\begin_inset Formula $e^{x}$
\end_inset

 from 
\begin_inset Formula $x=1$
\end_inset

to 
\begin_inset Formula $2$
\end_inset

.
\end_layout

\begin_layout Enumerate
Solve 
\begin_inset Formula $2x+y=3;-x+4y=0;3+3y=-1$
\end_inset

 using matrices.
\end_layout

\begin_layout Enumerate
Modify the program julia.py, 
\begin_inset Formula $c=0.2-0.8j$
\end_inset

 and 
\begin_inset Formula $z=z^{6}+c$
\end_inset


\end_layout

\begin_layout Enumerate
Write Python code, using pylab, to solve the following equations using matrices
\newline

\begin_inset Formula $\begin{array}[b]{r}
4x+y\,-2z=0\\
2x-3y+3z=9\\
-6x-2y\,+z=0\end{array}$
\end_inset


\end_layout

\begin_layout Enumerate
Find the roots of 
\begin_inset Formula $5x^{2}+3x-6$
\end_inset

 using bisection method.
\end_layout

\begin_layout Enumerate
Find the all the roots of 
\begin_inset Formula $sin(x)$
\end_inset

 between 0 and 10, using Newton-Raphson method.
\end_layout

\begin_layout Chapter*
Appendix A : Installing GNU/Linux
\begin_inset ERT
status collapsed

\begin_layout Standard


\backslash
addcontentsline{toc}{chapter}{Appendix A}
\end_layout

\end_inset

 
\begin_inset ERT
status collapsed

\begin_layout Standard


\backslash
markboth{Appendix A}{Installing Ubuntu}
\end_layout

\end_inset


\end_layout

\begin_layout Standard
Programming can be learned better by practicing and it requires an operating
 system, and Python interpreter along with some library modules.
 All these requirements are packaged on the Live CD comes along with this
 book.
 You can boot any PC from this CD and start working.
 However, it is better to install the whole thing to a harddisk.
 The following section explains howto install GNU/Linux.
 We have selected the Ubuntu distribution due to its relatively simple installat
ion procedure, ease of maintenanace and support for most of the hardware
 available in the market.
\end_layout

\begin_layout Section
Installing Ubuntu
\end_layout

\begin_layout Standard
Most of the users prefer a dual boot system, to keep their MSWindows working.
 We will explain the installation process keeping that handicap in mind.
 All we need is an empty partition of minimum 5 GB size to install Ubuntu.
 Free space inside a Windows partition will not do, we need to format the
 partition to install Ubuntu.
 The Ubuntu installer will make the system multi-boot by searching through
 all the partitions for installed operating systems.
\end_layout

\begin_layout Standard
\align left

\shape italic
\bar under
The System
\end_layout

\begin_layout Standard
This section will describe how Ubuntu was installed on a system, with MSWindows,
 having the following partitions:
\end_layout

\begin_layout Standard
C: (GNU/Linux calls it /dev/sda1) 20 GB
\end_layout

\begin_layout Standard
D: ( /dev/sda5) 20 GB
\end_layout

\begin_layout Standard
E: (/dev/sda6) 30 GB
\end_layout

\begin_layout Standard
We will use the partition E: to install Ubuntu, it will be formatted.
 
\end_layout

\begin_layout Standard
\align left

\shape italic
\bar under
The Procedure
\end_layout

\begin_layout Standard
Set the first boot device CD ROM from the BIOS.
 Boot the PC from the Ubuntu installation CD, we have used Phoenix Live
 CD (a modified version on Ubuntu 9.1).
 After 2 to 3 minutes a desktop as shown below will appear.
 Click on the Installer icon, the window shown next will pop up.
 Screens will appear to select the language, time zone and keyboard layout
 as shown in the figures below.
\end_layout

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/desktop.png
	lyxscale 30
	width 6cm

\end_inset

 
\begin_inset Graphics
	filename pics/inst1.png
	lyxscale 50
	width 6cm

\end_inset


\end_layout

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/inst2.png
	lyxscale 50
	width 6cm

\end_inset

 
\begin_inset Graphics
	filename pics/inst3.png
	lyxscale 50
	width 6cm

\end_inset


\end_layout

\begin_layout Standard
Now we proceed to the important part, choosing a partition to install Ubuntu.
\end_layout

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/inst_disk1.png
	lyxscale 50
	width 12cm

\end_inset


\end_layout

\begin_layout Standard
The bar on the top graphically displays the existing partitions.
 Below that there are three options provided :
\end_layout

\begin_layout Enumerate
Install them side by side.
 
\end_layout

\begin_layout Enumerate
Erase and use the entire disk.
\end_layout

\begin_layout Enumerate
Specify partitions manually.
\end_layout

\begin_layout Standard
If you choose the first option, the Installer will resize and repartition
 the disk to make some space for the new system.
 By default this option is marked as selected.
 The bar at the bottom shows the proposed partition scheme.
 In the present example, the installer plans to divide the C: drive in to
 two partitions to put ubuntu on the second.
\end_layout

\begin_layout Standard
We are going to choose the third option, choose the partition manually.
 We will use the last partition (drive E: ) for installing Ubuntu.
 Once you choose that and click forward, a screen will appear where we can
 add, delete and change partitions.
 We have selected the third partition and clicked on Change.
 A pop-up window appeared.
 Using that we selected the file-system type to ext3, marked the format
 option, and selected the mount point as / .
 The screen with the pop-up window is shown below.
\end_layout

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/inst_disk2.png
	lyxscale 50
	width 12cm

\end_inset


\end_layout

\begin_layout Standard
\align left
If we proceed with this, a warning will appear complaining about the absence
 of swap partitions.
 The swap partition is used for supplementing the RAM with some virtual
 memory.
 When RAM is full, processes started but not running will be swapped out.
 One can install a system without swap partition but it is a good idea to
 have one.
\end_layout

\begin_layout Standard
We decide to go back on the warning, to delete the E: drive, create two
 new partitions in that space and make one of them as swap.
 This also demonstrates how to make new partitions.
 The screen after deleting E: , with the pop-up window to make the swap
 partition is shown below.
\end_layout

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/inst_makeswap.png
	lyxscale 50
	width 12cm

\end_inset


\end_layout

\begin_layout Standard
We made a 2 GB swap.
 The remaining space is used for making one more partition, as shown in
 the figure 
\begin_inset LatexCommand ref
reference "fig:Making-the-partition"

\end_inset

.
\end_layout

\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/inst_disk3.png
	lyxscale 50
	width 12cm

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Caption

\begin_layout Standard
Making the partition to install Ubuntu
\begin_inset LatexCommand label
name "fig:Making-the-partition"

\end_inset

.
\end_layout

\end_inset


\end_layout

\begin_layout Standard

\end_layout

\end_inset


\end_layout

\begin_layout Standard
Once disk partitioning is over, you will be presented with a screen to enter
 a user name and password.
\begin_inset Foot
status collapsed

\begin_layout Standard
All GNU/Linux installations ask for a root password during installation.
 For simplicity, Ubuntu has decided to hide this information.
 The first user created during installation has special privileges and that
 password is asked, instead of the root password, for all system administration
 jobs, like installing new software.
\end_layout

\end_inset

 A warning will be issued if the password is less than 8 characters in length.
 You will be given an option to import desktop settings from other installations
 already on the disk, choose this if you like.
 The next screen will confirm the installation.
 After the installation is over, mat take 10 to 15 minutes, you will be
 prompted to reboot the system.
 On rebooting you will be presented with a menu, to choose the operating
 system to boot.
 First item in the menu will be the newly installed Ubuntu.
\end_layout

\begin_layout Section
Package Management
\end_layout

\begin_layout Standard
The Ubuntu install CD contains some common application programs like web
 browser, office package, document viewer, image manipulation program etc.
 After installing Ubuntu, you may want to add more applications.
 The Ubuntu repository has an enormous number of packages, that can be installed
 very easily.
 You need to have a reasonably fast Internet connection for this purpose.
\end_layout

\begin_layout Standard
From the main menu, open System->Administration->Synaptic package manager.
 After providing the pass word (of the first user, created during installation),
 the synaptic window will popup as shown in figure 
\begin_inset LatexCommand ref
reference "fig:Synaptic-package-manager"

\end_inset

.
\end_layout

\begin_layout Standard
\begin_inset Float figure
wide false
sideways false
status collapsed

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/synaptic1.png
	lyxscale 50
	width 12cm

\end_inset


\end_layout

\begin_layout Standard
\begin_inset Caption

\begin_layout Standard
Synaptic package manager window
\begin_inset LatexCommand label
name "fig:Synaptic-package-manager"

\end_inset


\end_layout

\end_inset


\end_layout

\begin_layout Standard

\end_layout

\end_inset


\end_layout

\begin_layout Standard
Select Settings->Repositories to get a pop-up window as shown below.
 Tick the four repositories, close the pop-up window and Click on Reload.
 Synaptic will now try to download the index files from all these repositories.
 It may take several minute.
\end_layout

\begin_layout Standard
\align center
\begin_inset Graphics
	filename pics/synaptic2.png
	lyxscale 50
	width 12cm

\end_inset


\end_layout

\begin_layout Standard
Now, you are ready to install any package from the Ubuntu repository.
 Search for any package by name, from these repositories, and install it.
 If you have done the installation from original Ubuntu CD, you may require
 the following packges:
\end_layout

\begin_layout Itemize
lyx : A latex front-end.
 Latex will be installed since lyx dpends on latex.
\end_layout

\begin_layout Itemize
python-matplotlib : The graphics library
\end_layout

\begin_layout Itemize
python-visual : 3D graphics
\end_layout

\begin_layout Itemize
python-imaging-tk : Tkinter, Python Imaging Library etc.
 will be installed
\end_layout

\begin_layout Itemize
build-essential : C compiler and related tools.
\end_layout

\begin_layout Subsection
Install from repository CD
\end_layout

\begin_layout Standard
We can also install packages from repository CDs.
 Insert the CD in the drive and Select Add CDROM from the Edit menu of Synaptic.
 Now all the packages on the CD will be available for search and install.
\end_layout

\begin_layout Subsubsection
Installing from the Terminal
\end_layout

\begin_layout Standard
You can install packages from the terminal also.
 You have to become the root user by giving the sudo command;
\end_layout

\begin_layout Standard
$ sudo -s
\end_layout

\begin_layout Standard
enter password :
\end_layout

\begin_layout Standard
# 
\end_layout

\begin_layout Standard
Note that the prompt changes from $ to #, when you become root.
 
\end_layout

\begin_layout Standard
Install packages using the command :
\end_layout

\begin_layout Standard
#apt-cdrom add
\end_layout

\begin_layout Standard
#apt-get install mayavi2
\end_layout

\begin_layout Subsection
Behind the scene
\end_layout

\begin_layout Standard
Even though there are installation programs that performs all these steps
 automatically,it is better to know what is really happening.
 Installing an operating system involves;
\end_layout

\begin_layout Itemize
Partitioning of the hard disk
\end_layout

\begin_layout Itemize
Formatting the partitions
\end_layout

\begin_layout Itemize
Copying the operating system files
\end_layout

\begin_layout Itemize
Installing a boot loader program
\end_layout

\begin_layout Standard
The storage space of a hard disk drive can be divided into separate data
 areas, known as partitions.
 You can create primary partitions and extended partitions.
 Logical drives (secondary partitions can be created inside the extended
 partitions).
 On a disk, you can have up to 4 partitions, where one of them could be
 an extended partition.
 You can have many logical drives inside the extended partition.
\end_layout

\begin_layout Standard
On a MSWindows system, the primary partition is called the C: drive.
 The logical drives inside the extended partition are named from D: onwards.
 GNU/Linux uses a different naming convention.
 The individual disks are named as /dev/sda , /dev/sdb etc.
 and the partitions inside them are named as /dev/sda1, /dev/sda2 etc.
 The numbering of secondary partitions inside the logical drive starts at
 /dev/sda5.
 (1 to 4 are reserved for primary and extended).
 Hard disk partitioning can be done using the fdisk program.
 The installation program also does this for you.
\end_layout

\begin_layout Standard
The process of making a file system on a partition is called formatting.
 There are many different types of file systems.
 MSWindows use file systems like FAT32, NTFS etc.
 and GNU/Linux mostly uses file systems like ext3, ext4 etc.
\end_layout

\begin_layout Standard
The operating system files are kept in directories named boot, sbin, bin,
 etc etc.
 The kernel that loads while booting the system is kept in /boot.
 The configuration files are kept in /etc.
 /sbin and /bin holds programs that implements many of the shell commands.
 Most of the application programs are kept in /usr/bin area.
\end_layout

\begin_layout Standard
The boot loader program is the one provides the selection of OS to boot,
 when you power on the system.
 GRUB is the boot loader used by most of the GNU/Linux systems.
\end_layout

\begin_layout Bibliography
\begin_inset LatexCommand bibitem
label "2"
key "wikipedia"

\end_inset

http://en.wikipedia.org/wiki/List_of_curves
\end_layout

\begin_layout Bibliography
\begin_inset LatexCommand bibitem
label "3"
key "gap-system"

\end_inset

http://www.gap-system.org/~history/Curves/Curves.html
\end_layout

\begin_layout Bibliography
\begin_inset LatexCommand bibitem
label "4"
key "ellipse"

\end_inset

http://www.gap-system.org/~history/Curves/Ellipse.html
\end_layout

\begin_layout Bibliography
\begin_inset LatexCommand bibitem
label "5"
key "wolfram"

\end_inset

http://mathworld.wolfram.com/
\end_layout

\begin_layout Bibliography
\begin_inset LatexCommand bibitem
label "6"
key "numpy examples"

\end_inset

http://www.scipy.org/Numpy_Example_List
\end_layout

\begin_layout Bibliography
\begin_inset LatexCommand bibitem
label "7"
key "scipy/doc"

\end_inset

http://docs.scipy.org/doc/
\end_layout

\begin_layout Bibliography
\begin_inset LatexCommand bibitem
label "8"
key "Numerical Integration"

\end_inset

http://numericalmethods.eng.usf.edu/mws/gen/07int/index.html
\end_layout

\begin_layout Bibliography
\begin_inset LatexCommand bibitem
label "9"
key "fractals"

\end_inset

http://www.angelfire.com/art2/fractals/lesson2.htm
\end_layout

\begin_layout Bibliography
\begin_inset LatexCommand bibitem
label "10"
key "numerical recepies"

\end_inset

http://www.fizyka.umk.pl/nrbook/bookcpdf.html
\end_layout

\begin_layout Bibliography
\begin_inset LatexCommand bibitem
label "11"
key "mathcs.emory"

\end_inset

http://www.mathcs.emory.edu/ccs/ccs315/ccs315/ccs315.html
\end_layout

\begin_layout Bibliography
\begin_inset LatexCommand bibitem
label "12"
key "Kiusalas"

\end_inset

Numerical Methods in Engineering with Python by Jaan Kiusalaas
\end_layout

\end_body
\end_document
