



from __future__ import annotations



class 	_lowercase							:





	"""simple docstring"""




	def __init__(self		,       lowerCamelCase_		):
						"""simple docstring"""

						a					     =   TypeError(
						    "Matrices must be formed from a list of zero or more lists containing at "
						    "least one and the same number of values, each of which must be of type "
						    "int or float."		)
						if len(lowerCamelCase_		) != 0:
											a					     =   len(rows[0]		)
											if cols == 0:
																raise error
											for row in rows:
																if len(lowerCamelCase_		) != cols:
																					raise error
																for value in row:
																					if not isinstance(lowerCamelCase_		,       (int, float)		):
																										raise error
											a					     =   rows
						else:
											a					     =   []




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						return [[row[i] for row in self.rows] for i in range(len(self.rows[0]		)		)]




	@property
	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						return len(self.rows		)




	@property
	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						return len(self.rows[0]		)




	@property
	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						return (self.num_rows, self.num_columns)




	@property
	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						return self.order[0] == self.order[1]




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						a					     =   [
						    [0 if column_num != row_num else 1 for column_num in range(self.num_rows		)]
						    for row_num in range(self.num_rows		)
						]
						return Matrix(lowerCamelCase_		)




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						if not self.is_square:
											return 0
						if self.order == (0, 0):
											return 1
						if self.order == (1, 1):
											return int(self.rows[0][0]		)
						if self.order == (2, 2):
											return int(
											    (self.rows[0][0] * self.rows[1][1])
											    - (self.rows[0][1] * self.rows[1][0])		)
						else:
											return sum(
											    self.rows[0][column] * self.cofactors().rows[0][column]
											    for column in range(self.num_columns		)		)




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						return bool(self.determinant()		)




	def      UpperCamelCase_       (self		,       lowerCamelCase_		,       lowerCamelCase_		):
						"""simple docstring"""

						a					     =   [
						    [
						        self.rows[other_row][other_column]
						        for other_column in range(self.num_columns		)
						        if other_column != column
						    ]
						    for other_row in range(self.num_rows		)
						    if other_row != row
						]
						return Matrix(lowerCamelCase_		).determinant()




	def      UpperCamelCase_       (self		,       lowerCamelCase_		,       lowerCamelCase_		):
						"""simple docstring"""

						if (row + column) % 2 == 0:
											return self.get_minor(lowerCamelCase_		,       lowerCamelCase_		)
						return -1 * self.get_minor(lowerCamelCase_		,       lowerCamelCase_		)




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						return Matrix(
						    [
						        [self.get_minor(lowerCamelCase_		,       lowerCamelCase_		) for column in range(self.num_columns		)]
						        for row in range(self.num_rows		)
						    ]		)




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						return Matrix(
						    [
						        [
						            self.minors().rows[row][column]
						            if (row + column) % 2 == 0
						            else self.minors().rows[row][column] * -1
						            for column in range(self.minors().num_columns		)
						        ]
						        for row in range(self.minors().num_rows		)
						    ]		)




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						a					     =   [
						    [self.cofactors().rows[column][row] for column in range(self.num_columns		)]
						    for row in range(self.num_rows		)
						]
						return Matrix(lowerCamelCase_		)




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						a					     =   self.determinant()
						if not determinant:
											raise TypeError("Only matrices with a non-zero determinant have an inverse"		)
						return self.adjugate() * (1 / determinant)




	def __repr__(self		):
						"""simple docstring"""

						return str(self.rows		)




	def __str__(self		):
						"""simple docstring"""

						if self.num_rows == 0:
											return "[]"
						if self.num_rows == 1:
											return "[[" + ". ".join(str(self.rows[0]		)		) + "]]"
						return (
						    "["
						    + "\n ".join(
						        [
						            "[" + ". ".join([str(lowerCamelCase_		) for value in row]		) + ".]"
						            for row in self.rows
						        ]		)
						    + "]"
						)




	def      UpperCamelCase_       (self		,       lowerCamelCase_		,       lowerCamelCase_ = None		):
						"""simple docstring"""

						a					     =   TypeError("Row must be a list containing all ints and/or floats"		)
						if not isinstance(lowerCamelCase_		,       lowerCamelCase_		):
											raise type_error
						for value in row:
											if not isinstance(lowerCamelCase_		,       (int, float)		):
																raise type_error
						if len(lowerCamelCase_		) != self.num_columns:
											raise ValueError(
											    "Row must be equal in length to the other rows in the matrix"		)
						if position is None:
											self.rows.append(lowerCamelCase_		)
						else:
											a					     =   self.rows[0:position] + [row] + self.rows[position:]




	def      UpperCamelCase_       (self		,       lowerCamelCase_		,       lowerCamelCase_ = None		):
						"""simple docstring"""

						a					     =   TypeError(
						    "Column must be a list containing all ints and/or floats"		)
						if not isinstance(lowerCamelCase_		,       lowerCamelCase_		):
											raise type_error
						for value in column:
											if not isinstance(lowerCamelCase_		,       (int, float)		):
																raise type_error
						if len(lowerCamelCase_		) != self.num_rows:
											raise ValueError(
											    "Column must be equal in length to the other columns in the matrix"		)
						if position is None:
											a					     =   [self.rows[i] + [column[i]] for i in range(self.num_rows		)]
						else:
											a					     =   [
											    self.rows[i][0:position] + [column[i]] + self.rows[i][position:]
											    for i in range(self.num_rows		)
											]




	def __eq__(self		,       lowerCamelCase_		):
						"""simple docstring"""

						if not isinstance(lowerCamelCase_		,       lowerCamelCase_		):
											return NotImplemented
						return self.rows == other.rows




	def __ne__(self		,       lowerCamelCase_		):
						"""simple docstring"""

						return not self == other




	def __neg__(self		):
						"""simple docstring"""

						return self * -1




	def __add__(self		,       lowerCamelCase_		):
						"""simple docstring"""

						if self.order != other.order:
											raise ValueError("Addition requires matrices of the same order"		)
						return Matrix(
						    [
						        [self.rows[i][j] + other.rows[i][j] for j in range(self.num_columns		)]
						        for i in range(self.num_rows		)
						    ]		)




	def __sub__(self		,       lowerCamelCase_		):
						"""simple docstring"""

						if self.order != other.order:
											raise ValueError("Subtraction requires matrices of the same order"		)
						return Matrix(
						    [
						        [self.rows[i][j] - other.rows[i][j] for j in range(self.num_columns		)]
						        for i in range(self.num_rows		)
						    ]		)




	def __mul__(self		,       lowerCamelCase_		):
						"""simple docstring"""

						if isinstance(lowerCamelCase_		,       (int, float)		):
											return Matrix(
											    [[int(element * other		) for element in row] for row in self.rows]		)
						elif isinstance(lowerCamelCase_		,       lowerCamelCase_		):
											if self.num_columns != other.num_rows:
																raise ValueError(
																    "The number of columns in the first matrix must "
																    "be equal to the number of rows in the second"		)
											return Matrix(
											    [
											        [Matrix.dot_product(lowerCamelCase_		,       lowerCamelCase_		) for column in other.columns()]
											        for row in self.rows
											    ]		)
						else:
											raise TypeError(
											    "A Matrix can only be multiplied by an int, float, or another matrix"		)




	def __pow__(self		,       lowerCamelCase_		):
						"""simple docstring"""

						if not isinstance(lowerCamelCase_		,       lowerCamelCase_		):
											raise TypeError("A Matrix can only be raised to the power of an int"		)
						if not self.is_square:
											raise ValueError("Only square matrices can be raised to a power"		)
						if other == 0:
											return self.identity()
						if other < 0:
											if self.is_invertable():
																return self.inverse() ** (-other)
											raise ValueError(
											    "Only invertable matrices can be raised to a negative power"		)
						a					     =   self
						for _ in range(other - 1		):
											result *= self
						return result




	@classmethod
	def      UpperCamelCase_       (cls		,       lowerCamelCase_		,       lowerCamelCase_		):
						"""simple docstring"""

						return sum(row[i] * column[i] for i in range(len(lowerCamelCase_		)		)		)


if __name__ == "__main__":
				import doctest

				doctest.testmod()





import numpy as np
from matplotlib import pyplot as plt
from sklearn.datasets import load_iris
from sklearn.metrics import ConfusionMatrixDisplay
from sklearn.model_selection import train_test_split
from xgboost import XGBClassifier






def     a(      A       :    dict       )		->       tuple:
					"""simple docstring"""





					return (data["data"], data["target"])






def     a(      A       :    np.ndarray ,     A       :    np.ndarray       )		->       XGBClassifier:
					"""simple docstring"""





					a					     =   XGBClassifier()
					classifier.fit(A ,     A       )
					return classifier






def     a(      )		->       None:
					"""simple docstring"""





					a					     =   load_iris()
					a     ,				a					     =   data_handling(A       )
					a     ,				a     ,				a     ,				a					     =   train_test_split(
					    A ,     A ,     test_size=0.25       )

					a					     =   iris["target_names"]

					# Create an XGBoost Classifier from the training data
					a					     =   xgboost(A ,     A       )

					# Display the confusion matrix of the classifier with both training and test sets
					ConfusionMatrixDisplay.from_estimator(
					    A ,     A ,     A ,     display_labels=A ,     cmap="Blues" ,     normalize="true" ,     )
					plt.title("Normalized Confusion Matrix - IRIS Dataset"       )
					plt.show()


if __name__ == "__main__":
				import doctest

				doctest.testmod(verbose=True)
				main()
