
import random


class 							lowercase   :



		def __init__(					self							, A_							, A_							, A_ = 0.01							, A_ = 1_000							, A_ = -1							, )    ->   None:
				"""simple docstring"""
				UpperCamelCase            =	sample
				if len(self.sample			) == 0:
						raise ValueError('Sample data can not be empty'			)
				UpperCamelCase            =	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'			)
				UpperCamelCase            =	learning_rate
				UpperCamelCase            =	epoch_number
				UpperCamelCase            =	bias
				UpperCamelCase            =	len(A_			)
				UpperCamelCase            =	len(sample[0]			)  # number of columns in dataset
				UpperCamelCase            =	[]



		def __UpperCamelCase					(					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			)

				UpperCamelCase            =	0

				while True:
						UpperCamelCase            =	False
						for i in range(self.number_sample			):
								UpperCamelCase            =	0
								for j in range(self.col_sample + 1			):
										UpperCamelCase            =	u + self.weight[j] * self.sample[i][j]
								UpperCamelCase            =	self.sign(A_			)
								if y != self.target[i]:
										for j in range(self.col_sample + 1			):
												UpperCamelCase            =	(
												    self.weight[j]
												    + self.learning_rate
												    * (self.target[i] - y)
												    * self.sample[i][j]
												)
										UpperCamelCase            =	True
            # print('Epoch: \n',epoch_count)
						UpperCamelCase            =	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 __UpperCamelCase					(					self							, A_			)    ->   None:
				"""simple docstring"""
				if len(self.sample			) == 0:
						raise ValueError('Sample data can not be empty'			)
				sample.insert(0							, self.bias			)
				UpperCamelCase            =	0
				for i in range(self.col_sample + 1			):
						UpperCamelCase            =	u + self.weight[i] * sample[i]

				UpperCamelCase            =	self.sign(A_			)

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



		def __UpperCamelCase					(					self							, A_			)    ->   int:
				"""simple docstring"""
				return 1 if u >= 0 else -1






_UpperCAmelCase   :					Dict    =			[
    [-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],
]

_UpperCAmelCase   :					int    =			[
    -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()

					_UpperCAmelCase   :					str    =			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:
										_UpperCAmelCase   :					list    =			[]
										for i in range(len(samples[0])):
															_UpperCAmelCase   :					Tuple    =			input("value: ").strip()
															if user_input == "q":
																				break
															_UpperCAmelCase   :					int    =			float(user_input)
															sample.insert(i, observation)
										network.sort(sample)


def  A			(   lowercase					)  ->    str:
		'''simple docstring'''

		if not isinstance(lowercase       ,			lowercase					):
				UpperCamelCase            =	(
				    'operation can not be conducted on a object of type '
				    f'''{type(lowercase					).__name__}'''
				)
				raise TypeError(lowercase					)
		UpperCamelCase            =	''
		for _ in range(0       ,			32					):
				bit_string += str(number % 2					)
				UpperCamelCase            =	number >> 1
		return bit_string


def  A			(   lowercase					)  ->    str:
		'''simple docstring'''

		if number < 0:
				raise ValueError('the value of input must be positive'					)
		elif isinstance(lowercase       ,			lowercase					):
				raise TypeError('Input value must be a \'int\' type'					)
		elif isinstance(lowercase       ,			lowercase					):
				raise TypeError('\'<\' not supported between instances of \'str\' and \'int\''					)
		UpperCamelCase            =	0
		# iterator over [1 to 32],since we are dealing with 32 bit integer
		for _ in range(1       ,			33					):
				# left shift the bits by unity
				UpperCamelCase            =	result << 1
				# get the end bit
				UpperCamelCase            =	number % 2
				# right shift the bits by unity
				UpperCamelCase            =	number >> 1
				# add that bit to our ans
				UpperCamelCase            =	result | end_bit
		return get_reverse_bit_string(lowercase					)


if __name__ == "__main__":
					import doctest

					doctest.testmod()
