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  :					Dict												=	20
  
  # Time between time steps in seconds
  __A  :					Tuple												=	INTERVAL / 10_00
  
  
  
  
  
  class     __UpperCamelCase				:
  
  
  		def __init__(self				:	Tuple  ,  __SCREAMING_SNAKE_CASE				:	float  ,  __SCREAMING_SNAKE_CASE				:	float  ,  __SCREAMING_SNAKE_CASE				:	float  ,  __SCREAMING_SNAKE_CASE				:	float  ,  __SCREAMING_SNAKE_CASE				:	float = 1.0  ,  __SCREAMING_SNAKE_CASE				:	float = 1.0  ,  __SCREAMING_SNAKE_CASE				:	str = "blue"  ,  ):
  							A    =      position_x
  							A    =      position_y
  							A    =      velocity_x
  							A    =      velocity_y
  							A    =      mass
  							A    =      size
  							A    =      color
  
  
  		@property
  		def       SCREAMING_SNAKE_CASE__     (self				:	Tuple):
  							return self.position_x, self.position_y
  
  
  		@property
  		def       SCREAMING_SNAKE_CASE__     (self				:	Union[str, Any]):
  							return self.velocity_x, self.velocity_y
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	str  ,  __SCREAMING_SNAKE_CASE				:	float  ,  __SCREAMING_SNAKE_CASE				:	float  ,  __SCREAMING_SNAKE_CASE				:	float):
  							self.velocity_x += force_x * delta_time
  							self.velocity_y += force_y * delta_time
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	Any  ,  __SCREAMING_SNAKE_CASE				:	float):
  							self.position_x += self.velocity_x * delta_time
  							self.position_y += self.velocity_y * delta_time
  
  
  
  
  
  class     __UpperCamelCase				:
  
  
  		def __init__(self				:	Tuple  ,  __SCREAMING_SNAKE_CASE				:	list[Body]  ,  __SCREAMING_SNAKE_CASE				:	float = 1.0  ,  __SCREAMING_SNAKE_CASE				:	float = 1.0  ,  __SCREAMING_SNAKE_CASE				:	float = 0.0  ,  ):
  							A    =      bodies
  							A    =      gravitation_constant
  							A    =      time_factor
  							A    =      softening_factor
  
  
  		def __len__(self				:	Optional[Any]):
  							return len(self.bodies)
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	str  ,  __SCREAMING_SNAKE_CASE				:	float):
  							for bodya in self.bodies:
  												A    =      0.0
  												A    =      0.0
  												for bodya in self.bodies:
  																	if bodya != bodya:
  																						A    =      bodya.position_x - bodya.position_x
  																						A    =      bodya.position_y - bodya.position_y
  
  																						# Calculation of the distance using Pythagoras's theorem
  																						# Extra factor due to the softening technique
  																						A    =      (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      __SCREAMING_SNAKE_CASE		(		lowercase__    ,							lowercase__    ,							lowercase__   ):
  					"""simple docstring"""
  					body_system.update_system(lowercase__   )
  
  					# Update the positions of the patches
  					for patch, body in zip(lowercase__    ,							body_system.bodies   ):
  										A    =      (body.position_x, body.position_y)
  def      __SCREAMING_SNAKE_CASE		(		lowercase__    ,							lowercase__    ,							lowercase__ = -1    ,							lowercase__ = 1    ,							lowercase__ = -1    ,							lowercase__ = 1    ,							):
  					"""simple docstring"""
  					A    =      plt.figure()
  					fig.canvas.set_window_title(lowercase__   )
  					A    =      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
  					A    =      [
  					    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__   ) -> list[plt.Circle]:
  										update_step(lowercase__    ,							lowercase__    ,							lowercase__   )
  										return patches
  
  					A    =      animation.FuncAnimation(  # noqa: F841
  					    lowercase__    ,							lowercase__    ,							interval=lowercase__    ,							blit=lowercase__   )
  
  					plt.show()
  def      __SCREAMING_SNAKE_CASE		(		):
  					"""simple docstring"""
  					A    =      0.9_70_04_36
  					A    =      -0.24_30_87_53
  					A    =      0.4_66_20_36_85
  					A    =      0.43_23_65_73
  
  					A    =      [
  					    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      __SCREAMING_SNAKE_CASE		(		):
  					"""simple docstring"""
  					A    =      7.3476e22
  					A    =      5.972e24
  					A    =      1_022
  					A    =      384_399_000
  					A    =      6.674e-11
  
  					# Calculation of the respective velocities so that total impulse is zero,
  					# i.e. the two bodies together don't move
  					A    =      earth_mass * velocity_dif / (earth_mass + moon_mass)
  					A    =      moon_velocity - velocity_dif
  
  					A    =      Body(-earth_moon_distance    ,							0    ,							0    ,							lowercase__    ,							lowercase__    ,							10_000_000    ,							"grey"   )
  					A    =      Body(0    ,							0    ,							0    ,							lowercase__    ,							lowercase__    ,							50_000_000    ,							"blue"   )
  					return BodySystem([earth, moon]    ,							lowercase__    ,							time_factor=1_000_000   )
  def      __SCREAMING_SNAKE_CASE		(		):
  					"""simple docstring"""
  					A    =      []
  					for _ in range(10   ):
  										A    =      random.uniform(-0.5    ,							0.5   )
  										A    =      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(),
  	    -4_30_00_00_00,
  	    4_30_00_00_00,
  	    -4_30_00_00_00,
  	    4_30_00_00_00,
  	)
  	plot('Random system with many bodies', example_a(), -1.5, 1.5, -1.5, 1.5)
  
  
  
  
  
  
style_context: 
  
  """simple docstring"""
  
  
  
  
  from typing import TYPE_CHECKING
  
  from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available
  
  
  __A  :					int												=	{
      'configuration_nystromformer': ['NYSTROMFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP', 'NystromformerConfig'],
  }
  
  try:
  	if not is_torch_available():
  		raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
  	pass
  else:
  	__A  :					Any												=	[
  	    'NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
  	    'NystromformerForMaskedLM',
  	    'NystromformerForMultipleChoice',
  	    'NystromformerForQuestionAnswering',
  	    'NystromformerForSequenceClassification',
  	    'NystromformerForTokenClassification',
  	    'NystromformerLayer',
  	    'NystromformerModel',
  	    'NystromformerPreTrainedModel',
  	]
  
  
  if TYPE_CHECKING:
  	from .configuration_nystromformer import NYSTROMFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, NystromformerConfig
  
  	try:
  		if not is_torch_available():
  			raise OptionalDependencyNotAvailable()
  	except OptionalDependencyNotAvailable:
  		pass
  	else:
  		from .modeling_nystromformer import (
  		    NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
  		    NystromformerForMaskedLM,
  		    NystromformerForMultipleChoice,
  		    NystromformerForQuestionAnswering,
  		    NystromformerForSequenceClassification,
  		    NystromformerForTokenClassification,
  		    NystromformerLayer,
  		    NystromformerModel,
  		    NystromformerPreTrainedModel,
  		)
  
  
  else:
  	import sys
  
  	__A  :					Optional[Any]												=	_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
  
  
  
  
  
  