python3_chapter2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.path.append('/Users/sushmitroy/Linear_algebra_coding')\n",
    "from plotting import  plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "L = [[2,2],[3,2],[1.75,1],[2,1],[2.25,1],[2.5,1],[2.75,1],[3,1],[3.25,1]]\n",
    "#plot(L,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def add2(v,w):\n",
    "    return [v[0] + w[0],v[1] + w[1]]\n",
    "\n",
    "plot([add2(v,[1,2]) for v in L],5)\n",
    "\n",
    "# adding n vectors:\n",
    "def addn( v ,w): return [x+y for (x,y) in zip(v,w)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def scalar_vector_mult(alpha ,v):\n",
    "    return [[alpha * v[i][0] ,alpha * v[i][1]] for i in range(len(v))]\n",
    "plot(scalar_vector_mult(-0.5,L),4)\n",
    "#scalar_vector_mult(0.5,L)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "v =[3,2]\n",
    "#plot(,4)\n",
    "\n",
    "plot([[i/100*v[0],i/100*v[1]] for i in range(101)],4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "v =[3,2]\n",
    "# Drawing a line segment\n",
    "plot([add2([i/100*v[0],i/100*v[1]],[0.5,1]) for i in range(101)],4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Task 2.6.9\n",
    "def segment(pt1,pt2):\n",
    "    return [ [i/100*pt1[0]+(1 - i/100)*pt2[0],\n",
    "            i/100*pt1[1]+(1 - i/100)*pt2[1]]\n",
    "            for i in range(101)]\n",
    "plot(segment([3.5,0],[0.5,1]),4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class Vec:\n",
    "    def __init__(self,labels,function):\n",
    "        self.D = labels\n",
    "        self.f = function\n",
    "v = Vec({'A','B','C'},{'A':1})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "for d in v.D:\n",
    "    if d in v.f:\n",
    "        print(v.f[d])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def zero_vec(D): return Vec(D , {})\n",
    "\n",
    "def setitem(v , d , val) : v.f[d] = val\n",
    "\n",
    "setitem(v , 'B' , 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def getitem(v,d): return v.f[d] if d in v.f else 0\n",
    "getitem(v, 'A')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#def scalar_mul(v , alpha):\n",
    "#    return Vec(v.D , {d:alpha* getitem(v,d) for d in v.D})\n",
    "def scalar_mul(v,alpha):\n",
    "    return Vec(v.D ,{d: alpha * value for d,value in v.f.items()})\n",
    "\n",
    "scalar_mul(v,2).f\n",
    "v.f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "u = Vec(v.D ,{'A':5 ,'C':10})\n",
    "def add(u,v):\n",
    "    return Vec(u.D ,{d:getitem(u,d) + getitem(v,d) for d in u.D})\n",
    "add(u,v).f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def neg(v): return scalar_mul(v,-1)\n",
    "\n",
    "neg(v).f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from GF2 import  one\n",
    "from GF2 import zero\n",
    "\n",
    "t1 ={(0,0):one ,(0,1):zero}\n",
    "\n",
    "t2 = {(0,0): one , (0,1):zero}\n",
    "\n",
    "type(t1[(0,0)]) # t2[(0,0)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "t = [1,2,3,4]\n",
    "t[1] =6\n",
    "t + [(1,2,3)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import itertools\n",
    "L = [1,2,3]\n",
    "L_comb = []\n",
    "for i in range(len(L)+1):\n",
    "    if i != 0:\n",
    "        L_comb=L_comb +list(itertools.combinations([1,2,3],i))\n",
    "\n",
    "\n",
    "L_comb[0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def create_s(m) : return {(x,y):zero for x in range(m) for  y in range(m)}\n",
    "\n",
    "s = create_s(2)\n",
    "s[(0,0)] = one\n",
    "s[(1,0)] = one\n",
    "s\n",
    "def create_subset(m):\n",
    "    dict_temp={(x,y):zero for x in range(m) for  y in range(m)}\n",
    "    List_possible = []\n",
    "    \n",
    "    for key in dict_temp.keys():\n",
    "        dict_temp_loop = {(x,y):zero for x in range(m) for  y in range(m)}\n",
    "        #print (key)\n",
    "        if key == (0,0):\n",
    "            dict_temp_loop[(0,0)] = one\n",
    "            dict_temp_loop[(0,1)] = one\n",
    "            dict_temp_loop[(1,0)] = one\n",
    "        elif key ==(m-1,m-1):\n",
    "            dict_temp_loop[(m-1,m-1)] = one\n",
    "            dict_temp_loop[(m-1,m-2)] = one\n",
    "            dict_temp_loop[(m-2,m-1)] = one\n",
    "        elif key == (0,m-1):\n",
    "            dict_temp_loop[(0,m-1)] = one\n",
    "            dict_temp_loop[(0,m-2)] = one\n",
    "            dict_temp_loop[(1,m-1)] = one\n",
    "        elif key == (m -1,0):\n",
    "            dict_temp_loop[(m-1,0)] = one\n",
    "            dict_temp_loop[(m-2,0)] = one\n",
    "            dict_temp_loop[(m-1,1)] = one\n",
    "        elif key[0] == 0:\n",
    "            dict_temp_loop[key] = one\n",
    "            dict_temp_loop[(key[0]+1,key[1])] = one\n",
    "            dict_temp_loop[(key[0],key[1]-1)] = one\n",
    "            dict_temp_loop[(key[0],key[1]+1)] = one\n",
    "        elif key[0] == m-1:\n",
    "            dict_temp_loop[key] = one\n",
    "            dict_temp_loop[(key[0]-1,key[1])] = one\n",
    "            dict_temp_loop[(key[0],key[1]-1)] = one\n",
    "            dict_temp_loop[(key[0],key[1]+1)] = one\n",
    "        elif key[1] == 0:\n",
    "            dict_temp_loop[key] = one\n",
    "            dict_temp_loop[(key[0]-1,key[1])] = one\n",
    "            dict_temp_loop[(key[0]+1,key[1])] = one\n",
    "            dict_temp_loop[(key[0],key[1]+1)] = one\n",
    "        elif key[1] == m-1:\n",
    "            dict_temp_loop[key] = one\n",
    "            dict_temp_loop[(key[0]-1,key[1])] = one\n",
    "            dict_temp_loop[(key[0]+1,key[1])] = one\n",
    "            dict_temp_loop[(key[0],key[1]-1)] = one          \n",
    "        \n",
    "        else:\n",
    "            dict_temp_loop[key] = one\n",
    "            dict_temp_loop[(key[0]-1,key[1])] = one\n",
    "            dict_temp_loop[(key[0]+1,key[1])] = one\n",
    "            dict_temp_loop[(key[0],key[1]-1)] = one\n",
    "            dict_temp_loop[(key[0],key[1]+1)] = one\n",
    "        List_possible = List_possible + [dict_temp_loop]\n",
    "       \n",
    "    return List_possible\n",
    "            \n",
    "            \n",
    "\n",
    "        \n",
    "create_subset(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "D = {(i,j) for i in range(2) for j in range(2)}\n",
    "\n",
    "f_1 = create_subset(2)\n",
    "f_1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "v_1 = Vec(D,f_1[0])\n",
    "v_2 = Vec(D,f_1[1])\n",
    "add(v_1,v_2).f\n",
    "\n",
    "import math\n",
    "math.sqrt(25)\n",
    "create_subset(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def check_light_out(s,L):\n",
    "    flag =0\n",
    "    length_s = int(math.sqrt(len(s)))\n",
    "    D = {(i,j) for i in range(length_s) for j in range(length_s)}\n",
    "    L_comb = []\n",
    "    for i in range(len(L)+1):\n",
    "        if i != 0:\n",
    "            L_comb=L_comb +list(itertools.combinations(range(len(L)),i))\n",
    "    list_class_vec = []\n",
    "    for class_list in L:\n",
    "        list_class_vec.append(Vec(D,class_list))\n",
    "    for list_index in L_comb:\n",
    "        temp_add_class = Vec(D,create_s(length_s))\n",
    "        for index_tuple in list_index:\n",
    "            temp_add_class=add(temp_add_class,list_class_vec[index_tuple])\n",
    "        if (temp_add_class.f == s):\n",
    "            flag =1\n",
    "            #print (list_class_vec[0].f)\n",
    "            #print (temp_add_class.f)\n",
    "            #print (s)\n",
    "            #print(list_index)\n",
    "            break\n",
    "    if flag == 0:\n",
    "        print(\"the solution does not exsist and they are \\n\")\n",
    "    else:\n",
    "        print(\"The solution exsist \") \n",
    "        for j in list_index:\n",
    "            print(list_class_vec[j].f)\n",
    "    \n",
    "     \n",
    "\n",
    "\n",
    "\n",
    "check_light_out(s,create_subset(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "length_s = int(math.sqrt(len(create_s(2))))\n",
    "length_s\n",
    "create_subset(2)\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def list_dot(u,v): return sum([u[i]* v[i] for i in range(len(u))])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "D = {'memory','radio','sensor','CPU'}\n",
    "\n",
    "rate = Vec(D,{'memory':0.06,'radio':0.1 ,'sensor': 0.004, 'CPU': 0.0025})\n",
    "duration = Vec(D,{'memeory':1.0 ,'radio':0.2, 'sensor':0.5 ,'CPU':1.0})\n",
    "\n",
    "#rate*duration\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def dot_product_list(needle,haystack):\n",
    "    s = len(needle)\n",
    "    return [(needle,haystack[i:i+s]) for i in range(len(haystack)- s+1)]\n",
    "\n",
    "needle = [1,2,3]\n",
    "haystack =[1,2,3,4,5,6]\n",
    "dot_product_list(needle,haystack)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def list2vec(L):\n",
    "    return Vec(set(range(len(L))), {k:x for k,x in enumerate(L)})\n",
    "\n",
    "s=list2vec([1,2,3,45,56])\n",
    "s.f\n",
    "def zero_vec(D): return Vec(D , {})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def triangular_solve_n(rowlist, b):\n",
    "    D = rowlist[0].D \n",
    "    n = len(D) \n",
    "    assert D == set(range(n)) \n",
    "    x = zero_vec(D) \n",
    "    for i in reversed(range(n)): \n",
    "        x[i] = (b[i] -  rowlist[i]*x)/rowlist[i][i] \n",
    "    return x\n",
    "\n",
    "#rowlist = [list2vec([0,0,0,2]),list2vec([0,0,1,5]),list2vec([0,3,3,2]),list2vec([1,0.5,-2,4])]\n",
    "rowlist = [list2vec([1,0.5,-2,4]),list2vec([0,3,3,2]),list2vec([0,0,1,5]),list2vec([0,0,0,2])]\n",
    "b = [-8,3,-4,6]\n",
    "\n",
    "\n",
    "print(triangular_solve_n(rowlist,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from vec import Vec\n",
    "v = Vec({'A','B','C'},{})\n",
    "v['A'] = 1.0\n",
    "v['D']\n",
    "v.D\n",
    "print(Vec({'a', 'b', 'c'}, {'a':0}) == Vec({'a', 'b', 'c'}, {'b':0}))\n",
    "print (Vec({'a', 'b', 'c'}, {'a': 0}) == Vec({'a', 'b', 'c'}, {}))\n",
    "print (Vec({'a', 'b', 'c'}, {}) == Vec({'a', 'b', 'c'}, {'a': 0}))\n",
    "print (Vec({'x','y','z'},{'y':1,'x':2}) == Vec({'x','y','z'},{'y':1,'z':0}))\n",
    "print ( Vec({'a','b','c'}, {'a':0,'c':1}) == Vec({'a','b','c'}, {'a':0,'c':1,'b':4}))\n",
    "print (Vec({'a','b','c'}, {'a':0,'c':1,'b':4}) == Vec({'a','b','c'}, {'a':0,'c':1}))\n",
    "print (Vec({'a','b'},{'a':1}) == Vec({'a','b'},{'b':1}))\n",
    "Vec({'x','y','z'},{'y':1,'x':2}) == Vec({'x','y','z'},{'y':1,'z':0})\n",
    "Vec({'a','b','c'}, {'a':0,'c':1}) == Vec({'a','b','c'}, {'a':0,'c':1,'b':4})\n",
    "Vec({'a','b','c'}, {'a':0,'c':1,'b':4}) == Vec({'a','b','c'}, {'a':0,'c':1})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = Vec({'a','e','i','o','u'}, {'a':0,'e':1,'i':2})\n",
    "b = Vec({'a','e','i','o','u'}, {'o':4,'u':7})\n",
    "a + b\n",
    "\n",
    "d = Vec({'x','y','z'}, {'x':2,'y':1})\n",
    "e = Vec({'x','y','z'}, {'z':4,'y':-1})\n",
    "d + e\n",
    "d == Vec({'x','y','z'}, {'x':2,'y':1})\n",
    "e == Vec({'x','y','z'}, {'z':4,'y':-1})\n",
    "d + e \n",
    "u1 = Vec({'a','b'}, {'a':1, 'b':2})\n",
    "u2 = Vec({'a','b'}, {'b':2, 'a':1})\n",
    "u1*u2\n",
    "v1 = Vec({'p','q','r','s'}, {'p':2,'s':3,'q':-1,'r':0})\n",
    "v2 = Vec({'p','q','r','s'}, {'p':-2,'r':5})\n",
    "v1*v2\n",
    "w1 = Vec({'a','b','c'}, {'a':2,'b':3,'c':4})\n",
    "w2 = Vec({'a','b','c'}, {'a':12,'b':8,'c':6})\n",
    "w1 * w2\n",
    "print(a)\n",
    "zero = Vec({'x','y','z','w'}, {})\n",
    "u = Vec({'x','y','z','w'},{'x':1,'y':2,'z':3,'w':4})\n",
    "0*u == zero\n",
    "1*u == u\n",
    "0.5*u == Vec({'x','y','z','w'},{'x':0.5,'y':1,'z':1.5,'w':2})\n",
    "u == Vec({'x','y','z','w'},{'x':1,'y':2,'z':3,'w':4})\n",
    "print(0.5*u)\n",
    "u = Vec({1,3,5,7},{1:1,3:2,5:3,7:4})\n",
    "print(-u)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def triangular_solve(rowlist, label_list, b):\n",
    "    D = rowlist[0].D\n",
    "    x = zero_vec(D)\n",
    "    for j in reversed(range(len(D))):\n",
    "        c = label_list[j]\n",
    "        row = rowlist[j]\n",
    "        x[c] = (b[j]  - x*row)/row[c]\n",
    "    return x\n",
    "label_list = ['a','b','c','d']\n",
    "D = set(label_list)\n",
    "rowlist=[Vec(D,{'a':4, 'b':-2,'c':0.5,'d':1}), Vec(D,{'b':2,'c':3,'d':3}), Vec(D,{'c':5, 'd':1}), Vec(D,{'d':2})]\n",
    "b = [6, -4, 3, -8]\n",
    "\n",
    "\n",
    "print (triangular_solve(rowlist, label_list, b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "f = open('voting_record_dump109.txt')\n",
    "mylist = list(f)\n",
    "#''.join(mylist[0].split()[3:])\n",
    "\n",
    "mylist[0]\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def create_voting_dict(strlist):\n",
    "    f = open('voting_record_dump109.txt')\n",
    "    list_senator = list(f)\n",
    "    dict_voting_record_opp = {}\n",
    "    for senator in list_senator:\n",
    "        #dict_voting_record[senator.split()[0]] = ''.join(senator.split()[3:])\n",
    "        dict_voting_record_opp[''.join(senator.split()[3:])] = senator.split()[0]\n",
    "    dict_voting_record = {}\n",
    "    for senator in list_senator:\n",
    "        dict_voting_record[senator.split()[0]] = [int(x) for x in senator.split()[3:]]\n",
    "        \n",
    "    dict_return_match = {}\n",
    "    for str_list_val in str_list:\n",
    "        if str_list_val in dict_voting_record_opp:\n",
    "            dict_return_match[dict_voting_record_opp[str_list_val]] = dict_voting_record[dict_voting_record_opp[str_list_val]]\n",
    "  \n",
    "        \n",
    "    return dict_return_match\n",
    "\n",
    "\n",
    "str_list = ['111111111-1-11-1011110111111111111111110111111111','111111111-11111-111111111-1-111111111111111111111-1']\n",
    "print(create_voting_dict(str_list))\n",
    "\n",
    "\n",
    "#print (int(test[0]))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import operator\n",
    "def create_voting_dict_1():\n",
    "    f = open('voting_record_dump109.txt')\n",
    "    list_senator = list(f)\n",
    "    dict_voting_record = {}\n",
    "    for senator in list_senator:\n",
    "        dict_voting_record[senator.split()[0]] = [int(x) for x in senator.split()[3:]]\n",
    "    return dict_voting_record\n",
    "\n",
    "def policy_compare(sen_a,sen_b,dict_voting_record):\n",
    "    #dict_voting_record = create_voting_dict_1()\n",
    "    similarity = sum([a*b for a,b in zip(dict_voting_record[sen_a],dict_voting_record[sen_b])])\n",
    "    return similarity\n",
    "\n",
    "print(policy_compare('Akaka','Obama',create_voting_dict_1()))\n",
    "\n",
    "def most_similar(sen,dict_voting_record):\n",
    "    dict_similarity_tuple = {}\n",
    "    for sen_key in dict_voting_record:\n",
    "        if sen_key != sen:\n",
    "            dict_similarity_tuple[(sen_key,sen)] = sum([a*b for a,b in zip(dict_voting_record[sen_key],dict_voting_record[sen])])\n",
    "    return max(dict_similarity_tuple.items(), key=operator.itemgetter(0))[0]\n",
    "\n",
    "def least_similar(sen,dict_voting_record):\n",
    "    dict_similarity_tuple = {}\n",
    "    for sen_key in dict_voting_record:\n",
    "        if sen_key != sen:\n",
    "            dict_similarity_tuple[(sen_key,sen)] = sum([a*b for a,b in zip(dict_voting_record[sen_key],dict_voting_record[sen])])\n",
    "    return min(dict_similarity_tuple.items(), key=operator.itemgetter(0))[0]\n",
    "\n",
    "\n",
    "            \n",
    "            \n",
    "print(most_similar('Chafee',create_voting_dict_1()))\n",
    "print(least_similar('Santorum',create_voting_dict_1()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import operator\n",
    "stats = {'a':1000, 'b':3000, 'c': 100, 'd':3000}\n",
    "max(stats.items(), key=operator.itemgetter(0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from plotting import plot\n",
    "\n",
    "# Task 2.14.8\n",
    "def segment(pt1,pt2):\n",
    "    return [ [i/100*pt1[0]+(1 - i/100)*pt2[0],\n",
    "            i/100*pt1[1]+(1 - i/100)*pt2[1]]\n",
    "            for i in range(101)]\n",
    "plot(segment([3.5,0],[-1.5,2]),4)\n",
    "plot(segment([2,1],[-2,2]),4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import doctest\n",
    "import sys\n",
    "from vec import Vec\n",
    "#sys.path.append('/Users/sushmitroy/Linear_algebra_coding')\n",
    "#path = r\"/Users/sushmitroy/Linear_algebra_coding/vec.py\"\n",
    "#doctest.testfile(path)\n",
    "v = Vec({'a','b','c', 'd'},{'a':2,'c':1,'d':3})\n",
    "v = Vec({'a', 'b', 'c'}, {'b':0})\n",
    "v['b'] = 5\n",
    "v['b']\n",
    "\n",
    "\n",
    "a = Vec({'a','e','i','o','u'}, {'a':0,'e':1,'i':2})\n",
    "b = Vec({'a','e','i','o','u'}, {'o':4,'u':7})\n",
    "c = Vec({'a','e','i','o','u'}, {'a':0,'e':1,'i':2,'o':4,'u':7})\n",
    "\n",
    "a + b ==c\n",
    "Vec({'x','y','z'},{'y':1,'x':2}) == Vec({'x','y','z'},{'y':1,'z':0})"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}