Worksheet_setup.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Importing modules, setting options and defining custom functions for use in other worksheets\n",
    "To import into another worksheet:\n",
    "\n",
    "```\n",
    "fun_include_ipynb('Worksheet_setup')\n",
    "```\n",
    "or\n",
    "```\n",
    "load('Worksheet_setup.sage')\n",
    "```\n",
    "Note: This worksheet is prepared for the open source software [sage](http://www.sagemath.org). In sage 7.3, nbconvert is missing dependencies. To rectify, enter the following commands in a terminal:\n",
    "\n",
    "```\n",
    "sage --sh\n",
    "pip install entrypoints\n",
    "pip install configparser\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/sschyman/Programs/sage-upgrade/local/lib/python2.7/site-packages/traitlets/traitlets.py:770: DeprecationWarning: A parent of InlineBackend._config_changed has adopted the new @observe(change) API\n",
      "  clsname, change_or_name), DeprecationWarning)\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import numpy as np  # for data array operations\n",
    "import pylab   # for plotting\n",
    "import json   # for reading notebook metadata\n",
    "\n",
    "list_plot.options[\"frame\"]=True\n",
    "list_plot.options[\"axes\"]=False\n",
    "plot.options[\"frame\"]=True\n",
    "plot.options[\"axes\"]=False\n",
    "\n",
    "try:\n",
    "    for s in units.amount_of_substance.trait_names():\n",
    "        globals()[s] = getattr(units.amount_of_substance,s) \n",
    "    for s in units.energy.trait_names():\n",
    "        globals()[s] = getattr(units.energy,s)\n",
    "    for s in units.length.trait_names():\n",
    "        globals()[s] = getattr(units.length,s)    \n",
    "    for s in units.mass.trait_names():\n",
    "        globals()[s] = getattr(units.mass,s)\n",
    "    for s in units.pressure.trait_names():\n",
    "        globals()[s] = getattr(units.pressure,s)\n",
    "    for s in units.temperature.trait_names():\n",
    "        globals()[s] = getattr(units.temperature,s)\n",
    "    for s in units.time.trait_names():\n",
    "        globals()[s] = getattr(units.time,s)\n",
    "    for s in units.power.trait_names():\n",
    "        globals()[s] = getattr(units.power,s)\n",
    "except:     # in newer versions of sage, need to use _tab_completion() instead of trait_names()\n",
    "    for s in units.amount_of_substance._tab_completion():\n",
    "        globals()[s] = getattr(units.amount_of_substance,s) \n",
    "    for s in units.energy._tab_completion():\n",
    "        globals()[s] = getattr(units.energy,s)\n",
    "    for s in units.length._tab_completion():\n",
    "        globals()[s] = getattr(units.length,s)    \n",
    "    for s in units.mass._tab_completion():\n",
    "        globals()[s] = getattr(units.mass,s)\n",
    "    for s in units.pressure._tab_completion():\n",
    "        globals()[s] = getattr(units.pressure,s)\n",
    "    for s in units.temperature._tab_completion():\n",
    "        globals()[s] = getattr(units.temperature,s)\n",
    "    for s in units.time._tab_completion():\n",
    "        globals()[s] = getattr(units.time,s)\n",
    "    for s in units.power._tab_completion():\n",
    "        globals()[s] = getattr(units.power,s)        \n",
    "\n",
    "\n",
    "udict = {}\n",
    "cdict = {}\n",
    "docdict = {}\n",
    "dict_latex = {}\n",
    "dict_domain = {}\n",
    "dict_vars ={}\n",
    "\n",
    "\n",
    "def var2(name, doc='', units=1, domain1='real', latexname='', value = False):\n",
    "    '''\n",
    "    Creates a symbolic variable in the given domain (standard:'real') and with the given \n",
    "    latexname. Further, it adds the string doc to docdict, the units to udict and the value\n",
    "    to cdict. All entries are optional except for name. Note that the information passed as\n",
    "    domain1 is saved as an assumption, e.g. 'a is read'. All assumptions can be viewed as a\n",
    "    list, using the command assumptions().\n",
    "    Usage example: \n",
    "        sage: var2('x', 'Distance' , units=meter, domain1 = 'positive', latexname = 'x_{1-2}', value = 1.0)\n",
    "    '''\n",
    "    if len(latexname)>0:\n",
    "        z = var(name,domain = domain1,latex_name = latexname)   \n",
    "    else:\n",
    "        z = var(name,domain = domain1) \n",
    "    var1 = eval(name)\n",
    "    dict_domain[var1] = domain1\n",
    "    dict_latex[var1] = var1._latex_()\n",
    "    docdict[var1] = doc\n",
    "    udict[var1] = units\n",
    "    dict_vars[var1] = {'doc': doc, 'units': units, 'domain1': domain1, 'latexname': latexname, 'value': value}\n",
    "    if value:\n",
    "        cdict[var1] = value\n",
    "    return z\n",
    "\n",
    "def fun_loadvars(vardict = False):\n",
    "    '''\n",
    "    Loads all information related to symbolic variables defined using var2.\n",
    "    Usage example:\n",
    "        sage: allvars = fun_loadvars()\n",
    "    '''\n",
    "    if vardict:\n",
    "        variables = vardict.keys()\n",
    "        for var1 in variables:\n",
    "            var2(str(var1), doc = vardict[var1]['doc'], units = vardict[var1]['units'], domain1 = vardict[var1]['domain1'],\\\n",
    "                 latexname = vardict[var1]['latexname'], value = vardict[var1]['value'])\n",
    "        \n",
    "    else:    \n",
    "        variables = docdict.keys()\n",
    "        for var1 in variables:\n",
    "            if var1 in cdict.keys():\n",
    "                var2(str(var1), doc=docdict[var1], units=udict[var1], domain1 = dict_domain[var1],\\\n",
    "                     latexname=dict_latex[var1], value=cdict[var1])\n",
    "            else:\n",
    "                var2(str(var1), doc=docdict[var1], units=udict[var1], domain1 = dict_domain[var1],\\\n",
    "                     latexname=dict_latex[var1])\n",
    "                     \n",
    "# Workaround from http://ask.sagemath.org/question/10260/convert-derived-si-units-to-base-units/\n",
    "def convert(expr):\n",
    "     op = expr.operator()\n",
    "     ops = expr.operands()\n",
    "     if op:\n",
    "        if len(ops) == 2:\n",
    "            return op(*map(convert, ops))\n",
    "        else:\n",
    "            return op(convert(ops[0]), reduce(op, map(convert, ops[1:])))\n",
    "     else:\n",
    "        return expr.convert() if hasattr(expr, 'convert') else expr\n",
    "    \n",
    "def units_check(eq, sfull = True):\n",
    "    '''\n",
    "    Checks whether all arguments are keys in udict and returns simplified units\n",
    "    '''\n",
    "    global udict, dict_units\n",
    "    udict1 = {}\n",
    "    # Need to multiply units with variable, so that we can devide by the symbolic equation later:\n",
    "    for key1 in udict.keys():\n",
    "        udict1[key1] = key1*udict[key1]\n",
    "    for blah in eq.arguments():\n",
    "        udict[blah]\n",
    "    eq.show()\n",
    "    if sfull:\n",
    "        return convert(eq.subs(udict1)/eq).simplify_full()\n",
    "    else:\n",
    "        return convert(eq.subs(udict1)/eq)\n",
    "    \n",
    "def fun_units_formatted(variable):\n",
    "    '''\n",
    "    Returns units of variable expanded to exponential notation.\n",
    "    \n",
    "    '''\n",
    "    global udict, subsdict\n",
    "    units1 = (eval(variable)*udict[eval(variable)]/eval(variable)).subs(subsdict)   # multiplication and division by the variable ensures that units1 is a symbolic expression, even if udict[var] = 1\n",
    "    facs = units1.factor_list()\n",
    "    str1 = ''\n",
    "    for term1 in facs:\n",
    "        op1 = term1[1]\n",
    "        if op1==1:\n",
    "            str1 = str(term1[0]) + ' ' + str1\n",
    "        if op1!=1:\n",
    "            str1 = str1 +' ' + str(term1[0])\n",
    "            str1 = str1 + '$^{' + str(op1) + '}$ '\n",
    "    return str1\n",
    "\n",
    "\n",
    "    \n",
    "def plot_fit(xdata, ydata, model, initial_guess = None, parameters = None, variables = None):\n",
    "    '''Fits the parameters of model to lists of xdata and ydata and plots the results\n",
    "       Example:\n",
    "          #linear regression through origin\n",
    "        var('x m')\n",
    "        model(x) = m*x\n",
    "        plot_fit(xdata,ydata,model)\n",
    "    '''\n",
    "    data = zip(xdata,ydata)\n",
    "    xdata1 = vector(xdata)\n",
    "    ydata1 = vector(ydata)\n",
    "    p1 = find_fit(data, model,solution_dict=True)\n",
    "    pkeys = p1.keys()\n",
    "    p2 = {}\n",
    "    for i in pkeys: p2[i] = n(p1[i],digits=3)\n",
    "    fitvals = vector([n(model(x1).subs(p1)) for x1 in xdata])\n",
    "    # root mean square deviation\n",
    "    rmsd = sqrt(mean(ydata1 - fitvals)^2)\n",
    "    nrmsd = rmsd/(max(ydata) - min(ydata))\n",
    "    blah = text(\"y=\"+str(model(x).subs(p2)),(0,0),fontsize=10,rgbcolor=(1,0,0))\n",
    "    print \"y=\"+str(model(x).subs(p2))\n",
    "    print \"NRMSD = \"+str(n(nrmsd,digits=5))\n",
    "    lentext = blah.xmax() - blah.xmin()\n",
    "    # plot\n",
    "    P = list_plot(data, frame=True, axes = False, faceted=True, color = \"white\")\n",
    "    P += plot(model.subs(p1),(x,min(xdata),max(xdata)),color = 'black', legend_label = \"y=\"+str(model(x).subs(p2)) + '\\n ' + \"NRMSD = \"+str(n(nrmsd,digits=5)))   \n",
    "    return P\n",
    "\n",
    "def dict_print(vdict1, list_names = None):\n",
    "    dtype1 = [('name', 'S10'), ('val', object)]\n",
    "    vdict2 = vdict1.copy()\n",
    "    if list_names:\n",
    "        vdict2 = {}\n",
    "        for name1 in list_names:\n",
    "            vdict2[name1] = vdict1[name1]\n",
    "    list1 = np.array(vdict2.items(), dtype = dtype1)\n",
    "    list2 = np.sort(list1,order = 'name')\n",
    "    for k, v in list2:\n",
    "            print \"{:<15} {:<15}\".format(k,v)    \n",
    "            \n",
    "def fun_dict_print(vdict1):\n",
    "    dtype1 = [('name', 'S10'), ('val', object)]\n",
    "    list1 = np.array(vdict1.items(), dtype = dtype1)\n",
    "    list2 = np.sort(list1,order = 'name')\n",
    "    for k, v in list2:\n",
    "            print \"{:<15} {:<15}\".format(k,v)\n",
    "            \n",
    "def fun_dict(dict1,dict2):\n",
    "    '''\n",
    "    Updates all entries of dict1 with entries co-occurring in dict2\n",
    "    and returns the udated dict1.\n",
    "    '''\n",
    "    dict1.update(dict2)\n",
    "    return dict1\n",
    "\n",
    "def fun_comp_array(expr1, nparray):\n",
    "    \"\"\"\n",
    "    Returns list of values for expr1 \n",
    "    corresponding to each row of nparray\n",
    "    where all arguments in expr1 are substituted\n",
    "    by the corresponding values in nparray.\n",
    "    \"\"\"\n",
    "    list_args = expr1.args()\n",
    "    return [expr1.subs(dict(zip(list_args, [nparray[str(dummy)][i] for dummy in list_args]))) for i in srange(len(nparray))]\n",
    "    \n",
    "def fun_printvar(varname):\n",
    "    pstring = str(varname)+': ' + docdict[varname]\n",
    "    try: \n",
    "        value = cdict[varname]\n",
    "        pstring1 = pstring + ', ' + str(n(value, prec = 16)) + ' ' + str(udict[varname]/varname)\n",
    "    except: pstring1 = pstring + ', ' + str(udict[varname]/varname)\n",
    "    print pstring1\n",
    "    return\n",
    "\n",
    "def fun_eq(eq, sfull = True):\n",
    "    print units_check(eq)\n",
    "    return eq\n",
    "\n",
    "def fun_export_ipynb(worksheet, folder):\n",
    "    '''\n",
    "    Exports worksheet.ipynb to a .py or .sage depending on kernel.\n",
    "    Example:\n",
    "    fun_export_ipynb('Worksheet_setup', 'temp/')\n",
    "    Need to import json before using this function. Unless option output=True is given,\n",
    "    each line of text has a semicolon added in the .py file, preventing any output.\n",
    "    '''\n",
    "    str1 = 'jupyter nbconvert  --to=python \\'' + worksheet+'.ipynb\\''\n",
    "    print str1\n",
    "    print 'Exporting specified worksheet to .py file...'\n",
    "    \n",
    "    try:\n",
    "        retcode = os.system(str1)\n",
    "        if retcode < 0:\n",
    "            print >>sys.stderr, \"nbconvert was terminated by signal\", -retcode\n",
    "        else:\n",
    "            print >>sys.stderr, \"nbconvert returned\", retcode\n",
    "    except OSError as e:\n",
    "        print >>sys.stderr, \"Execution failed:\", e\n",
    "        print >>sys.stderr, \"Trying ipython nbconvert instead...\"\n",
    "        str1 = 'ipython nbconvert  --to script \\'' + worksheet+'.ipynb\\''    # for new version of python\n",
    "        try:      \n",
    "            retcode = os.system(str1)\n",
    "            if retcode < 0:\n",
    "                print >>sys.stderr, \"nbconvert was terminated by signal\", -retcode\n",
    "            else:\n",
    "                print >>sys.stderr, \"nbconvert returned\", retcode\n",
    "        except OSError as e:\n",
    "            print >>sys.stderr, \"Execution failed:\", e              \n",
    "\n",
    "    str1 = worksheet + '.py'\n",
    "    \n",
    "    print 'Checking if specified ipynb file was run with sage kernel...'\n",
    "    with open(worksheet+'.ipynb') as data_file:    \n",
    "        data = json.load(data_file)\n",
    "    \n",
    "    if data['metadata']['kernelspec']['name'][0:4] == 'sage':\n",
    "        print 'Renaming .py file to .sage if notebook kernel was sage (to avoid exponent error)'\n",
    "        str2 = folder + worksheet + '.sage'\n",
    "        os.rename(str1, str2)\n",
    "                     \n",
    "\n",
    "def fun_include_ipynb(worksheet, del1 = True, output = True):\n",
    "    '''\n",
    "    Exports worksheet.ipynb to a sage file and loads it into current worksheet.\n",
    "    Example:\n",
    "    fun_include_ipynb('Worksheet_setup')\n",
    "    Need to import json before using this function. Unless option output=True is given,\n",
    "    each line of text has a semicolon added in the .py file, preventing any output.\n",
    "    '''\n",
    "    str1 = 'jupyter nbconvert  --to=python \\'' + worksheet+'.ipynb\\''\n",
    "    print str1\n",
    "    print 'Exporting specified worksheet to .py file...'\n",
    "    \n",
    "    try:\n",
    "        retcode = os.system(str1)\n",
    "        if retcode < 0:\n",
    "            print >>sys.stderr, \"nbconvert was terminated by signal\", -retcode\n",
    "        else:\n",
    "            print >>sys.stderr, \"nbconvert returned\", retcode\n",
    "    except OSError as e:\n",
    "        print >>sys.stderr, \"Execution failed:\", e\n",
    "        print >>sys.stderr, \"Trying ipython nbconvert instead...\"\n",
    "        str1 = 'ipython nbconvert  --to script \\'' + worksheet+'.ipynb\\''    # for new version of python\n",
    "        try:      \n",
    "            retcode = os.system(str1)\n",
    "            if retcode < 0:\n",
    "                print >>sys.stderr, \"nbconvert was terminated by signal\", -retcode\n",
    "            else:\n",
    "                print >>sys.stderr, \"nbconvert returned\", retcode\n",
    "        except OSError as e:\n",
    "            print >>sys.stderr, \"Execution failed:\", e              \n",
    "        \n",
    "    str1 = worksheet + '.py'\n",
    "    \n",
    "    print 'Checking if specified ipynb file was run with sage kernel...'\n",
    "    with open(worksheet+'.ipynb') as data_file:    \n",
    "        data = json.load(data_file)\n",
    "    \n",
    "    if data['metadata']['kernelspec']['name'][0:4] == 'sage':\n",
    "        print 'Renaming .py file to .sage if notebook kernel was sage (to avoid exponent error)'\n",
    "        str2 = worksheet + '.sage'\n",
    "        os.rename(str1, str2)\n",
    "        str1 = str2\n",
    "    if output == False:\n",
    "        input_file = open(str1, \"r\")\n",
    "        str2 = '0_'+ str1\n",
    "        output_file = open(str2, \"w\")\n",
    "        for line in input_file:\n",
    "            line = line.strip() # remove line end marks\n",
    "            final = line+'\\n'\n",
    "            if len(line)>0:\n",
    "                if line[-1] != ';':\n",
    "                    final= line+';\\n'\n",
    "            output_file.write(final)\n",
    "        input_file.close()\n",
    "        os.remove(str1)\n",
    "        output_file.close()\n",
    "        str1 = str2\n",
    "        \n",
    "        \n",
    "    print 'Loading file into current worksheet...'\n",
    "    load(str1)\n",
    "    if del1:\n",
    "        print 'Removing file generated above...'\n",
    "        os.remove(str1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below, we export the above commands to a file called Worksheet_setup.sage in the temp folder, which can be loaded in other worksheets by typing:\n",
    "\n",
    "`load('temp/Worksheet_setup.sage')`\n",
    "However, to avoid re-exporting the file every time it is loaded, we will comment out the command and instead execute it from a different worksheet, Worksheet_update.ipynb."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#fun_export_ipynb('Worksheet_setup', 'temp/')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "SageMath 7.3",
   "language": "",
   "name": "sagemath"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.10"
  },
  "nav_menu": {},
  "toc": {
   "navigate_menu": true,
   "number_sections": true,
   "sideBar": true,
   "threshold": 6,
   "toc_cell": false,
   "toc_section_display": "block",
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}