


from __future__ import annotations







class 							UpperCamelCase__ :

					def __init__(  self							: Union[str, Any]				,       UpperCamelCase__							: List[str]							):






										'''simple docstring'''






										lowercase_					=      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:
															lowercase_					=      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
															lowercase_					=      rows
										else:
															lowercase_					=      []

					def 	UpperCAmelCase__							(  self							: Optional[Any]							):






										'''simple docstring'''






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

					@property
					def 	UpperCAmelCase__							(  self							: str							):






										'''simple docstring'''






										return len(self.rows							)

					@property
					def 	UpperCAmelCase__							(  self							: int							):






										'''simple docstring'''






										return len(self.rows[0]							)

					@property
					def 	UpperCAmelCase__							(  self							: int							):






										'''simple docstring'''






										return (self.num_rows, self.num_columns)

					@property
					def 	UpperCAmelCase__							(  self							: Optional[Any]							):






										'''simple docstring'''






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

					def 	UpperCAmelCase__							(  self							: List[Any]							):






										'''simple docstring'''






										lowercase_					=      [
										    [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							: List[Any]							):






										'''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							: Optional[int]							):






										'''simple docstring'''






										return bool(self.determinant()							)

					def 	UpperCAmelCase__							(  self							: Dict				,       UpperCamelCase__							: Tuple				,       UpperCamelCase__							: List[Any]							):






										'''simple docstring'''






										lowercase_					=      [
										    [
										        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							: Dict				,       UpperCamelCase__							: Optional[Any]				,       UpperCamelCase__							: str							):






										'''simple docstring'''






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

					def 	UpperCAmelCase__							(  self							: Optional[Any]							):






										'''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							: Optional[int]							):






										'''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							: List[str]							):






										'''simple docstring'''






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






										'''simple docstring'''






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






										'''simple docstring'''






										return str(self.rows							)

					def __str__(  self							: List[Any]							):






										'''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							: Tuple				,       UpperCamelCase__							: Union[str, Any]				,       UpperCamelCase__							: Optional[Any] = None							):






										'''simple docstring'''






										lowercase_					=      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:
															lowercase_					=      self.rows[0:position] + [row] + self.rows[position:]

					def 	UpperCAmelCase__							(  self							: Optional[Any]				,       UpperCamelCase__							: Optional[int]				,       UpperCamelCase__							: Dict = None							):






										'''simple docstring'''






										lowercase_					=      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:
															lowercase_					=      [self.rows[i] + [column[i]] for i in range(self.num_rows							)]
										else:
															lowercase_					=      [
															    self.rows[i][0:position] + [column[i]] + self.rows[i][position:]
															    for i in range(self.num_rows							)
															]

					def __eq__(  self							: str				,       UpperCamelCase__							: Any							):






										'''simple docstring'''






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

					def __ne__(  self							: List[str]				,       UpperCamelCase__							: Tuple							):






										'''simple docstring'''






										return not self == other

					def __neg__(  self							: Union[str, Any]							):






										'''simple docstring'''






										return self * -1

					def __add__(  self							: Optional[Any]				,       UpperCamelCase__							: int							):






										'''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							: int				,       UpperCamelCase__							: Union[str, Any]							):






										'''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							: Union[str, Any]				,       UpperCamelCase__							: List[str]							):






										'''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							: Any				,       UpperCamelCase__							: str							):






										'''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"""							)
										lowercase_					=      self
										for _ in range(other - 1							):
															result *= self
										return result







					@classmethod
					def 	UpperCAmelCase__							(  cls							: int				,       UpperCamelCase__							: List[str]				,       UpperCamelCase__							: Optional[Any]							):






										'''simple docstring'''






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


if __name__ == "__main__":
							import doctest

							doctest.testmod()










'''simple docstring'''

from ...utils import (
    OptionalDependencyNotAvailable,
    is_flax_available,
    is_torch_available,
    is_transformers_available,
)


try:
      if not (is_transformers_available() and is_torch_available()):
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      from ...utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
      from .multicontrolnet import MultiControlNetModel
      from .pipeline_controlnet import StableDiffusionControlNetPipeline
      from .pipeline_controlnet_imgaimg import StableDiffusionControlNetImgaImgPipeline
      from .pipeline_controlnet_inpaint import StableDiffusionControlNetInpaintPipeline


if is_transformers_available() and is_flax_available():
      from .pipeline_flax_controlnet import FlaxStableDiffusionControlNetPipeline






