def QR_solve(A):
col_labels = sorted(A.D[1], key=repr)
Acolms = dict2list(mat2coldict(A), col_labels)
(Qlist, Rlist) = aug_orthogonalize(Acolms)
Q = coldict2mat(list2dict(Qlist, col_labels))
R = coldict2mat(list2dict(Rlist, col_labels))
return Q, R
def QR_solve(A, b):
'''
Input:
- A: a Mat
- b: a Vec
Output:
- vector x that minimizes norm(b - A*x)
Example:
>>> domain = ({'a','b','c'},{'A','B'})
>>> A = Mat(domain,{('a','A'):-1, ('a','B'):2,('b','A'):5, ('b','B'):3,('c','A'):1,('c','B'):-2})
>>> Q, R = QR.factor(A)
>>> b = Vec(domain[0], {'a': 1, 'b': -1})
>>> x = QR_solve(A, b)
>>> result = A.transpose()*(b-A*x)
>>> result * result < 1E-10
True
'''
from triangular import triangular_solve
from QR import factor
from dictutil import dict2list
from vecutil import vec2list
Q,R = factor(A)
b = Q.transpose()*b
rowdict = mat2rowdict(R)
rowlist = dict2list(rowdict, list(rowdict.keys()))
x = triangular_solve(rowlist, list(rowlist[0].D), vec2list(b))
return x
def QR_factor(A):
col_labels = sorted(A.D[1], key=repr)
Acols = dict2list(mat2coldict(A),col_labels)
Qlist, Rlist = aug_orthonormalize(Acols)
#Now make Mats
Q = coldict2mat(Qlist)
R = coldict2mat(list2dict(Rlist, col_labels))
return Q,R
def QR_factor(A):
col_labels = sorted(A.D[1], key=repr)
Acols = dict2list(mat2coldict(A), col_labels)
Qlist, Rlist = aug_orthonormalize(Acols)
#Now make Mats
Q = coldict2mat(Qlist)
R = coldict2mat(list2dict(Rlist, col_labels))
return Q, R
def factor(A):
""" Implementation of the Gram-Schmidt procedure.
"""
col_labels = sorted(A.D[1], key=hash)
Acols = dict2list(matrix2coldict(A), col_labels)
Qlist, Rlist = aug_orthonormalize(Acols)
# Now make Matrices
Q = coldict2mat(Qlist)
R = coldict2mat(list2dict(Rlist, col_labels))
return Q, R
def is_invertible(M):
'''
input: A matrix, M
outpit: A boolean indicating if M is invertible.
>>> M = Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): 0, (1, 2): 1, (3, 2): 0, (0, 0): 1, (3, 3): 4, (3, 0): 0, (3, 1): 0, (1, 1): 2, (2, 1): 0, (0, 2): 1, (2, 0): 0, (1, 3): 0, (2, 3): 1, (2, 2): 3, (1, 0): 0, (0, 3): 0})
>>> is_invertible(M)
True
'''
if len(M.D[0]) != len(M.D[1]):
return False
if not my_is_independent(dict2list(mat2coldict(M), list(M.D[1]))):
return False
return True
def aug_orthonormalize(L):
'''
Input:
- L: a list of Vecs
Output:
- A pair Qlist, Rlist such that:
* coldict2mat(L) == coldict2mat(Qlist) * coldict2mat(Rlist)
* Qlist = orthonormalize(L)
>>> from vec import Vec
>>> D={'a','b','c','d'}
>>> L = [Vec(D, {'a':4,'b':3,'c':1,'d':2}), Vec(D, {'a':8,'b':9,'c':-5,'d':-5}), Vec(D, {'a':10,'b':1,'c':-1,'d':5})]
>>> Qlist, Rlist = aug_orthonormalize(L)
>>> from matutil import coldict2mat
>>> print(coldict2mat(Qlist))
<BLANKLINE>
0 1 2
---------------------
b | 0.548 0.403 -0.653
a | 0.73 0.187 0.528
c | 0.183 -0.566 -0.512
d | 0.365 -0.695 0.181
<BLANKLINE>
>>> print(coldict2mat(Rlist))
<BLANKLINE>
0 1 2
------------------
0 | 5.48 8.03 9.49
1 | 0 11.4 -0.636
2 | 0 0 6.04
<BLANKLINE>
>>> print(coldict2mat(Qlist)*coldict2mat(Rlist))
<BLANKLINE>
0 1 2
---------
b | 3 9 1
a | 4 8 10
c | 1 -5 -1
d | 2 -5 5
'''
pass
Qlist = orthonormalize(L)
Qlist_unormalized , Rlist = aug_orthogonalize(L)
v = [(item*item)**(1/2) for item in Qlist_unormalized]
multipliers = mat2rowdict(coldict2mat(Rlist))
Rlist = mat2coldict(rowdict2mat(adjust(v, multipliers)))
Rlist = dict2list(Rlist, range(len(Qlist)))
return Qlist, Rlist
def orSearch(inverseIndex, query):
'''
Find documents that contain any words in the query list.
Parameters
inverseIndex: dictionary with words as keys
and indexes of strings in strlist where the word
appears as values (values are in a set)
query: list of words
Returns
S: set of document indexes containing any of the words
'''
S = set()
docs = dict2list(inverseIndex, query)
for e in docs:
S.update(e)
return S
def find_triangular_matrix_inverse(A):
'''
input: An upper triangular Mat, A, with nonzero diagonal elements
output: Inverse of A
>>> A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]])
>>> find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0})
True
'''
D = A.D[0]
I = Mat((D,D), {(d,d):1 for d in D})
col_I = mat2coldict(I)
rowdict_A = mat2rowdict(A)
rowlist_A = dict2list(rowdict_A, list(D))
B = dict()
for i in col_I.keys():
B[i] = triangular_solve(rowlist_A, list(D), col_I[i])
return coldict2mat(B)
def andSearch(inverseIndex, query):
'''
Find documents that contain all words in the query list.
Parameters
inverseIndex: dictionary with words as keys
and indexes of strings in strlist where the word
appears as values (values are in a set)
query: list of words
Returns
S: set of document indexes containing all of the words
'''
docs = dict2list(inverseIndex, query)
for i, e in enumerate(docs):
if i == 0:
S = set(e)
else:
S.intersection_update(e)
return S
def fog(d1, d2):
import dictutil
d1k = list(d1.keys())
d1v = dictutil.dict2list(d1, d1.keys())
d2v = dictutil.dict2list(d2, d1v)
return dictutil.list2dict(d2v, d1k)
def fog(d1,d2):
import dictutil
d1k=list(d1.keys())
d1v=dictutil.dict2list(d1,d1.keys())
d2v=dictutil.dict2list(d2,d1v)
return dictutil.list2dict(d2v,d1k)
all_3_digit_numbers(3, {0,1,2})
#0.6
#Task 0.6.1
import math
help(math)
math.sqrt(3)
#Task 0.6.2
from random import randint
randint(1,10)
def movie_review(name): return ["See it","A gem!","Ideologcial claptrap!"][randint(0,2)]
movie_review('hello')
#Task 0.6.3
import dictutil
dictutil.dict2list({'a':'A','b':'B','c':'C'},['b','c','a'])
dictutil.list2dict(['A','B','C'], ['a','b','c'])
from importlib import reload
reload(dictutil)
#Task 0.6.4
dictutil.listrange2dict(['A','B','C'])
for x in {1,2,3}:
print(x)
v = [1,2,0]
i = 0
while v[i] == 0:
print(v[i])
i = i + 1
def baseSearch(merge_policy, invIndex, query):
return reduce(merge_policy, dictutil.dict2list(invIndex, query))
