



import random



class 	__lowerCAmelCase       :




 def __init__(  self		,			__UpperCAmelCase		,			__UpperCAmelCase		,			__UpperCAmelCase = 0.01		,			__UpperCAmelCase = 1000		,			__UpperCAmelCase = -1		,			):



    '''simple docstring'''
    __lowerCamelCase  							=      sample
    if len(self.sample			) == 0:
       raise ValueError('''Sample data can not be empty'''			)
    __lowerCamelCase  							=      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'''			)
    __lowerCamelCase  							=      learning_rate
    __lowerCamelCase  							=      epoch_number
    __lowerCamelCase  							=      bias
    __lowerCamelCase  							=      len(__UpperCAmelCase			)
    __lowerCamelCase  							=      len(sample[0]			)  # number of columns in dataset
    __lowerCamelCase  							=      []




 def     lowerCamelCase (  self			):



    '''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			)

    __lowerCamelCase  							=      0

    while True:
       __lowerCamelCase  							=      False
       for i in range(self.number_sample			):
          __lowerCamelCase  							=      0
          for j in range(self.col_sample + 1			):
             __lowerCamelCase  							=      u + self.weight[j] * self.sample[i][j]
          __lowerCamelCase  							=      self.sign(__UpperCAmelCase			)
          if y != self.target[i]:
             for j in range(self.col_sample + 1			):
                __lowerCamelCase  							=      (
                    self.weight[j]
                    + self.learning_rate
                    * (self.target[i] - y)
                    * self.sample[i][j]
                )
             __lowerCamelCase  							=      True
            # print('Epoch: \n',epoch_count)
       __lowerCamelCase  							=      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     lowerCamelCase (  self		,			__UpperCAmelCase			):



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

    __lowerCamelCase  							=      self.sign(__UpperCAmelCase			)

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




 def     lowerCamelCase (  self		,			__UpperCAmelCase			):



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



a_								=   [
    [-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],
]

a_								=   [
    -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()

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











def 						a__     (						_UpperCamelCase     :	int							):
   if not isinstance(_UpperCamelCase	,_UpperCamelCase							):
      __lowerCamelCase  							=      (
          '''operation can not be conducted on a object of type '''
          F"""{type(_UpperCamelCase							).__name__}"""
      )
      raise TypeError(_UpperCamelCase							)
   __lowerCamelCase  							=      ''''''
   for _ in range(0	,32							):
      bit_string += str(number % 2							)
      __lowerCamelCase  							=      number >> 1
   return bit_string





def 						a__     (						_UpperCamelCase     :	int							):
   if number < 0:
      raise ValueError('''the value of input must be positive'''							)
   elif isinstance(_UpperCamelCase	,_UpperCamelCase							):
      raise TypeError('''Input value must be a \'int\' type'''							)
   elif isinstance(_UpperCamelCase	,_UpperCamelCase							):
      raise TypeError('''\'<\' not supported between instances of \'str\' and \'int\''''							)
   __lowerCamelCase  							=      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
      __lowerCamelCase  							=      result << 1
      # get the end bit
      __lowerCamelCase  							=      number % 2
      # right shift the bits by unity
      __lowerCamelCase  							=      number >> 1
      # add that bit to our ans
      __lowerCamelCase  							=      result | end_bit
   return get_reverse_bit_string(_UpperCamelCase							)


if __name__ == "__main__":
  import doctest

  doctest.testmod()






