
class        _SCREAMING_SNAKE_CASE	:
      def __init__(      self		,						lowerCamelCase		,						lowerCamelCase=None		,						lowerCamelCase=None			):
          snake_case__    =					data
          snake_case__    =					previous
          snake_case__    =					next_node
      def __str__(      self			):
          return F"""{self.data}"""
      def A_      (      self			):
          return self.data
      def A_      (      self			):
          return self.next



      def A_      (      self			):
          return self.previous





class        _SCREAMING_SNAKE_CASE	:
      def __init__(      self		,						lowerCamelCase			):
          snake_case__    =					head
      def __iter__(      self			):
          return self



      def A_      (      self			):
          if not self.current:
              raise StopIteration
          else:
              snake_case__    =					self.current.get_data()
              snake_case__    =					self.current.get_next()
              return value





class        _SCREAMING_SNAKE_CASE	:
      def __init__(      self			):
          snake_case__    =					None  # First node in list
          snake_case__    =					None  # Last node in list
      def __str__(      self			):
          snake_case__    =					self.head
          snake_case__    =					[]
          while current is not None:
              nodes.append(current.get_data()			)
              snake_case__    =					current.get_next()
          return " ".join(str(lowerCamelCase			) for node in nodes			)
      def __contains__(      self		,						lowerCamelCase			):
          snake_case__    =					self.head
          while current:
              if current.get_data() == value:
                  return True
              snake_case__    =					current.get_next()
          return False
      def __iter__(      self			):
          return LinkedListIterator(self.head			)
      def A_      (      self			):
          if self.head:
              return self.head.get_data()
          return None
      def A_      (      self			):
          if self.tail:
              return self.tail.get_data()
          return None
      def A_      (      self		,						lowerCamelCase			):
          if self.head is None:
              snake_case__    =					node
              snake_case__    =					node
          else:
              self.insert_before_node(self.head		,						lowerCamelCase			)
      def A_      (      self		,						lowerCamelCase			):
          if self.head is None:
              self.set_head(lowerCamelCase			)
          else:
              self.insert_after_node(self.tail		,						lowerCamelCase			)
      def A_      (      self		,						lowerCamelCase			):
          snake_case__    =					Node(lowerCamelCase			)
          if self.head is None:
              self.set_head(lowerCamelCase			)
          else:
              self.set_tail(lowerCamelCase			)
      def A_      (      self		,						lowerCamelCase		,						lowerCamelCase			):
          snake_case__    =					node
          snake_case__    =					node.previous

          if node.get_previous() is None:
              snake_case__    =					node_to_insert
          else:
              snake_case__    =					node_to_insert

          snake_case__    =					node_to_insert
      def A_      (      self		,						lowerCamelCase		,						lowerCamelCase			):
          snake_case__    =					node
          snake_case__    =					node.next

          if node.get_next() is None:
              snake_case__    =					node_to_insert
          else:
              snake_case__    =					node_to_insert

          snake_case__    =					node_to_insert
      def A_      (      self		,						lowerCamelCase		,						lowerCamelCase			):
          snake_case__    =					1
          snake_case__    =					Node(lowerCamelCase			)
          snake_case__    =					self.head
          while node:
              if current_position == position:
                  self.insert_before_node(lowerCamelCase		,						lowerCamelCase			)
                  return
              current_position += 1
              snake_case__    =					node.next
          self.insert_after_node(self.tail		,						lowerCamelCase			)
      def A_      (      self		,						lowerCamelCase			):
          snake_case__    =					self.head
          while node:
              if node.get_data() == item:
                  return node
              snake_case__    =					node.get_next()
          raise Exception("Node not found"			)
      def A_      (      self		,						lowerCamelCase			):
          if (node := self.get_node(lowerCamelCase			)) is not None:
              if node == self.head:
                  snake_case__    =					self.head.get_next()

              if node == self.tail:
                  snake_case__    =					self.tail.get_previous()

              self.remove_node_pointers(lowerCamelCase			)
      @staticmethod
      def A_      (      lowerCamelCase			):
          if node.get_next():
              snake_case__    =					node.previous

          if node.get_previous():
              snake_case__    =					node.next

          snake_case__    =					None
          snake_case__    =					None



      def A_      (      self			):
          return self.head is None





def 						SCREAMING_SNAKE_CASE__     (   ):
    pass


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)
__magic_name__  							=	299_792_458

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





def 						SCREAMING_SNAKE_CASE__     (   __lowerCAmelCase				):
    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__     (   __lowerCAmelCase				):
    return 1 / sqrt(1 - beta(__lowerCAmelCase				) ** 2				)





def 						SCREAMING_SNAKE_CASE__     (   __lowerCAmelCase				):
    return np.array(
        [
            [gamma(__lowerCAmelCase				), -gamma(__lowerCAmelCase				) * beta(__lowerCAmelCase				), 0, 0],
            [-gamma(__lowerCAmelCase				) * beta(__lowerCAmelCase				), gamma(__lowerCAmelCase				), 0, 0],
            [0, 0, 1, 0],
            [0, 0, 0, 1],
        ]				)





def 						SCREAMING_SNAKE_CASE__     (   __lowerCAmelCase     ,		__lowerCAmelCase = None				):
    # Ensure event is not empty
    if event is None:
        snake_case__    =					np.array([ct, x, y, z]				)  # Symbolic four vector
    else:
        event[0] *= c  # x0 is ct (speed of light * time)

    return transformation_matrix(__lowerCAmelCase				) @ event


if __name__ == "__main__":
     import doctest

     doctest.testmod()

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

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



