


from __future__ import annotations

import numpy as np
from numpy import floataa
from numpy.typing import NDArray



def       _lowerCAmelCase    (				lowerCAmelCase_				:NDArray[floataa]		,    lowerCAmelCase_				:NDArray[floataa]		,    lowerCAmelCase_				:list[int]		,    lowerCAmelCase_				:int		,    )->list[float]:
   '''simple docstring'''






   snake_case_     ,     snake_case_            =       coefficient_matrix.shape
   snake_case_     ,     snake_case_            =       constant_matrix.shape

   if rowsa != colsa:
      snake_case_            =       F'''Coefficient matrix dimensions must be nxn but received {rowsa}x{colsa}'''
      raise ValueError(lowerCAmelCase_				)

   if colsa != 1:
      snake_case_            =       F'''Constant matrix must be nx1 but received {rowsa}x{colsa}'''
      raise ValueError(lowerCAmelCase_				)

   if rowsa != rowsa:
      snake_case_            =       (
          "Coefficient and constant matrices dimensions must be nxn and nx1 but "
          F'''received {rowsa}x{colsa} and {rowsa}x{colsa}'''
      )
      raise ValueError(lowerCAmelCase_				)

   if len(lowerCAmelCase_				) != rowsa:
      snake_case_            =       (
          "Number of initial values must be equal to number of rows in coefficient "
          F'''matrix but received {len(lowerCAmelCase_				)} and {rowsa}'''
      )
      raise ValueError(lowerCAmelCase_				)

   if iterations <= 0:
      raise ValueError("Iterations must be at least 1"				)

   snake_case_            =       np.concatenate(
       (coefficient_matrix, constant_matrix)		,    axis=1				)

   snake_case_     ,     snake_case_            =       table.shape

   strictly_diagonally_dominant(lowerCAmelCase_				)

   # Iterates the whole matrix for given number of times
   for _ in range(lowerCAmelCase_				):
      snake_case_            =       []
      for row in range(lowerCAmelCase_				):
         snake_case_            =       0
         for col in range(lowerCAmelCase_				):
            if col == row:
               snake_case_            =       table[row][col]
            elif col == cols - 1:
               snake_case_            =       table[row][col]
            else:
               temp += (-1) * table[row][col] * init_val[col]
         snake_case_            =       (temp + val) / denom
         new_val.append(lowerCAmelCase_				)
      snake_case_            =       new_val

   return [float(lowerCAmelCase_				) for i in new_val]



def       _lowerCAmelCase    (				lowerCAmelCase_				:NDArray[floataa]				)->bool:
   '''simple docstring'''






   snake_case_     ,     snake_case_            =       table.shape

   snake_case_            =       True

   for i in range(0		,    lowerCAmelCase_				):
      snake_case_            =       0
      for j in range(0		,    cols - 1				):
         if i == j:
            continue
         else:
            total += table[i][j]

      if table[i][i] <= total:
         raise ValueError("Coefficient matrix is not strictly diagonally dominant"				)

   return is_diagonally_dominant


# Test Cases
if __name__ == "__main__":
   import doctest

   doctest.testmod()








def       _lowerCAmelCase    (				lowerCAmelCase_				:int		,    lowerCAmelCase_				:int				)->int:
   '''simple docstring'''






   return int((input_a, input_a).count(0				) == 0				)



def       _lowerCAmelCase    (				)->None:
   '''simple docstring'''






   assert and_gate(0		,    0				) == 0
   assert and_gate(0		,    1				) == 0
   assert and_gate(1		,    0				) == 0
   assert and_gate(1		,    1				) == 1


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




