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)