



import random


class 	snake_case_			:




       """simple docstring"""






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

             """simple docstring"""





             UpperCAmelCase_	:						List[str]					   =		sample
             if len(self.sample) == 0:
                   raise ValueError("Sample data can not be empty")
             UpperCAmelCase_	:						Tuple					   =		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_	:						List[Any]					   =		learning_rate
             UpperCAmelCase_	:						Tuple					   =		epoch_number
             UpperCAmelCase_	:						Tuple					   =		bias
             UpperCAmelCase_	:						Tuple					   =		len(lowercase)
             UpperCAmelCase_	:						Optional[int]					   =		len(sample[0])  # number of columns in dataset
             UpperCAmelCase_	:						list					   =		[]



       def 			A_ (  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)

             UpperCAmelCase_	:						Optional[int]					   =		0

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

             """simple docstring"""





             if len(self.sample) == 0:
                   raise ValueError("Sample data can not be empty")
             sample.insert(0  ,self.bias)
             UpperCAmelCase_	:						List[Any]					   =		0
             for i in range(self.col_sample + 1):
                   UpperCAmelCase_	:						str					   =		u + self.weight[i] * sample[i]

             UpperCAmelCase_	:						Any					   =		self.sign(lowercase)

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



       def 			A_ (  self  ,lowercase):

             """simple docstring"""





             return 1 if u >= 0 else -1


__lowerCamelCase								=      [
    [-0.6_5_0_8, 0.1_0_9_7, 4.0_0_0_9],
    [-1.4_4_9_2, 0.8_8_9_6, 4.4_0_0_5],
    [2.0_8_5_0, 0.6_8_7_6, 1_2.0_7_1_0],
    [0.2_6_2_6, 1.1_4_7_6, 7.7_9_8_5],
    [0.6_4_1_8, 1.0_2_3_4, 7.0_4_2_7],
    [0.2_5_6_9, 0.6_7_3_0, 8.3_2_6_5],
    [1.1_1_5_5, 0.6_0_4_3, 7.4_4_4_6],
    [0.0_9_1_4, 0.3_3_9_9, 7.0_6_7_7],
    [0.0_1_2_1, 0.5_2_5_6, 4.6_3_1_6],
    [-0.0_4_2_9, 0.4_6_6_0, 5.4_3_2_3],
    [0.4_3_4_0, 0.6_8_7_0, 8.2_2_8_7],
    [0.2_7_3_5, 1.0_2_8_7, 7.1_9_3_4],
    [0.4_8_3_9, 0.4_8_5_1, 7.4_8_5_0],
    [0.4_0_8_9, -0.1_2_6_7, 5.5_0_1_9],
    [1.4_3_9_1, 0.1_6_1_4, 8.5_8_4_3],
    [-0.9_1_1_5, -0.1_9_7_3, 2.1_9_6_2],
    [0.3_6_5_4, 1.0_4_7_5, 7.4_8_5_8],
    [0.2_1_4_4, 0.7_5_1_5, 7.1_6_9_9],
    [0.2_0_1_3, 1.0_0_1_4, 6.5_4_8_9],
    [0.6_4_8_3, 0.2_1_8_3, 5.8_9_9_1],
    [-0.1_1_4_7, 0.2_2_4_2, 7.2_4_3_5],
    [-0.7_9_7_0, 0.8_7_9_5, 3.8_7_6_2],
    [-1.0_6_2_5, 0.6_3_6_6, 2.4_7_0_7],
    [0.5_3_0_7, 0.1_2_8_5, 5.6_8_8_3],
    [-1.2_2_0_0, 0.7_7_7_7, 1.7_2_5_2],
    [0.3_9_5_7, 0.1_0_7_6, 5.6_6_2_3],
    [-0.1_0_1_3, 0.5_9_8_9, 7.1_8_1_2],
    [2.4_4_8_2, 0.9_4_5_5, 1_1.2_0_9_5],
    [2.0_1_4_9, 0.6_1_9_2, 1_0.9_2_6_3],
    [0.2_0_1_2, 0.2_6_1_1, 5.4_6_3_1],
]

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

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





import math

import qiskit
from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute







def  _snake_case			(							__snake_case = 1       ,	__snake_case = 1     )  ->  qiskit.result.counts.Counts:






      '''simple docstring'''







      if isinstance(__snake_case       ,	__snake_case     ) or isinstance(__snake_case       ,	__snake_case     ):
            raise TypeError("inputs must be integers."     )
      if (bit_a < 0) or (bit_a < 0):
            raise ValueError("inputs must be positive."     )
      if (math.floor(__snake_case     ) != bit_a) or (math.floor(__snake_case     ) != bit_a):
            raise ValueError("inputs must be exact integers."     )
      if (bit_a > 1) or (bit_a > 1):
            raise ValueError("inputs must be less or equal to 1."     )

      # build registers
      UpperCAmelCase_	:						Union[str, Any]					   =		QuantumRegister(2       ,	"qr"     )
      UpperCAmelCase_	:						Tuple					   =		ClassicalRegister(2       ,	"cr"     )

      UpperCAmelCase_	:						Union[str, Any]					   =		QuantumCircuit(__snake_case       ,	__snake_case     )

      # entanglement the qubits
      quantum_circuit.h(1     )
      quantum_circuit.cx(1       ,	0     )

      # send the information
      UpperCAmelCase_	:						Any					   =		str(__snake_case     ) + str(__snake_case     )

      if c_information == "11":
            quantum_circuit.x(1     )
            quantum_circuit.z(1     )
      elif c_information == "10":
            quantum_circuit.z(1     )
      elif c_information == "01":
            quantum_circuit.x(1     )
      else:
            quantum_circuit.i(1     )

      # unentangled the circuit
      quantum_circuit.cx(1       ,	0     )
      quantum_circuit.h(1     )

      # measure the circuit
      quantum_circuit.measure(__snake_case       ,	__snake_case     )

      UpperCAmelCase_	:						Union[str, Any]					   =		Aer.get_backend("aer_simulator"     )
      UpperCAmelCase_	:						Dict					   =		execute(__snake_case       ,	__snake_case       ,	shots=1_0_0_0     )

      return job.result().get_counts(__snake_case     )


if __name__ == "__main__":
   print(F'''Counts for classical state send: {superdense_coding(1,1)}''')
