



"""simple docstring"""

from __future__ import annotations

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




def __lowercase			(							_a		,			_a		,			_a		,			_a		,			):
    snake_case_,	snake_case_ :     int				=	coefficient_matrix.shape
    snake_case_,	snake_case_ :     Tuple				=	constant_matrix.shape

    if rowsa != colsa:
        snake_case_ :     str				=	f"Coefficient matrix dimensions must be nxn but received {rowsa}x{colsa}"
        raise ValueError(_a    )

    if colsa != 1:
        snake_case_ :     str				=	f"Constant matrix must be nx1 but received {rowsa}x{colsa}"
        raise ValueError(_a    )

    if rowsa != rowsa:
        snake_case_ :     List[str]				=	(
            '''Coefficient and constant matrices dimensions must be nxn and nx1 but '''
            f"received {rowsa}x{colsa} and {rowsa}x{colsa}"
        )
        raise ValueError(_a    )

    if len(_a    ) != rowsa:
        snake_case_ :     List[str]				=	(
            '''Number of initial values must be equal to number of rows in coefficient '''
            f"matrix but received {len(_a    )} and {rowsa}"
        )
        raise ValueError(_a    )

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

    snake_case_ :     NDArray[floataa]				=	np.concatenate(
        (coefficient_matrix, constant_matrix)		,			axis=1    )

    snake_case_,	snake_case_ :     int				=	table.shape

    strictly_diagonally_dominant(_a    )

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

    return [float(_a    ) for i in new_val]




def __lowercase			(							_a    ):
    snake_case_,	snake_case_ :     Union[str, Any]				=	table.shape

    snake_case_ :     Union[str, Any]				=	True

    for i in range(0		,			_a    ):
        snake_case_ :     Optional[int]				=	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()










"""simple docstring"""

from functools import lru_cache




@lru_cache
def __lowercase			(							_a    ):
    if num < 0:
        raise ValueError('''Number should not be negative.'''    )

    return 1 if num in (0, 1) else num * factorial(num - 1    )


if __name__ == "__main__":
     import doctest

     doctest.testmod()





