






from __future__ import annotations


class    __lowercase   :







     '''simple docstring'''




     def __init__(					self							:      Dict			,						UpperCamelCase_							:      Any					):


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




     def 		lowerCAmelCase_  (					self							:      List[Any]					):


         """simple docstring"""



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




     @property
     def 		lowerCAmelCase_  (					self							:      str					):


         """simple docstring"""



         return len(self.rows					)




     @property
     def 		lowerCAmelCase_  (					self							:      Tuple					):


         """simple docstring"""



         return len(self.rows[0]					)




     @property
     def 		lowerCAmelCase_  (					self							:      str					):


         """simple docstring"""



         return (self.num_rows, self.num_columns)




     @property
     def 		lowerCAmelCase_  (					self							:      Tuple					):


         """simple docstring"""



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




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


         """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(a__					)




     def 		lowerCAmelCase_  (					self							:      str					):


         """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 		lowerCAmelCase_  (					self							:      Dict					):


         """simple docstring"""



         return bool(self.determinant()					)




     def 		lowerCAmelCase_  (					self							:      Union[str, Any]			,						UpperCamelCase_							:      Any			,						UpperCamelCase_							:      Dict					):


         """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(a__					).determinant()




     def 		lowerCAmelCase_  (					self							:      Dict			,						UpperCamelCase_							:      Optional[int]			,						UpperCamelCase_							:      Any					):


         """simple docstring"""



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




     def 		lowerCAmelCase_  (					self							:      List[str]					):


         """simple docstring"""



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




     def 		lowerCAmelCase_  (					self							:      str					):


         """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 		lowerCAmelCase_  (					self							:      List[str]					):


         """simple docstring"""



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




     def 		lowerCAmelCase_  (					self							:      int					):


         """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							:      Tuple					):


         """simple docstring"""



         return str(self.rows					)




     def __str__(					self							:      int					):


         """simple docstring"""



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




     def 		lowerCAmelCase_  (					self							:      List[Any]			,						UpperCamelCase_							:      List[Any]			,						UpperCamelCase_							:      Optional[Any] = None					):


         """simple docstring"""



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




     def 		lowerCAmelCase_  (					self							:      str			,						UpperCamelCase_							:      Any			,						UpperCamelCase_							:      int = None					):


         """simple docstring"""



         __A       =						TypeError(
             """Column must be a list containing all ints and/or floats"""					)
         if not isinstance(a__			,						a__					):
             raise type_error
         for value in column:
             if not isinstance(a__			,						(int, float)					):
                 raise type_error
         if len(a__					) != 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							:      Dict			,						UpperCamelCase_							:      Optional[Any]					):


         """simple docstring"""



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




     def __ne__(					self							:      Tuple			,						UpperCamelCase_							:      Dict					):


         """simple docstring"""



         return not self == other




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


         """simple docstring"""



         return self * -1




     def __add__(					self							:      List[str]			,						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							:      List[str]			,						UpperCamelCase_							:      str					):


         """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							:      List[Any]			,						UpperCamelCase_							:      Any					):


         """simple docstring"""



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


         """simple docstring"""



         if not isinstance(a__			,						a__					):
             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 		lowerCAmelCase_  (					cls							:      Dict			,						UpperCamelCase_							:      int			,						UpperCamelCase_							:      Optional[int]					):


         """simple docstring"""



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


if __name__ == "__main__":
  import doctest

  doctest.testmod()









from typing import TYPE_CHECKING

from ....utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_lowercase    	=		{
    "configuration_mctct": ["MCTCT_PRETRAINED_CONFIG_ARCHIVE_MAP", "MCTCTConfig"],
    "feature_extraction_mctct": ["MCTCTFeatureExtractor"],
    "processing_mctct": ["MCTCTProcessor"],
}


try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _lowercase    	=		[
       "MCTCT_PRETRAINED_MODEL_ARCHIVE_LIST",
       "MCTCTForCTC",
       "MCTCTModel",
       "MCTCTPreTrainedModel",
   ]


if TYPE_CHECKING:
   from .configuration_mctct import MCTCT_PRETRAINED_CONFIG_ARCHIVE_MAP, MCTCTConfig
   from .feature_extraction_mctct import MCTCTFeatureExtractor
   from .processing_mctct import MCTCTProcessor

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_mctct import MCTCT_PRETRAINED_MODEL_ARCHIVE_LIST, MCTCTForCTC, MCTCTModel, MCTCTPreTrainedModel

else:
   import sys

   _lowercase    	=		_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
