





'''simple docstring'''



import random

class     A_ :

			'''simple docstring'''





			def __init__(					self			,     A_			,     A_			,     A_ = 0.01			,     A_ = 10_00			,     A_ = -1			,     ):
								_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       a	(					self   ):
								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       a	(					self			,     A_   ):
								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       a	(					self			,     A_   ):
								return 1 if u >= 0 else -1




snake_case_   :  List[Any]								=      [
    [-0.65_08, 0.10_97, 4.00_09],
    [-1.44_92, 0.88_96, 4.40_05],
    [2.08_50, 0.68_76, 12.07_10],
    [0.26_26, 1.14_76, 7.79_85],
    [0.64_18, 1.02_34, 7.04_27],
    [0.25_69, 0.67_30, 8.32_65],
    [1.11_55, 0.60_43, 7.44_46],
    [0.09_14, 0.33_99, 7.06_77],
    [0.01_21, 0.52_56, 4.63_16],
    [-0.04_29, 0.46_60, 5.43_23],
    [0.43_40, 0.68_70, 8.22_87],
    [0.27_35, 1.02_87, 7.19_34],
    [0.48_39, 0.48_51, 7.48_50],
    [0.40_89, -0.12_67, 5.50_19],
    [1.43_91, 0.16_14, 8.58_43],
    [-0.91_15, -0.19_73, 2.19_62],
    [0.36_54, 1.04_75, 7.48_58],
    [0.21_44, 0.75_15, 7.16_99],
    [0.20_13, 1.00_14, 6.54_89],
    [0.64_83, 0.21_83, 5.89_91],
    [-0.11_47, 0.22_42, 7.24_35],
    [-0.79_70, 0.87_95, 3.87_62],
    [-1.06_25, 0.63_66, 2.47_07],
    [0.53_07, 0.12_85, 5.68_83],
    [-1.22_00, 0.77_77, 1.72_52],
    [0.39_57, 0.10_76, 5.66_23],
    [-0.10_13, 0.59_89, 7.18_12],
    [2.44_82, 0.94_55, 11.20_95],
    [2.01_49, 0.61_92, 10.92_63],
    [0.20_12, 0.26_11, 5.46_31],
]

snake_case_   :  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()

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










'''simple docstring'''



from __future__ import annotations



def  lowercase__(		_UpperCamelCase  : list[list[int]] ,   _UpperCamelCase  : int ,   _UpperCamelCase  : int ,   _UpperCamelCase  : int | float				)->   None:






					"""simple docstring"""

					_UpperCamelCase				,	_UpperCamelCase											=   m - 1, 0
					while i >= 0 and j < n:
										if key == mat[i][j]:
															print(f"Key {key} found at row- {i + 1} column- {j + 1}"				)
															return
										if key < mat[i][j]:
															i -= 1
										else:
															j += 1
					print(f"Key {key} not found"				)



def  lowercase__(		)->   None:






					"""simple docstring"""

					_UpperCamelCase											=   [[2, 5, 7], [4, 8, 13], [9, 11, 15], [12, 17, 20]]
					_UpperCamelCase											=   int(input("Enter the element to be searched:"				)				)
					print(_UpperCamelCase				)
					search_in_a_sorted_matrix(_UpperCamelCase ,   len(_UpperCamelCase				) ,   len(mat[0]				) ,   _UpperCamelCase				)


if __name__ == "__main__":
			import doctest

			doctest.testmod()
			main()



