


'''simple docstring'''

from math import sqrt

import numpy as np
from sympy import symbols

# Coefficient
# Speed of light (m/s)
lowerCamelCase				:  Optional[Any]    		=      299_792_458

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

def _SCREAMING_SNAKE_CASE (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 _SCREAMING_SNAKE_CASE (A			)			->			float:






       """simple docstring"""







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

def _SCREAMING_SNAKE_CASE (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 _SCREAMING_SNAKE_CASE (A    ,					A = None			)			->			np.ndarray:






       """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(A			) @ event


if __name__ == "__main__":
 import doctest

 doctest.testmod()

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

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








'''simple docstring'''

from math import sqrt

def _SCREAMING_SNAKE_CASE (A = 1_000_000			)			->			int:






       """simple docstring"""







       lowercase__      =					0
       lowercase__      =					0
       lowercase__      =					42

       while num_cuboids <= limit:
              max_cuboid_size += 1
              for sum_shortest_sides in range(2    ,					2 * max_cuboid_size + 1			):
                     if sqrt(sum_shortest_sides**2 + max_cuboid_size**2			).is_integer():
                            num_cuboids += (
                                min(A    ,					sum_shortest_sides // 2			)
                                - max(1    ,					sum_shortest_sides - max_cuboid_size			)
                                + 1
                            )

       return max_cuboid_size


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




