"""simple docstring"""




from math import sqrt

import numpy as np
from sympy import symbols

# Coefficient
# Speed of light (m/s)
_UpperCAmelCase            =		299792458

# Symbols
_UpperCAmelCase      ,_UpperCAmelCase      ,_UpperCAmelCase      ,_UpperCAmelCase            =		symbols("""ct x y z""")




def     UpperCamelCase						(	__lowercase						:			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						(	__lowercase						:			float     ):
		'''simple docstring'''




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




def     UpperCamelCase						(	__lowercase						:			float     ):
		'''simple docstring'''




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




def     UpperCamelCase						(	__lowercase						:			float						,__lowercase						:			np.ndarray | None = None     ):
		'''simple docstring'''




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

		return transformation_matrix(__lowercase     ) @ event


if __name__ == "__main__":
	import doctest

	doctest.testmod()

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

	print(F"""\n{numerical_vector}""")







from math import isqrt




def     UpperCamelCase						(	__lowercase						:			int     ):
		'''simple docstring'''




		return all(number % divisor != 0 for divisor in range(2						,isqrt(__lowercase     ) + 1     )     )




def     UpperCamelCase						(	__lowercase						:			int = 10**6     ):
		'''simple docstring'''




		A_		:    Optional[Any]         =				0
		A_		:    List[str]         =				1
		A_		:    Dict         =				7
		while prime_candidate < max_prime:
				primes_count += is_prime(__lowercase     )

				cube_index += 1
				prime_candidate += 6 * cube_index

		return primes_count


if __name__ == "__main__":
	print(F"""{solution() = }""")






