


SCREAMING_SNAKE_CASE       :		Optional[Any]         =				[4, 1, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5]
SCREAMING_SNAKE_CASE       :		str         =				[3, 7, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5]
SCREAMING_SNAKE_CASE       :		int         =				{
    0: "Sunday",
    1: "Monday",
    2: "Tuesday",
    3: "Wednesday",
    4: "Thursday",
    5: "Friday",
    6: "Saturday",
}




def     UpperCamelCase    (      _a       ,		_a       ,		_a		)					->							str:
     '''simple docstring'''





     assert len(str(_a		)		) > 2, "year should be in YYYY format"
     assert 1 <= month <= 1_2, "month should be between 1 to 12"
     assert 1 <= day <= 3_1, "day should be between 1 to 31"

     # Doomsday algorithm:
     lowercase_       :Optional[Any]     =       year // 1_0_0
     lowercase_       :str     =       (5 * (century % 4) + 2) % 7
     lowercase_       :Any     =       year % 1_0_0
     lowercase_       :Optional[int]     =       centurian % 1_2
     lowercase_       :List[Any]     =       (
         (centurian // 1_2) + centurian_m + (centurian_m // 4) + century_anchor
     ) % 7
     lowercase_       :int     =       (
         DOOMSDAY_NOT_LEAP[month - 1]
         if (year % 4 != 0) or (centurian == 0 and (year % 4_0_0) == 0)
         else DOOMSDAY_LEAP[month - 1]
     )
     lowercase_       :Dict     =       (dooms_day + day - day_anchor) % 7
     return WEEK_DAY_NAMES[week_day]


if __name__ == "__main__":
   import doctest

   doctest.testmod()





from math import sqrt

import numpy as np
from sympy import symbols

# Coefficient
# Speed of light (m/s)
SCREAMING_SNAKE_CASE       :		int         =				299_792_458

# Symbols
SCREAMING_SNAKE_CASE     ,		SCREAMING_SNAKE_CASE     ,		SCREAMING_SNAKE_CASE     ,		SCREAMING_SNAKE_CASE       :		Optional[Any]         =				symbols("ct x y z")




def     UpperCamelCase    (      _a		)					->							float:
     '''simple docstring'''





     if velocity > c:
          raise ValueError('''Speed must not exceed light speed 299,792,458 [m/s]!'''		)
     elif velocity < 1:
          # Usually the speed should be much higher than 1 (c order of magnitude)
          raise ValueError('''Speed must be greater than or equal to 1!'''		)

     return velocity / c




def     UpperCamelCase    (      _a		)					->							float:
     '''simple docstring'''





     return 1 / sqrt(1 - beta(_a		) ** 2		)




def     UpperCamelCase    (      _a		)					->							np.ndarray:
     '''simple docstring'''





     return np.array(
         [
             [gamma(_a		), -gamma(_a		) * beta(_a		), 0, 0],
             [-gamma(_a		) * beta(_a		), gamma(_a		), 0, 0],
             [0, 0, 1, 0],
             [0, 0, 0, 1],
         ]		)




def     UpperCamelCase    (      _a       ,		_a = None		)					->							np.ndarray:
     '''simple docstring'''





     if event is None:
          lowercase_       :Optional[int]     =       np.array([ct, x, y, z]		)  # Symbolic four vector
     else:
          event[0] *= c  # x0 is ct (speed of light * time)

     return transformation_matrix(_a		) @ event


if __name__ == "__main__":
   import doctest

   doctest.testmod()

   # Example of symbolic vector:
   SCREAMING_SNAKE_CASE       :		List[str]         =				transform(29_979_245)
   print("Example of four vector: ")
   print(f"ct' = {four_vector[0]}")
   print(f"x' = {four_vector[1]}")
   print(f"y' = {four_vector[2]}")
   print(f"z' = {four_vector[3]}")

   # Substitute symbols with numerical values
   SCREAMING_SNAKE_CASE       :		Optional[int]         =				{ct: c, x: 1, y: 1, z: 1}
   SCREAMING_SNAKE_CASE       :		str         =				[four_vector[i].subs(sub_dict) for i in range(4)]

   print(f"\n{numerical_vector}")

