def main():
A = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12],
[13, 14, 15, 16]])
Ainv = inverse(A)
print('.............................................')
print('........Testing with a small matrix..........')
print('.............................................')
print(A)
print('........A inverse is.............')
print(Ainv)
print('.......condition number of A with 2-norm is........')
print(cond(A, 2))
print('.......condition number of A with 1-norm is.........')
print(cond(A, 1))
print('.............................................')
print('........Testing with a large matrix..........')
print('.............................................')
A = np.random.randn(50, 50)
Ainv = inverse(A)
print(A)
print('........A inverse is.............')
print(Ainv)
print('.......condition number of A with 2-norm is........')
print(cond(A, 2))
print('.......condition number of A with 1-norm is.........')
print(cond(A, 1))
def rest(self):
try:
p = int(self.plainTextEdit.toPlainText())
q = int(self.plainTextEdit_2.toPlainText())
except ValueError:
self.plainTextEdit_3.setPlainText(
"Ongeldige invoer!\n"
"Controleer of alle velden zijn ingevuld en of ze het goede"
" type (geheel getal) hebben."
)
self.lineEdit.setText("")
self.plainTextEdit_4.setPlainText("")
else:
global g_n
g_n = p * q
phi = (p - 1) * (q - 1)
self.plainTextEdit_3.setPlainText(str(g_n))
for e in sorted([3, 5, 17, 257, 65537], reverse=True):
if GGD(phi, e) == 1:
break
d = inverse(e, phi) % phi
global g_d
global g_e
g_d, g_e = d, e
self.lineEdit.setText(str(e))
self.plainTextEdit_4.setPlainText(str(d))
def dispatch(s):
resolve = s.split()
operation = resolve[1]
try:
resolve[0] = int(resolve[0])
resolve[2] = int(resolve[2])
except:
pass
if operation == "+":
return add.add(resolve[0], resolve[2])
elif operation == "-":
return minus.minus(resolve[0], resolve[2])
elif operation == "*":
return multiply.multiply(resolve[0], resolve[2])
elif operation == "/":
return divide.divide(resolve[0], resolve[2])
elif operation == "!":
return factorial.factorial(resolve[0])
elif operation == "to_hex":
return dec_to_hex.dec_to_hex(resolve[0])
elif operation == "to_bin":
pass
elif operation == "inv":
return inverse.inverse(resolve[0])
elif operation == "**":
return power.power(resolve[0], resolve[2])
def calc(self):
a = str(self.lineEdit.text())
b = str(self.lineEdit_2.text())
m = str(self.lineEdit_4.text())
if not (a.isdigit() and b.isdigit() and m.isdigit()):
self.lineEdit_3.setText("Ongeldige invoer! Alleen gehele getallen " "zijn toegestaan.")
return
a, b, m = map(int, (a, b, m))
res = ""
if self.op == "+":
res = (a + b) % m
elif self.op == "-":
res = (a - b) % m
elif self.op == "*":
res = (a * b) % m
elif self.op == "^":
res = pow(a, b, m)
elif self.op == "/":
if is_prime(m):
res = (a * inverse(b, m)) % m
else:
res = "De modulus moet een priemgetal zijn bij delen."
else:
res = "Error, ongeldige operator geselecteerd!"
self.lineEdit_3.setText(str(res))
def test_inverse_simple(self):
T = np.array([[2, 1, 1, 0], [4, 3, 3, 1], [8, 7, 9, 5], [6, 7, 9, 8]])
actual = inverse(T)
expected = LA.inv(T)
self.assertTrue(np.allclose(actual, expected))
def CRT(y, d, p, q):
n = p * q
# 1- Convert to CRT domain
yp = y % p
yq = y % q
# print("(yp, yq) = ", str((yp, yq)))
# 2- Do the computations
dp = d % (p - 1)
dq = d % (q - 1)
# print("(dp, dq) = ", str((dp, dq)))
xp = pow(yp, dp, p)
xq = pow(yq, dq, q)
# print("(xp, xq) = ", str((xp, xq)))
# 3- Inverse transform
inv = inverse(p, q)
print(inv)
cp = pow(q, p - 2, p)
cq = pow(p, q - 2, q)
# print(cq == pow(p, q-2, q))
# print("(cp, cq) = ", str((p, q)))
x = ((q * cp * xp) + (p * cq * xq)) % n
# print("x = ", x, "mod " + str(n))
return x
def test_inverse_random(self):
T = np.random.randn(100, 100)
actual = inverse(T)
expected = LA.inv(T)
self.assertTrue(np.allclose(actual, expected))
def test_multiple_strings():
assert inverse({
'key1': 'value1',
'key2': 'value2',
'key3': 'value1'
}) == {
'value1': ['key1', 'key3'],
'value2': ['key2']
}
def test_all_duplicates():
assert inverse({
1: 'A',
2: 'A',
3: 'A',
4: 'A',
}) == {
'A': [1, 2, 3, 4]
}
def cond(A, p_norm):
"""
Outputs the condition number of the square matrix
cond = ||A||*||inv(A)||
"""
# get the inverse of A matrix
Ainv = inverse(A)
return norm(A, p_norm) * norm(Ainv, p_norm)
def test_inverse(d):
'''
The result should be the actual inverse.
'''
d_inverse = inverse(d)
for k in d:
assert k in d_inverse[d[k]]
for v in d_inverse:
for k in d_inverse[v]:
assert d[k] == v
def inverse_test(self, a, ai_true):
a = torch.Tensor(a)
a = torch.autograd.Variable(a)
ai_test = inverse.inverse(a)
ai_true = torch.Tensor(ai_true)
ai_true = torch.autograd.Variable(ai_true)
self.assertFalse((ai_test != ai_true).data.sum())
def setup(nbits=512):
p = get_rand_prime(nbits)
q = get_rand_prime(nbits)
while p == q:
q = get_rand_prime(nbits)
n = p * q
phi = (p-1) * (q-1)
e = randrange(2**16, 2**17)
d = inverse(phi, e)
while d == -1:
e = randrange(2**16, 2**17)
d = inverse(phi, e)
return {
"p": p,
"q": q,
"n": n,
"phi": phi,
"e": e,
"d": d
}
def test_no_duplicates():
assert inverse({
1: 'A',
2: 'B',
3: 'C',
4: 'D',
}) == {
'A': [1],
'B': [2],
'C': [3],
'D': [4]
}
def delta(g):
"""Compute delta from G0"""
if type(g) == BlockGf:
return BlockGf(name_block_generator = [ (n, delta(g0)) for n,g0 in g], make_copies=False)
elif type(g) == GfImFreq:
g0_iw_inv = inverse(g)
delta_iw = g0_iw_inv.copy()
delta_iw << A_Omega_Plus_B(g0_iw_inv.tail[-1], g0_iw_inv.tail[0])
delta_iw -= g0_iw_inv
return delta_iw
else:
raise TypeError, "No function delta for g0 object of type %s"%type(g)
def make_keys(bits=1024):
p, q = gen_pq(bits)
n = p * q
phi = (p - 1) * (q - 1)
print phi
for e in [3, 5, 17, 257, 65537]:
if GGD(phi, e) == 1:
break
print e
x = inverse(e, phi)
d = x % phi
print 'd =', d
return (n, e), (n, d)
def initializePage(self):
global d
global e
global n
n = g_p * g_q
for e in [3, 5, 17, 257, 65537]:
if GGD(g_phi, e) == 1:
break
d = inverse(e, g_phi) % g_phi
self.plainTextEdit.setPlainText(str(e))
self.plainTextEdit_2.setPlainText(str(d))
global g_pub
global g_pvt
g_pub = (n, e)
g_pvt = (n, d)
def test_example():
assert inverse({1: 'A', 2: 'B', 3: 'A'}) == {'A': [1, 3], 'B': [2]}
def test_empty():
assert inverse({}) == {}
def test_specifications():
assert inverse({1: 'A', 2: 'B', 3: 'A'}) == {'A': [1, 3], 'B': [2]}
def test_single_string():
assert inverse({'key': 'value'}) == {'value': ['key']}
boutouv.pack(pady=10)
bouton3 = Button(decoder,
text='Quitter',
command=decoder.destroy,
width=5,
height=1)
bouton3.config(fg='blue', bg='VioletRed2') #Bouton pour quitter l'interface
bouton3.config(font=('verdana', 12))
bouton3.place(x='450', y='500')
decoder.mainloop()
try:
inverse(
nom, filI, fil
) #L'essai de l'exécution de la fonction inverse() avec affichage des messages
encoder = Tk(
) #selon l'entier retourné par cette fonction (opération réussie ou attention)
encoder.geometry("0x0+560+430")
messagebox.showinfo('Decodage réussi', "L'image est decodée avec succès")
encoder.destroy()
encoder.mainloop()
except:
decoder = Tk()
decoder.geometry("0x0+560+430")
messagebox.showwarning("Warning", "Aucune image n'est decodée")
elif res[i][0] == 'be' and res[i+1][2] == 'VBG' :
print('主系表结构，过去将来进行时时' )
break
else:
print('主谓宾,过去将来时')
elif count_comma ==1:
# 先对非限制性定语和状语从句进行判断
attrib(res)
advclause_OneComma(res)
object(res)
special(res)
inverse(res)
paralel(res)
predicat(res)
compara(res)
nonFinite(res)
for i in range(len(t)):
if t[i].label() == ',':
if t[i-1].label() in ['PP','ADVP','S']:
print('-----------------修辞部分-----------------------------')
print(t[i-1].leaves())
print('-----------------从句部分-----------------------------')
for j in range(i+1,len(t)):
for k in t[j].treepositions()[1:]:
if type(t[j]) == nltk.tree.Tree and t[j].label() == 'VP':
# print(t[j,0].label())
def __find_d__(e, phi): from inverse import inverse return inverse(e, phi)
def test_empty_items():
assert inverse({1: ' ', 2: 'B', 3: 'A'}) == {' ': [1], 'B': [2], 'A': [3]}
assert inverse({1: '', 2: 'B', 3: 'A'}) == {'': [1], 'B': [2], 'A': [3]}
from music21 import *
import math
import inverse
import sys
filename = sys.argv[1]
axis = sys.argv[2]
print "Parsing file..."
#s = corpus.parse(filename)
s = converter.parse(filename)
print "File parsed"
newS = inverse.inverse(s,axis)
print "Sending to MuseScore..."
newS.show('midi')
def texture(file):
db1.w2d(file)
haar.w2d(file)
inverse.inverse(file)
