code: 
  
  
  
  
  """simple docstring"""
  
  from __future__ import annotations
  
  import random
  
  from matplotlib import animation
  from matplotlib import pyplot as plt
  
  # Frame rate of the animation
  __A 		=			20
  
  # Time between time steps in seconds
  __A 		=			INTERVAL / 1_000
  class 			lowerCamelCase__    :
  
  
  			def __init__(     self				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE = 1.0				, SCREAMING_SNAKE_CASE = 1.0				, SCREAMING_SNAKE_CASE = "blue"				, ):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Optional[int]								=				position_x
  					snake_case		:						Union[str, Any]								=				position_y
  					snake_case		:						List[str]								=				velocity_x
  					snake_case		:						Optional[Any]								=				velocity_y
  					snake_case		:						List[str]								=				mass
  					snake_case		:						int								=				size
  					snake_case		:						List[str]								=				color
  
  
  			@property
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					return self.position_x, self.position_y
  
  
  			@property
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					return self.velocity_x, self.velocity_y
  
  
  			def 							lowerCamelCase_				(     self				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					self.velocity_x += force_x * delta_time
  					self.velocity_y += force_y * delta_time
  
  
  
  			def 							lowerCamelCase_				(     self				, SCREAMING_SNAKE_CASE							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					self.position_x += self.velocity_x * delta_time
  					self.position_y += self.velocity_y * delta_time
  
  
  
  
  
  
  
  class 			lowerCamelCase__    :
  
  
  			def __init__(     self				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE = 1.0				, SCREAMING_SNAKE_CASE = 1.0				, SCREAMING_SNAKE_CASE = 0.0				, ):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						str								=				bodies
  					snake_case		:						Union[str, Any]								=				gravitation_constant
  					snake_case		:						Tuple								=				time_factor
  					snake_case		:						List[str]								=				softening_factor
  
  
  			def __len__(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					return len(self.bodies							)
  
  
  
  			def 							lowerCamelCase_				(     self				, SCREAMING_SNAKE_CASE							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					for bodya in self.bodies:
  							snake_case		:						Any								=				0.0
  							snake_case		:						List[Any]								=				0.0
  							for bodya in self.bodies:
  									if bodya != bodya:
  											snake_case		:						Tuple								=				bodya.position_x - bodya.position_x
  											snake_case		:						Any								=				bodya.position_y - bodya.position_y
  
  											# Calculation of the distance using Pythagoras's theorem
  											# Extra factor due to the softening technique
  											snake_case		:						str								=				(dif_x**2 + dif_y**2 + self.softening_factor) ** (
  											    1 / 2
  											)
  
  											# Newton's law of universal gravitation.
  											force_x += (
  											    self.gravitation_constant * bodya.mass * dif_x / distance**3
  											)
  											force_y += (
  											    self.gravitation_constant * bodya.mass * dif_y / distance**3
  											)
  
              # Update the body's velocity once all the force components have been added
  							bodya.update_velocity(SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, delta_time * self.time_factor							)
  
  					# Update the positions only after all the velocities have been updated
  					for body in self.bodies:
  							body.update_position(delta_time * self.time_factor							)
  
  
  
  
  
  
  
  def   UpperCamelCase__     (		lowercase__  :     BodySystem       ,     lowercase__  :     float       ,     lowercase__  :     list[plt.Circle]   ):
  		body_system.update_system(lowercase__   )
  
  		# Update the positions of the patches
  		for patch, body in zip(lowercase__       ,     body_system.bodies   ):
  				snake_case		:						List[str]								=				(body.position_x, body.position_y)
  
  
  
  def   UpperCamelCase__     (		lowercase__  :     str       ,     lowercase__  :     BodySystem       ,     lowercase__  :     float = -1       ,     lowercase__  :     float = 1       ,     lowercase__  :     float = -1       ,     lowercase__  :     float = 1       ,     ):
  		snake_case		:						List[Any]								=				plt.figure()
  		fig.canvas.set_window_title(lowercase__   )
  		snake_case		:						Dict								=				plt.axes(
  		    xlim=(x_start, x_end)       ,     ylim=(y_start, y_end)   )  # Set section to be plotted
  		plt.gca().set_aspect("equal"   )  # Fix aspect ratio
  
  		# Each body is drawn as a patch by the plt-function
  		snake_case		:						List[Any]								=				[
  		    plt.Circle((body.position_x, body.position_y)       ,     body.size       ,     fc=body.color   )
  		    for body in body_system.bodies
  		]
  
  		for patch in patches:
  				ax.add_patch(lowercase__   )
  
  		# Function called at each step of the animation
  		def update(lowercase__  :     int   ) -> list[plt.Circle]:
  				update_step(lowercase__       ,     lowercase__       ,     lowercase__   )
  				return patches
  
  		snake_case		:						Any								=				animation.FuncAnimation(  # noqa: F841
  		    lowercase__       ,     lowercase__       ,     interval=lowercase__       ,     blit=lowercase__   )
  
  		plt.show()
  
  
  
  def   UpperCamelCase__     (		):
  		snake_case		:						Optional[Any]								=				0.9_70_04_36
  		snake_case		:						List[str]								=				-0.24_30_87_53
  		snake_case		:						Optional[Any]								=				0.4_66_20_36_85
  		snake_case		:						List[Any]								=				0.43_23_65_73
  
  		snake_case		:						List[str]								=				[
  		    Body(lowercase__       ,     lowercase__       ,     lowercase__       ,     lowercase__       ,     size=0.2       ,     color="red"   ),
  		    Body(-position_x       ,     -position_y       ,     lowercase__       ,     lowercase__       ,     size=0.2       ,     color="green"   ),
  		    Body(0       ,     0       ,     -2 * velocity_x       ,     -2 * velocity_y       ,     size=0.2       ,     color="blue"   ),
  		]
  		return BodySystem(lowercase__       ,     time_factor=3   )
  
  
  
  def   UpperCamelCase__     (		):
  		snake_case		:						int								=				7.3476E22
  		snake_case		:						str								=				5.972E24
  		snake_case		:						Any								=				1022
  		snake_case		:						List[str]								=				3_8439_9000
  		snake_case		:						Tuple								=				6.674E-11
  
  		# Calculation of the respective velocities so that total impulse is zero,
  		# i.e. the two bodies together don't move
  		snake_case		:						Any								=				earth_mass * velocity_dif / (earth_mass + moon_mass)
  		snake_case		:						Dict								=				moon_velocity - velocity_dif
  
  		snake_case		:						Tuple								=				Body(-earth_moon_distance       ,     0       ,     0       ,     lowercase__       ,     lowercase__       ,     1000_0000       ,     "grey"   )
  		snake_case		:						int								=				Body(0       ,     0       ,     0       ,     lowercase__       ,     lowercase__       ,     5000_0000       ,     "blue"   )
  		return BodySystem([earth, moon]       ,     lowercase__       ,     time_factor=100_0000   )
  
  
  
  def   UpperCamelCase__     (		):
  		snake_case		:						int								=				[]
  		for _ in range(10   ):
  				snake_case		:						List[str]								=				random.uniform(-0.5       ,     0.5   )
  				snake_case		:						Union[str, Any]								=				random.uniform(-0.5       ,     0.5   )
  
  				# Bodies are created pairwise with opposite velocities so that the
  				# total impulse remains zero
  				bodies.append(
  				    Body(
  				        random.uniform(-0.5       ,     0.5   )       ,     random.uniform(-0.5       ,     0.5   )       ,     lowercase__       ,     lowercase__       ,     size=0.05       ,     )   )
  				bodies.append(
  				    Body(
  				        random.uniform(-0.5       ,     0.5   )       ,     random.uniform(-0.5       ,     0.5   )       ,     -velocity_x       ,     -velocity_y       ,     size=0.05       ,     )   )
  		return BodySystem(lowercase__       ,     0.01       ,     10       ,     0.1   )
  
  
  if __name__ == "__main__":
  							plot("Figure-8 solution to the 3-body-problem", example_a(), -2, 2, -2, 2)
  							plot(
  							    "Moon's orbit around the earth",
  							    example_a(),
  							    -430_000_000,
  							    430_000_000,
  							    -430_000_000,
  							    430_000_000,
  							)
  							plot("Random system with many bodies", example_a(), -1.5, 1.5, -1.5, 1.5)
  
  
style_context: 
  
  
  
  
  """simple docstring"""
  
  def   UpperCamelCase__     (		lowercase__  :     int   ):
  		if not isinstance(lowercase__       ,     lowercase__   ):
  				snake_case		:						Optional[Any]								=				F'''Input value of [number={number}] must be an integer'''
  				raise TypeError(lowercase__   )
  		if number < 0 or number % 2 == 1:
  				return False
  		snake_case		:						str								=				int(number**0.5   )
  		return number == number_sqrt * (number_sqrt + 1)
  
  
  if __name__ == "__main__":
  							import doctest
  
  							doctest.testmod()
  
  