'''simple docstring'''




import random




class 					a__   :






     def __init__(				self	:	Optional[Any]						,       a	:	list[list[float]]						,       a	:	list[int]						,       a	:	float = 0.01						,       a	:	int = 10_00						,       a	:	float = -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(a					)
         __lowerCamelCase						=						len(sample[0]					)  # number of columns in dataset
         __lowerCamelCase						=						[]






     def      SCREAMING_SNAKE_CASE__     (				self	:	int					):





         """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(a					)
                 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      SCREAMING_SNAKE_CASE__     (				self	:	Optional[int]						,       a	:	list[float]					):





         """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(a					)

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






     def      SCREAMING_SNAKE_CASE__     (				self	:	List[str]						,       a	:	float					):





         """simple docstring"""



         return 1 if u >= 0 else -1
__UpperCAmelCase  							=[
    [-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  							=[
    -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  							=Perceptron(
      sample=samples, target=target, learning_rate=0.01, epoch_number=1_0_0_0, bias=-1
  )
  network.training()
  print("Finished training perceptron")
  print("Enter values to predict or q to exit")
  while True:
    __UpperCAmelCase  							=[]
    for i in range(len(samples[0])):
      __UpperCAmelCase  							=input("value: ").strip()
      if user_input == "q":
        break
      __UpperCAmelCase  							=float(user_input)
      sample.insert(i, observation)
    network.sort(sample)

'''simple docstring'''




from __future__ import annotations






def __lowerCAmelCase				(							UpperCamelCase__       ,						UpperCamelCase__       ,						UpperCamelCase__       )			->					tuple[float, float]:
    assert (
        c % greatest_common_divisor(UpperCamelCase__       ,						UpperCamelCase__       ) == 0
    )  # greatest_common_divisor(a,b) function implemented below
    ((__lowerCamelCase)			,						(__lowerCamelCase)			,						(__lowerCamelCase))						=						extended_gcd(UpperCamelCase__       ,						UpperCamelCase__       )  # extended_gcd(a,b) function implemented below
    __lowerCamelCase						=						c / d
    return (r * x, r * y)






def __lowerCAmelCase				(							UpperCamelCase__       ,						UpperCamelCase__       ,						UpperCamelCase__       ,						UpperCamelCase__ = 2       )			->					None:
    ((__lowerCamelCase)			,						(__lowerCamelCase))						=						diophantine(UpperCamelCase__       ,						UpperCamelCase__       ,						UpperCamelCase__       )  # Initial value
    __lowerCamelCase						=						greatest_common_divisor(UpperCamelCase__       ,						UpperCamelCase__       )
    __lowerCamelCase						=						a // d
    __lowerCamelCase						=						b // d

    for i in range(UpperCamelCase__       ):
        __lowerCamelCase						=						xa + i * q
        __lowerCamelCase						=						ya - i * p
        print(UpperCamelCase__       ,						UpperCamelCase__       )






def __lowerCAmelCase				(							UpperCamelCase__       ,						UpperCamelCase__       )			->					int:
    if a < b:
        __lowerCamelCase			,						__lowerCamelCase						=						b, a

    while a % b != 0:
        __lowerCamelCase			,						__lowerCamelCase						=						b, a % b

    return b






def __lowerCAmelCase				(							UpperCamelCase__       ,						UpperCamelCase__       )			->					tuple[int, int, int]:
    assert a >= 0 and b >= 0

    if b == 0:
        __lowerCamelCase			,						__lowerCamelCase			,						__lowerCamelCase						=						a, 1, 0
    else:
        ((__lowerCamelCase)			,						(__lowerCamelCase)			,						(__lowerCamelCase))						=						extended_gcd(UpperCamelCase__       ,						a % b       )
        __lowerCamelCase						=						q
        __lowerCamelCase						=						p - q * (a // b)

    assert a % d == 0 and b % d == 0
    assert d == a * x + b * y

    return (d, x, y)


if __name__ == "__main__":
  from doctest import testmod

  testmod(name="diophantine", verbose=True)
  testmod(name="diophantine_all_soln", verbose=True)
  testmod(name="extended_gcd", verbose=True)
  testmod(name="greatest_common_divisor", verbose=True)
