



from __future__ import annotations

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



def 			__a	(       lowerCAmelCase_  :   Tuple     ,lowerCAmelCase_  :   Optional[Any]     ,lowerCAmelCase_  :   Any     ,lowerCAmelCase_  :   int     ,) ->					Optional[Any]:






						'''simple docstring'''



						UpperCAmelCase_,  UpperCAmelCase_=  coefficient_matrix.shape
						UpperCAmelCase_,  UpperCAmelCase_=  constant_matrix.shape

						if rowsa != colsa:
												UpperCAmelCase_=  F"""Coefficient matrix dimensions must be nxn but received {rowsa}x{colsa}"""
												raise ValueError(lowerCamelCase__							)

						if colsa != 1:
												UpperCAmelCase_=  F"""Constant matrix must be nx1 but received {rowsa}x{colsa}"""
												raise ValueError(lowerCamelCase__							)

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

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

						UpperCAmelCase_,  UpperCAmelCase_=  table.shape

						strictly_diagonally_dominant(lowerCamelCase__							)

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

						return [float(lowerCamelCase__							) for i in new_val]



def 			__a	(       lowerCAmelCase_  :   Any							) ->					Optional[Any]:






						'''simple docstring'''



						UpperCAmelCase_,  UpperCAmelCase_=  table.shape

						UpperCAmelCase_=  True

						for i in range(0     ,lowerCamelCase__							):
												UpperCAmelCase_=  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"""




import math
from datetime import datetime, timedelta







def 				_UpperCAmelCase		(							lowerCamelCase__  ):





		"""simple docstring"""




		lowerCAmelCase__   = year % 19
		lowerCAmelCase__   = year % 4
		lowerCAmelCase__   = year % 7
		lowerCAmelCase__   = math.floor(year / 100  )
		lowerCAmelCase__   = math.floor((13 + 8 * leap_day_inhibits) / 25  )
		lowerCAmelCase__   = leap_day_inhibits / 4
		lowerCAmelCase__   = (
		    15 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
		) % 30
		lowerCAmelCase__   = (4 + leap_day_inhibits - leap_day_reinstall_number) % 7

		# days to be added to March 21
		lowerCAmelCase__   = (19 * metonic_cycle + secular_moon_shift) % 30

		# PHM -> Paschal Full Moon
		lowerCAmelCase__   = (
		    2 * julian_leap_year
		    + 4 * non_leap_year
		    + 6 * days_to_add
		    + century_starting_point
		) % 7

		if days_to_add == 29 and days_from_phm_to_sunday == 6:
				return datetime(lowerCamelCase__      ,	4      ,	19  )
		elif days_to_add == 28 and days_from_phm_to_sunday == 6:
				return datetime(lowerCamelCase__      ,	4      ,	18  )
		else:
				return datetime(lowerCamelCase__      ,	3      ,	22  ) + timedelta(
				    days=int(days_to_add + days_from_phm_to_sunday  )  )


if __name__ == "__main__":
			for year in (19_94, 20_00, 20_10, 20_21, 20_23):
						__lowerCAmelCase     :				List[str]    				=    "will be" if year > datetime.now().year else "was"
						print(F"Easter in {year} {tense} {gauss_easter(year)}")




