Numpy-specific_help_functions_Solutions.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.11.2'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.__version__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q1. Search for docstrings of the numpy functions on linear algebra."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Search results for 'linear algebra'\n",
      "-----------------------------------\n",
      "numpy.linalg.solve\n",
      "    Solve a linear matrix equation, or system of linear scalar equations.\n",
      "numpy.poly\n",
      "    Find the coefficients of a polynomial with the given sequence of roots.\n",
      "numpy.restoredot\n",
      "    Restore `dot`, `vdot`, and `innerproduct` to the default non-BLAS\n",
      "numpy.linalg.eig\n",
      "    Compute the eigenvalues and right eigenvectors of a square array.\n",
      "numpy.linalg.cond\n",
      "    Compute the condition number of a matrix.\n",
      "numpy.linalg.eigh\n",
      "    Return the eigenvalues and eigenvectors of a Hermitian or symmetric matrix.\n",
      "numpy.linalg.pinv\n",
      "    Compute the (Moore-Penrose) pseudo-inverse of a matrix.\n",
      "numpy.linalg.LinAlgError\n",
      "    Generic Python-exception-derived object raised by linalg functions.\n"
     ]
    }
   ],
   "source": [
    "np.lookfor('linear algebra')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q2. Get help information for numpy dot function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dot(a, b, out=None)\n",
      "\n",
      "Dot product of two arrays.\n",
      "\n",
      "For 2-D arrays it is equivalent to matrix multiplication, and for 1-D\n",
      "arrays to inner product of vectors (without complex conjugation). For\n",
      "N dimensions it is a sum product over the last axis of `a` and\n",
      "the second-to-last of `b`::\n",
      "\n",
      "    dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])\n",
      "\n",
      "Parameters\n",
      "----------\n",
      "a : array_like\n",
      "    First argument.\n",
      "b : array_like\n",
      "    Second argument.\n",
      "out : ndarray, optional\n",
      "    Output argument. This must have the exact kind that would be returned\n",
      "    if it was not used. In particular, it must have the right type, must be\n",
      "    C-contiguous, and its dtype must be the dtype that would be returned\n",
      "    for `dot(a,b)`. This is a performance feature. Therefore, if these\n",
      "    conditions are not met, an exception is raised, instead of attempting\n",
      "    to be flexible.\n",
      "\n",
      "Returns\n",
      "-------\n",
      "output : ndarray\n",
      "    Returns the dot product of `a` and `b`.  If `a` and `b` are both\n",
      "    scalars or both 1-D arrays then a scalar is returned; otherwise\n",
      "    an array is returned.\n",
      "    If `out` is given, then it is returned.\n",
      "\n",
      "Raises\n",
      "------\n",
      "ValueError\n",
      "    If the last dimension of `a` is not the same size as\n",
      "    the second-to-last dimension of `b`.\n",
      "\n",
      "See Also\n",
      "--------\n",
      "vdot : Complex-conjugating dot product.\n",
      "tensordot : Sum products over arbitrary axes.\n",
      "einsum : Einstein summation convention.\n",
      "matmul : '@' operator as method with out parameter.\n",
      "\n",
      "Examples\n",
      "--------\n",
      ">>> np.dot(3, 4)\n",
      "12\n",
      "\n",
      "Neither argument is complex-conjugated:\n",
      "\n",
      ">>> np.dot([2j, 3j], [2j, 3j])\n",
      "(-13+0j)\n",
      "\n",
      "For 2-D arrays it is the matrix product:\n",
      "\n",
      ">>> a = [[1, 0], [0, 1]]\n",
      ">>> b = [[4, 1], [2, 2]]\n",
      ">>> np.dot(a, b)\n",
      "array([[4, 1],\n",
      "       [2, 2]])\n",
      "\n",
      ">>> a = np.arange(3*4*5*6).reshape((3,4,5,6))\n",
      ">>> b = np.arange(3*4*5*6)[::-1].reshape((5,4,6,3))\n",
      ">>> np.dot(a, b)[2,3,2,1,2,2]\n",
      "499128\n",
      ">>> sum(a[2,3,2,:] * b[1,2,:,2])\n",
      "499128\n"
     ]
    }
   ],
   "source": [
    "np.info(np.dot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}