PythonicGeodynamicsMorra/Ch01 Birds eye view.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Bird's eye view\n",
    "\n",
    "*Review of the history of Python, description of the main differences between the 2.x and the 3.x versions and how to choose the appropriate version go start with. Show how the interactive mode (iPython) has been now superseeded by  **Jupyter**. Illustration of the two main large development platforms used to develop large projects: **Anaconda Spyder** and **Enthought Canopy**. The main libraries used through the book are quickly introduced, among them MatPlotLib, NumPy and Cython.*\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">Readability counts.<br />\n",
    ">Simple is better than complex.<br />\n",
    ">Complex is better than complicated.<br />\n",
    ">If the implementation is hard to explain, it's a bad idea <br /> \n",
    ">If the implementation is easy to explain, it may be a good idea.<br />\n",
    " \n",
    ">from \"The Zen of Python\" of T. Peters \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The purpose of the book [Pythonic Geodynamics](https://www.springer.com/us/book/9783319556802) and of these Jupyter Notebooks is to introduce the reader to some fundamental techniques used to model the evolution of solid planets, such as is Earth, using computers of small as well as great power. I will treat these numerical methods from a very general standpoint, using examples of how to solve fundamental equations in physics and fluid-dynamics, and only finally showing the application to geodynamics. The intention is to leave to the reader the freedom to develop the geodynamic model that they desire, without sticking to a specific numerical approach or predetermined assumptions for geodynamics. \n",
    "\n",
    "To teach these techniques I will employ *Python*, a free programming language that uniquely shares the property of being simple, powerful and widely used in science and engineering. During the development of Python many projects have grown together with it. For example *NumPy* has been developed to increase performance for all vectorial operations, the main tool necessary to solve numerical problems. *MatPlotLib* has been introduced to offer a visualization experience similar to the commercial package Matlab, but has now grown to being the standard for Python users. \n",
    "\n",
    "In the first part of the book I will teach to use *iPython* (interactive Python), a powerful front-end that allows to easily familiarizing with the language and testing it. Later in the book I will present more advanced and sophisticated implementations that can be run from a bash shell or from a comprehensive environments. While I write, the two largest projects aimed at developing a universal environment for Python are [Anaconda Spyder](https://www.continuum.io/) and [Enthought Canopy](https://www.enthought.com/products/canopy/). Both are available and come with the numerical and visualization libraries on Linux, OS X and Windows platforms, allowing every user to skip the tedious procedure of installing a large number of libraries.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## History\n",
    "\n",
    "The genesis of Python goes back to the work of the dutch programmer Guido van Rossum who created the first implementation in December 1989, and released it for the first time in 1991. For this reason he has been informally nominated *Benevolent Dictator for Life* by the Python developers community. This simply means that in case of an unsolvable controversy he will take the definitive decision. \n",
    "\n",
    "Since then Python, together with other popular dynamic programming languages such as Perl and Ruby, has taken off becoming the standard in many sectors of software development. Definitive versions have been released on January 1994 (1.0) and on October 2000 (2.0). \n",
    "\n",
    "The development of Python faced a twist on December 2008 when a backwards-incompatible 3.0 version was released. Suddenly some Python software could run only on Python 2.x while others only on Python 3.x, which irritated many users. After 8 years from the first release of Python 3.x, however, the new software is almost exclusively developed for the new version of Python. In fact Python 2.x will continue to be supported only until 2020. After that Python 3.x will become the only supported version, therefore it is wise to write your software on Python 3.x only. It is important to emphasize that most incompatibilities between Python 2.x and 3.x are not related to the content of this book, but concern mostly I/O (input/output). Still some new features are essential in allowing Python programmers to use *threads* that are essential today with the large availability of heterogeneous parallel machines, therefore Python 3.x has to be the choice for the new developer. Most examples of this book run equally well on both platform, with some possible conflicts arising when exporting the results and data. \n",
    "\n",
    "In many ways computer science is an art. When two different implementations exist for solving the same problem, computer scientists debate about which one is the \"best\" one, or the \"most elegant\", often related to subjective opinions. Languages are therefore preferred by computer scientist when for each problem there is clearly one and only one *best* way to implement its solution. Python often displays this property, however as T. Peters in *The Zen of Python* observed: \n",
    ">There should be one, and preferably only one obvious way to do it. \n",
    ">Although that way may not be obvious at first unless you're Dutch.\n",
    "\n",
    "Many books can introduce you to the Python Language. For the ones who did not have any experience at all with programming, **Think Python** from Allen B. Downey, O'Reilly, is a clear and simple guide. The book is presently freely available [here](http://www.greenteapress.com/thinkpython/) where a PDF copy of the book can be downloaded, both for the 2.x and 3.x versions. More details, the complete manuals and tutorials are freely available on the [Python Website](http://python.org/), as well as many on other sources such as [Code Academy](https://www.codecademy.com/learn/python) and [Python Course](http://www.python-course.eu/). \n",
    "\n",
    "The rise of Python has triggered the development of a huge number of tools to expand its functionality. Its ability to integrate existing compiled software, C and C++ above all, but also Fortran, has allowed building hybrid projects where Python plays the role of glue between them. In the last years, in particular, [Cython](http://cython.org/) has become the principle way for creating compiled extension for Numerical Python. It is as well possible to integrate C and C++ code inside the Python programs, for example by using CPython.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Programming or Scripting\n",
    "\n",
    "Often in literature one reads about *Python scripts*. We will however work with Programs and not with scripts. What is the difference? \n",
    "\n",
    "Generally scripts are not structured, but simply a list of instructions that operate on a dataset organized ad-hoc for the script. Programs are more autonomous, create own data structures, allocate memory, and in general take more control of the machine. As we will see more in detail in the next chapter using NumPy, Cython and analogue tools we take full control of the machine as with a standard programming language, therefore literally *programming* in Python.\n",
    "\n",
    "The file containing a Python program finishes always with **.py** . Python programs are not compiled, but execute instruction by instruction (which ends at the end of line or at a the next semi-colon). Python programs however are also parsed before execution to check whether evident syntactic errors already exist, and will not run until they are fixed. \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Interfaces\n",
    "\n",
    "In this book I will either show examples from the *Enthought* edition of Python, [Canopy](https://www.enthought.com/products/epd/) or from *Anaconda*, [Spyder](https://pypi.python.org/pypi/spyder), both with a similar graphical style to MatLab. Each of these interfaces are based on a *three windows* system in which one has a (i) editor, a (ii) object/variable explorer and a (iii) standard or iPython console. By using these three at the same time, on a large screen, writing, debugging and testing Python programs is very fast and practical. This is an example of how *Anaconda Spyder* looks like: \n",
    "\n",
    "![Screenshot of Spyder, the development environment of Anaconda. On the left there is the editor. On the right on the top the variables created in this Python session and on the bottom this \\emph{IPython} session with the graphical output.](figures/Screenshot-Spyder.png)\n",
    "\n",
    "\n",
    "Where it is quite clear the similarity with Matlab, which has been naturally chosen since many are presently transitioning from Matlab to Python.\n",
    "\n",
    "Installing the  *Enthought*  and *Anaconda* distributions on a Linux or OSX terminal can be easily done using *bash* or *pip*. Graphical installers exist for both Windows and OSX. Most of the examples shown in this book have been created by using the free version of *Anaconda*. \n",
    "\n",
    "The easiest way to learn Python and also to begin a new project is to use *iPython*, a project created by the programmer Fernando Perez in 2001 while he was a graduate student in particle physics at the University of Colorado Boulder. During his research Perez realized that the existing tools for scientific computing were insufficient and that Python was the perfect base to start to build new ones. Since then Perez has been involved in the development of the interactive version of Python, which nowadays became the Jupyter Notebook that you are reading and using. The goal of this giant effort is to create the simplest, most practical, flexible and easy to transport tool to prototyping and experimenting computational work. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## iPython: interactive Python\n",
    "\n",
    "When you are ready to learn new computational techniques the question is always what is the fastest and less painful way to start. A straightforward approach is to use *iPython* from the *Anaconda* distribution. After installing the libraries at the link https://www.continuum.io/ one can start the iPython with the command:\n",
    "\n",
    "```\n",
    "$ ipython \n",
    "Python 3.5.2 |Anaconda 4.2.0 (x86_64)| (default, Jul  2 2016, 17:52:12) \n",
    "Type \"copyright\", \"credits\" or \"license\" for more information.\n",
    "\n",
    "IPython 5.1.0 -- An enhanced Interactive Python.\n",
    "?         -> Introduction and overview of IPython's features.\n",
    "%quickref -> Quick reference.\n",
    "help      -> Python's own help system.\n",
    "object?   -> Details about 'object', use 'object??' for extra details.\n",
    "```\n",
    "\n",
    "Since Python is a relatively new programming language, its tools have been often built in a way to resemble existing well known software. Aesthetically the *iPython* prompt looks similar to Mathematica. *iPython* has also a number of properties that make it a very practical testing tool, together with its twin environment *Spyder*. People who used Matlab will find *Spyder* and *Canopy* very familiar. \n",
    "\n",
    "The online help of *iPython* is very clear and self-explanatory. If this is your first experience with Python I suggest you to play with it and test commands such as:\n",
    "\n",
    "1. Type ```help()```, or ```help('for')```, or look for other instructions\n",
    "1. ```print('I like Geodynamics!')```\n",
    "1. Assign values to string, integer and float variable types.\n",
    "    * ```In[1]: a=1; print(a)```\n",
    "    * ```In[2]: a=1.0; print(a)```\n",
    "\t* ```In[3]: a='a'; print(a)```\t\t\t\n",
    "1. Make some mathematical operations (\\*,/,+,-,\\**) using the interpreter as a calculator. Notice how python automatically decides which one of the three types of variable, integer, float and string must the answer be.\n",
    "\t* ```In[4]: 2+2```\n",
    "    * ```In[5]: 2+2.0```\n",
    "\t* ```In[6]: 3**3```\n",
    "\t* ```In[7]: 3.0**3```\n",
    "\t* ```In[8]: 6/2```\n",
    "\t* ```In[9]: 2/6```\n",
    "\t* ```In[10]: 'a'+'b'```\n",
    "1. You can also change the type of each variable:\n",
    "\t* ```In[11]: int('32')```\n",
    "\t* ```In[12]: str(3.2)```\n",
    "\t* ```In[13]: int(5.99)```\n",
    "\t* ```In[14]: int('5.99')``` This will give you error! Why?\n",
    "\t* ```In[15]: int(float('5.99'))``` Instead this works!!\n",
    "\n",
    "If this is your first programming experience, reflect on the answer that *Python* is giving to you. Programming languages have, like in algebra that we learn at school, the equivalent of *integer numbers*, of *real numbers* and of *text strings*, therefore its answers reflect these categories, that in Python are called integer ```int()```, *float* ```float()``` and string ```str()```. Python has always to choose one among them and the interpretation of your instruction will depend to this choice. This is radically difference from languages such as C or Fortran where you define to start with the type that you are using. \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Assignment Operator and variables\n",
    "Scientists and engineers routinely use programming language to perform numerically demanding calculations that would otherwise be really time consuming to perform manually. The calculated results have to stored into the computer's memory. Variables are used to store such results. \n",
    "\n",
    "Values can be assigned to the variables using assignment operator ('='). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a=3 #assigning an integer value '3' to the variable "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7.341\n"
     ]
    }
   ],
   "source": [
    "print('7.341')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Functions \n",
    "Blocks of statements that recur often in a program are better placed separetely and called everytime this is necessary. A unit of code like that is called a *Function*. The values passed to a function are called parameters and the values given back by the function are called return values.\n",
    "\n",
    "The following simple function averages three grades. Then it is used for two students."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum of the grades for student A is 173 and the average grade  57.666666666666664\n",
      "The sum of the grades for student A is 184 and the average grade  61.33333333333333\n"
     ]
    }
   ],
   "source": [
    "#function example\n",
    "def grading(mathGrade,scienceGrade,englishGrade):\n",
    "    total = mathGrade+scienceGrade+englishGrade\n",
    "    totalGrade = total/300.*100.\n",
    "    return total,totalGrade\n",
    "\n",
    "totalA,totalGradeA=grading(55,90,28)\n",
    "print('The sum of the grades for student A is',totalA, 'and the average grade ', totalGradeA)\n",
    "\n",
    "totalB,totalGradeB=grading(72,67,45)\n",
    "print('The sum of the grades for student A is',totalB, 'and the average grade ', totalGradeB)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An important characteristic of Python is that the variables passed in do not have to be of a specific type, either integer or real or string. Let's now define a function named 'printSomething' and call it twice in the program with very different inputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I like Geodynamics\n",
      "4a\n"
     ]
    }
   ],
   "source": [
    "def printSomething(whateverIwant):\n",
    "    print(whateverIwant)\n",
    "printSomething('I like Geodynamics')\n",
    "printSomething(str(4)+'a')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's embedd now a function inside another function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "ciaociao\n"
     ]
    }
   ],
   "source": [
    "def doublePrint(a):\n",
    "    printSomething(a+a)\n",
    "doublePrint(2)\n",
    "doublePrint('ciao')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*An original and practical characteristic of Python (compared to other programming languages) is that it uses the indentation to determine the body of a loop or a function. *\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What follows is a bit advanced, but a classical implementation of functions. Since we can embedd a function inside another, then we can also embedd the function itself inside. This type of function is called *recursive* and can be used for example to elegantly calculate the factorial of a positive integer number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2432902008176640000\n"
     ]
    }
   ],
   "source": [
    "def fact(n):\n",
    "    if n==1: # here n==1 is a conditional statement discussed later in this notebook\n",
    "        return 1\n",
    "    else:\n",
    "        return n*fact(n-1)\n",
    "print(fact(20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Conditional statements and Logical operators\n",
    "Conditional statements are used to make comparisons between two or more variables/values. \n",
    "For example, if we wrote 'print(1==2)', meaning '1 is equal to 2', the statement would be wrong. Conditional statements are used to make such types of decisions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(1==2) # here '==' is the equal operator. It is true only when both LHS and RHS are equal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(1!=2) # '!' is the not operator. Here '!=' means not equal. Since '1 is not equal to 2' so the value is true."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Logical operators are used to connect two or more conditional operators. The most common types of logical operators are 'and', or'and 'not'. \n",
    "The 'and' operator is true when all the conditions are true. The 'or' operator is true when any of the conditions are true. And the 'not' operator reverses the value of the condition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(1==2 and 1==1)\n",
    "print(1==2 or 1==1)\n",
    "print(1!=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Result of Student 1 \n",
      "===================\n",
      "Mmm, something went wrong\n",
      "\n",
      "Result: Student 2 \n",
      "=================\n",
      "Fantastic!\n"
     ]
    }
   ],
   "source": [
    "#Conditional statements\n",
    "def congratulateGrade(grade):\n",
    "    if grade=='F':\n",
    "        print('Mmm, something went wrong')\n",
    "    elif grade=='D':\n",
    "        print('Not the best performance')\n",
    "    elif grade=='C':\n",
    "        print('It is ok!')\n",
    "    elif grade=='B':\n",
    "        print('Very good!')\n",
    "    elif grade=='A':\n",
    "        print('Fantastic!')\n",
    "\n",
    "#calling the function \n",
    "print('\\nResult of Student 1 \\n===================' )\n",
    "congratulateGrade('F')\n",
    "\n",
    "print('\\nResult: Student 2 \\n=================' )\n",
    "congratulateGrade('A')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "a=5; b=5\n",
    "if a: #this is true when the value of a is nonzero\n",
    "    print(10)\n",
    "b=0\n",
    "if b: #this is false because the value of b is zero \n",
    "    print(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Iterations \n",
    "A series of statements can be executed repeatedly in programming using iterations (also known as loop). \n",
    "The most common types of loop used in python are 'for' loop and 'while' loop.\n",
    "The for loop has the following syntax;\n",
    "\n",
    ">for (variable in list):<br>\n",
    "&nbsp;&nbsp;    statement_1<br>\n",
    "&nbsp;&nbsp;    .<br>\n",
    "&nbsp;&nbsp;    .<br>\n",
    "&nbsp;&nbsp;    statement_N<br>\n",
    "\n",
    "The loop variable takes individual elements from the loop list. The stetements (1 to N) are executed every time the the loop variable takes another value from the loop list.\n",
    "\n",
    "\n",
    ">while (condition):<br>\n",
    "&nbsp;&nbsp;    statement_1<br>\n",
    "&nbsp;&nbsp;    .<br>\n",
    "&nbsp;&nbsp;    .<br>\n",
    "&nbsp;&nbsp;    statement_N<br>\n",
    "\n",
    "The while loop executes the series of statements (here from statement_1 to statement_N) unless the given condition is false."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following program shows that the variables inside the iteration list can contain anything including 'range of integers', 'list of string', 'a single number/string' etc. and that Python automatically detects what they are."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.0     is a    <class 'float'>\n",
      "98     is a    <class 'int'>\n",
      "a string     is a    <class 'str'>\n",
      "(3.0, 5.0, 'ciao')     is a    <class 'tuple'>\n",
      "True     is a    <class 'bool'>\n",
      "<function congratulateGrade at 0x105748e18>     is a    <class 'function'>\n"
     ]
    }
   ],
   "source": [
    "myStrangeSet=(5.0,98,'a string', (3.0,5.,'ciao'), 5>2, congratulateGrade)\n",
    "for x in myStrangeSet:\n",
    "    print(x,'    is a   ',type(x))  #printing the type of variable used in the loop list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another example: calculate the sum of numbers from 0 to 100 using for loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5050\n"
     ]
    }
   ],
   "source": [
    "sum=0\n",
    "for x in range(101): #the value of x ranges from 0 to 100\n",
    "    sum+=x  # also can be written as sum=sum+x. This is an example of accumulator variable\n",
    "print(sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Extending Python\n",
    "\n",
    "Besides being dynamic, interpreted and interactive Python is also Object-Oriented (OO) and extensible. *Object Oriented Programming (OOP)* is a programming paradigm based on the idea that *objects*, and not *procedures* are at the center of a program, as in traditional programming. *OOP* is based on the idea of *Classes*, from which *Objects* are instantiated. The procedures are then defined only as *methods* associated to each Class and then inherited by objects, or by subclasses, which share some properties with the original Class, and possibly have new methods. The all concept of programming changes in *OOP* as in it objects interact with each other. \n",
    "\n",
    "While initially *OPP* was mainly used for static programming, the most important of them is *C++*, in recent years many dynamic programming have been built based on the OOP concept, being *Python* the first of them. *OOP* plays a particular role in Python as it allows its exceptional *extensibility*, or in other words Python can be used to *Glue Together* a vast range of existing software, developed in a variety of languages, that otherwise could be forgotten, or not used, although they had been written with great care and in order to be very efficient. It was Guido van Rossum in person who pointed this out in 1998.\n",
    "\n",
    "The use of *OOP* in numerical modeling, in particular geodynamic modeling, has been until present modest. This is mainly because our software is mainly based on solving complex and challenging mathematical formulations of geoscientific problems, which do not immediately require being written in *OOP*. However in the case of Python its *Modular* structure allows several important advantages. The first being the possibility to replace some inefficient Numerical Procedure in Standard Python with the better ones of Numerical Python (*NumPy*), but also to import fast libraries initially written in other languages. Let's see how this can be easily done.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Importing Libraries\n",
    "\n",
    "Every library, or module, can be imported with the command **import**, or a function can be extract from a model by using **from**. If a command exists with the same name, it will be override by the new one. For example let's look at the generation of an array of 10 integers using the module NumPy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "from numpy import *\n",
    "a=arange(10)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**arange()** belongs to the *numpy* library, however this is not self evident, and makes reading the source not immediate. The solution to this ambiguity is to importe NumPy as a separate module:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  2  3  4  5  6  7  8  9 10 11]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "b=np.arange(12)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The advantage of the first method is compactness and speed in writing your script, however the second approach is more clean and helps the reader who might not be familiar with each library to know where each instruction is coming from. Furthermore the risk of involuntarily redefining a function called with the same name in two libraries is avoided. For this reason in this book we will always use the second form."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### NumPy: Numerical Python\n",
    "\n",
    "For scientists Python represented the arrival of a programming language that finally integrates power and ease of use in a nearly optimal way. Its syntax is so simple to be comparable to a scripting language. Its enforced code structure makes it ideal for learning programming for scientists at learn their first language. However initially the main obstacle to a wide implementation was its lack of performance for large problems. \n",
    "\n",
    "The *game changing* innovation has been the arrival of numerical libraries that, if properly used, bring up its efficiency to the one of languages like C and Fortran. I will often use the words *C-speed*, in analogy to the speed of light, to mean that using specific libraries one can achieve computing efficiency comparable to the language *C*, that like *c* is the unsurpassable speed of physical objects, represents the optimal speed for standard programs. \n",
    "\n",
    "With the right mix of knowledge between how Python, and in particular its numerical library NumPy, uses the low level computer memory, it is possible to make Python performing like compiled codes, avoiding long implementations that are difficult to read and long and tedious debugging. Until now, most scientists have achieved a result comparable to that using Matlab, which is however a proprietary software, therefore with the limits imposed by the company and requiring a license. Python is an open source project and is freely available to everyone. While we write Python is scaling up globally and becoming the *de facto* programming language in science. \n",
    "\n",
    "Specifically in geophysics and geodynamics in particular, however, there is a lack of textbooks showing how Python can be used for specific applications. It is my intention to fill this gap with this book, searching for the right balance between introducing geophysicists to programming and teaching them to build geodynamics software.\n",
    "\n",
    "We will look at the features of *NumPy* in depth in a following Notebook. To show only a first example, we have seen above that in standard Python one can loop through different objects, and one can call functions with different *variable types*. While this in general is a powerful feature and has been designed to imitate human language, this is also what makes Python really slow. Every time the parser processes a new variable it has to *understand* what type it is and then use the right method. Also with very long lists the access of elements is slow due to the unknown size of every variable which makes its access consequential, i.e. O(n) where n is the size the list. \n",
    "\n",
    "These inefficiencies do not exist in standard compiled languages such as C and Fortran where instead of lists there are arrays of equal types, which allows both processing every variable and accessing every element at the speed of O(1). It also allows extremely efficient storage. *NumPy* offers these properties within a Python framework, leaving the remaining programming experience light and straightforward. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "from numpy import *\n",
    "a=arange(10)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  2  3  4  5  6  7  8  9 10 11]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "b=np.arange(12)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Visualization\n",
    "\n",
    "One of the largest projects in Python is the development of the visualization library *MatPlotLib*, available from http://matplotlib.org/. While, as it is clear from its name, the initial goal was to create a plotting suite that would imitate the features of Matlab, with time it gained momentum and is now an independent project and the main visualization library within Python. \n",
    "\n",
    "While Matplot is a very powerful tool in 2D, in 3D its potential is limited. For this reason for visualizing 3D data and modeling results the best option is to export the data in formats readable by powerful external software such as *Paraview* and *VisIt*. Visualization will be treated in more detail in the next Notebook. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Summary\n",
    "\n",
    "1.  History of Python. Python was created in 1989. The version 3.0, released in 2008, was back-incompatible, so new programs should be written with Python 3.x. \n",
    "2. Python is Object Oriented. This allows its highly modular structure. Software can be organized in Classes. \n",
    "3. Python is Extensible. Libraries written in with in Python or in other languages such as C and Fortran can be efficiently and immediately imported as *Modules*.\n",
    "4. Python is Easy to use. The syntax is extremely simple, compact and intuitive. The interactive version of Python, *iPython* allows testing codes just on time.\n",
    "5. Modeling with Python. Most numerical outcomes are obtained by using Numerical Python (NumPy), Cython  (Python code automatically translated in C) and libraries written in other languages.\n",
    "6. Visualization in Python. Matplotlib is the main visualization library. Python interfaces with VTK, Binary and other storage and visualization formats. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Problems\n",
    "1. To gain familiarity with the output functions of Python, write a program that writes a sentence on\n",
    "\n",
    "\ta. the screen\n",
    "\n",
    "    b. on a text file\n",
    "\t\n",
    "    We did not look yet at how to open and close a file, but it is a simple task that can be found on the online Python documentation, and is therefore a good chance to familiarize with it. Take into account that a file can be open in *writing* mode, or *reading* mode, and of course you will need the first one. Python 2.x and Python 3.x handle input and output differently, so be aware of which Python version you use be consistent. \n",
    "<br><br>\n",
    "2. Arithmetic, Geometric and Harmonic means are very important and different ways to average small or large sets of numbers. We will encounter these types in averaging many times, for example when averaging the properties of a large number of particles in a cell in the *Particles in Cell* method, or when projecting the solution of a Meshless method to a 3D Lattice in space. Briefly they are defined as:\n",
    "\n",
    "    a. Geometric mean: $A=\\left(\\prod _{i=1}^{n}a_{i}\\right)^{\\frac {1}{n}}={\\sqrt[{n}]{a_{1}a_{2}\\cdots a_{n}}}$ \n",
    "\n",
    "    b. Arithmetic mean: $A=\\frac{1}{n} \\sum\\limits_{i=1}^n a_i$\n",
    "\t\n",
    "    c. Harmonic mean: $H={\\frac {n}{{\\frac {1}{x_{1}}}+{\\frac {1}{x_{2}}}+\\cdots +{\\frac {1}{x_{n}}}}}={\\frac {n}{\\sum \\limits _{i=1}^{n}{\\frac {1}{x_{i}}}}}$.\n",
    "\t\t\n",
    "\tYour task is to write a Python program that generates $n$ random numbers (you can use **a=np.random.rnd(n)** ), for example 10, or 1000 numbers, calculates the three means, and verify which one is systematically the greatest and which one the smallest. Reflect on why it is so. We will use this property.\n",
    "<br><br>\n",
    "3. Write a program that from an integer number calculates its factorial. There are several approaches for this task. It can be done with a **for** loop, but also with a more elegant recursive function, i.e. a function that calls itself. You can also allow an external user to input the initial number, in which case you can use **Try** and **Except** to handle the possibility that the input is not a positive integer. \n",
    "<br><br>\n",
    "4.  Write a program that calculates the arithmetic mean and standard deviatoric mean of a set of random numbers (google about the deviatoric mean, if you are not familiar with it!). Uniformly distributed random numbers can be generated in Python using the *uniform* instruction within the \\pyln{numpy.random} module.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [anaconda]",
   "language": "python",
   "name": "Python [anaconda]"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}