
from math import sqrt

import numpy as np
from sympy import symbols

# Coefficient
# Speed of light (m/s)
_snake_case      :							str     	=    2_99_79_24_58

# Symbols
_snake_case	,       _snake_case	,       _snake_case	,       _snake_case      :							List[str]     	=    symbols("ct x y z")

def  __snake_case							(	__magic_name__						):







				'''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  __snake_case							(	__magic_name__						):







				'''simple docstring'''


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

def  __snake_case							(	__magic_name__						):







				'''simple docstring'''


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

def  __snake_case							(	__magic_name__		,    __magic_name__ = None						):







				'''simple docstring'''


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

				return transformation_matrix(__magic_name__						) @ event


if __name__ == "__main__":
						import doctest

						doctest.testmod()

						# Example of symbolic vector:
						_snake_case      :							int     	=    transform(29_97_92_45)
						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
						_snake_case      :							Tuple     	=    {ct: c, x: 1, y: 1, z: 1}
						_snake_case      :							List[str]     	=    [four_vector[i].subs(sub_dict) for i in range(4)]

						print(F"\n{numerical_vector}")


from __future__ import annotations

def  __snake_case							(	__magic_name__						):







				'''simple docstring'''


				if len(__magic_name__						) == 0:
								return []
				lowercase     ,	lowercase         =      min(__magic_name__						), max(__magic_name__						)
				lowercase         =      int(max_value - min_value						) + 1
				lowercase         =      [[] for _ in range(__magic_name__						)]

				for i in my_list:
								buckets[int(i - min_value						)].append(__magic_name__						)

				return [v for bucket in buckets for v in sorted(__magic_name__						)]


if __name__ == "__main__":
						from doctest import testmod

						testmod()
						assert bucket_sort([4, 5, 3, 2, 1]) == [1, 2, 3, 4, 5]
						assert bucket_sort([0, 1, -10, 15, 2, -2]) == [-10, -2, 0, 1, 2, 15]
