






'''simple docstring'''

import math







class 	SCREAMING_SNAKE_CASE	:




       def 					a_					(					self      : Any	,    A__      : list[list[float]]	,    A__      : list[int]					):


            """simple docstring"""







            __lowerCamelCase						:       Optional[Any]				   =				0.0
            __lowerCamelCase						:       Union[str, Any]				   =				0.0
            for i in range(len(A__					)					):
                 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 					a_					(					self      : Optional[int]	,    A__      : list[list[int | float]]	,    A__      : list[int]	,    A__      : int	,    A__      : float					):


            """simple docstring"""







            for i in range(len(A__					)					):
                 weights[j][i] += alpha * (sample[i] - weights[j][i])
            return weights

def     __lowercase  ()   ->     None:


     """simple docstring"""
     # Training Examples ( m, n )
     __lowerCamelCase						:       Dict				   =				[[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						:       int				   =				SelfOrganizingMap()
     __lowerCamelCase						:       List[Any]				   =				3
     __lowerCamelCase						:       Dict				   =				0.5

     for _ in range(_lowercase     ):
          for j in range(len(_lowercase     )     ):
               # training sample
               __lowerCamelCase						:       Dict				   =				training_samples[j]

               # Compute the winning vector
               __lowerCamelCase						:       str				   =				self_organizing_map.get_winner(_lowercase,						_lowercase     )

               # Update the winning vector
               __lowerCamelCase						:       Optional[Any]				   =				self_organizing_map.update(_lowercase,						_lowercase,						_lowercase,						_lowercase     )

    # classify test sample
     __lowerCamelCase						:       Dict				   =				[0, 0, 0, 1]
     __lowerCamelCase						:       Dict				   =				self_organizing_map.get_winner(_lowercase,						_lowercase     )

     # 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     __lowercase  (_lowercase     )   ->     list:


     """simple docstring"""

     # 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						:       Optional[Any]				   =				gray_code_sequence_string(_lowercase     )
     #
     # convert them to integers
     for i in range(len(_lowercase     )     ):
          __lowerCamelCase						:       List[str]				   =				int(sequence[i],						2     )

     return sequence
def     __lowercase  (_lowercase     )   ->     list:


     """simple docstring"""

     # 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						:       str				   =				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						:       Union[str, Any]				   =				gray_code_sequence_string(bit_count - 1     )

     __lowerCamelCase						:       Optional[int]				   =				[]

     # append 0 to first half of the smaller sequence generated
     for i in range(seq_len // 2     ):
          __lowerCamelCase						:       Union[str, Any]				   =				"""0""" + smaller_sequence[i]
          sequence.append(_lowercase     )

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

     return sequence


if __name__ == "__main__":
   import doctest

   doctest.testmod()



