
import unittest

import numpy as np







def 						_snake_case(  SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ = None ,     )			->   np.ndarray:
       lowercase							:					List[Any]	     =				np.shape(a__    )
       lowercase							:					str	     =				np.shape(a__    )
       lowercase							:					Union[str, Any]	     =				np.shape(a__    )

       if shape_a[0] != shape_b[0]:
              lowercase							:					Union[str, Any]	     =				(
                  """Expected the same number of rows for A and B. """
                  f"Instead found A of size {shape_a} and B of size {shape_b}"
              )
              raise ValueError(a__    )

       if shape_b[1] != shape_c[1]:
              lowercase							:					List[Any]	     =				(
                  """Expected the same number of columns for B and C. """
                  f"Instead found B of size {shape_b} and C of size {shape_c}"
              )
              raise ValueError(a__    )

       lowercase							:					Dict	     =				pseudo_inv
       if a_inv is None:
              try:
                     lowercase							:					Union[str, Any]	     =				np.linalg.inv(a__    )
              except np.linalg.LinAlgError:
                     raise ValueError(
                         """Input matrix A is not invertible. Cannot compute Schur complement."""    )

       return mat_c - mat_b.T @ a_inv @ mat_b

class __snake_case		(				unittest.TestCase					):
    def 				_SCREAMING_SNAKE_CASE	(  self				):



           '''simple docstring'''







           lowercase							:					Union[str, Any]	     =				np.array([[1, 2, 1], [2, 1, 2], [3, 2, 4]]				)
           lowercase							:					Optional[Any]	     =				np.array([[0, 3], [3, 0], [2, 3]]				)
           lowercase							:					Union[str, Any]	     =				np.array([[2, 1], [6, 3]]				)

           lowercase							:					str	     =				schur_complement(lowercase_		,lowercase_		,lowercase_				)

           lowercase							:					List[Any]	     =				np.block([[a, b], [b.T, c]]				)

           lowercase							:					Union[str, Any]	     =				np.linalg.det(lowercase_				)
           lowercase							:					int	     =				np.linalg.det(lowercase_				)
           lowercase							:					Union[str, Any]	     =				np.linalg.det(lowercase_				)

           self.assertAlmostEqual(lowercase_		,det_a * det_s				)
    def 				_SCREAMING_SNAKE_CASE	(  self				):



           '''simple docstring'''







           lowercase							:					Any	     =				np.array([[1, 2, 1], [2, 1, 2], [3, 2, 4]]				)
           lowercase							:					List[Any]	     =				np.array([[0, 3], [3, 0], [2, 3]]				)
           lowercase							:					Optional[int]	     =				np.array([[2, 1], [6, 3]]				)

           with self.assertRaises(lowercase_				):
                  schur_complement(lowercase_		,lowercase_		,lowercase_				)
    def 				_SCREAMING_SNAKE_CASE	(  self				):



           '''simple docstring'''







           lowercase							:					str	     =				np.array([[1, 2, 1], [2, 1, 2], [3, 2, 4]]				)
           lowercase							:					Any	     =				np.array([[0, 3], [3, 0], [2, 3]]				)
           lowercase							:					int	     =				np.array([[2, 1, 3], [6, 3, 5]]				)

           with self.assertRaises(lowercase_				):
                  schur_complement(lowercase_		,lowercase_		,lowercase_				)


if __name__ == "__main__":
  import doctest

  doctest.testmod()
  unittest.main()


import math
from datetime import datetime, timedelta







def 						_snake_case(  SCREAMING_SNAKE_CASE__    )			->   datetime:
       lowercase							:					Any	     =				year % 19
       lowercase							:					Optional[int]	     =				year % 4
       lowercase							:					Any	     =				year % 7
       lowercase							:					str	     =				math.floor(year / 100    )
       lowercase							:					List[str]	     =				math.floor((13 + 8 * leap_day_inhibits) / 25    )
       lowercase							:					Tuple	     =				leap_day_inhibits / 4
       lowercase							:					Any	     =				(
           15 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
       ) % 30
       lowercase							:					Union[str, Any]	     =				(4 + leap_day_inhibits - leap_day_reinstall_number) % 7

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

       # PHM -> Paschal Full Moon
       lowercase							:					List[Any]	     =				(
           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(SCREAMING_SNAKE_CASE__ ,     4 ,     19    )
       elif days_to_add == 28 and days_from_phm_to_sunday == 6:
              return datetime(SCREAMING_SNAKE_CASE__ ,     4 ,     18    )
       else:
              return datetime(SCREAMING_SNAKE_CASE__ ,     3 ,     22    ) + timedelta(
                  days=int(days_to_add + days_from_phm_to_sunday    )    )


if __name__ == "__main__":
  for year in (1994, 2000, 2010, 2021, 2023):
    lowercase  : List[str]						   =							"""will be""" if year > datetime.now().year else """was"""
    print(F'''Easter in {year} {tense} {gauss_easter(year)}''')
