


"""simple docstring"""
from __future__ import annotations



class 			_UpperCAmelCase :






		'''simple docstring'''

		def __init__(self				,       a_					):





			'''simple docstring'''

			__snake_case	:						List[Any]						=				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:
				__snake_case	:						List[Any]						=				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
				__snake_case	:						List[Any]						=				rows
			else:
				__snake_case	:						int						=				[]



		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

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



		@property
		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			return len(self.rows					)



		@property
		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			return len(self.rows[0]					)



		@property
		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			return (self.num_rows, self.num_columns)



		@property
		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

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



		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			__snake_case	:						Any						=				[
			    [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 				SCREAMING_SNAKE_CASE  (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 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			return bool(self.determinant()					)



		def 				SCREAMING_SNAKE_CASE  (self				,       a_				,       a_					):





			'''simple docstring'''

			__snake_case	:						Optional[int]						=				[
			    [
			        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 				SCREAMING_SNAKE_CASE  (self				,       a_				,       a_					):





			'''simple docstring'''

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



		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

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



		def 				SCREAMING_SNAKE_CASE  (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 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			__snake_case	:						Dict						=				[
			    [self.cofactors().rows[column][row] for column in range(self.num_columns					)]
			    for row in range(self.num_rows					)
			]
			return Matrix(a_					)



		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			__snake_case	:						str						=				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(a_					) for value in row]					) + '''.]'''
			            for row in self.rows
			        ]					)
			    + "]"
			)



		def 				SCREAMING_SNAKE_CASE  (self				,       a_				,       a_ = None					):





			'''simple docstring'''

			__snake_case	:						List[str]						=				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:
				__snake_case	:						List[Any]						=				self.rows[0:position] + [row] + self.rows[position:]



		def 				SCREAMING_SNAKE_CASE  (self				,       a_				,       a_ = None					):





			'''simple docstring'''

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



		def __eq__(self				,       a_					):





			'''simple docstring'''

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



		def __ne__(self				,       a_					):





			'''simple docstring'''

			return not self == other



		def __neg__(self					):





			'''simple docstring'''

			return self * -1



		def __add__(self				,       a_					):





			'''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				,       a_					):





			'''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				,       a_					):





			'''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				,       a_					):





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



		@classmethod
		def 				SCREAMING_SNAKE_CASE  (cls				,       a_				,       a_					):





			'''simple docstring'''

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


if __name__ == "__main__":
			import doctest

			doctest.testmod()









"""simple docstring"""
# this script reports modified .py files under the desired list of top-level sub-dirs passed as a list of arguments, e.g.:
#   python ./utils/get_modified_files.py utils src tests examples
#
# it uses git to find the forking point and which files were modified - i.e. files not under git won't be considered
# since the output of this script is fed into Makefile commands it doesn't print a newline after the results

import re
import subprocess
import sys


SCREAMING_SNAKE_CASE :    Union[str, Any]									=				subprocess.check_output("""git merge-base main HEAD""".split()).decode("""utf-8""")
SCREAMING_SNAKE_CASE :    Any									=				subprocess.check_output(F'git diff --name-only {fork_point_sha}'.split()).decode("""utf-8""").split()

SCREAMING_SNAKE_CASE :    Union[str, Any]									=				"""|""".join(sys.argv[1:])
SCREAMING_SNAKE_CASE :    int									=				re.compile(rF'^({joined_dirs}).*?\.py$')

SCREAMING_SNAKE_CASE :    str									=				[x for x in modified_files if regex.match(x)]
print(""" """.join(relevant_modified_files), end="""""")





