code: 
  
  
  
  
  
  from __future__ import annotations
  
  from typing import Any
  
  
  def 		_SCREAMING_SNAKE_CASE    (   *lowerCAmelCase__	):
    if all(_check_not_integer(lowerCAmelCase__	) for m in matrix_s	):
      for i in matrix_s[1:]:
        _verify_matrix_sizes(matrix_s[0]       ,lowerCAmelCase__	)
      return [[sum(lowerCAmelCase__	) for t in zip(*lowerCAmelCase__	)] for m in zip(*lowerCAmelCase__	)]
    raise TypeError('Expected a matrix, got int/list instead'	)
  
  
  def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__       ,lowerCAmelCase__	):
    if (
        _check_not_integer(lowerCAmelCase__	)
        and _check_not_integer(lowerCAmelCase__	)
        and _verify_matrix_sizes(lowerCAmelCase__       ,lowerCAmelCase__	)
    ):
      return [[i - j for i, j in zip(*lowerCAmelCase__	)] for m in zip(lowerCAmelCase__       ,lowerCAmelCase__	)]
    raise TypeError('Expected a matrix, got int/list instead'	)
  
  
  def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__       ,lowerCAmelCase__	):
    return [[x * n for x in row] for row in matrix]
  
  
  def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__       ,lowerCAmelCase__	):
    if _check_not_integer(lowerCAmelCase__	) and _check_not_integer(lowerCAmelCase__	):
      lowerCamelCase_  :    Optional[Any]   	=			_verify_matrix_sizes(lowerCAmelCase__       ,lowerCAmelCase__	)
  
    if cols[0] != rows[1]:
      lowerCamelCase_  :    Dict   	=			(
          "Cannot multiply matrix of dimensions "
          F"({rows[0]},{cols[0]}) and ({rows[1]},{cols[1]})"
      )
      raise ValueError(lowerCAmelCase__	)
    return [
        [sum(m * n for m, n in zip(lowerCAmelCase__       ,lowerCAmelCase__	)	) for j in zip(*lowerCAmelCase__	)] for i in matrix_a
    ]
  
  
  def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__	):
    lowerCamelCase_  :    List[Any]   	=			int(lowerCAmelCase__	)
    return [[int(row == column	) for column in range(lowerCAmelCase__	)] for row in range(lowerCAmelCase__	)]
  
  
  def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__       ,lowerCAmelCase__ = True	):
    if _check_not_integer(lowerCAmelCase__	):
      if return_map:
        return map(lowerCAmelCase__       ,zip(*lowerCAmelCase__	)	)
      else:
        return list(map(lowerCAmelCase__       ,zip(*lowerCAmelCase__	)	)	)
    raise TypeError('Expected a matrix, got int/list instead'	)
  
  
  def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__	):
    lowerCamelCase_  :    Optional[Any]   	=			matrix[:row] + matrix[row + 1 :]
    return [row[:column] + row[column + 1 :] for row in minor]
  
  
  def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__	):
    if len(lowerCAmelCase__	) == 1:
      return matrix[0][0]
  
    return sum(
        x * determinant(minor(lowerCAmelCase__       ,0       ,lowerCAmelCase__	)	) * (-1) ** i
        for i, x in enumerate(matrix[0]	)	)
  
  
  def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__	):
    lowerCamelCase_  :    Any   	=			determinant(lowerCAmelCase__	)
    if det == 0:
      return None
  
    lowerCamelCase_  :    Any   	=			[
        [determinant(minor(lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__	)	) for j in range(len(lowerCAmelCase__	)	)]
        for i in range(len(lowerCAmelCase__	)	)
    ]
  
    lowerCamelCase_  :    Optional[int]   	=			[
        [x * (-1) ** (row + col) for col, x in enumerate(matrix_minor[row]	)]
        for row in range(len(lowerCAmelCase__	)	)
    ]
    lowerCamelCase_  :    Union[str, Any]   	=			list(transpose(lowerCAmelCase__	)	)
    return scalar_multiply(lowerCAmelCase__       ,1 / det	)
  
  
  def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__	):
    return not isinstance(lowerCAmelCase__       ,lowerCAmelCase__	) and not isinstance(matrix[0]       ,lowerCAmelCase__	)
  
  
  def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__	):
    return len(lowerCAmelCase__	), len(matrix[0]	)
  
  
  def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__       ,lowerCAmelCase__	):
    lowerCamelCase_  :    str   	=			_shape(lowerCAmelCase__	) + _shape(lowerCAmelCase__	)
    if shape[0] != shape[3] or shape[1] != shape[2]:
      lowerCamelCase_  :    str   	=			(
          "operands could not be broadcast together with shape "
          F"({shape[0], shape[1]}), ({shape[2], shape[3]})"
      )
      raise ValueError(lowerCAmelCase__	)
    return (shape[0], shape[2]), (shape[1], shape[3])
  
  
  def 		_SCREAMING_SNAKE_CASE    (   ):
    lowerCamelCase_  :    Optional[int]   	=			[[12, 10], [3, 9]]
    lowerCamelCase_  :    List[str]   	=			[[3, 4], [7, 4]]
    lowerCamelCase_  :    int   	=			[[11, 12, 13, 14], [21, 22, 23, 24], [31, 32, 33, 34], [41, 42, 43, 44]]
    lowerCamelCase_  :    Union[str, Any]   	=			[[3, 0, 2], [2, 0, -2], [0, 1, 1]]
    print(F"Add Operation, {add(lowerCAmelCase__       ,lowerCAmelCase__	) = } \n"	)
    print(
        F"Multiply Operation, {multiply(lowerCAmelCase__       ,lowerCAmelCase__	) = } \n"       ,)
    print(F"Identity: {identity(5	)}\n"	)
    print(F"Minor of {matrix_c} = {minor(lowerCAmelCase__       ,1       ,2	)} \n"	)
    print(F"Determinant of {matrix_b} = {determinant(lowerCAmelCase__	)} \n"	)
    print(F"Inverse of {matrix_d} = {inverse(lowerCAmelCase__	)}\n"	)
  
  
  if __name__ == "__main__":
    import doctest
  
    doctest.testmod()
    main()
  
style_context: 
  
  
  
  
  
  import os
  import unittest
  
  import pytest
  from parameterized import parameterized
  
  from transformers.testing_utils import require_torch, require_torch_gpu, slow, torch_device
  
  
  # skipping in unittest tests
  
  _lowercase		:     Optional[Any] 					=[(1,)]
  
  
  def 		_SCREAMING_SNAKE_CASE    (   ):
  		lowerCamelCase_  :    Union[str, Any]   	=			bool(os.getenv('RUN_SLOW'       ,0	)	)
  		if run_slow:
  				assert True
  		else:
  				assert False, "should have been skipped"
  
  
  def 		_SCREAMING_SNAKE_CASE    (   ):
  		lowerCamelCase_  :    List[str]   	=			bool(os.getenv('RUN_SLOW'       ,0	)	)
  		if run_slow and torch_device == "cuda":
  				assert True
  		else:
  				assert False, "should have been skipped"
  
  
  
  
  
  
  @require_torch
  class 	UpperCamelCase_     (     unittest.TestCase       ):
  
  
  
  					@slow
  					@require_torch_gpu
  					def      __a    (		self    :    Tuple	):
  							check_slow_torch_cuda()
  
  
  
  					@require_torch_gpu
  					@slow
  					def      __a    (		self    :    Optional[int]	):
  							check_slow_torch_cuda()
  
  
  
  
  
  					@parameterized.expand(lowerCamelCase	)
  					@slow
  					def      __a    (		self    :    List[str]					,			lowerCamelCase    :    Optional[Any]=None	):
  							check_slow()
  
  
  @slow
  @require_torch_gpu
  def 		_SCREAMING_SNAKE_CASE    (   ):
  		check_slow_torch_cuda()
  
  
  @require_torch_gpu
  @slow
  def 		_SCREAMING_SNAKE_CASE    (   ):
  		check_slow_torch_cuda()
  
  
  @slow
  @pytest.mark.parametrize('param'       ,[1]	)
  def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__	):
  		check_slow()
  
  
  
  
  
  @pytest.mark.parametrize('param'       ,[1]	)
  @slow
  def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__	):
  		check_slow()
  