increment 1

Author: AlexDvorak

analysis/Compression_Analysis/PSNR.py

@@ -0,0 +1,38 @@
+import numpy as np
+import math
+import cv2
+
+def Representational(r,g,b):
+	return (0.299*r+0.287*g+0.114*b)
+
+def calculate(img):
+	b,g,r = cv2.split(img)
+	pixelAt = Representational(r,g,b)
+	return pixelAt
+
+def main():
+	
+	#Loading images (orignal image and compressed image)
+	orignal_image = cv2.imread('orignal_image.png',1)
+	compressed_image = cv2.imread('compressed_image.png',1)
+
+	#Getting image height and width
+	height,width = orignal_image.shape[:2]
+
+	orignalPixelAt = calculate(orignal_image)
+	compressedPixelAt = calculate(compressed_image)
+
+	diff = orignalPixelAt - compressedPixelAt
+	error = np.sum(np.abs(diff) ** 2)
+
+	error = error/(height*width)
+
+	#MSR = error_sum/(height*width)
+	PSNR = -(10*math.log10(error/(255*255)))
+
+	print("PSNR value is {}".format(PSNR))
+
+
+if __name__ == '__main__':
+	main()
+

analysis/Compression_Analysis/compressed_image.png

@@ -0,0 +1,33 @@
+import math
+
+
+def bisection(function, a, b):  # finds where the function becomes 0 in [a,b] using bolzano
+
+    start = a
+    end = b
+    if function(a) == 0:  # one of the a or b is a root for the function
+        return a
+    elif function(b) == 0:
+        return b
+    elif function(a) * function(b) > 0:  # if none of these are root and they are both positive or negative,
+        # then his algorithm can't find the root
+        print("couldn't find root in [a,b]")
+        return
+    else:
+        mid = (start + end) / 2
+        while abs(start - mid) > 0.0000001:  # until we achieve precise equals to 10^-7
+            if function(mid) == 0:
+                return mid
+            elif function(mid) * function(start) < 0:
+                end = mid
+            else:
+                start = mid
+            mid = (start + end) / 2
+        return mid
+
+
+def f(x):
+    return math.pow(x, 3) - 2*x - 5
+
+
+print(bisection(f, 1, 1000))

analysis/Compression_Analysis/example_image.jpg

@@ -0,0 +1,16 @@
+import math
+
+def intersection(function,x0,x1): #function is the f we want to find its root and x0 and x1 are two random starting points
+    x_n = x0
+    x_n1 = x1
+    while True:
+        x_n2 = x_n1-(function(x_n1)/((function(x_n1)-function(x_n))/(x_n1-x_n)))
+        if abs(x_n2 - x_n1)<0.00001 :
+            return x_n2
+        x_n=x_n1
+        x_n1=x_n2
+
+def f(x):
+    return math.pow(x,3)-2*x-5
+
+print(intersection(f,3,3.5))

analysis/Compression_Analysis/orignal_image.png

@@ -0,0 +1,34 @@
+import numpy
+
+def LUDecompose (table):
+    #table that contains our data
+    #table has to be a square array so we need to check first
+    rows,columns=numpy.shape(table)
+    L=numpy.zeros((rows,columns))
+    U=numpy.zeros((rows,columns))
+    if rows!=columns:
+        return
+    for i in range (columns):
+        for j in range(i-1):
+            sum=0
+            for k in range (j-1):
+                sum+=L[i][k]*U[k][j]
+            L[i][j]=(table[i][j]-sum)/U[j][j]
+        L[i][i]=1
+        for j in range(i-1,columns):
+            sum1=0
+            for k in range(i-1):
+                sum1+=L[i][k]*U[k][j]
+            U[i][j]=table[i][j]-sum1
+    return L,U
+
+
+
+
+
+
+
+matrix =numpy.array([[2,-2,1],[0,1,2],[5,3,1]])
+L,U = LUDecompose(matrix)
+print(L)
+print(U)

arithmetic_analysis/bisection.py

@@ -0,0 +1,15 @@
+def newton(function,function1,startingInt): #function is the f(x) and function1 is the f'(x)
+  x_n=startingInt
+  while True:
+      x_n1=x_n-function(x_n)/function1(x_n)
+      if abs(x_n-x_n1)<0.00001:
+          return x_n1
+      x_n=x_n1
+      
+def f(x):
+    return (x**3)-2*x-5
+
+def f1(x):
+    return 3*(x**2)-2
+
+print(newton(f,f1,3))

arithmetic_analysis/intersection.py

@@ -0,0 +1,36 @@
+# Implementing Newton Raphson method in Python
+# Author: Haseeb
+
+from sympy import diff
+from decimal import Decimal
+
+def NewtonRaphson(func, a):
+    ''' Finds root from the point 'a' onwards by Newton-Raphson method '''
+    while True:
+        c = Decimal(a) - ( Decimal(eval(func)) / Decimal(eval(str(diff(func)))) )
+        
+        a = c
+
+        # This number dictates the accuracy of the answer
+        if  abs(eval(func)) < 10**-15:
+            return  c
+    
+
+# Let's Execute
+if __name__ == '__main__':
+    # Find root of trigonometric function
+    # Find value of pi
+    print ('sin(x) = 0', NewtonRaphson('sin(x)', 2))
+    
+    # Find root of polynomial
+    print ('x**2 - 5*x +2 = 0', NewtonRaphson('x**2 - 5*x +2', 0.4))
+    
+    # Find Square Root of 5
+    print ('x**2 - 5 = 0', NewtonRaphson('x**2 - 5', 0.1))
+
+    # Exponential Roots
+    print ('exp(x) - 1 = 0', NewtonRaphson('exp(x) - 1', 0))
+    
+    
+    
+

arithmetic_analysis/lu_decomposition.py

@@ -0,0 +1,116 @@
+def compare_string(string1, string2):
+	l1 = list(string1); l2 = list(string2)
+	count = 0
+	for i in range(len(l1)):
+		if l1[i] != l2[i]:
+			count += 1
+			l1[i] = '_'
+	if count > 1:
+		return -1
+	else:
+		return("".join(l1))
+
+def check(binary):
+	pi = []
+	while 1:
+		check1 = ['$']*len(binary)
+		temp = []
+		for i in range(len(binary)):
+			for j in range(i+1, len(binary)):
+				k=compare_string(binary[i], binary[j])
+				if k != -1:
+					check1[i] = '*'
+					check1[j] = '*'
+					temp.append(k)
+		for  i in range(len(binary)):
+			if check1[i] == '$':
+				pi.append(binary[i])
+		if len(temp) == 0:
+			return pi
+		binary = list(set(temp))
+
+def decimal_to_binary(no_of_variable, minterms):
+	temp = []
+	s = ''
+	for m in minterms:
+		for i in range(no_of_variable):
+			s = str(m%2) + s
+			m //= 2
+		temp.append(s)
+		s = ''
+	return temp
+
+def is_for_table(string1, string2, count):
+	l1 = list(string1);l2=list(string2)
+	count_n = 0
+	for i in range(len(l1)):
+		if l1[i] != l2[i]:
+			count_n += 1
+	if count_n == count:
+		return True
+	else:
+		return False 
+
+def selection(chart, prime_implicants):
+	temp = []
+	select = [0]*len(chart)
+	for i in range(len(chart[0])):
+		count = 0
+		rem = -1
+		for j in range(len(chart)):
+			if chart[j][i] == 1:
+				count += 1
+				rem = j
+		if count == 1:
+			select[rem] = 1
+	for i in range(len(select)):
+		if select[i] == 1:
+			for j in range(len(chart[0])):
+				if chart[i][j] == 1:
+					for k in range(len(chart)):
+						chart[k][j] = 0 
+			temp.append(prime_implicants[i])
+	while 1:
+		max_n = 0; rem = -1; count_n = 0
+		for i in range(len(chart)):
+			count_n = chart[i].count(1)
+			if count_n > max_n:
+				max_n = count_n
+				rem = i
+		
+		if max_n == 0:
+			return temp
+		
+		temp.append(prime_implicants[rem])
+		
+		for i in range(len(chart[0])):
+			if chart[rem][i] == 1:
+				for j in range(len(chart)):
+					chart[j][i] = 0
+		
+def prime_implicant_chart(prime_implicants, binary):
+	chart = [[0 for x in range(len(binary))] for x in range(len(prime_implicants))]
+	for i in range(len(prime_implicants)):
+		count = prime_implicants[i].count('_')
+		for j in range(len(binary)):
+			if(is_for_table(prime_implicants[i], binary[j], count)):
+				chart[i][j] = 1
+	
+	return chart
+
+def main():
+	no_of_variable = int(raw_input("Enter the no. of variables\n"))
+	minterms = [int(x) for x in raw_input("Enter the decimal representation of Minterms 'Spaces Seprated'\n").split()]
+	binary = decimal_to_binary(no_of_variable, minterms)
+	
+	prime_implicants = check(binary)
+	print("Prime Implicants are:")
+	print(prime_implicants)
+	chart = prime_implicant_chart(prime_implicants, binary)
+	
+	essential_prime_implicants = selection(chart,prime_implicants)
+	print("Essential Prime Implicants are:")
+	print(essential_prime_implicants)
+
+if __name__ == '__main__':
+	main()

arithmetic_analysis/newton_method.py

@@ -0,0 +1,54 @@
+from __future__ import print_function
+def decrypt(message):
+    """
+    >>> decrypt('TMDETUX PMDVU')
+    Decryption using Key #0: TMDETUX PMDVU
+    Decryption using Key #1: SLCDSTW OLCUT
+    Decryption using Key #2: RKBCRSV NKBTS
+    Decryption using Key #3: QJABQRU MJASR
+    Decryption using Key #4: PIZAPQT LIZRQ
+    Decryption using Key #5: OHYZOPS KHYQP
+    Decryption using Key #6: NGXYNOR JGXPO
+    Decryption using Key #7: MFWXMNQ IFWON
+    Decryption using Key #8: LEVWLMP HEVNM
+    Decryption using Key #9: KDUVKLO GDUML
+    Decryption using Key #10: JCTUJKN FCTLK
+    Decryption using Key #11: IBSTIJM EBSKJ
+    Decryption using Key #12: HARSHIL DARJI
+    Decryption using Key #13: GZQRGHK CZQIH
+    Decryption using Key #14: FYPQFGJ BYPHG
+    Decryption using Key #15: EXOPEFI AXOGF
+    Decryption using Key #16: DWNODEH ZWNFE
+    Decryption using Key #17: CVMNCDG YVMED
+    Decryption using Key #18: BULMBCF XULDC
+    Decryption using Key #19: ATKLABE WTKCB
+    Decryption using Key #20: ZSJKZAD VSJBA
+    Decryption using Key #21: YRIJYZC URIAZ
+    Decryption using Key #22: XQHIXYB TQHZY
+    Decryption using Key #23: WPGHWXA SPGYX
+    Decryption using Key #24: VOFGVWZ ROFXW
+    Decryption using Key #25: UNEFUVY QNEWV
+    """
+    LETTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    for key in range(len(LETTERS)):
+        translated = ""
+        for symbol in message:
+            if symbol in LETTERS:
+                num = LETTERS.find(symbol)
+                num = num - key
+                if num < 0:
+                    num = num + len(LETTERS)
+                translated = translated + LETTERS[num]
+            else:
+                translated = translated + symbol
+        print("Decryption using Key #%s: %s" % (key, translated))
+
+def main():
+    message = raw_input("Encrypted message: ")
+    message = message.upper()
+    decrypt(message)
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()
+    main()

arithmetic_analysis/newton_raphson_method.py

@@ -0,0 +1,32 @@
+from __future__ import print_function
+
+import random
+
+
+class Onepad:
+    def encrypt(self, text):
+        '''Function to encrypt text using psedo-random numbers'''
+        plain = [ord(i) for i in text]
+        key = []
+        cipher = []
+        for i in plain:
+            k = random.randint(1, 300)
+            c = (i+k)*k
+            cipher.append(c)
+            key.append(k)
+        return cipher, key
+    
+    def decrypt(self, cipher, key):
+        '''Function to decrypt text using psedo-random numbers.'''
+        plain = []
+        for i in range(len(key)):
+            p = (cipher[i]-(key[i])**2)/key[i]
+            plain.append(chr(p))
+        plain = ''.join([i for i in plain])
+        return plain
+
+
+if __name__ == '__main__':
+    c, k = Onepad().encrypt('Hello')
+    print(c, k)
+    print(Onepad().decrypt(c, k))