






'''simple docstring'''







import math

class _lowercase     :




							def 		lowerCamelCase_    (							self:    Dict      ,							UpperCamelCase__:    list[list[float]]      ,							UpperCamelCase__:    list[int]					):
														lowerCamelCase__ :     int	  =	0.0
														lowerCamelCase__ :     Union[str, Any]	  =	0.0
														for i in range(len(UpperCamelCase__					)					):
																					da += math.pow((sample[i] - weights[0][i])      ,							2					)
																					da += math.pow((sample[i] - weights[1][i])      ,							2					)
																					return 0 if da > da else 1
														return 0




							def 		lowerCamelCase_    (							self:    Dict      ,							UpperCamelCase__:    list[list[int | float]]      ,							UpperCamelCase__:    list[int]      ,							UpperCamelCase__:    int      ,							UpperCamelCase__:    float					):
														for i in range(len(UpperCamelCase__					)					):
																					weights[j][i] += alpha * (sample[i] - weights[j][i])
														return weights





def 			SCREAMING_SNAKE_CASE_	()				->	None:
							# Training Examples ( m, n )
							lowerCamelCase__ :     Any	  =	[[1, 1, 0, 0], [0, 0, 0, 1], [1, 0, 0, 0], [0, 0, 1, 1]]

							# weight initialization ( n, C )
							lowerCamelCase__ :     Dict	  =	[[0.2, 0.6, 0.5, 0.9], [0.8, 0.4, 0.7, 0.3]]

							# training
							lowerCamelCase__ :     Optional[int]	  =	SelfOrganizingMap()
							lowerCamelCase__ :     Optional[Any]	  =	3
							lowerCamelCase__ :     Tuple	  =	0.5

							for _ in range(UpperCamelCase				):
														for j in range(len(UpperCamelCase				)				):
																					# training sample
																					lowerCamelCase__ :     List[Any]	  =	training_samples[j]

																					# Compute the winning vector
																					lowerCamelCase__ :     Optional[int]	  =	self_organizing_map.get_winner(UpperCamelCase    ,      UpperCamelCase				)

																					# Update the winning vector
																					lowerCamelCase__ :     str	  =	self_organizing_map.update(UpperCamelCase    ,      UpperCamelCase    ,      UpperCamelCase    ,      UpperCamelCase				)

    # classify test sample
							lowerCamelCase__ :     List[Any]	  =	[0, 0, 0, 1]
							lowerCamelCase__ :     List[Any]	  =	self_organizing_map.get_winner(UpperCamelCase    ,      UpperCamelCase				)

							# results
							print(f'''Clusters that the test sample belongs to : {winner}'''				)
							print(f'''Weights that have been trained : {weights}'''				)


# running the main() function
if __name__ == "__main__":
			main()









'''simple docstring'''







def 			SCREAMING_SNAKE_CASE_	(UpperCamelCase				)				->	list:

							# bit count represents no. of bits in the gray code
							if bit_count < 0:
														raise ValueError("""The given input must be positive"""				)

							# get the generated string sequence
							lowerCamelCase__ :     List[str]	  =	gray_code_sequence_string(UpperCamelCase				)
							#
							# convert them to integers
							for i in range(len(UpperCamelCase				)				):
														lowerCamelCase__ :     int	  =	int(sequence[i]    ,      2				)

							return sequence





def 			SCREAMING_SNAKE_CASE_	(UpperCamelCase				)				->	list:

							# The approach is a recursive one
							# Base case achieved when either n = 0 or n=1
							if bit_count == 0:
														return ["0"]

							if bit_count == 1:
														return ["0", "1"]

							lowerCamelCase__ :     Optional[Any]	  =	1 << bit_count  # defines the length of the sequence
							# 1<< n is equivalent to 2^n

							# recursive answer will generate answer for n-1 bits
							lowerCamelCase__ :     Any	  =	gray_code_sequence_string(bit_count - 1				)

							lowerCamelCase__ :     Union[str, Any]	  =	[]

							# append 0 to first half of the smaller sequence generated
							for i in range(seq_len // 2				):
														lowerCamelCase__ :     Optional[int]	  =	"""0""" + smaller_sequence[i]
														sequence.append(UpperCamelCase				)

							# append 1 to second half ... start from the end of the list
							for i in reversed(range(seq_len // 2				)				):
														lowerCamelCase__ :     int	  =	"""1""" + smaller_sequence[i]
														sequence.append(UpperCamelCase				)

							return sequence


if __name__ == "__main__":
			import doctest

			doctest.testmod()

