





from __future__ import annotations

from collections import deque

class    _UpperCAmelCase							:
      def __init__(		self      ,       a__       ):
         A_     :				list[dict]			      =	[]
         self.adlist.append(
             {"""value""": """""", """next_states""": [], """fail_state""": 0, """output""": []}       )

         for keyword in keywords:
            self.add_keyword(a__       )
         self.set_fail_transitions()
      def 		_lowerCamelCase      (		self      ,       a__      ,       a__       ):
         for state in self.adlist[current_state]["next_states"]:
            if char == self.adlist[state]["value"]:
               return state
         return None
      def 		_lowerCamelCase      (		self      ,       a__       ):
         A_     :				Union[str, Any]			      =	0
         for character in keyword:
            A_     :				Optional[Any]			      =	self.find_next_state(a__      ,       a__       )
            if next_state is None:
               self.adlist.append(
                   {
                       """value""": character,
                       """next_states""": [],
                       """fail_state""": 0,
                       """output""": [],
                   }       )
               self.adlist[current_state]["next_states"].append(len(self.adlist       ) - 1       )
               A_     :				Any			      =	len(self.adlist       ) - 1
            else:
               A_     :				Tuple			      =	next_state
         self.adlist[current_state]["output"].append(a__       )
      def 		_lowerCamelCase      (		self       ):
         A_     :				deque			      =	deque()
         for node in self.adlist[0]["next_states"]:
            q.append(a__       )
            A_     :				Tuple			      =	0
         while q:
            A_     :				Any			      =	q.popleft()
            for child in self.adlist[r]["next_states"]:
               q.append(a__       )
               A_     :				Any			      =	self.adlist[r]["""fail_state"""]
               while (
                   self.find_next_state(a__      ,       self.adlist[child]["""value"""]       ) is None
                   and state != 0
               ):
                  A_     :				int			      =	self.adlist[state]["""fail_state"""]
               A_     :				List[Any]			      =	self.find_next_state(
                   a__      ,       self.adlist[child]["""value"""]       )
               if self.adlist[child]["fail_state"] is None:
                  A_     :				List[str]			      =	0
               A_     :				List[str]			      =	(
                   self.adlist[child]["""output"""]
                   + self.adlist[self.adlist[child]["""fail_state"""]]["""output"""]
               )






      def 		_lowerCamelCase      (		self      ,       a__       ):
         A_     :				dict			      =	{}  # returns a dict with keywords and list of its occurrences
         A_     :				List[Any]			      =	0
         for i in range(len(a__       )       ):
            while (
                self.find_next_state(a__      ,       string[i]       ) is None
                and current_state != 0
            ):
               A_     :				Union[str, Any]			      =	self.adlist[current_state]["""fail_state"""]
            A_     :				Dict			      =	self.find_next_state(a__      ,       string[i]       )
            if next_state is None:
               A_     :				int			      =	0
            else:
               A_     :				List[Any]			      =	next_state
               for key in self.adlist[current_state]["output"]:
                  if key not in result:
                     A_     :				Tuple			      =	[]
                  result[key].append(i - len(a__       ) + 1       )
         return result


if __name__ == "__main__":
      import doctest

      doctest.testmod()













from __future__ import annotations

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



def     _lowerCAmelCase		(  _lowerCAmelCase  ,_lowerCAmelCase  ,_lowerCAmelCase  ,_lowerCAmelCase  ,):
   '''simple docstring'''


   A_      ,				A_     :				int			      =	coefficient_matrix.shape
   A_      ,				A_     :				Tuple			      =	constant_matrix.shape

   if rowsa != colsa:
      A_     :				int			      =	f"""Coefficient matrix dimensions must be nxn but received {rowsa}x{colsa}"""
      raise ValueError(_lowerCAmelCase     )

   if colsa != 1:
      A_     :				List[Any]			      =	f"""Constant matrix must be nx1 but received {rowsa}x{colsa}"""
      raise ValueError(_lowerCAmelCase     )

   if rowsa != rowsa:
      A_     :				str			      =	(
          """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:
      A_     :				Any			      =	(
          """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"""     )

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

   A_      ,				A_     :				str			      =	table.shape

   strictly_diagonally_dominant(_lowerCAmelCase     )

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

   return [float(_lowerCAmelCase     ) for i in new_val]



def     _lowerCAmelCase		(  _lowerCAmelCase     ):
   '''simple docstring'''


   A_      ,				A_     :				str			      =	table.shape

   A_     :				Any			      =	True

   for i in range(0  ,_lowerCAmelCase     ):
      A_     :				Optional[Any]			      =	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()






