Feeds:
Posts

## Installation of SageManifold

Hello again! If you are looking for a Differential Geometry tool, a Sage package which is under development is `SageManifold`. Let’s see how to install it.

1. Download the package using the link (currently v.0.2). I’d assume it is saved on your `Downloads` folder.
2. Assuming you have SAGE installed, and you have created an alias to call it (see my previous post), run the following command
`\$ sage -f ~/Downloads/manifolds-0.2.spkg`
3. To generate the documentation (in case you don’t want to or cannot download it), use either of the commands
```\$ sage -docbuild sagemanifolds pdf
\$ sage -docbuild sagemanifolds html```
4. In order for using the package, start your WorkSheet with the command line
`from manifolds.all import *`
Have a nice calculation!

## Installing SAGE from the source on Debian.

I’m installing SAGE1 v.5.12 on my laptop which runs Debian. Here I describe the procedure.

1. Since there is no Debian binary package, you should download the source code. Here the link.
2. When it finishes, open a terminal `C-M-t` (sorry for the emacs notation, it means `Ctrl+Alt+t`)
• Go to the Downloads folder (or the right place where the tar file was saved)
`\$ cd ~/Downloads`
• Untar the file
`\$ tar xvf sage-5.12.tar`
• Move to the `sage-5.12` folder just created
`cd sage-5.12/`
3. Install the dependencies of the first line. Optionally install `LaTeX` and `ImageMagick` using the second line. (NOTE: superuser power is needed to run the below code)
```\$ sudo apt-get install -y gcc perl m4 dpkg-dev
\$ sudo apt-get install -y texlive imagemagick```
4. In machines with more than one core, the instruction to perform parallel compilation is (yo should change the “4” by the amount of cores in your machine)
`\$ export MAKE="make -j4"`
5. Now is time to compile the code.For a local compilation, run
`make`

For a
You can relax, go and have a coffee, because the compilation may longs one hour (or more depending of the machine specifications).

6. For running the software after the installation is complete, run (on the SAGE directory) the command
`\$ ./sage`
• I don’t like to move to the SAGE directory every time and then run the `./sage` command, therefore, I tend to create an alias on my `~/.bash_aliases` file,
`\$ echo "alias sage="sh ~/Downloads/sage-5.12/sage" >> ~/.bash_aliases`

This command adds the line `alias sage="sh ~/Downloads/sage-5.12/sage` at the end of the file `~/.bash_aliases`, you can do it by hand with your favourite editor (gedit, emacs, nano, vim, …)

• If you refresh your terminal (or open a new one) you just have to run the command `sage` to start SAGE. Additionally, the notebook environment can be started directly from the terminal by using the flag `-n`,
`\$ sage -n`

Hope you find this post useful! Remember to leave your comments or suggestions.

Enjoy!

## Footnotes:

1SAGE is an open source mathematical software which allows numerical and symbolic manipulations

## Table of all possible irreps of Lie groups

Last weekend, I wrote a program in SAGE that list all possible irreps of a Lie group, one specified the group (in Cartan’s classification) and the maximum sum of the Dynkin labels.

Check the notebook in here.

Since I’m not a programmer, please feel free to leave comments, specially if you find ways to optimize the program

Cheers,

DOX

Sage beginner’s guide is a book by  Craig Finch, published recently by PACKT publishing.

After spending two weeks looking at different aspects of the book, I can say with property that this is an excellent book, an I’ll recommend it for beginners to medium experienced SAGE users.

Since this is the first book I review, and also the first I own from this publisher, I’d say that its format is quite understandable, and one might learn a lot by following examples… and then, just then, the details are explained. I really love that feature of the writing.

The first chapter, called What can we do with Sage?, shows in about 20 pages some powerful tools available in Sage, from symbolic calculation, linear algebra, ODE’s, to plotting functions in 2D and 3D… even fitting of curves.  I’ll say this is an impressive chapter, and it’s just the start point. Nonetheless, as in any book, one might notice that in some examples the graphics do not correspond to the code, but when you try the code yourself, you get the right ones.

The chapter about Installing Sage, is written in detail, and explain how to install the software in the three major operative systems: Windows, X OS, and Linux. Of course, due to the unstoppable develop of open source software, there’s a delay in the version shown in the book, however, the steps to follow are the same. A nice thing is that it’s explained how to compile the source for multi-core systems.

Getting Started with Sage, shows a huge amount of small tricks, I mean… I’ve been using Sage for about one a half year, and had no idea of plenty of the tricks explained in this chapter. Awesome!!!

All aspects of Sage are exploited, command line, notebook, different cells in the notebook, all the different types of variables available… and their operations. Functions and even a quick introduction to object oriented programming.

Another useful chapter of the book is the one where some differences (and similarities) between Sage and Python are explained. As a example, the use of commands like range, xrange or srange.

Chapters 5 to 8 show with plenty examples and incredible detail uses of Sage in linear algebra, visualization (plotting), symbolic and numerical calculation. Of course, there is no way I can explain how vast the content is, but include:

• Simplifications in symbolic calculation,
• Manipulation and analysis of data,
• Integral transforms,
• Differential equations,
• Series,
• Differential and integral calculus,
• Numerical calculus, et cetera.

Finally, the last two chapters are more a complement for intermediate users, specially with programming knowledge. They cover python programming, say functions, classes and modules, and its uses, and more advanced features of Sage as $\LaTeX$ integration, optimization of numerical calculation (with NumPy and Cython), and an introduction to the interactive mode.

Thus, In a scale from zero to ten I’d give a 9/10 to this book, because managing such a variety of tricks and functions are worth it.

You can check out the book at http://www.packtpub.com/sage-beginners-guide/book

## Parallel python

In case you wanna explore with parallel python, the web page is
http://www.parallelpython.com/

#### Installation in Linux (debian based):

* in a console type:

```\$ cd
\$ tar xzf pp-1.6.1.tar.gz
\$ cd pp-1.6.1/
\$ sudo python setup.py install```

* it should be installed in just one sec.
* for testing it, run the program in the example page,

`\$ python sum_primes.py`

Dox.

P.D.: My results

Usage: python sum_primes.py [ncpus]
[ncpus] – the number of workers to run in parallel,
if omitted it will be set to the number of processors in the system

Starting pp with 2 workers
Sum of primes below 100 is 1060
Sum of primes below 100000 is 454396537
Sum of primes below 100100 is 454996777
Sum of primes below 100200 is 455898156
Sum of primes below 100300 is 456700218
Sum of primes below 100400 is 457603451
Sum of primes below 100500 is 458407033
Sum of primes below 100600 is 459412387
Sum of primes below 100700 is 460217613
Time elapsed: 3.31923294067 s
Job execution statistics:
job count | % of all jobs | job time sum | time per job | job server
9 | 100.00 | 6.4885 | 0.720947 | local
Time elapsed since server creation 3.32604193687

## Sage tip: Plots with shadow

No comments! It was beautiful 🙂

```p = plot(sin(x), (x,-5, 5), thickness=2, color='red')
for n in xrange(1,20):
p += plot((1-n/20)*sin(x), (x,-pi,0), thickness=0, fill='axis', fillcolor='blue', fillalpha=.01)
p += plot((1-n/20)*sin(x), (x,0,pi), thickness=0, fill='axis', fillcolor='gray', fillalpha=.01)
show(p, figsize=10,ticks=pi/3,tick_formatter=pi, fontsize=16)```

Another variation

```reset()
var('x')
f(x) = sin(x)
p = plot(f(x), (x,-5, 5), thickness=2, color='red')
for n in xrange(1,20):
p += plot(((n-1)/20)*sin(x), (x,-pi,0), thickness=0, fill=f, fillcolor='blue', fillalpha=.01)
p += plot(((n-1)/20)*sin(x), (x,0,pi), thickness=0, fill=f, fillcolor='gray', fillalpha=.01)
show(p, figsize=10,ticks=pi/3,tick_formatter=pi, fontsize=16) ```

Dox.

## SAGE tip: More about Differential Forms

In a previous post we discuss the definition of the coordinated patch on a manifold, how to define differential forms, wedge them or calculate their exterior derivative… even simplify’em.

This time a zero form will be defined and a list of forms will be created… So, let’s begin!

# Define a 0-form

Once created the coordinated patch and the differential forms algebra

```sage: reset()
sage: var('t,x,y,z')
sage: U = CoordinatePatch((t,x,y,z))
sage: Omega = DifferentialForms(U)```

A 0-form is defined as an element of $\Omega^0(U)$, but the value of the 0-form is given inside the declaration command,

`sage: A = DifferentialForm(Omega, 0, exp(x*y))`

I tried addition, multiplication, wedge product and exterior differentiation on 0-forms and they worked!

Of course you can combine them with forms of different degrees.

# New method of defining a form

I wrote to Joris this morning… but before he was able to answer, from the documentation of the differential form package.

When one calls the generators of the differential form,

```sage: Omega.gen(1)
dx```

and the result is a differential form… Thus, one can assign a form as follow,

```sage: A = sin(x)* Omega.gen(2)
sage: B = cos(y) * Omega.gen(0)
sage: C = sin(z) *Omega.gen(1)
sage: D = cos(y) * Omega.gen(2)```

And this forms can be wedged, differentiated, et cetera. 🙂

# List of forms

Finally, after discovering the above behavior I tried the following, a list of differential forms ;-), for example,

```sage: pro = matrix([[A, B], [C, D]])
sage: for i in range(2):
...       for j in range(2):
...           show(pro[i,j].diff())```

returns
$cos(x)dx\wedge dz$
$sin(y)dx\wedge dy$
$-cos(z)dy\wedge dz$
$-sin(y)dy\wedge dz$

This implies that somehow one can manage a series of forms by using list properties… I expect to go deeper on this subject in the future! 😀

Enjoy people!!!

Dox