interface IAttractorSolver {
    /**
     * @notice Simulates the evolution of a chaotic system.
     * @dev This is the core piece of this class that performs everything
     * at once. All relevant algorithm for the evaluation of the ODEs
     * the numerical scheme, the projection and storage are contained within
     * this method for performance reasons.
     * @return An `AttractorSolution` containing already projected 2D points
     * and tangents to them.
     */
    function computeSolution(
        SolverParameters calldata,
        StartingPoint calldata,
        ProjectionParameters calldata
    ) external pure returns (AttractorSolution memory);

    /**
     * @notice Generates a random starting point for the system.
     */
    function getRandomStartingPoint(uint256 randomSeed)
        external
        view
        returns (StartingPoint memory);

    /**
     * @notice Generates the default projection for a given edition of the
     * system.
     */
    function getDefaultProjectionParameters(uint256 editionId)
        external
        view
        returns (ProjectionParameters memory);

    /**
     * @notice Returns the type/name of the dynamical system.
     */
    function getSystemType() external pure returns (string memory);

    /**
     * @notice Returns the dimensionality of the dynamical system (number of
     * ODEs).
     */
    function getDimensionality() external pure returns (uint8);

    /**
     * @notice Returns the precision of the internally used fixed-point numbers.
     * @dev The solvers operate on fixed-point numbers with a given PRECISION,
     * i.e. the amount of bits reserved for decimal places.
     * By convention, this method will return 96 throughout the project.
     */
    function getFixedPointPrecision() external pure returns (uint8);

    /**
     * @notice Checks if given `ProjectionParameters` are valid`
     */
    function isValidProjectionParameters(ProjectionParameters memory)
        external
        pure
        returns (bool);
}
/**
 * @notice Interface for simulators of chaotic systems.
 * @dev Implementations of this interface will contain the mathematical
 * description of the underlying differential equations, deal with its numerical
 * solution and the 2D projection of the results.
 * Implementations will internally use fixed-point numbers with a precision of
 * 96 bits by convention.
 * @author David Huber (@cxkoda)
 */
function getFixedPointPrecision() external pure returns (uint8);

/**
 * @notice Returns the precision of the internally used fixed-point numbers.
 * @dev The solvers operate on fixed-point numbers with a given PRECISION,
 * i.e. the amount of bits reserved for decimal places.
 * By convention, this method will return 96 throughout the project.
 */