.. Objectives

.. ----------

.. By the end of this tutorial, you will be able to

.. 1. Defining symbolic expressions in sage.  

.. # Using built-in costants and functions. 

.. # Performing Integration, differentiation using sage. 

.. # Defining matrices. 

.. # Defining Symbolic functions.  

.. # Simplifying and solving symbolic expressions and functions.

.. Prerequisites

.. -------------

..   1. getting started with sage notebook

.. Author              : Amit 

   Internal Reviewer   :  

   External Reviewer   :

   Checklist OK?       : <put date stamp here, if OK> [2010-10-05]

Symbolics with Sage

-------------------

Hello friends and welcome to the tutorial on symbolics with sage.

{{{ Show welcome slide }}}

.. #[Madhu: What is this line doing here. I don't see much use of it]

During the course of the tutorial we will learn

{{{ Show outline slide  }}}

* Defining symbolic expressions in sage.  

* Using built-in costants and functions. 

* Performing Integration, differentiation using sage. 

* Defining matrices. 

* Defining Symbolic functions.  

* Simplifying and solving symbolic expressions and functions.

We can use Sage for symbolic maths. 

On the sage notebook type::

    sin(y)

It raises a name error saying that y is not defined. But in sage we

can declare y as a symbol using var function.

::

    var('y')

Now if you type::

    sin(y)

sage simply returns the expression.

Thus sage treats sin(y) as a symbolic expression . We can use

this to do  symbolic maths using sage's built-in constants and

expressions..

So let us try ::

   var('x,alpha,y,beta') 

   x^2/alpha^2+y^2/beta^2

taking another example

   var('theta')

   sin^2(theta)+cos^2(theta)

Similarly, we can define many algebraic and trigonometric expressions

using sage .

Sage also provides a few built-in constants which are commonly used in

mathematics .

example : pi,e,infinity , Function n gives the numerical values of all these

    constants.

{{{ Type n(pi)

   	n(e)

	n(oo) 

    On the sage notebook }}}  

If you look into the documentation of function "n" by doing

.. #[Madhu: "documentation of the function "n"?]

::

   n(<Tab>

You will see what all arguments it takes and what it returns. It will be very

helpful if you look at the documentation of all functions introduced through

this script.

Also we can define the no. of digits we wish to use in the numerical

value . For this we have to pass an argument digits.  Type

.. #[Madhu: "no of digits"? Also "We wish to obtain" than "we wish to

     use"?]

::

   n(pi, digits = 10)

Apart from the constants sage also has a lot of builtin functions like

sin,cos,log,factorial,gamma,exp,arcsin etc ...

lets try some of them out on the sage notebook.

::

   sin(pi/2)

   arctan(oo)

   log(e,e)

Given that we have defined variables like x,y etc .. , We can define

an arbitrary function with desired name in the following way.::

       var('x') 

       function('f',x)

Here f is the name of the function and x is the independent variable .

Now we can define f(x) to be ::

     f(x) = x/2 + sin(x)

Evaluating this function f for the value x=pi returns pi/2.::

	   f(pi)

We can also define functions that are not continuous but defined

piecewise.  Let us define a function which is a parabola between 0

to 1 and a constant from 1 to 2 .  Type the following as given on the

screen

::

      var('x') 

      h(x)=x^2 g(x)=1 

      f=Piecewise(<Tab>

{{{ Show the documentation of Piecewise }}} 

::

      f=Piecewise([[(0,1),h(x)],[(1,2),g(x)]],x) f

We can also define functions which are series 

We first define a function f(n) in the way discussed above.::

   var('n') 

   function('f', n)

To sum the function for a range of discrete values of n, we use the

sage function sum.

For a convergent series , f(n)=1/n^2 we can say ::

   var('n') 

   function('f', n)

   f(n) = 1/n^2

   sum(f(n), n, 1, oo)

Lets us now try another series ::

    f(n) = (-1)^(n-1)*1/(2*n - 1)

    sum(f(n), n, 1, oo)

This series converges to pi/4. 

Moving on let us see how to perform simple calculus operations using Sage

For example lets try an expression first ::

    diff(x**2+sin(x),x) 

    2x+cos(x)

The diff function differentiates an expression or a function. Its

first argument is expression or function and second argument is the

independent variable.

We have already tried an expression now lets try a function ::

   f=exp(x^2)+arcsin(x) 

   diff(f(x),x)

To get a higher order differential we need to add an extra third argument

for order ::

   diff(<tab> diff(f(x),x,3)

in this case it is 3.

Just like differentiation of expression you can also integrate them ::

     x = var('x') 

     s = integral(1/(1 + (tan(x))**2),x) 

     s

Many a times we need to find factors of an expression ,we can use the "factor" function

::

    factor(<tab> 

    y = (x^100 - x^70)*(cos(x)^2 + cos(x)^2*tan(x)^2) 

    f = factor(y)

One can  simplify complicated expression ::

    f.simplify_full()

This simplifies the expression fully . We can also do simplification

of just the algebraic part and the trigonometric part ::

    f.simplify_exp() 

    f.simplify_trig()

One can also find roots of an equation by using find_root function::

    phi = var('phi') 

    find_root(cos(phi)==sin(phi),0,pi/2)

Lets substitute this solution into the equation and see we were

correct ::

     var('phi') 

     f(phi)=cos(phi)-sin(phi)

     root=find_root(f(phi)==0,0,pi/2) 

     f.substitute(phi=root)

as we can see when we substitute the value the answer is almost = 0 showing 

the solution we got was correct.

Lets us now try some matrix algebra symbolically ::

   var('a,b,c,d') 

   A=matrix([[a,1,0],[0,b,0],[0,c,d]]) 

   A

Now lets do some of the matrix operations on this matrix

::

    A.det() 

    A.inverse()

{{{ Part of the notebook with summary }}}

So in this tutorial we learnt how to

* We learnt about defining symbolic expression and functions.  

* Using built-in constants and functions.  

* Using <Tab>  to see the documentation of a function.  

* Simple calculus operations .  

* Substituting values in expression using substitute function.

* Creating symbolic matrices and performing operation on them .