Engines

def __init__(self, _config: _BaseEngineConfigDictT):
    """Initialize the class.

    Args:
        _config: The configuration object.
    """
    self._config: BaseEngineConfig = create_base_engine_config(_config)
    self.gravity_vector: Vector = Vector(0.0, self._config.cGravityConstant, 0.0)

def __init__(self, config: BaseEngineConfigDict) -> None:
    """Initialize the RK4 integration engine.

    Args:
        config: Configuration dictionary containing engine parameters.
               See BaseEngineConfigDict for available options.
               Common settings include cStepMultiplier for accuracy control
               and cMinimumVelocity for termination conditions.

    Examples:
        >>> precise_config = BaseEngineConfigDict(
        ...     cStepMultiplier=0.5,  # Smaller steps
        ...     cMinimumVelocity=20.0  # Continue to lower velocities
        ... )
        >>> precise_engine = RK4IntegrationEngine(precise_config)
    """
    super().__init__(config)
    self.integration_step_count: int = 0
    self.trajectory_count = 0  # Number of trajectories calculated

def __init__(self, config: BaseEngineConfigDict) -> None:
    """Initialize the Euler integration engine.

    Args:
        config: Configuration dictionary containing engine parameters.
               See BaseEngineConfigDict for available options.
    """
    super().__init__(config)
    self.integration_step_count: int = 0

def __init__(self, config: BaseEngineConfigDict) -> None:
    """Initialize the Velocity Verlet integration engine.

    Args:
        config: Configuration dictionary containing engine parameters.
               See BaseEngineConfigDict for available options.

    Examples:
        >>> config = BaseEngineConfigDict(
        ...     cStepMultiplier=0.5,
        ...     cMinimumVelocity=10.0
        ... )
        >>> engine = VelocityVerletIntegrationEngine(config)
    """
    super().__init__(config)
    self.integration_step_count: int = 0

@override
def __init__(self, _config: SciPyEngineConfigDict) -> None:
    """Initialize the SciPy integration engine with configuration.

    Sets up the engine with the provided configuration dictionary, initializing
    all necessary parameters for high-precision ballistic trajectory calculations.
    The configuration is converted to a structured format with appropriate
    defaults for any unspecified parameters.

    Args:
        _config: Configuration dictionary containing engine parameters.
                Can include SciPy-specific options (integration_method,
                tolerances, max_time) as well as all standard BaseEngineConfigDict
                parameters (cMinimumVelocity, cStepMultiplier, etc.).

                SciPy-specific parameters:
                - integration_method: SciPy method ('RK45', 'DOP853', etc.)
                - relative_tolerance: Relative error tolerance (rtol)
                - absolute_tolerance: Absolute error tolerance (atol)
                - max_time: Maximum simulation time in seconds

                Standard ballistic parameters:
                - cMinimumVelocity: Minimum velocity to continue calculation
                - cStepMultiplier: Integration step size multiplier
                - cGravityConstant: Gravitational acceleration
                - And other BaseEngineConfigDict parameters

    Raises:
        ImportError: If scipy or numpy packages are not available.
        ValueError: If configuration contains invalid parameters.

    Examples:
        >>> config = SciPyEngineConfigDict(
        ...     integration_method='DOP853',
        ...     relative_tolerance=1e-10,
        ...     cMinimumVelocity=50.0
        ... )
        >>> engine = SciPyIntegrationEngine(config)

    Attributes Initialized:
        - _config: Complete configuration with defaults applied
        - gravity_vector: Gravitational acceleration vector
        - integration_step_count: Counter for integration steps (debugging)
        - trajectory_count: Counter for calculated trajectories (debugging)
        - eval_points: List of evaluation points (debugging/analysis)

    Note:
        The configuration is processed through create_scipy_engine_config()
        which applies defaults for any unspecified parameters. This ensures
        the engine always has a complete, valid configuration.
    """

    # dependencies guard
    if not _HAS_NUMPY:
        raise ImportError("Numpy is required for SciPyIntegrationEngine.")
    if not _HAS_SCIPY:
        raise ImportError("SciPy is required for SciPyIntegrationEngine.")

    self._config: SciPyEngineConfig = create_scipy_engine_config(_config)  # type: ignore
    self.gravity_vector: Vector = Vector(0.0, self._config.cGravityConstant, 0.0)
    self.integration_step_count = 0  # Number of evaluations of diff_eq during ._integrate()
    self.trajectory_count = 0  # Number of trajectories calculated
    self.eval_points: List[float] = []  # Points at which diff_eq is called