



from __future__ import annotations

import math

import numpy as np
from numpy.linalg import norm

def        a						(      _UpperCAmelCase							:					np.ndarray ,   _UpperCAmelCase							:					np.ndarray						):







		'''simple docstring'''





		return math.sqrt(sum(pow(a - b ,   2						) for a, b in zip(_UpperCAmelCase ,   _UpperCAmelCase						)						)						)

def        a						(      _UpperCAmelCase							:					np.ndarray ,   _UpperCAmelCase							:					np.ndarray						):







		'''simple docstring'''





		if dataset.ndim != value_array.ndim:
				__UpperCAmelCase    :     Union[str, Any]													=	(
				    '''Wrong input data\'s dimensions... '''
				    f'dataset : {dataset.ndim}, value_array : {value_array.ndim}'
				)
				raise ValueError(_UpperCAmelCase						)

		try:
				if dataset.shape[1] != value_array.shape[1]:
						__UpperCAmelCase    :     Optional[int]													=	(
						    '''Wrong input data\'s shape... '''
						    f'dataset : {dataset.shape[1]}, value_array : {value_array.shape[1]}'
						)
						raise ValueError(_UpperCAmelCase						)
		except IndexError:
				if dataset.ndim != value_array.ndim:
						raise TypeError('''Wrong shape'''						)

		if dataset.dtype != value_array.dtype:
				__UpperCAmelCase    :     Dict													=	(
				    '''Input data have different datatype... '''
				    f'dataset : {dataset.dtype}, value_array : {value_array.dtype}'
				)
				raise TypeError(_UpperCAmelCase						)

		__UpperCAmelCase    :     Tuple													=	[]

		for value in value_array:
				__UpperCAmelCase    :     List[Any]													=	euclidean(_UpperCAmelCase ,   dataset[0]						)
				__UpperCAmelCase    :     Union[str, Any]													=	dataset[0].tolist()

				for dataset_value in dataset[1:]:
						__UpperCAmelCase    :     List[Any]													=	euclidean(_UpperCAmelCase ,   _UpperCAmelCase						)

						if dist > temp_dist:
								__UpperCAmelCase    :     Optional[int]													=	temp_dist
								__UpperCAmelCase    :     Dict													=	dataset_value.tolist()

				answer.append([vector, dist]						)

		return answer

def        a						(      _UpperCAmelCase							:					np.ndarray ,   _UpperCAmelCase							:					np.ndarray						):







		'''simple docstring'''





		return np.dot(_UpperCAmelCase ,   _UpperCAmelCase						) / (norm(_UpperCAmelCase						) * norm(_UpperCAmelCase						))


if __name__ == "__main__":
				import doctest

				doctest.testmod()










import qiskit

def        a						(      _UpperCAmelCase							:					int ,   _UpperCAmelCase							:					int						):







		'''simple docstring'''





		__UpperCAmelCase    :     List[str]													=	qiskit.Aer.get_backend('''aer_simulator'''						)

		__UpperCAmelCase    :     Optional[Any]													=	qiskit.QuantumCircuit(4 ,   2						)
		# encode inputs in qubits 0 and 1
		if bita == 1:
				qc_ha.x(0						)
		if bita == 1:
				qc_ha.x(1						)
		qc_ha.barrier()

		# use cnots to write XOR of the inputs on qubit2
		qc_ha.cx(0 ,   2						)
		qc_ha.cx(1 ,   2						)

		# use ccx / toffoli gate to write AND of the inputs on qubit3
		qc_ha.ccx(0 ,   1 ,   3						)
		qc_ha.barrier()

		# extract outputs
		qc_ha.measure(2 ,   0						)  # extract XOR value
		qc_ha.measure(3 ,   1						)  # extract AND value

		# Execute the circuit on the qasm simulator
		__UpperCAmelCase    :     str													=	qiskit.execute(_UpperCAmelCase ,   _UpperCAmelCase ,   shots=10_00						)

		# Return the histogram data of the results of the experiment
		return job.result().get_counts(_UpperCAmelCase						)


if __name__ == "__main__":
				__A   			=half_adder(1, 1)
				print(f'''Half Adder Output Qubit Counts: {counts}''')





