


"""simple docstring"""



from math import sqrt

import numpy as np
from sympy import symbols

# Coefficient
# Speed of light (m/s)
UpperCAmelCase      		=			299_792_458

# Symbols
UpperCAmelCase		,	UpperCAmelCase		,	UpperCAmelCase		,	UpperCAmelCase      		=			symbols('''ct x y z''')






def       lowerCamelCase					(a_						:float)     ->							float:
							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       lowerCamelCase					(a_						:float)     ->							float:
							return 1 / sqrt(1 - beta(a_) ** 2)






def       lowerCamelCase					(a_						:float)     ->							np.ndarray:
							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       lowerCamelCase					(a_						:float				,				a_						:np.ndarray | None = None)     ->							np.ndarray:
							# Ensure event is not empty
							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:
	UpperCAmelCase      		=			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
	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}""")





"""simple docstring"""



from __future__ import annotations

from decimal import Decimal

from numpy import array






def       lowerCamelCase					(a_						:list[list[float]])     ->							list[list[float]]:
       lowercase		:List[str]       							=				Decimal

       # Check if the provided matrix has 2 rows and 2 columns
       # since this implementation only works for 2x2 matrices
       if len(a_) == 2 and len(matrix[0]) == 2 and len(matrix[1]) == 2:
              # Calculate the determinant of the matrix
              lowercase		:List[str]       							=				float(
                  d(matrix[0][0]) * d(matrix[1][1]) - d(matrix[1][0]) * d(matrix[0][1]))
              if determinant == 0:
                     raise ValueError('''This matrix has no inverse.''')

              # Creates a copy of the matrix with swapped positions of the elements
              lowercase		:Optional[Any]       							=				[[0.0, 0.0], [0.0, 0.0]]
              lowercase							,  lowercase		:List[Any]       							=				matrix[1][1], matrix[0][0]
              lowercase							,  lowercase		:Union[str, Any]       							=				-matrix[1][0], -matrix[0][1]

              # Calculate the inverse of the matrix
              return [
                  [(float(d(a_)) / determinant) or 0.0 for n in row] for row in swapped_matrix
              ]
       elif (
           len(a_) == 3
           and len(matrix[0]) == 3
           and len(matrix[1]) == 3
           and len(matrix[2]) == 3
       ):
              # Calculate the determinant of the matrix using Sarrus rule
              lowercase		:Any       							=				float(
                  (
                      (d(matrix[0][0]) * d(matrix[1][1]) * d(matrix[2][2]))
                      + (d(matrix[0][1]) * d(matrix[1][2]) * d(matrix[2][0]))
                      + (d(matrix[0][2]) * d(matrix[1][0]) * d(matrix[2][1]))
                  )
                  - (
                      (d(matrix[0][2]) * d(matrix[1][1]) * d(matrix[2][0]))
                      + (d(matrix[0][1]) * d(matrix[1][0]) * d(matrix[2][2]))
                      + (d(matrix[0][0]) * d(matrix[1][2]) * d(matrix[2][1]))
                  ))
              if determinant == 0:
                     raise ValueError('''This matrix has no inverse.''')

              # Creating cofactor matrix
              lowercase		:Optional[Any]       							=				[
                  [d(0.0), d(0.0), d(0.0)],
                  [d(0.0), d(0.0), d(0.0)],
                  [d(0.0), d(0.0), d(0.0)],
              ]
              lowercase		:Optional[int]       							=				(d(matrix[1][1]) * d(matrix[2][2])) - (
                  d(matrix[1][2]) * d(matrix[2][1])
              )
              lowercase		:str       							=				-(
                  (d(matrix[1][0]) * d(matrix[2][2])) - (d(matrix[1][2]) * d(matrix[2][0]))
              )
              lowercase		:Union[str, Any]       							=				(d(matrix[1][0]) * d(matrix[2][1])) - (
                  d(matrix[1][1]) * d(matrix[2][0])
              )
              lowercase		:Union[str, Any]       							=				-(
                  (d(matrix[0][1]) * d(matrix[2][2])) - (d(matrix[0][2]) * d(matrix[2][1]))
              )
              lowercase		:Union[str, Any]       							=				(d(matrix[0][0]) * d(matrix[2][2])) - (
                  d(matrix[0][2]) * d(matrix[2][0])
              )
              lowercase		:List[str]       							=				-(
                  (d(matrix[0][0]) * d(matrix[2][1])) - (d(matrix[0][1]) * d(matrix[2][0]))
              )
              lowercase		:Union[str, Any]       							=				(d(matrix[0][1]) * d(matrix[1][2])) - (
                  d(matrix[0][2]) * d(matrix[1][1])
              )
              lowercase		:Union[str, Any]       							=				-(
                  (d(matrix[0][0]) * d(matrix[1][2])) - (d(matrix[0][2]) * d(matrix[1][0]))
              )
              lowercase		:Any       							=				(d(matrix[0][0]) * d(matrix[1][1])) - (
                  d(matrix[0][1]) * d(matrix[1][0])
              )

              # Transpose the cofactor matrix (Adjoint matrix)
              lowercase		:Union[str, Any]       							=				array(a_)
              for i in range(3):
                     for j in range(3):
                            lowercase		:Any       							=				cofactor_matrix[j][i]

        # Inverse of the matrix using the formula (1/determinant) * adjoint matrix
              lowercase		:str       							=				array(a_)
              for i in range(3):
                     for j in range(3):
                            inverse_matrix[i][j] /= d(a_)

        # Calculate the inverse of the matrix
              return [[float(d(a_)) or 0.0 for n in row] for row in inverse_matrix]
       raise ValueError('''Please provide a matrix of size 2x2 or 3x3.''')

