
"""simple docstring"""




from __future__ import annotations



class 	lowerCAmelCase_						:


				"""simple docstring"""



				def __init__(self   ,       SCREAMING_SNAKE_CASE__    )					->		Union[str, Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       Dict           =   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(SCREAMING_SNAKE_CASE__    ) != 0:
																		SCREAMING_SNAKE_CASE__						:       Optional[int]           =   len(rows[0]    )
																		if cols == 0:
																									raise error
																		for row in rows:
																									if len(SCREAMING_SNAKE_CASE__    ) != cols:
																																raise error
																									for value in row:
																																if not isinstance(SCREAMING_SNAKE_CASE__   ,       (int, float)    ):
																																							raise error
																		SCREAMING_SNAKE_CASE__						:       int           =   rows
											else:
																		SCREAMING_SNAKE_CASE__						:       List[str]           =   []



				def 	__magic_name__    (self    )					->		list[list[int]]:



											"""simple docstring"""




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



				@property
				def 	__magic_name__    (self    )					->		int:



											"""simple docstring"""




											return len(self.rows    )



				@property
				def 	__magic_name__    (self    )					->		int:



											"""simple docstring"""




											return len(self.rows[0]    )



				@property
				def 	__magic_name__    (self    )					->		tuple[int, int]:



											"""simple docstring"""




											return (self.num_rows, self.num_columns)



				@property
				def 	__magic_name__    (self    )					->		bool:



											"""simple docstring"""




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



				def 	__magic_name__    (self    )					->		Matrix:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   [
											    [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(SCREAMING_SNAKE_CASE__    )



				def 	__magic_name__    (self    )					->		int:



											"""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 	__magic_name__    (self    )					->		bool:



											"""simple docstring"""




											return bool(self.determinant()    )



				def 	__magic_name__    (self   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    )					->		int:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       Any           =   [
											    [
											        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(SCREAMING_SNAKE_CASE__    ).determinant()



				def 	__magic_name__    (self   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    )					->		int:



											"""simple docstring"""




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



				def 	__magic_name__    (self    )					->		Matrix:



											"""simple docstring"""




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



				def 	__magic_name__    (self    )					->		Matrix:



											"""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 	__magic_name__    (self    )					->		Matrix:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       List[str]           =   [
											    [self.cofactors().rows[column][row] for column in range(self.num_columns    )]
											    for row in range(self.num_rows    )
											]
											return Matrix(SCREAMING_SNAKE_CASE__    )



				def 	__magic_name__    (self    )					->		Matrix:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   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    )					->		str:



											"""simple docstring"""




											return str(self.rows    )



				def __str__(self    )					->		str:



											"""simple docstring"""




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



				def 	__magic_name__    (self   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__ = None    )					->		None:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       Tuple           =   TypeError("""Row must be a list containing all ints and/or floats"""    )
											if not isinstance(SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    ):
																		raise type_error
											for value in row:
																		if not isinstance(SCREAMING_SNAKE_CASE__   ,       (int, float)    ):
																									raise type_error
											if len(SCREAMING_SNAKE_CASE__    ) != 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(SCREAMING_SNAKE_CASE__    )
											else:
																		SCREAMING_SNAKE_CASE__						:       Any           =   self.rows[0:position] + [row] + self.rows[position:]



				def 	__magic_name__    (self   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__ = None    )					->		None:



											"""simple docstring"""




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



				def __eq__(self   ,       SCREAMING_SNAKE_CASE__    )					->		bool:



											"""simple docstring"""




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



				def __ne__(self   ,       SCREAMING_SNAKE_CASE__    )					->		bool:



											"""simple docstring"""




											return not self == other



				def __neg__(self    )					->		Matrix:



											"""simple docstring"""




											return self * -1



				def __add__(self   ,       SCREAMING_SNAKE_CASE__    )					->		Matrix:



											"""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   ,       SCREAMING_SNAKE_CASE__    )					->		Matrix:



											"""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   ,       SCREAMING_SNAKE_CASE__    )					->		Matrix:



											"""simple docstring"""




											if isinstance(SCREAMING_SNAKE_CASE__   ,       (int, float)    ):
																		return Matrix(
																		    [[int(element * other    ) for element in row] for row in self.rows]    )
											elif isinstance(SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    ):
																		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(SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    ) 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   ,       SCREAMING_SNAKE_CASE__    )					->		Matrix:



											"""simple docstring"""




											if not isinstance(SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    ):
																		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"""    )
											SCREAMING_SNAKE_CASE__						:       Dict           =   self
											for _ in range(other - 1    ):
																		result *= self
											return result



				@classmethod
				def 	__magic_name__    (cls   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    )					->		int:



											"""simple docstring"""




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


if __name__ == "__main__":
					import doctest

					doctest.testmod()






"""simple docstring"""




def lowercase_  (   _snake_case   ,_snake_case						):
							return 1 if input_a == input_a else 0

def lowercase_  (   ):
							assert xnor_gate(0   ,0						) == 1
							assert xnor_gate(0   ,1						) == 0
							assert xnor_gate(1   ,0						) == 0
							assert xnor_gate(1   ,1						) == 1


if __name__ == "__main__":
					print(xnor_gate(0, 0))
					print(xnor_gate(0, 1))
					print(xnor_gate(1, 0))
					print(xnor_gate(1, 1))




