class Affine(Cipher): """ Affine cipher that uses a combination of Caesar and Multiplication cipher """ def __init__(self): self.__caesar__ = Caesar() self.__multi__ = Multiplication() def encode(self, clear_text, key): """ Encode message, first with multiplication then caesar. :param clear_text: clear text :param key: Tuple, (Multi_key, Caesar_key) :return: encoded message """ encoded_multi = self.__multi__.encode(clear_text, key[0]) encoded_caesar = self.__caesar__.encode(encoded_multi, key[1]) return encoded_caesar def decode(self, encoded_text, key): """ Decode message, first with caesar then multiplication :param encoded_text: encoded message :param key: Tuple, (Multi_key, Caesar_key) :return: decoded message """ decoded_caesar = self.__caesar__.decode(encoded_text, key[1]) decoded_multi = self.__multi__.decode(decoded_caesar, key[0]) return decoded_multi def generate_keys(self): """ Generates two keys for sender and receiver :return: keys with (Multiplication, Caesar) and inverse of that """ key_1_1, key_2_1 = self.__multi__.generate_keys() key_1_2, key_2_2 = self.__caesar__.generate_keys() return (key_1_1, key_1_2), (key_2_1, key_2_2) def possible_keys(self): return self.__multi__.possible_keys() * self.__caesar__.possible_keys()
def create_expression(self, lhs, op, rhs): if op == '+': return Addition(lhs, rhs) elif op == '-': return Subtraction(lhs, rhs) elif op == '*': return Multiplication(lhs, rhs) elif op == '/': return Division(lhs, rhs) else: return Compare(lhs, op, rhs)
from Addition import Addition from MatrixMultiplication import MatrixMultiplication from Activation import Activation import numpy as np import matplotlib.pyplot as plt # Example : z = ax + b g = Graph() dGraph = g.set_as_default() a = Variables(10, dGraph) b = Variables(1, dGraph) x = Placeholder(dGraph) y = Multiplication(a, x, dGraph) z = Addition(y, b, dGraph) sess = Session() result = sess.run(z, {x:12}) print("z = ax + b = 10*12 + 1 = ", result) # Matrix multiplication process g2 = Graph() dGraph2 = g2.set_as_default() a = Variables([[10,23], [23,1], [20,56]], dGraph2) b = Variables([1,2], dGraph2) x = Placeholder(dGraph2)
from Caesar import Caesar from Multiplication import Multiplication from Sender import Sender from Receiver import Receiver from Hacker import Hacker from Affine import Affine from Unbreakable import Unbreakable from RSA import RSA cipher_list = {"Caesar": Caesar(), "Multiplication": Multiplication(), "Affine": Affine(), "Unbreakable": Unbreakable()} def main(): verify_ciphers() # verify_hacker() def verify_hacker(): for name, cipher in cipher_list.items(): key_encrypt, key_decrypt = cipher.generate_keys() sender = Sender(cipher=cipher, key=key_encrypt) receiver = Receiver(cipher=cipher, key=key_decrypt) hacker = Hacker(cipher=cipher) clear_text = "Hello World" encrypted_message = sender.send_message(clear_text) decrypted_message = receiver.receive_message(encrypted_message)
class Computer: opCodeTable = { 1: lambda computer, programlocation: Addition(computer, programlocation, 3, True, True), 2: lambda computer, programlocation: Multiplication( computer, programlocation, 3, True, True), 3: lambda computer, programlocation: Input(computer, programlocation, 1, True, True), 4: lambda computer, programlocation: Output(computer, programlocation, 1, False, True), 5: lambda computer, programlocation: JumpIfTrue(computer, programlocation, 2, False, False), 6: lambda computer, programlocation: JumpIfFalse( computer, programlocation, 2, False, False), 7: lambda computer, programlocation: LessThan(computer, programlocation, 3, True, True), 8: lambda computer, programlocation: Equals(computer, programlocation, 3, True, True), 9: lambda computer, programlocation: AdjustRelativeBase( computer, programlocation, 1, False, True), 99: lambda computer, programlocation: Halt(computer, programlocation, 1, False, False) } def GetOriginalProgram(self): return self._originalProgramData def LoadProgram(self, programData): self._programData = programData.copy() self._originalProgramData = self._programData.copy() moreMemory = [0] * 1024 * 10 self._programData.extend(moreMemory) self._programIndex = 0 self._programLine = 0 return self def __init__(self): self._programData = None self._programIndex = None self._programLine = None self._relativeBase = 0 self._input = None self._output = None self._halted = None def GetRelativeBase(self): return self._relativeBase def AdjustRelativeBase(self, val): self._relativeBase = self._relativeBase + val def SetInput(self, val): self._input = val def GetOutput(self): val = self._output self._output = None return val def GetInput(self): assert (self._input != None) val = self._input.pop(0) if (len(self._input) == 0): self._input = None return val def SetOutput(self, val): assert (self._output == None) self._output = val return self def ReadLocation(self, location): return self._programData[location] def MoveByOffset(self, amount): self._programIndex = self._programIndex + amount def MoveAbsolute(self, location): self._programIndex = location def WriteLocation(self, location, value): self._programData[location] = value def PeekAtOpCodeValue(self): opCodeValue = self.ReadLocation(self._programIndex) valueAsString = str(opCodeValue) if (len(valueAsString) > 2): opCodeValue = int(valueAsString[-2:]) return opCodeValue def GetHalted(self): return self._halted is not None and self._halted == True def RunToNextIO(self): continueRun = True result = None inputNext = False while (continueRun and result is None and inputNext == False): oneResult, continueRun, inputNext = self.DoNext() if (oneResult is not None): result = oneResult if (self.PeekAtOpCodeValue() == 99): break return (result, continueRun, inputNext) def GetLine(self): continueRun = True inputNext = False output = [] oneResult = 0 while (continueRun and inputNext == False and oneResult != 10): oneResult, continueRun, inputNext = self.RunToNextIO() assert (inputNext == False) assert (continueRun == True) print(oneResult) output.append(oneResult) if (output[-1] == 10): output.pop() #chop trailing newline #Rewrite in ascii output = "".join(list(map(lambda x: chr(x), output))) return output def SendLine(self): continueRun = True oneResult = None characterAboutToSend = 0 while (continueRun and characterAboutToSend != 10): oneResult, continueRun, inputNext = self.RunToNextIO() assert (inputNext == True) assert (oneResult is None) characterAboutToSend = self._input[0] assert (self.PeekAtOpCodeValue() == 3) oneResult, continueRun, inputNext = self.DoNext() def DoNext(self): assert (self._halted is None or self._halted == False) self._halted = False opCodeValue = self.PeekAtOpCodeValue() opCodeConstructor = Computer.opCodeTable[opCodeValue] opCodeInstance = opCodeConstructor(self, self._programIndex) opCodeInstance.RunOpCode() returnValue = None if (opCodeValue == 4): returnValue = self.GetOutput() continueRun = True if (opCodeValue == 99): continueRun = False self._halted = True self._programLine = self._programLine + 1 inputNext = False opCodeValue = self.PeekAtOpCodeValue() if (opCodeValue == 3): inputNext = True return (returnValue, continueRun, inputNext)
#!/usr/bin/python "Calculadora basica" "Importar la clase Sum del archivo Sum.py" from Sum import Sum from Multiplication import Multiplication from Subtract import Subtract from Division import Division print("Ingrese un numero:") numeroUno = input() print("Ingrese otro numero:") numeroDos = input() sumar = Sum() print sumar.calculateSum(numeroUno, numeroDos) restar = Subtract() print restar.calculateSubtract(numeroUno, numeroDos) dividir = Division() print dividir.calculateDivision(numeroUno, numeroDos) multiplicar = Multiplication() print multiplicar.calculateMultiplication(numeroUno, numeroDos)
from Addition import Addition from Subtraction import Subtraction from Multiplication import Multiplication from Division import Division my_add = Addition() my_sub = Subtraction() my_mult = Multiplication() my_div = Division() def main(): while True: print("Welcome! Select operation:") print("1.Addition") print("2.Subtraction") print("3.Multiplication") print("4.Division") print("5.Exit") operation = int(input()) if operation == 1: x = input("Enter value for x:") y = input("Enter value for y:") sum_ = my_add.sum(x, y) print(sum_) elif operation == 2: x = input("Enter value for x:") y = input("Enter value for y:") sub = my_sub.subtraction(x, y)
import sys from Addition import Addition from Subtract import Subtract from Multiplication import Multiplication print("Menu") print("1. Addition") print("2. Subtraction") print("3. Multiplication") i = sys.argv[1] #input("Enter your option between 1-3 : ") if (i == "1"): op = Addition() elif (i == "2"): op = Subtract() elif (i == "3"): op = Multiplication() else: print("Wrong input given") sys.exit(0) a = int(sys.argv[2]) #int(input("value for A :")) b = int(sys.argv[3]) #int(input("value for B :")) print(op.operation(a, b))
class Computer: opCodeTable = { 1: lambda computer, programlocation: Addition(computer, programlocation, 3, True, True), 2: lambda computer, programlocation: Multiplication( computer, programlocation, 3, True, True), 3: lambda computer, programlocation: Input(computer, programlocation, 1, True, True), 4: lambda computer, programlocation: Output(computer, programlocation, 1, False, True), 5: lambda computer, programlocation: JumpIfTrue(computer, programlocation, 2, False, False), 6: lambda computer, programlocation: JumpIfFalse( computer, programlocation, 2, False, False), 7: lambda computer, programlocation: LessThan(computer, programlocation, 3, True, True), 8: lambda computer, programlocation: Equals(computer, programlocation, 3, True, True), 9: lambda computer, programlocation: AdjustRelativeBase( computer, programlocation, 1, False, True), 99: lambda computer, programlocation: Halt(computer, programlocation, 1, False, False) } def __init__(self, programData, unattended=False, unattendedInputs=None, inputOutputEvents=None, programStart=0): self._programData = programData.copy() moreMemory = [] for idx in range(0, 1024): moreMemory.append(0) self._programData.extend(moreMemory) self._programIndex = programStart self._programLine = 0 self._unattended = unattended self._unattendedInputs = unattendedInputs self._currentUnattendedInput = 0 self._outputs = [] self._state = -1 if (inputOutputEvents is not None): self._inputEvent = inputOutputEvents[0] self._outputEvent = inputOutputEvents[1] else: self._inputEvent = None self._outputEvent = None self._relativeBase = 0 def GetRelativeBase(self): return self._relativeBase def AdjustRelativeBase(self, val): self._relativeBase = self._relativeBase + val def AddInput(self, inputValue): assert (self._unattended == True) self._unattendedInputs.append(inputValue) if (self._inputEvent is not None): self._inputEvent.set() def GetState(self): return self._state def GetAllOutputs(self): return self._outputs def GetLastOutput(self): assert (self.GetState() == 0) return self._outputs[-1] def GetHighestOutput(self): if (self._outputEvent is not None): self._outputEvent.wait() self._outputEvent.clear() return self._outputs[-1] def SetOutput(self, value): self._outputs.append(value) def GetUnattendedInput(self): if (self._unattendedInputs is None): return None assert (self._unattended == True) if (self._unattended == True): if (self._currentUnattendedInput == len(self._unattendedInputs) and self._inputEvent != None): self._inputEvent.wait() self._inputEvent.clear() assert (self._currentUnattendedInput < len(self._unattendedInputs)) val = self._unattendedInputs[self._currentUnattendedInput] self._currentUnattendedInput = self._currentUnattendedInput + 1 return val else: return None def ReadLocation(self, location): return self._programData[location] def MoveByOffset(self, amount): self._programIndex = self._programIndex + amount def MoveAbsolute(self, location): self._programIndex = location def WriteLocation(self, location, value): self._programData[location] = value def Run(self): self._state = 1 go = True while (True == go): opCodeValue = self.ReadLocation(self._programIndex) valueAsString = str(opCodeValue) if (len(valueAsString) > 2): opCodeValue = int(valueAsString[-2:]) opCodeConstructor = self.opCodeTable[opCodeValue] opCodeInstance = opCodeConstructor(self, self._programIndex) if (isinstance(opCodeInstance, Halt)): go = False opCodeReturnValue = opCodeInstance.RunOpCode() if (isinstance(opCodeInstance, Output)): self._outputs.append(opCodeReturnValue) if (self._outputEvent is not None): self._outputEvent.set() self._programLine = self._programLine + 1 self._state = 0 return self._outputs[-1]
def calc_mult(): my_test_calc = Multiplication() return my_test_calc
input("Enter your choice(1/2/3/4): ")) #Store the user operation userFirstNumber = int( input("Enter first number: ")) #Store the first user entered number userSecondNumber = int( input("Enter second number: ")) #Store the second user entered number if userChoice == 1: #If the menu choice is 1 print("{0} + {1} = {2}".format( userFirstNumber, userSecondNumber, int(Addition(userFirstNumber, userSecondNumber)))) #Print the sum of the user numbers if userChoice == 2: #If the menu choice is 2 print("{0} - {1} = {2}".format( userFirstNumber, userSecondNumber, int(Subtraction( userFirstNumber, userSecondNumber)))) #Print the difference of the user numbers if userChoice == 3: #If the menu choice is 3 print("{0} * {1} = {2}".format( userFirstNumber, userSecondNumber, int(Multiplication( userFirstNumber, userSecondNumber)))) #Print the product of the user numbers if userChoice == 4: #If the menu choice is 4 print("{0} / {1} = {2}".format( userFirstNumber, userSecondNumber, int(Division( userFirstNumber, userSecondNumber)))) #Print the quotient of the user numbers
def __init__(self): self.__caesar__ = Caesar() self.__multi__ = Multiplication()