- Create a folder called
`Mathematica`

on the`/opt/`

directory$ sudo mkdir -p /opt/Mathematica

- Move the installed file to the created folder
$ sudo mv MathemacicaInstaller.sh /opt/Mathematica

- Run the Installer
$ sudo sh MathemacicaInstaller.sh

- After the installation you just have to register your
`Mathematica`

software.

## Posts Tagged ‘Mathematica’

## Install Mathematica 9 on Linux

Posted in Linux, Mathematics, Science, tagged Install, Linux, Mathematica, mathematica software, Software on September 16, 2013| 1 Comment »

## Deleting Mathematica in Linux (Ubuntu)

Posted in Linux, Mathematics, Science, tagged CLI, Command, Computer, Delete, Line, Linux, Mathematica, Shell, Software, technology, Terminal, Ubuntu, Uninstall, wolfram on April 17, 2013| Leave a Comment »

If for any reason you need to un-install Mathematica, you should delete the files associated to it. If the installation was the usual one, follow the below steps.

$ cd /usr/local $ sudo rm -r Wolfram $ cd bin $ sudo rm math mathematica Mathematica MathKernel mcc $ cd ../../share $ sudo rm -r Mathematica

This would be enough.

Enjoy!

## Table of all possible irreps of Lie groups

Posted in Linux, Mathematics, SAGE, Science, tagged Calculation, Cartan, Classification, Dynkin, Functions, Groups, How to, HowTo, Labels, Lie, lie group, Linux, Maple, Mathematica, Mathematics, Matlab, Matrices, Matrix, Notebook, Packages, Programming, Python, Representation, Sage, Sagemath, Tips and Tricks on February 27, 2012| 1 Comment »

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

## Review: Sage beginner’s guide.

Posted in Hobbies, Linux, Personal, SAGE, Science, tagged Book, Calculation, CLI, Command, Computers, Craig, Finch, Free, Functions, Graphics, How to, HowTo, Install, LaTeX, Line, Linux, Maple, Mathematica, Mathematics, Matlab, Notebook, Online, Packages, Plot, Plotting, Programming, Python, Review, Sage, Sage-dev, Sagemath, Symbolic, Tips and Tricks, Ubuntu on June 21, 2011| Leave a Comment »

**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 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

## Mathematics, Mathematica and other softwares

Posted in Mathematics, Personal, Physics, Science, tagged Development, Differential, Forms, General, Maple, Mathematica, Mathematics, Open, Package, Personal, Physics, Python, Relativity, Sage, Software, Source, Supergravity, Tensors on March 1, 2011| Leave a Comment »

This post is more about a personal opinion.

Most of the followers of my blog know that I’m a devote Linux user, and that I prefer Open Source than any other software.

It is clear than most business people prefer to spend money for a piece of software which get the job done. And additionally, developers will align with the mainstream vendor… or in some cases, money convince them.

The last to months I’ve been working in some supergravity theory, and you might imagine that even a easy calculation is messy… at least, and will take a huge amount of time to complete.

On the other hand Mathematica offers a huge (really huge) toolkit for mathematicians, physicists, economists, and so on. I admit it… I sort of hate to use Mathematica, really do!, but although we all know is amazing as a toolkit.

Nonetheless, most scientist (specially those who grow up using this kind of software), trust the results as if it was not possible to be wrong!!! But if you look further…. there is a book, as enormous as Mathematica user’s guide, of bugs :-S

A year ago one of my office mate found two bugs: one in an integration routine, and another in a loop routine!!!! **A LOOP ROUTINE**… Do you know someone who has never used a loop routine? How many possible errors have been publish and propagated?! Moreover, I found a bug myself… in the plot function 😐

Since then I use SAGE… or Python, so I’ve spent a lot of time learning, developing and proving routines, asking in the help channels and so on!

I know that this alternatives are far away from Mathematica or Maple or whatever your favourite calculation software is… but imagine!

Today I found a Mathematica package for computing GR tensors, you can use differential forms, first order formalism, redefine quantities in term of vielbeins, write equations using differential forms (with Hodge star and so on)… Incredible! Isn’t it?

Who develop this package? It was not Wolfram!!!! If I were the developer of this marvelous package, I’d prefer to kill myself before writing such a thing for a product which is not available for everyone. Exaggeration?! yes, may be… but I’m citizen of a wealth country, full of poor people. Yes, I also know that any pirate page has a cracked copy of Mathematica… but why should I crack a program?

I don’t want to crack Mathematica… I want an open source software which do as Mathematica. Sorry, I correct:* I want an open source software which do BETTER than Mathematica.*

My bet is on SAGE, and that’s why I’m willing to contribute with this project.

Live wide and prosper! Enjoy!

Dox

## SAGE tip: GRmodule. Day 07.

Posted in Mathematics, Physics, SAGE, tagged Calculation, chrome, chromium, CLI, Command, Dictionary, Eye, Free, Functions, General, GRPy, How to, HowTo, Install, Joris, Keys, Line, Linux, Maple, Mathematica, Mathematics, Matlab, Module, Notebook, Numpy, Packages, Physics, Programming, Python, Relativity, Sage, Sage-dev, Sagemath, Science, Symbolic, Sympy, Tensor, Tensors, Terminal, Tips and Tricks, Ubuntu, Vankerschaver, Web Browser on February 26, 2011| Leave a Comment »

This code is supposed to be (if some one does the work in the future) located in **sage.tensor.differential_form_element**.

The code presented below is a slight modification of Joris code for differential forms manipulation on SAGE.

## Needed modules

from sage.symbolic.ring import SymbolicRing, SR from sage.rings.ring_element import RingElement from sage.algebras.algebra_element import AlgebraElement from sage.rings.integer import Integer from sage.combinat.permutation import Permutation

The advantage of using this is that, tensors defined here are an *Algebra* element, not just a python object as in the previous code.

The *sage.combinat.permutation* won’t be used (yet), but could be useful if tensor symmetries are defined.

#### TensorFormatter

class TensorFormatter: r""" This class contains all the functionality to print a tensor in a graphically pleasing way. This class is called by the ``_latex_`` and ``_repr_`` methods of the Tensor class. """ def __init__(self, space): r""" Construct a tensor formatter. See ``TensorFormatter`` for more information. """ self._space = space def repr(self, comp, fun): r""" String representation of a primitive tensor, i.e. a function times a tensor product of d's of the coordinate functions. INPUT: - ``comp`` -- a subscript of a differential form. - ``fun`` -- the component function of this form. EXAMPLES:: sage: from sage.tensor.tensor_element import TensorFormatter sage: x, y, z = var('x, y, z') sage: U = CoordinatePatch((x, y, z)) sage: D = TensorFormatter(U) sage: D.repr((0, 1), z^3) 'z^3*dx@dy' """ str = "@".join( \ [('d%s' % self._space.coordinate(c).__repr__()) for c in comp]) if fun == 1 and len(comp) > 0: # We have a non-trivial form whose component function is 1, # so we just return the formatted form part and ignore the 1. return str else: funstr = fun._repr_() if not self._is_atomic(funstr): funstr = '(' + funstr + ')' if len(str) > 0: return funstr + "*" + str else: return funstr def latex(self, comp, fun): r""" Latex representation of a primitive differential form, i.e. a function times a tensor product of d's of the coordinate functions. INPUT: - ``comp`` -- a subscript of a differential form. - ``fun`` -- the component function of this form. EXAMPLES:: sage: from sage.tensor.tensor_element import TensorFormatter sage: x, y, z = var('x, y, z') sage: U = CoordinatePatch((x, y, z)) sage: D = TensorFormatter(U) sage: D.latex((0, 1), z^3) 'z^{3} d x \otimes d y' """ from sage.misc.latex import latex str = " \otimes ".join( \ [('d %s' % latex(self._space.coordinate(c))) for c in comp]) if fun == 1 and len(comp) > 0: return str else: funstr = latex(fun) if not self._is_atomic(funstr): funstr = '(' + funstr + ')' return funstr + " " + str def _is_atomic(self, str): r""" Helper function to check whether a given string expression is atomic. EXAMPLES:: sage: x, y, z = var('x, y, z') sage: U = CoordinatePatch((x, y, z)) sage: from sage.tensor.tensor_element import TensorFormatter sage: D = TensorFormatter(U) sage: D._is_atomic('a + b') False sage: D._is_atomic('(a + b)') True """ level = 0 for n, c in enumerate(str): if c == '(': level += 1 elif c == ')': level -= 1 if c == '+' or c == '-': if level == 0 and n > 0: return False return True

The only I’ve changed here is “DifferentialForm” by “Tensor” and “\wedge” by “\otimes”

The above code allows to write the tensor product in a basis, . The chosen symbol for denoting the tensor product was @.

## Tensor Class

This code is incomplete due to:

class Tensor(AlgebraElement): r""" Tensor class. """ def __init__(self, parent, degree, fun = None): r""" Construct a tensor. INPUT: - ``parent`` -- Parent algebra of tensors. - ``degree`` -- Degree of the tensor. - ``fun`` (default: None) -- Initialize this differential form with the given function. If the degree is not zero, this argument is silently ignored. EXAMPLES:: sage: x, y, z = var('x, y, z') sage: F = Tensors(); F Algebra of tensors in the variables x, y, z sage: f = Tensor(F, 0, sin(z)); f sin(z) """ from sage.tensor.tensorss import Tensors if not isinstance(parent, Tensors): raise TypeError, "Parent not an algebra of tensors." RingElement.__init__(self, parent) self._degree = degree self._components = {} if degree == 0 and fun is not None: self.__setitem__([], fun) def __getitem__(self, subscript): r""" Return a given component of the tensor. INPUT: - ``subscript``: subscript of the component. Must be an integer or a list of integers. EXAMPLES:: sage: x, y, z = var('x, y, z') sage: F = Tensors(); F Algebra of tensors in the variables x, y, z sage: f = Tensor(F, 0, sin(x*y)); f sin(x*y) sage: f[()] sin(x*y) """ if isinstance(subscript, (Integer, int)): subscript = (subscript, ) else: subscript = tuple(subscript) dim = self.parent().base_space().dim() if any([s >= dim for s in subscript]): raise ValueError, "Index out of bounds." if len(subscript) != self._degree: raise TypeError, "%s is not a subscript of degree %s" %\ (subscript, self._degree) """sign, subscript = sort_subscript(subscript)""" if subscript in self._components: return sign*self._components[subscript] else: return 0 def __setitem__(self, subscript, fun): r""" Modify a given component of the tensor. INPUT: - ``subscript``: subscript of the component. Must be an integer or a list of integers. EXAMPLES:: sage: F = Tensors(); F Algebra of tensors in the variables x, y, z sage: f = Tensor(F, 2) sage: f[1, 2] = x; f x*dy@dz """ if isinstance(subscript, (Integer, int)): subscript = (subscript, ) else: subscript = tuple(subscript) dim = self.parent().base_space().dim() if any([s >= dim for s in subscript]): raise ValueError, "Index out of bounds." if len(subscript) != self._degree: raise TypeError, "%s is not a subscript of degree %s" %\ (subscript, self._degree) """sign, subscript = sort_subscript(subscript)""" self._components[subscript] = SR(fun)

Ok, so again I’ve changed “DifferentialForm(s)” by “Tensor(s)”, drop the permutation of indices (’cause tensors do not need to be neither symmetric nor anti-symmetric.

I’ll keep working with this code… It’s all by now. Oh! I’ll post next week the rest of the code based in Sergey’s GRPy.

Enjoy.

Dox