

import random






class 			__magic_name__					:





			def __init__(	self      ,						__snake_case      ,						__snake_case      ,						__snake_case = 0.01      ,						__snake_case = 1000      ,						__snake_case = -1      ,						)     ->				None:




						'''simple docstring'''
						__a						   =sample
						if len(self.sample      ) == 0:
									raise ValueError('Sample data can not be empty'      )
						__a						   =target
						if len(self.target      ) == 0:
									raise ValueError('Target data can not be empty'      )
						if len(self.sample      ) != len(self.target      ):
									raise ValueError('Sample data and Target data do not have matching lengths'      )
						__a						   =learning_rate
						__a						   =epoch_number
						__a						   =bias
						__a						   =len(__snake_case      )
						__a						   =len(sample[0]      )  # number of columns in dataset
						__a						   =[]





			def 	__magic_name__					(	self      )     ->				None:




						'''simple docstring'''
						for sample in self.sample:
									sample.insert(0      ,						self.bias      )

						for _ in range(self.col_sample      ):
									self.weight.append(random.random()      )

						self.weight.insert(0      ,						self.bias      )

						__a						   =0

						while True:
									__a						   =False
									for i in range(self.number_sample      ):
												__a						   =0
												for j in range(self.col_sample + 1      ):
															__a						   =u + self.weight[j] * self.sample[i][j]
												__a						   =self.sign(__snake_case      )
												if y != self.target[i]:
															for j in range(self.col_sample + 1      ):
																		__a						   =(
																		    self.weight[j]
																		    + self.learning_rate
																		    * (self.target[i] - y)
																		    * self.sample[i][j]
																		)
															__a						   =True
            # print('Epoch: \n',epoch_count)
									__a						   =epoch_count + 1
									# if you want control the epoch or just by error
									if not has_misclassified:
												print(('\nEpoch:\n', epoch_count)      )
												print('------------------------\n'      )
												# if epoch_count > self.epoch_number or not error:
												break





			def 	__magic_name__					(	self      ,						__snake_case      )     ->				None:




						'''simple docstring'''
						if len(self.sample      ) == 0:
									raise ValueError('Sample data can not be empty'      )
						sample.insert(0      ,						self.bias      )
						__a						   =0
						for i in range(self.col_sample + 1      ):
									__a						   =u + self.weight[i] * sample[i]

						__a						   =self.sign(__snake_case      )

						if y == -1:
									print(('Sample: ', sample)      )
									print('classification: P1'      )
						else:
									print(('Sample: ', sample)      )
									print('classification: P2'      )





			def 	__magic_name__					(	self      ,						__snake_case      )     ->				int:




						'''simple docstring'''
						return 1 if u >= 0 else -1


_lowerCAmelCase      :    List[str]						       =    [
    [-0.6508, 0.1097, 4.0009],
    [-1.4492, 0.8896, 4.4005],
    [2.0850, 0.6876, 12.0710],
    [0.2626, 1.1476, 7.7985],
    [0.6418, 1.0234, 7.0427],
    [0.2569, 0.6730, 8.3265],
    [1.1155, 0.6043, 7.4446],
    [0.0914, 0.3399, 7.0677],
    [0.0121, 0.5256, 4.6316],
    [-0.0429, 0.4660, 5.4323],
    [0.4340, 0.6870, 8.2287],
    [0.2735, 1.0287, 7.1934],
    [0.4839, 0.4851, 7.4850],
    [0.4089, -0.1267, 5.5019],
    [1.4391, 0.1614, 8.5843],
    [-0.9115, -0.1973, 2.1962],
    [0.3654, 1.0475, 7.4858],
    [0.2144, 0.7515, 7.1699],
    [0.2013, 1.0014, 6.5489],
    [0.6483, 0.2183, 5.8991],
    [-0.1147, 0.2242, 7.2435],
    [-0.7970, 0.8795, 3.8762],
    [-1.0625, 0.6366, 2.4707],
    [0.5307, 0.1285, 5.6883],
    [-1.2200, 0.7777, 1.7252],
    [0.3957, 0.1076, 5.6623],
    [-0.1013, 0.5989, 7.1812],
    [2.4482, 0.9455, 11.2095],
    [2.0149, 0.6192, 10.9263],
    [0.2012, 0.2611, 5.4631],
]

_lowerCAmelCase      :    Any						       =    [
    -1,
    -1,
    -1,
    1,
    1,
    -1,
    1,
    -1,
    1,
    1,
    -1,
    1,
    -1,
    -1,
    -1,
    -1,
    1,
    1,
    1,
    1,
    -1,
    1,
    1,
    1,
    1,
    -1,
    -1,
    1,
    -1,
    1,
]


if __name__ == "__main__":
						import doctest

						doctest.testmod()

						_lowerCAmelCase      :    Any						       =    Perceptron(
						    sample=samples, target=target, learning_rate=0.01, epoch_number=1_000, bias=-1
						)
						network.training()
						print("Finished training perceptron")
						print("Enter values to predict or q to exit")
						while True:
												_lowerCAmelCase      :    list						       =    []
												for i in range(len(samples[0])):
																		_lowerCAmelCase      :    Optional[Any]						       =    input("value: ").strip()
																		if user_input == "q":
																								break
																		_lowerCAmelCase      :    Tuple						       =    float(user_input)
																		sample.insert(i, observation)
												network.sort(sample)









import os
import sys
import time

from . import transposition_cipher as trans_cipher






def  UpperCamelCase_(							):




			"""simple docstring"""






			__a						   ='Prehistoric Men.txt'
			__a						   ='Output.txt'
			__a						   =int(input('Enter key: '			)			)
			__a						   =input('Encrypt/Decrypt [e/d]: '			)

			if not os.path.exists(_snake_case			):
						print(F'File {input_file} does not exist. Quitting...'			)
						sys.exit()
			if os.path.exists(_snake_case			):
						print(F'Overwrite {output_file}? [y/n]'			)
						__a						   =input('> '			)
						if not response.lower().startswith('y'			):
									sys.exit()

			__a						   =time.time()
			if mode.lower().startswith('e'			):
						with open(_snake_case			) as f:
									__a						   =f.read()
						__a						   =trans_cipher.encrypt_message(_snake_case ,  _snake_case			)
			elif mode.lower().startswith('d'			):
						with open(_snake_case			) as f:
									__a						   =f.read()
						__a						   =trans_cipher.decrypt_message(_snake_case ,  _snake_case			)

			with open(_snake_case ,  'w'			) as output_obj:
						output_obj.write(_snake_case			)

			__a						   =round(time.time() - start_time ,  2			)
			print(('Done (', total_time, 'seconds )')			)


if __name__ == "__main__":
						main()






