SYMBOL INDEX (3275 symbols across 233 files)

FILE: .tools/create_algo_selection_code.py
  function main (line 14) | def main() -> None:
  function _import_optimizer_modules (line 80) | def _import_optimizer_modules(package_name: str) -> list[ModuleType]:
  function _get_all_algorithms (line 96) | def _get_all_algorithms(modules: list[ModuleType]) -> dict[str, Type[Alg...
  function _get_algorithms_in_module (line 104) | def _get_algorithms_in_module(module: ModuleType) -> dict[str, Type[Algo...
  function _is_gradient_based (line 121) | def _is_gradient_based(algo: Type[Algorithm]) -> bool:
  function _is_gradient_free (line 125) | def _is_gradient_free(algo: Type[Algorithm]) -> bool:
  function _is_global (line 129) | def _is_global(algo: Type[Algorithm]) -> bool:
  function _is_local (line 133) | def _is_local(algo: Type[Algorithm]) -> bool:
  function _is_bounded (line 137) | def _is_bounded(algo: Type[Algorithm]) -> bool:
  function _is_linear_constrained (line 141) | def _is_linear_constrained(algo: Type[Algorithm]) -> bool:
  function _is_nonlinear_constrained (line 145) | def _is_nonlinear_constrained(algo: Type[Algorithm]) -> bool:
  function _is_scalar (line 149) | def _is_scalar(algo: Type[Algorithm]) -> bool:
  function _is_least_squares (line 153) | def _is_least_squares(algo: Type[Algorithm]) -> bool:
  function _is_likelihood (line 157) | def _is_likelihood(algo: Type[Algorithm]) -> bool:
  function _is_parallel (line 161) | def _is_parallel(algo: Type[Algorithm]) -> bool:
  function _get_filters (line 165) | def _get_filters() -> dict[str, Callable[[Type[Algorithm]], bool]]:
  function _create_selection_info (line 189) | def _create_selection_info(
  function _generate_category_combinations (line 213) | def _generate_category_combinations(categories: list[str]) -> list[tuple...
  function _apply_filters (line 229) | def _apply_filters(
  function create_dataclass_code (line 255) | def create_dataclass_code(
  function _get_class_name (line 314) | def _get_class_name(active_categories: tuple[str, ...]) -> str:
  function _get_children (line 319) | def _get_children(
  function _get_imports (line 353) | def _get_imports(modules: list[ModuleType]) -> str:
  function _get_base_class_code (line 374) | def _get_base_class_code() -> str:
  function _get_docstring_code (line 419) | def _get_docstring_code() -> str:
  function _get_instantiation_code (line 433) | def _get_instantiation_code() -> str:

FILE: .tools/test_create_algo_selection_code.py
  function test_generate_category_combinations (line 4) | def test_generate_category_combinations() -> None:

FILE: .tools/update_algo_selection_hook.py
  function run (line 14) | def run(cmd: list[str], **kwargs: Any) -> None:
  function ensure_optimagic_is_locally_installed (line 18) | def ensure_optimagic_is_locally_installed() -> None:
  function main (line 23) | def main() -> int:

FILE: docs/source/_static/js/custom.js
  function createTermynals (line 41) | function createTermynals() {
  function loadVisibleTermynals (line 122) | function loadVisibleTermynals() {

FILE: docs/source/_static/js/require.js
  function commentReplace (line 5) | function commentReplace(e,t){return t||""}
  function isFunction (line 5) | function isFunction(e){return"[object Function]"===ostring.call(e)}
  function isArray (line 5) | function isArray(e){return"[object Array]"===ostring.call(e)}
  function each (line 5) | function each(e,t){if(e)for(var i=0;i<e.length&&(!e[i]||!t(e[i],i,e));i+...
  function eachReverse (line 5) | function eachReverse(e,t){if(e)for(var i=e.length-1;-1<i&&(!e[i]||!t(e[i...
  function hasProp (line 5) | function hasProp(e,t){return hasOwn.call(e,t)}
  function getOwn (line 5) | function getOwn(e,t){return hasProp(e,t)&&e[t]}
  function eachProp (line 5) | function eachProp(e,t){for(var i in e)if(hasProp(e,i)&&-1==disallowedPro...
  function mixin (line 5) | function mixin(i,e,r,n){e&&eachProp(e,function(e,t){!r&&hasProp(i,t)||(!...
  function bind (line 5) | function bind(e,t){return function(){return t.apply(e,arguments)}}
  function scripts (line 5) | function scripts(){return document.getElementsByTagName("script")}
  function defaultOnError (line 5) | function defaultOnError(e){throw e}
  function getGlobal (line 5) | function getGlobal(e){var t;return e&&(t=global,each(e.split("."),functi...
  function makeError (line 5) | function makeError(e,t,i,r){t=new Error(t+"\nhttps://requirejs.org/docs/...
  function newContext (line 5) | function newContext(u){var t,e,f,c,i,b={waitSeconds:7,baseUrl:"./",paths...
  function getInteractiveScript (line 5) | function getInteractiveScript(){return interactiveScript&&"interactive"=...

FILE: docs/source/_static/js/termynal.js
  class Termynal (line 42) | class Termynal {
    method constructor (line 58) | constructor(container = '#termynal', options = {}) {
    method loadLines (line 80) | loadLines() {
    method init (line 102) | init() {
    method start (line 124) | async start() {
    method generateRestart (line 157) | generateRestart() {
    method generateFinish (line 170) | generateFinish() {
    method addRestart (line 185) | addRestart() {
    method addFinish (line 190) | addFinish() {
    method type (line 199) | async type(line) {
    method progress (line 215) | async progress(line) {
    method _wait (line 240) | _wait(time) {
    method lineDataToElements (line 251) | lineDataToElements(lineData) {
    method _attributes (line 266) | _attributes(line) {

FILE: src/estimagic/__init__.py
  class OptimizeLogReader (line 63) | class OptimizeLogReader(_OptimizeLogReader):
    method __init__ (line 64) | def __init__(self, path):
  class OptimizeResult (line 75) | class OptimizeResult(_OptimizeResult):
    method __post_init__ (line 76) | def __post_init__(self):

FILE: src/estimagic/bootstrap.py
  function bootstrap (line 20) | def bootstrap(
  class BootstrapResult (line 121) | class BootstrapResult:
    method _se (line 127) | def _se(self):
    method _cov (line 131) | def _cov(self):
    method _ci (line 135) | def _ci(self):
    method _p_values (line 139) | def _p_values(self):
    method _summary (line 143) | def _summary(self):
    method base_outcome (line 147) | def base_outcome(self):
    method outcomes (line 158) | def outcomes(self):
    method se (line 174) | def se(self):
    method cov (line 191) | def cov(self, return_type="pytree"):
    method ci (line 221) | def ci(self, ci_method="percentile", ci_level=0.95):
    method p_values (line 248) | def p_values(self):
    method summary (line 259) | def summary(self, ci_method="percentile", ci_level=0.95):
  function _calulcate_summary_data_bootstrap (line 287) | def _calulcate_summary_data_bootstrap(bootstrap_result, ci_method, ci_le...

FILE: src/estimagic/bootstrap_ci.py
  function calculate_ci (line 7) | def calculate_ci(
  function _ci_percentile (line 55) | def _ci_percentile(estimates, alpha):
  function _ci_bc (line 78) | def _ci_bc(estimates, base_outcome, alpha):
  function _ci_t (line 113) | def _ci_t(estimates, base_outcome, alpha):
  function _ci_normal (line 145) | def _ci_normal(estimates, base_outcome, alpha):
  function _ci_basic (line 173) | def _ci_basic(estimates, base_outcome, alpha):
  function _eqf (line 202) | def _eqf(sample):

FILE: src/estimagic/bootstrap_helpers.py
  function check_inputs (line 4) | def check_inputs(

FILE: src/estimagic/bootstrap_outcomes.py
  function get_bootstrap_outcomes (line 6) | def get_bootstrap_outcomes(
  function _get_bootstrap_outcomes_from_indices (line 62) | def _get_bootstrap_outcomes_from_indices(
  function _take_indices_and_calculate_outcome (line 101) | def _take_indices_and_calculate_outcome(indices, data, outcome):

FILE: src/estimagic/bootstrap_samples.py
  function get_bootstrap_indices (line 5) | def get_bootstrap_indices(
  function _calculate_bootstrap_indices_weights (line 48) | def _calculate_bootstrap_indices_weights(data, weight_by, cluster_by):
  function _convert_cluster_ids_to_indices (line 75) | def _convert_cluster_ids_to_indices(cluster_col, drawn_clusters):
  function get_bootstrap_samples (line 89) | def get_bootstrap_samples(
  function _get_bootstrap_samples_from_indices (line 123) | def _get_bootstrap_samples_from_indices(data, bootstrap_indices):

FILE: src/estimagic/estimate_ml.py
  function estimate_ml (line 56) | def estimate_ml(
  class LikelihoodResult (line 436) | class LikelihoodResult:
    method __post_init__ (line 454) | def __post_init__(self):
    method _get_free_cov (line 475) | def _get_free_cov(
    method params (line 515) | def params(self):
    method optimize_result (line 519) | def optimize_result(self):
    method jacobian (line 523) | def jacobian(self):
    method hessian (line 531) | def hessian(self):
    method _se (line 539) | def _se(self):
    method _cov (line 543) | def _cov(self):
    method _summary (line 547) | def _summary(self):
    method _ci (line 551) | def _ci(self):
    method _p_values (line 555) | def _p_values(self):
    method se (line 558) | def se(
    method cov (line 608) | def cov(
    method summary (line 661) | def summary(
    method ci (line 713) | def ci(
    method p_values (line 773) | def p_values(
    method to_pickle (line 826) | def to_pickle(self, path):
  function _calculate_free_cov_ml (line 836) | def _calculate_free_cov_ml(

FILE: src/estimagic/estimate_msm.py
  function estimate_msm (line 61) | def estimate_msm(
  function get_msm_optimization_functions (line 378) | def get_msm_optimization_functions(
  function _msm_criterion (line 447) | def _msm_criterion(
  function _partial_kwargs (line 465) | def _partial_kwargs(func, kwargs):
  class MomentsResult (line 484) | class MomentsResult:
    method _get_free_cov (line 502) | def _get_free_cov(self, method, n_samples, bounds_handling, seed):
    method params (line 536) | def params(self):
    method optimize_result (line 540) | def optimize_result(self):
    method weights (line 544) | def weights(self):
    method jacobian (line 548) | def jacobian(self):
    method _se (line 552) | def _se(self):
    method _cov (line 556) | def _cov(self):
    method _summary (line 560) | def _summary(self):
    method _ci (line 564) | def _ci(self):
    method _p_values (line 568) | def _p_values(self):
    method se (line 571) | def se(
    method cov (line 622) | def cov(
    method summary (line 676) | def summary(
    method ci (line 728) | def ci(
    method p_values (line 789) | def p_values(
    method sensitivity (line 840) | def sensitivity(
    method to_pickle (line 994) | def to_pickle(self, path):
  function _calculate_free_cov_msm (line 1004) | def _calculate_free_cov_msm(

FILE: src/estimagic/estimation_table.py
  function estimation_table (line 17) | def estimation_table(
  function render_latex (line 234) | def render_latex(
  function _render_latex (line 302) | def _render_latex(
  function render_html (line 414) | def render_html(
  function _process_model (line 504) | def _process_model(model):
  function _get_estimation_table_body_and_footer (line 540) | def _get_estimation_table_body_and_footer(
  function _build_estimation_table_body (line 624) | def _build_estimation_table_body(
  function _build_estimation_table_footer (line 713) | def _build_estimation_table_footer(
  function _reindex_and_float_format_params (line 764) | def _reindex_and_float_format_params(
  function _get_params_frames_with_common_index (line 776) | def _get_params_frames_with_common_index(models):
  function _get_common_index (line 784) | def _get_common_index(dfs):
  function _get_cols_to_format (line 792) | def _get_cols_to_format(show_inference, confidence_intervals):
  function _apply_number_formatting_frames (line 808) | def _apply_number_formatting_frames(dfs, columns, number_format, add_tra...
  function _update_show_col_groups (line 825) | def _update_show_col_groups(show_col_groups, column_groups):
  function _set_default_stats_options (line 840) | def _set_default_stats_options(stats_options):
  function _get_model_names (line 859) | def _get_model_names(processed_models):
  function _check_order_of_model_names (line 880) | def _check_order_of_model_names(model_names):
  function _get_default_column_names_and_groups (line 899) | def _get_default_column_names_and_groups(model_names):
  function _customize_col_groups (line 923) | def _customize_col_groups(default_col_groups, custom_col_groups):
  function _customize_col_names (line 962) | def _customize_col_names(default_col_names, custom_col_names):
  function _create_group_to_col_position (line 997) | def _create_group_to_col_position(column_groups):
  function _convert_frame_to_string_series (line 1017) | def _convert_frame_to_string_series(
  function _combine_series (line 1075) | def _combine_series(value_sr, inference_sr):
  function _create_statistics_sr (line 1105) | def _create_statistics_sr(
  function _process_frame_indices (line 1187) | def _process_frame_indices(
  function _generate_notes_latex (line 1238) | def _generate_notes_latex(
  function _generate_notes_html (line 1298) | def _generate_notes_html(
  function _extract_params_from_sm (line 1360) | def _extract_params_from_sm(model):
  function _extract_info_from_sm (line 1372) | def _extract_info_from_sm(model):
  function _apply_number_format (line 1391) | def _apply_number_format(df_raw, number_format, format_integers):
  function _format_non_scientific_numbers (line 1430) | def _format_non_scientific_numbers(number_string, format_string):
  function _process_number_format (line 1439) | def _process_number_format(raw_format):
  function _get_digits_after_decimal (line 1459) | def _get_digits_after_decimal(df):
  function _center_align_integers_and_non_numeric_strings (line 1481) | def _center_align_integers_and_non_numeric_strings(sr):
  function _get_updated_styler (line 1494) | def _get_updated_styler(
  function _is_integer (line 1510) | def _is_integer(num):

FILE: src/estimagic/examples/logit.py
  function logit_loglike_and_derivative (line 9) | def logit_loglike_and_derivative(params, y, x):
  function scalar_logit_fun_and_jac (line 14) | def scalar_logit_fun_and_jac(params, y, x):
  function logit_loglike (line 19) | def logit_loglike(params, y, x):
  function logit_grad (line 43) | def logit_grad(params, y, x):
  function logit_jac (line 47) | def logit_jac(params, y, x):
  function logit_hess (line 72) | def logit_hess(params, y, x):  # noqa: ARG001

FILE: src/estimagic/lollipop_plot.py
  function lollipop_plot (line 10) | def lollipop_plot(
  function _harmonize_data (line 139) | def _harmonize_data(data):
  function _make_string_index (line 163) | def _make_string_index(ind):

FILE: src/estimagic/ml_covs.py
  function cov_hessian (line 11) | def cov_hessian(hess):
  function cov_jacobian (line 42) | def cov_jacobian(jac):
  function cov_robust (line 66) | def cov_robust(jac, hess):
  function se_from_cov (line 97) | def se_from_cov(cov):
  function cov_cluster_robust (line 115) | def cov_cluster_robust(jac, hess, design_info):
  function cov_strata_robust (line 147) | def cov_strata_robust(jac, hess, design_info):
  function _sandwich_step (line 181) | def _sandwich_step(hess, meat):
  function _clustering (line 202) | def _clustering(jac, design_info):
  function _stratification (line 229) | def _stratification(jac, design_info):

FILE: src/estimagic/msm_covs.py
  function cov_robust (line 8) | def cov_robust(jac, weights, moments_cov):
  function cov_optimal (line 44) | def cov_optimal(jac, weights):

FILE: src/estimagic/msm_sensitivity.py
  function calculate_sensitivity_to_bias (line 20) | def calculate_sensitivity_to_bias(jac, weights):
  function calculate_fundamental_sensitivity_to_noise (line 49) | def calculate_fundamental_sensitivity_to_noise(
  function calculate_actual_sensitivity_to_noise (line 106) | def calculate_actual_sensitivity_to_noise(
  function calculate_actual_sensitivity_to_removal (line 163) | def calculate_actual_sensitivity_to_removal(jac, weights, moments_cov, p...
  function calculate_fundamental_sensitivity_to_removal (line 215) | def calculate_fundamental_sensitivity_to_removal(jac, moments_cov, param...
  function calculate_sensitivity_to_weighting (line 273) | def calculate_sensitivity_to_weighting(jac, weights, moments_cov, params...
  function _sandwich (line 347) | def _sandwich(a, b):
  function _sandwich_plus (line 353) | def _sandwich_plus(a, b, c):

FILE: src/estimagic/msm_weighting.py
  function get_moments_cov (line 14) | def get_moments_cov(
  function get_weighting_matrix (line 76) | def get_weighting_matrix(
  function _assemble_block_diagonal_matrix (line 135) | def _assemble_block_diagonal_matrix(matrices):

FILE: src/estimagic/shared_covs.py
  function transform_covariance (line 12) | def transform_covariance(
  function calculate_summary_data_estimation (line 90) | def calculate_summary_data_estimation(
  function calculate_estimation_summary (line 123) | def calculate_estimation_summary(
  function process_pandas_arguments (line 218) | def process_pandas_arguments(**kwargs):
  function _to_numpy (line 267) | def _to_numpy(df_or_array, name):
  function _check_names_coincide (line 279) | def _check_names_coincide(name_dict):
  function get_derivative_case (line 290) | def get_derivative_case(derivative):
  function calculate_ci (line 301) | def calculate_ci(free_values, free_standard_errors, ci_level):
  function calculate_p_values (line 309) | def calculate_p_values(free_values, free_standard_errors):
  function calculate_free_estimates (line 315) | def calculate_free_estimates(estimates, internal_estimates):
  function transform_free_cov_to_cov (line 331) | def transform_free_cov_to_cov(free_cov, free_params, params, return_type):
  function transform_free_values_to_params_tree (line 349) | def transform_free_values_to_params_tree(values, free_params, params):
  class FreeParams (line 359) | class FreeParams(NamedTuple):

FILE: src/optimagic/algorithms.py
  class AlgoSelection (line 120) | class AlgoSelection:
    method _all (line 121) | def _all(self) -> list[Type[Algorithm]]:
    method _available (line 125) | def _available(self) -> list[Type[Algorithm]]:
    method All (line 134) | def All(self) -> list[Type[Algorithm]]:
    method Available (line 138) | def Available(self) -> list[Type[Algorithm]]:
    method AllNames (line 142) | def AllNames(self) -> list[str]:
    method AvailableNames (line 146) | def AvailableNames(self) -> list[str]:
    method _all_algorithms_dict (line 150) | def _all_algorithms_dict(self) -> dict[str, Type[Algorithm]]:
    method _available_algorithms_dict (line 154) | def _available_algorithms_dict(self) -> dict[str, Type[Algorithm]]:
  class BoundedGlobalGradientFreeNonlinearConstrainedParallelScalarAlgorithms (line 159) | class BoundedGlobalGradientFreeNonlinearConstrainedParallelScalarAlgorit...
  class BoundedGlobalGradientBasedNonlinearConstrainedScalarAlgorithms (line 168) | class BoundedGlobalGradientBasedNonlinearConstrainedScalarAlgorithms(Alg...
  class BoundedGradientBasedLocalNonlinearConstrainedScalarAlgorithms (line 173) | class BoundedGradientBasedLocalNonlinearConstrainedScalarAlgorithms(Algo...
  class BoundedGlobalGradientFreeNonlinearConstrainedScalarAlgorithms (line 182) | class BoundedGlobalGradientFreeNonlinearConstrainedScalarAlgorithms(Algo...
    method Parallel (line 189) | def Parallel(
  class BoundedGlobalGradientFreeNonlinearConstrainedParallelAlgorithms (line 196) | class BoundedGlobalGradientFreeNonlinearConstrainedParallelAlgorithms(Al...
    method Scalar (line 202) | def Scalar(
  class BoundedGlobalGradientFreeParallelScalarAlgorithms (line 209) | class BoundedGlobalGradientFreeParallelScalarAlgorithms(AlgoSelection):
    method NonlinearConstrained (line 235) | def NonlinearConstrained(
  class GlobalGradientFreeNonlinearConstrainedParallelScalarAlgorithms (line 242) | class GlobalGradientFreeNonlinearConstrainedParallelScalarAlgorithms(Alg...
    method Bounded (line 248) | def Bounded(
  class BoundedGradientFreeLocalNonlinearConstrainedScalarAlgorithms (line 255) | class BoundedGradientFreeLocalNonlinearConstrainedScalarAlgorithms(AlgoS...
  class BoundedGradientFreeLocalParallelScalarAlgorithms (line 260) | class BoundedGradientFreeLocalParallelScalarAlgorithms(AlgoSelection):
  class BoundedGradientFreeLeastSquaresLocalParallelAlgorithms (line 265) | class BoundedGradientFreeLeastSquaresLocalParallelAlgorithms(AlgoSelecti...
  class BoundedGradientFreeNonlinearConstrainedParallelScalarAlgorithms (line 271) | class BoundedGradientFreeNonlinearConstrainedParallelScalarAlgorithms(Al...
    method Global (line 277) | def Global(
  class BoundedGlobalNonlinearConstrainedParallelScalarAlgorithms (line 284) | class BoundedGlobalNonlinearConstrainedParallelScalarAlgorithms(AlgoSele...
    method GradientFree (line 290) | def GradientFree(
  class BoundedGlobalGradientBasedNonlinearConstrainedAlgorithms (line 297) | class BoundedGlobalGradientBasedNonlinearConstrainedAlgorithms(AlgoSelec...
    method Scalar (line 301) | def Scalar(self) -> BoundedGlobalGradientBasedNonlinearConstrainedScal...
  class BoundedGlobalGradientBasedScalarAlgorithms (line 306) | class BoundedGlobalGradientBasedScalarAlgorithms(AlgoSelection):
    method NonlinearConstrained (line 312) | def NonlinearConstrained(
  class GlobalGradientBasedNonlinearConstrainedScalarAlgorithms (line 319) | class GlobalGradientBasedNonlinearConstrainedScalarAlgorithms(AlgoSelect...
    method Bounded (line 323) | def Bounded(self) -> BoundedGlobalGradientBasedNonlinearConstrainedSca...
  class BoundedGradientBasedLocalNonlinearConstrainedAlgorithms (line 328) | class BoundedGradientBasedLocalNonlinearConstrainedAlgorithms(AlgoSelect...
    method Scalar (line 336) | def Scalar(self) -> BoundedGradientBasedLocalNonlinearConstrainedScala...
  class BoundedGradientBasedLocalScalarAlgorithms (line 341) | class BoundedGradientBasedLocalScalarAlgorithms(AlgoSelection):
    method NonlinearConstrained (line 357) | def NonlinearConstrained(
  class BoundedGradientBasedLeastSquaresLocalAlgorithms (line 364) | class BoundedGradientBasedLeastSquaresLocalAlgorithms(AlgoSelection):
  class GradientBasedLocalNonlinearConstrainedScalarAlgorithms (line 370) | class GradientBasedLocalNonlinearConstrainedScalarAlgorithms(AlgoSelecti...
    method Bounded (line 378) | def Bounded(self) -> BoundedGradientBasedLocalNonlinearConstrainedScal...
  class BoundedGradientBasedNonlinearConstrainedScalarAlgorithms (line 383) | class BoundedGradientBasedNonlinearConstrainedScalarAlgorithms(AlgoSelec...
    method Global (line 392) | def Global(self) -> BoundedGlobalGradientBasedNonlinearConstrainedScal...
    method Local (line 396) | def Local(self) -> BoundedGradientBasedLocalNonlinearConstrainedScalar...
  class BoundedGlobalGradientFreeNonlinearConstrainedAlgorithms (line 401) | class BoundedGlobalGradientFreeNonlinearConstrainedAlgorithms(AlgoSelect...
    method Parallel (line 408) | def Parallel(
    method Scalar (line 414) | def Scalar(self) -> BoundedGlobalGradientFreeNonlinearConstrainedScala...
  class BoundedGlobalGradientFreeScalarAlgorithms (line 419) | class BoundedGlobalGradientFreeScalarAlgorithms(AlgoSelection):
    method NonlinearConstrained (line 481) | def NonlinearConstrained(
    method Parallel (line 487) | def Parallel(self) -> BoundedGlobalGradientFreeParallelScalarAlgorithms:
  class BoundedGlobalGradientFreeParallelAlgorithms (line 492) | class BoundedGlobalGradientFreeParallelAlgorithms(AlgoSelection):
    method NonlinearConstrained (line 518) | def NonlinearConstrained(
    method Scalar (line 524) | def Scalar(self) -> BoundedGlobalGradientFreeParallelScalarAlgorithms:
  class GlobalGradientFreeNonlinearConstrainedScalarAlgorithms (line 529) | class GlobalGradientFreeNonlinearConstrainedScalarAlgorithms(AlgoSelecti...
    method Bounded (line 536) | def Bounded(self) -> BoundedGlobalGradientFreeNonlinearConstrainedScal...
    method Parallel (line 540) | def Parallel(
  class GlobalGradientFreeNonlinearConstrainedParallelAlgorithms (line 547) | class GlobalGradientFreeNonlinearConstrainedParallelAlgorithms(AlgoSelec...
    method Bounded (line 553) | def Bounded(
    method Scalar (line 559) | def Scalar(self) -> GlobalGradientFreeNonlinearConstrainedParallelScal...
  class GlobalGradientFreeParallelScalarAlgorithms (line 564) | class GlobalGradientFreeParallelScalarAlgorithms(AlgoSelection):
    method Bounded (line 590) | def Bounded(self) -> BoundedGlobalGradientFreeParallelScalarAlgorithms:
    method NonlinearConstrained (line 594) | def NonlinearConstrained(
  class BoundedGradientFreeLocalNonlinearConstrainedAlgorithms (line 601) | class BoundedGradientFreeLocalNonlinearConstrainedAlgorithms(AlgoSelecti...
    method Scalar (line 605) | def Scalar(self) -> BoundedGradientFreeLocalNonlinearConstrainedScalar...
  class BoundedGradientFreeLocalScalarAlgorithms (line 610) | class BoundedGradientFreeLocalScalarAlgorithms(AlgoSelection):
    method NonlinearConstrained (line 622) | def NonlinearConstrained(
    method Parallel (line 628) | def Parallel(self) -> BoundedGradientFreeLocalParallelScalarAlgorithms:
  class BoundedGradientFreeLeastSquaresLocalAlgorithms (line 633) | class BoundedGradientFreeLeastSquaresLocalAlgorithms(AlgoSelection):
    method Parallel (line 640) | def Parallel(self) -> BoundedGradientFreeLeastSquaresLocalParallelAlgo...
  class BoundedGradientFreeLocalParallelAlgorithms (line 645) | class BoundedGradientFreeLocalParallelAlgorithms(AlgoSelection):
    method LeastSquares (line 651) | def LeastSquares(self) -> BoundedGradientFreeLeastSquaresLocalParallel...
    method Scalar (line 655) | def Scalar(self) -> BoundedGradientFreeLocalParallelScalarAlgorithms:
  class GradientFreeLocalNonlinearConstrainedScalarAlgorithms (line 660) | class GradientFreeLocalNonlinearConstrainedScalarAlgorithms(AlgoSelection):
    method Bounded (line 665) | def Bounded(self) -> BoundedGradientFreeLocalNonlinearConstrainedScala...
  class GradientFreeLocalParallelScalarAlgorithms (line 670) | class GradientFreeLocalParallelScalarAlgorithms(AlgoSelection):
    method Bounded (line 675) | def Bounded(self) -> BoundedGradientFreeLocalParallelScalarAlgorithms:
  class GradientFreeLeastSquaresLocalParallelAlgorithms (line 680) | class GradientFreeLeastSquaresLocalParallelAlgorithms(AlgoSelection):
    method Bounded (line 685) | def Bounded(self) -> BoundedGradientFreeLeastSquaresLocalParallelAlgor...
  class BoundedGradientFreeNonlinearConstrainedScalarAlgorithms (line 690) | class BoundedGradientFreeNonlinearConstrainedScalarAlgorithms(AlgoSelect...
    method Global (line 698) | def Global(self) -> BoundedGlobalGradientFreeNonlinearConstrainedScala...
    method Local (line 702) | def Local(self) -> BoundedGradientFreeLocalNonlinearConstrainedScalarA...
    method Parallel (line 706) | def Parallel(
  class BoundedGradientFreeNonlinearConstrainedParallelAlgorithms (line 713) | class BoundedGradientFreeNonlinearConstrainedParallelAlgorithms(AlgoSele...
    method Global (line 719) | def Global(self) -> BoundedGlobalGradientFreeNonlinearConstrainedParal...
    method Scalar (line 723) | def Scalar(self) -> BoundedGradientFreeNonlinearConstrainedParallelSca...
  class BoundedGradientFreeParallelScalarAlgorithms (line 728) | class BoundedGradientFreeParallelScalarAlgorithms(AlgoSelection):
    method Global (line 755) | def Global(self) -> BoundedGlobalGradientFreeParallelScalarAlgorithms:
    method Local (line 759) | def Local(self) -> BoundedGradientFreeLocalParallelScalarAlgorithms:
    method NonlinearConstrained (line 763) | def NonlinearConstrained(
  class BoundedGradientFreeLeastSquaresParallelAlgorithms (line 770) | class BoundedGradientFreeLeastSquaresParallelAlgorithms(AlgoSelection):
    method Local (line 775) | def Local(self) -> BoundedGradientFreeLeastSquaresLocalParallelAlgorit...
  class GradientFreeNonlinearConstrainedParallelScalarAlgorithms (line 780) | class GradientFreeNonlinearConstrainedParallelScalarAlgorithms(AlgoSelec...
    method Bounded (line 786) | def Bounded(
    method Global (line 792) | def Global(self) -> GlobalGradientFreeNonlinearConstrainedParallelScal...
  class BoundedGlobalNonlinearConstrainedScalarAlgorithms (line 797) | class BoundedGlobalNonlinearConstrainedScalarAlgorithms(AlgoSelection):
    method GradientBased (line 805) | def GradientBased(
    method GradientFree (line 811) | def GradientFree(
    method Parallel (line 817) | def Parallel(self) -> BoundedGlobalNonlinearConstrainedParallelScalarA...
  class BoundedGlobalNonlinearConstrainedParallelAlgorithms (line 822) | class BoundedGlobalNonlinearConstrainedParallelAlgorithms(AlgoSelection):
    method GradientFree (line 828) | def GradientFree(
    method Scalar (line 834) | def Scalar(self) -> BoundedGlobalNonlinearConstrainedParallelScalarAlg...
  class BoundedGlobalParallelScalarAlgorithms (line 839) | class BoundedGlobalParallelScalarAlgorithms(AlgoSelection):
    method GradientFree (line 865) | def GradientFree(self) -> BoundedGlobalGradientFreeParallelScalarAlgor...
    method NonlinearConstrained (line 869) | def NonlinearConstrained(
  class GlobalNonlinearConstrainedParallelScalarAlgorithms (line 876) | class GlobalNonlinearConstrainedParallelScalarAlgorithms(AlgoSelection):
    method Bounded (line 882) | def Bounded(self) -> BoundedGlobalNonlinearConstrainedParallelScalarAl...
    method GradientFree (line 886) | def GradientFree(
  class BoundedLocalNonlinearConstrainedScalarAlgorithms (line 893) | class BoundedLocalNonlinearConstrainedScalarAlgorithms(AlgoSelection):
    method GradientBased (line 902) | def GradientBased(
    method GradientFree (line 908) | def GradientFree(
  class BoundedLocalParallelScalarAlgorithms (line 915) | class BoundedLocalParallelScalarAlgorithms(AlgoSelection):
    method GradientFree (line 919) | def GradientFree(self) -> BoundedGradientFreeLocalParallelScalarAlgori...
  class BoundedLeastSquaresLocalParallelAlgorithms (line 924) | class BoundedLeastSquaresLocalParallelAlgorithms(AlgoSelection):
    method GradientFree (line 929) | def GradientFree(self) -> BoundedGradientFreeLeastSquaresLocalParallel...
  class BoundedNonlinearConstrainedParallelScalarAlgorithms (line 934) | class BoundedNonlinearConstrainedParallelScalarAlgorithms(AlgoSelection):
    method Global (line 940) | def Global(self) -> BoundedGlobalNonlinearConstrainedParallelScalarAlg...
    method GradientFree (line 944) | def GradientFree(
  class BoundedGlobalGradientBasedAlgorithms (line 951) | class BoundedGlobalGradientBasedAlgorithms(AlgoSelection):
    method NonlinearConstrained (line 957) | def NonlinearConstrained(
    method Scalar (line 963) | def Scalar(self) -> BoundedGlobalGradientBasedScalarAlgorithms:
  class GlobalGradientBasedNonlinearConstrainedAlgorithms (line 968) | class GlobalGradientBasedNonlinearConstrainedAlgorithms(AlgoSelection):
    method Bounded (line 972) | def Bounded(self) -> BoundedGlobalGradientBasedNonlinearConstrainedAlg...
    method Scalar (line 976) | def Scalar(self) -> GlobalGradientBasedNonlinearConstrainedScalarAlgor...
  class GlobalGradientBasedScalarAlgorithms (line 981) | class GlobalGradientBasedScalarAlgorithms(AlgoSelection):
    method Bounded (line 987) | def Bounded(self) -> BoundedGlobalGradientBasedScalarAlgorithms:
    method NonlinearConstrained (line 991) | def NonlinearConstrained(
  class BoundedGradientBasedLocalAlgorithms (line 998) | class BoundedGradientBasedLocalAlgorithms(AlgoSelection):
    method LeastSquares (line 1016) | def LeastSquares(self) -> BoundedGradientBasedLeastSquaresLocalAlgorit...
    method NonlinearConstrained (line 1020) | def NonlinearConstrained(
    method Scalar (line 1026) | def Scalar(self) -> BoundedGradientBasedLocalScalarAlgorithms:
  class GradientBasedLocalNonlinearConstrainedAlgorithms (line 1031) | class GradientBasedLocalNonlinearConstrainedAlgorithms(AlgoSelection):
    method Bounded (line 1039) | def Bounded(self) -> BoundedGradientBasedLocalNonlinearConstrainedAlgo...
    method Scalar (line 1043) | def Scalar(self) -> GradientBasedLocalNonlinearConstrainedScalarAlgori...
  class GradientBasedLocalScalarAlgorithms (line 1048) | class GradientBasedLocalScalarAlgorithms(AlgoSelection):
    method Bounded (line 1067) | def Bounded(self) -> BoundedGradientBasedLocalScalarAlgorithms:
    method NonlinearConstrained (line 1071) | def NonlinearConstrained(
  class GradientBasedLeastSquaresLocalAlgorithms (line 1078) | class GradientBasedLeastSquaresLocalAlgorithms(AlgoSelection):
    method Bounded (line 1084) | def Bounded(self) -> BoundedGradientBasedLeastSquaresLocalAlgorithms:
  class GradientBasedLikelihoodLocalAlgorithms (line 1089) | class GradientBasedLikelihoodLocalAlgorithms(AlgoSelection):
  class BoundedGradientBasedNonlinearConstrainedAlgorithms (line 1094) | class BoundedGradientBasedNonlinearConstrainedAlgorithms(AlgoSelection):
    method Global (line 1103) | def Global(self) -> BoundedGlobalGradientBasedNonlinearConstrainedAlgo...
    method Local (line 1107) | def Local(self) -> BoundedGradientBasedLocalNonlinearConstrainedAlgori...
    method Scalar (line 1111) | def Scalar(self) -> BoundedGradientBasedNonlinearConstrainedScalarAlgo...
  class BoundedGradientBasedScalarAlgorithms (line 1116) | class BoundedGradientBasedScalarAlgorithms(AlgoSelection):
    method Global (line 1135) | def Global(self) -> BoundedGlobalGradientBasedScalarAlgorithms:
    method Local (line 1139) | def Local(self) -> BoundedGradientBasedLocalScalarAlgorithms:
    method NonlinearConstrained (line 1143) | def NonlinearConstrained(
  class BoundedGradientBasedLeastSquaresAlgorithms (line 1150) | class BoundedGradientBasedLeastSquaresAlgorithms(AlgoSelection):
    method Local (line 1155) | def Local(self) -> BoundedGradientBasedLeastSquaresLocalAlgorithms:
  class GradientBasedNonlinearConstrainedScalarAlgorithms (line 1160) | class GradientBasedNonlinearConstrainedScalarAlgorithms(AlgoSelection):
    method Bounded (line 1169) | def Bounded(self) -> BoundedGradientBasedNonlinearConstrainedScalarAlg...
    method Global (line 1173) | def Global(self) -> GlobalGradientBasedNonlinearConstrainedScalarAlgor...
    method Local (line 1177) | def Local(self) -> GradientBasedLocalNonlinearConstrainedScalarAlgorit...
  class BoundedGlobalGradientFreeAlgorithms (line 1182) | class BoundedGlobalGradientFreeAlgorithms(AlgoSelection):
    method NonlinearConstrained (line 1244) | def NonlinearConstrained(
    method Parallel (line 1250) | def Parallel(self) -> BoundedGlobalGradientFreeParallelAlgorithms:
    method Scalar (line 1254) | def Scalar(self) -> BoundedGlobalGradientFreeScalarAlgorithms:
  class GlobalGradientFreeNonlinearConstrainedAlgorithms (line 1259) | class GlobalGradientFreeNonlinearConstrainedAlgorithms(AlgoSelection):
    method Bounded (line 1266) | def Bounded(self) -> BoundedGlobalGradientFreeNonlinearConstrainedAlgo...
    method Parallel (line 1270) | def Parallel(self) -> GlobalGradientFreeNonlinearConstrainedParallelAl...
    method Scalar (line 1274) | def Scalar(self) -> GlobalGradientFreeNonlinearConstrainedScalarAlgori...
  class GlobalGradientFreeScalarAlgorithms (line 1279) | class GlobalGradientFreeScalarAlgorithms(AlgoSelection):
    method Bounded (line 1341) | def Bounded(self) -> BoundedGlobalGradientFreeScalarAlgorithms:
    method NonlinearConstrained (line 1345) | def NonlinearConstrained(
    method Parallel (line 1351) | def Parallel(self) -> GlobalGradientFreeParallelScalarAlgorithms:
  class GlobalGradientFreeParallelAlgorithms (line 1356) | class GlobalGradientFreeParallelAlgorithms(AlgoSelection):
    method Bounded (line 1382) | def Bounded(self) -> BoundedGlobalGradientFreeParallelAlgorithms:
    method NonlinearConstrained (line 1386) | def NonlinearConstrained(
    method Scalar (line 1392) | def Scalar(self) -> GlobalGradientFreeParallelScalarAlgorithms:
  class BoundedGradientFreeLocalAlgorithms (line 1397) | class BoundedGradientFreeLocalAlgorithms(AlgoSelection):
    method LeastSquares (line 1413) | def LeastSquares(self) -> BoundedGradientFreeLeastSquaresLocalAlgorithms:
    method NonlinearConstrained (line 1417) | def NonlinearConstrained(
    method Parallel (line 1423) | def Parallel(self) -> BoundedGradientFreeLocalParallelAlgorithms:
    method Scalar (line 1427) | def Scalar(self) -> BoundedGradientFreeLocalScalarAlgorithms:
  class GradientFreeLocalNonlinearConstrainedAlgorithms (line 1432) | class GradientFreeLocalNonlinearConstrainedAlgorithms(AlgoSelection):
    method Bounded (line 1437) | def Bounded(self) -> BoundedGradientFreeLocalNonlinearConstrainedAlgor...
    method Scalar (line 1441) | def Scalar(self) -> GradientFreeLocalNonlinearConstrainedScalarAlgorit...
  class GradientFreeLocalScalarAlgorithms (line 1446) | class GradientFreeLocalScalarAlgorithms(AlgoSelection):
    method Bounded (line 1461) | def Bounded(self) -> BoundedGradientFreeLocalScalarAlgorithms:
    method NonlinearConstrained (line 1465) | def NonlinearConstrained(
    method Parallel (line 1471) | def Parallel(self) -> GradientFreeLocalParallelScalarAlgorithms:
  class GradientFreeLeastSquaresLocalAlgorithms (line 1476) | class GradientFreeLeastSquaresLocalAlgorithms(AlgoSelection):
    method Bounded (line 1483) | def Bounded(self) -> BoundedGradientFreeLeastSquaresLocalAlgorithms:
    method Parallel (line 1487) | def Parallel(self) -> GradientFreeLeastSquaresLocalParallelAlgorithms:
  class GradientFreeLocalParallelAlgorithms (line 1492) | class GradientFreeLocalParallelAlgorithms(AlgoSelection):
    method Bounded (line 1499) | def Bounded(self) -> BoundedGradientFreeLocalParallelAlgorithms:
    method LeastSquares (line 1503) | def LeastSquares(self) -> GradientFreeLeastSquaresLocalParallelAlgorit...
    method Scalar (line 1507) | def Scalar(self) -> GradientFreeLocalParallelScalarAlgorithms:
  class BoundedGradientFreeNonlinearConstrainedAlgorithms (line 1512) | class BoundedGradientFreeNonlinearConstrainedAlgorithms(AlgoSelection):
    method Global (line 1520) | def Global(self) -> BoundedGlobalGradientFreeNonlinearConstrainedAlgor...
    method Local (line 1524) | def Local(self) -> BoundedGradientFreeLocalNonlinearConstrainedAlgorit...
    method Parallel (line 1528) | def Parallel(self) -> BoundedGradientFreeNonlinearConstrainedParallelA...
    method Scalar (line 1532) | def Scalar(self) -> BoundedGradientFreeNonlinearConstrainedScalarAlgor...
  class BoundedGradientFreeScalarAlgorithms (line 1537) | class BoundedGradientFreeScalarAlgorithms(AlgoSelection):
    method Global (line 1608) | def Global(self) -> BoundedGlobalGradientFreeScalarAlgorithms:
    method Local (line 1612) | def Local(self) -> BoundedGradientFreeLocalScalarAlgorithms:
    method NonlinearConstrained (line 1616) | def NonlinearConstrained(
    method Parallel (line 1622) | def Parallel(self) -> BoundedGradientFreeParallelScalarAlgorithms:
  class BoundedGradientFreeLeastSquaresAlgorithms (line 1627) | class BoundedGradientFreeLeastSquaresAlgorithms(AlgoSelection):
    method Local (line 1634) | def Local(self) -> BoundedGradientFreeLeastSquaresLocalAlgorithms:
    method Parallel (line 1638) | def Parallel(self) -> BoundedGradientFreeLeastSquaresParallelAlgorithms:
  class BoundedGradientFreeParallelAlgorithms (line 1643) | class BoundedGradientFreeParallelAlgorithms(AlgoSelection):
    method Global (line 1672) | def Global(self) -> BoundedGlobalGradientFreeParallelAlgorithms:
    method LeastSquares (line 1676) | def LeastSquares(self) -> BoundedGradientFreeLeastSquaresParallelAlgor...
    method Local (line 1680) | def Local(self) -> BoundedGradientFreeLocalParallelAlgorithms:
    method NonlinearConstrained (line 1684) | def NonlinearConstrained(
    method Scalar (line 1690) | def Scalar(self) -> BoundedGradientFreeParallelScalarAlgorithms:
  class GradientFreeNonlinearConstrainedScalarAlgorithms (line 1695) | class GradientFreeNonlinearConstrainedScalarAlgorithms(AlgoSelection):
    method Bounded (line 1704) | def Bounded(self) -> BoundedGradientFreeNonlinearConstrainedScalarAlgo...
    method Global (line 1708) | def Global(self) -> GlobalGradientFreeNonlinearConstrainedScalarAlgori...
    method Local (line 1712) | def Local(self) -> GradientFreeLocalNonlinearConstrainedScalarAlgorithms:
    method Parallel (line 1716) | def Parallel(self) -> GradientFreeNonlinearConstrainedParallelScalarAl...
  class GradientFreeNonlinearConstrainedParallelAlgorithms (line 1721) | class GradientFreeNonlinearConstrainedParallelAlgorithms(AlgoSelection):
    method Bounded (line 1727) | def Bounded(self) -> BoundedGradientFreeNonlinearConstrainedParallelAl...
    method Global (line 1731) | def Global(self) -> GlobalGradientFreeNonlinearConstrainedParallelAlgo...
    method Scalar (line 1735) | def Scalar(self) -> GradientFreeNonlinearConstrainedParallelScalarAlgo...
  class GradientFreeParallelScalarAlgorithms (line 1740) | class GradientFreeParallelScalarAlgorithms(AlgoSelection):
    method Bounded (line 1768) | def Bounded(self) -> BoundedGradientFreeParallelScalarAlgorithms:
    method Global (line 1772) | def Global(self) -> GlobalGradientFreeParallelScalarAlgorithms:
    method Local (line 1776) | def Local(self) -> GradientFreeLocalParallelScalarAlgorithms:
    method NonlinearConstrained (line 1780) | def NonlinearConstrained(
  class GradientFreeLeastSquaresParallelAlgorithms (line 1787) | class GradientFreeLeastSquaresParallelAlgorithms(AlgoSelection):
    method Bounded (line 1792) | def Bounded(self) -> BoundedGradientFreeLeastSquaresParallelAlgorithms:
    method Local (line 1796) | def Local(self) -> GradientFreeLeastSquaresLocalParallelAlgorithms:
  class BoundedGlobalNonlinearConstrainedAlgorithms (line 1801) | class BoundedGlobalNonlinearConstrainedAlgorithms(AlgoSelection):
    method GradientBased (line 1809) | def GradientBased(self) -> BoundedGlobalGradientBasedNonlinearConstrai...
    method GradientFree (line 1813) | def GradientFree(self) -> BoundedGlobalGradientFreeNonlinearConstraine...
    method Parallel (line 1817) | def Parallel(self) -> BoundedGlobalNonlinearConstrainedParallelAlgorit...
    method Scalar (line 1821) | def Scalar(self) -> BoundedGlobalNonlinearConstrainedScalarAlgorithms:
  class BoundedGlobalScalarAlgorithms (line 1826) | class BoundedGlobalScalarAlgorithms(AlgoSelection):
    method GradientBased (line 1891) | def GradientBased(self) -> BoundedGlobalGradientBasedScalarAlgorithms:
    method GradientFree (line 1895) | def GradientFree(self) -> BoundedGlobalGradientFreeScalarAlgorithms:
    method NonlinearConstrained (line 1899) | def NonlinearConstrained(self) -> BoundedGlobalNonlinearConstrainedSca...
    method Parallel (line 1903) | def Parallel(self) -> BoundedGlobalParallelScalarAlgorithms:
  class BoundedGlobalParallelAlgorithms (line 1908) | class BoundedGlobalParallelAlgorithms(AlgoSelection):
    method GradientFree (line 1934) | def GradientFree(self) -> BoundedGlobalGradientFreeParallelAlgorithms:
    method NonlinearConstrained (line 1938) | def NonlinearConstrained(
    method Scalar (line 1944) | def Scalar(self) -> BoundedGlobalParallelScalarAlgorithms:
  class GlobalNonlinearConstrainedScalarAlgorithms (line 1949) | class GlobalNonlinearConstrainedScalarAlgorithms(AlgoSelection):
    method Bounded (line 1957) | def Bounded(self) -> BoundedGlobalNonlinearConstrainedScalarAlgorithms:
    method GradientBased (line 1961) | def GradientBased(self) -> GlobalGradientBasedNonlinearConstrainedScal...
    method GradientFree (line 1965) | def GradientFree(self) -> GlobalGradientFreeNonlinearConstrainedScalar...
    method Parallel (line 1969) | def Parallel(self) -> GlobalNonlinearConstrainedParallelScalarAlgorithms:
  class GlobalNonlinearConstrainedParallelAlgorithms (line 1974) | class GlobalNonlinearConstrainedParallelAlgorithms(AlgoSelection):
    method Bounded (line 1980) | def Bounded(self) -> BoundedGlobalNonlinearConstrainedParallelAlgorithms:
    method GradientFree (line 1984) | def GradientFree(self) -> GlobalGradientFreeNonlinearConstrainedParall...
    method Scalar (line 1988) | def Scalar(self) -> GlobalNonlinearConstrainedParallelScalarAlgorithms:
  class GlobalParallelScalarAlgorithms (line 1993) | class GlobalParallelScalarAlgorithms(AlgoSelection):
    method Bounded (line 2019) | def Bounded(self) -> BoundedGlobalParallelScalarAlgorithms:
    method GradientFree (line 2023) | def GradientFree(self) -> GlobalGradientFreeParallelScalarAlgorithms:
    method NonlinearConstrained (line 2027) | def NonlinearConstrained(
  class BoundedLocalNonlinearConstrainedAlgorithms (line 2034) | class BoundedLocalNonlinearConstrainedAlgorithms(AlgoSelection):
    method GradientBased (line 2043) | def GradientBased(self) -> BoundedGradientBasedLocalNonlinearConstrain...
    method GradientFree (line 2047) | def GradientFree(self) -> BoundedGradientFreeLocalNonlinearConstrained...
    method Scalar (line 2051) | def Scalar(self) -> BoundedLocalNonlinearConstrainedScalarAlgorithms:
  class BoundedLocalScalarAlgorithms (line 2056) | class BoundedLocalScalarAlgorithms(AlgoSelection):
    method GradientBased (line 2081) | def GradientBased(self) -> BoundedGradientBasedLocalScalarAlgorithms:
    method GradientFree (line 2085) | def GradientFree(self) -> BoundedGradientFreeLocalScalarAlgorithms:
    method NonlinearConstrained (line 2089) | def NonlinearConstrained(self) -> BoundedLocalNonlinearConstrainedScal...
    method Parallel (line 2093) | def Parallel(self) -> BoundedLocalParallelScalarAlgorithms:
  class BoundedLeastSquaresLocalAlgorithms (line 2098) | class BoundedLeastSquaresLocalAlgorithms(AlgoSelection):
    method GradientBased (line 2107) | def GradientBased(self) -> BoundedGradientBasedLeastSquaresLocalAlgori...
    method GradientFree (line 2111) | def GradientFree(self) -> BoundedGradientFreeLeastSquaresLocalAlgorithms:
    method Parallel (line 2115) | def Parallel(self) -> BoundedLeastSquaresLocalParallelAlgorithms:
  class BoundedLocalParallelAlgorithms (line 2120) | class BoundedLocalParallelAlgorithms(AlgoSelection):
    method GradientFree (line 2126) | def GradientFree(self) -> BoundedGradientFreeLocalParallelAlgorithms:
    method LeastSquares (line 2130) | def LeastSquares(self) -> BoundedLeastSquaresLocalParallelAlgorithms:
    method Scalar (line 2134) | def Scalar(self) -> BoundedLocalParallelScalarAlgorithms:
  class LocalNonlinearConstrainedScalarAlgorithms (line 2139) | class LocalNonlinearConstrainedScalarAlgorithms(AlgoSelection):
    method Bounded (line 2149) | def Bounded(self) -> BoundedLocalNonlinearConstrainedScalarAlgorithms:
    method GradientBased (line 2153) | def GradientBased(self) -> GradientBasedLocalNonlinearConstrainedScala...
    method GradientFree (line 2157) | def GradientFree(self) -> GradientFreeLocalNonlinearConstrainedScalarA...
  class LocalParallelScalarAlgorithms (line 2162) | class LocalParallelScalarAlgorithms(AlgoSelection):
    method Bounded (line 2167) | def Bounded(self) -> BoundedLocalParallelScalarAlgorithms:
    method GradientFree (line 2171) | def GradientFree(self) -> GradientFreeLocalParallelScalarAlgorithms:
  class LeastSquaresLocalParallelAlgorithms (line 2176) | class LeastSquaresLocalParallelAlgorithms(AlgoSelection):
    method Bounded (line 2181) | def Bounded(self) -> BoundedLeastSquaresLocalParallelAlgorithms:
    method GradientFree (line 2185) | def GradientFree(self) -> GradientFreeLeastSquaresLocalParallelAlgorit...
  class BoundedNonlinearConstrainedScalarAlgorithms (line 2190) | class BoundedNonlinearConstrainedScalarAlgorithms(AlgoSelection):
    method Global (line 2204) | def Global(self) -> BoundedGlobalNonlinearConstrainedScalarAlgorithms:
    method GradientBased (line 2208) | def GradientBased(self) -> BoundedGradientBasedNonlinearConstrainedSca...
    method GradientFree (line 2212) | def GradientFree(self) -> BoundedGradientFreeNonlinearConstrainedScala...
    method Local (line 2216) | def Local(self) -> BoundedLocalNonlinearConstrainedScalarAlgorithms:
    method Parallel (line 2220) | def Parallel(self) -> BoundedNonlinearConstrainedParallelScalarAlgorit...
  class BoundedNonlinearConstrainedParallelAlgorithms (line 2225) | class BoundedNonlinearConstrainedParallelAlgorithms(AlgoSelection):
    method Global (line 2231) | def Global(self) -> BoundedGlobalNonlinearConstrainedParallelAlgorithms:
    method GradientFree (line 2235) | def GradientFree(self) -> BoundedGradientFreeNonlinearConstrainedParal...
    method Scalar (line 2239) | def Scalar(self) -> BoundedNonlinearConstrainedParallelScalarAlgorithms:
  class BoundedParallelScalarAlgorithms (line 2244) | class BoundedParallelScalarAlgorithms(AlgoSelection):
    method Global (line 2271) | def Global(self) -> BoundedGlobalParallelScalarAlgorithms:
    method GradientFree (line 2275) | def GradientFree(self) -> BoundedGradientFreeParallelScalarAlgorithms:
    method Local (line 2279) | def Local(self) -> BoundedLocalParallelScalarAlgorithms:
    method NonlinearConstrained (line 2283) | def NonlinearConstrained(
  class BoundedLeastSquaresParallelAlgorithms (line 2290) | class BoundedLeastSquaresParallelAlgorithms(AlgoSelection):
    method GradientFree (line 2295) | def GradientFree(self) -> BoundedGradientFreeLeastSquaresParallelAlgor...
    method Local (line 2299) | def Local(self) -> BoundedLeastSquaresLocalParallelAlgorithms:
  class NonlinearConstrainedParallelScalarAlgorithms (line 2304) | class NonlinearConstrainedParallelScalarAlgorithms(AlgoSelection):
    method Bounded (line 2310) | def Bounded(self) -> BoundedNonlinearConstrainedParallelScalarAlgorithms:
    method Global (line 2314) | def Global(self) -> GlobalNonlinearConstrainedParallelScalarAlgorithms:
    method GradientFree (line 2318) | def GradientFree(self) -> GradientFreeNonlinearConstrainedParallelScal...
  class GlobalGradientBasedAlgorithms (line 2323) | class GlobalGradientBasedAlgorithms(AlgoSelection):
    method Bounded (line 2329) | def Bounded(self) -> BoundedGlobalGradientBasedAlgorithms:
    method NonlinearConstrained (line 2333) | def NonlinearConstrained(self) -> GlobalGradientBasedNonlinearConstrai...
    method Scalar (line 2337) | def Scalar(self) -> GlobalGradientBasedScalarAlgorithms:
  class GradientBasedLocalAlgorithms (line 2342) | class GradientBasedLocalAlgorithms(AlgoSelection):
    method Bounded (line 2365) | def Bounded(self) -> BoundedGradientBasedLocalAlgorithms:
    method LeastSquares (line 2369) | def LeastSquares(self) -> GradientBasedLeastSquaresLocalAlgorithms:
    method Likelihood (line 2373) | def Likelihood(self) -> GradientBasedLikelihoodLocalAlgorithms:
    method NonlinearConstrained (line 2377) | def NonlinearConstrained(self) -> GradientBasedLocalNonlinearConstrain...
    method Scalar (line 2381) | def Scalar(self) -> GradientBasedLocalScalarAlgorithms:
  class BoundedGradientBasedAlgorithms (line 2386) | class BoundedGradientBasedAlgorithms(AlgoSelection):
    method Global (line 2407) | def Global(self) -> BoundedGlobalGradientBasedAlgorithms:
    method LeastSquares (line 2411) | def LeastSquares(self) -> BoundedGradientBasedLeastSquaresAlgorithms:
    method Local (line 2415) | def Local(self) -> BoundedGradientBasedLocalAlgorithms:
    method NonlinearConstrained (line 2419) | def NonlinearConstrained(
    method Scalar (line 2425) | def Scalar(self) -> BoundedGradientBasedScalarAlgorithms:
  class GradientBasedNonlinearConstrainedAlgorithms (line 2430) | class GradientBasedNonlinearConstrainedAlgorithms(AlgoSelection):
    method Bounded (line 2439) | def Bounded(self) -> BoundedGradientBasedNonlinearConstrainedAlgorithms:
    method Global (line 2443) | def Global(self) -> GlobalGradientBasedNonlinearConstrainedAlgorithms:
    method Local (line 2447) | def Local(self) -> GradientBasedLocalNonlinearConstrainedAlgorithms:
    method Scalar (line 2451) | def Scalar(self) -> GradientBasedNonlinearConstrainedScalarAlgorithms:
  class GradientBasedScalarAlgorithms (line 2456) | class GradientBasedScalarAlgorithms(AlgoSelection):
    method Bounded (line 2478) | def Bounded(self) -> BoundedGradientBasedScalarAlgorithms:
    method Global (line 2482) | def Global(self) -> GlobalGradientBasedScalarAlgorithms:
    method Local (line 2486) | def Local(self) -> GradientBasedLocalScalarAlgorithms:
    method NonlinearConstrained (line 2490) | def NonlinearConstrained(self) -> GradientBasedNonlinearConstrainedSca...
  class GradientBasedLeastSquaresAlgorithms (line 2495) | class GradientBasedLeastSquaresAlgorithms(AlgoSelection):
    method Bounded (line 2501) | def Bounded(self) -> BoundedGradientBasedLeastSquaresAlgorithms:
    method Local (line 2505) | def Local(self) -> GradientBasedLeastSquaresLocalAlgorithms:
  class GradientBasedLikelihoodAlgorithms (line 2510) | class GradientBasedLikelihoodAlgorithms(AlgoSelection):
    method Local (line 2514) | def Local(self) -> GradientBasedLikelihoodLocalAlgorithms:
  class GlobalGradientFreeAlgorithms (line 2519) | class GlobalGradientFreeAlgorithms(AlgoSelection):
    method Bounded (line 2581) | def Bounded(self) -> BoundedGlobalGradientFreeAlgorithms:
    method NonlinearConstrained (line 2585) | def NonlinearConstrained(self) -> GlobalGradientFreeNonlinearConstrain...
    method Parallel (line 2589) | def Parallel(self) -> GlobalGradientFreeParallelAlgorithms:
    method Scalar (line 2593) | def Scalar(self) -> GlobalGradientFreeScalarAlgorithms:
  class GradientFreeLocalAlgorithms (line 2598) | class GradientFreeLocalAlgorithms(AlgoSelection):
    method Bounded (line 2617) | def Bounded(self) -> BoundedGradientFreeLocalAlgorithms:
    method LeastSquares (line 2621) | def LeastSquares(self) -> GradientFreeLeastSquaresLocalAlgorithms:
    method NonlinearConstrained (line 2625) | def NonlinearConstrained(self) -> GradientFreeLocalNonlinearConstraine...
    method Parallel (line 2629) | def Parallel(self) -> GradientFreeLocalParallelAlgorithms:
    method Scalar (line 2633) | def Scalar(self) -> GradientFreeLocalScalarAlgorithms:
  class BoundedGradientFreeAlgorithms (line 2638) | class BoundedGradientFreeAlgorithms(AlgoSelection):
    method Global (line 2713) | def Global(self) -> BoundedGlobalGradientFreeAlgorithms:
    method LeastSquares (line 2717) | def LeastSquares(self) -> BoundedGradientFreeLeastSquaresAlgorithms:
    method Local (line 2721) | def Local(self) -> BoundedGradientFreeLocalAlgorithms:
    method NonlinearConstrained (line 2725) | def NonlinearConstrained(self) -> BoundedGradientFreeNonlinearConstrai...
    method Parallel (line 2729) | def Parallel(self) -> BoundedGradientFreeParallelAlgorithms:
    method Scalar (line 2733) | def Scalar(self) -> BoundedGradientFreeScalarAlgorithms:
  class GradientFreeNonlinearConstrainedAlgorithms (line 2738) | class GradientFreeNonlinearConstrainedAlgorithms(AlgoSelection):
    method Bounded (line 2747) | def Bounded(self) -> BoundedGradientFreeNonlinearConstrainedAlgorithms:
    method Global (line 2751) | def Global(self) -> GlobalGradientFreeNonlinearConstrainedAlgorithms:
    method Local (line 2755) | def Local(self) -> GradientFreeLocalNonlinearConstrainedAlgorithms:
    method Parallel (line 2759) | def Parallel(self) -> GradientFreeNonlinearConstrainedParallelAlgorithms:
    method Scalar (line 2763) | def Scalar(self) -> GradientFreeNonlinearConstrainedScalarAlgorithms:
  class GradientFreeScalarAlgorithms (line 2768) | class GradientFreeScalarAlgorithms(AlgoSelection):
    method Bounded (line 2842) | def Bounded(self) -> BoundedGradientFreeScalarAlgorithms:
    method Global (line 2846) | def Global(self) -> GlobalGradientFreeScalarAlgorithms:
    method Local (line 2850) | def Local(self) -> GradientFreeLocalScalarAlgorithms:
    method NonlinearConstrained (line 2854) | def NonlinearConstrained(self) -> GradientFreeNonlinearConstrainedScal...
    method Parallel (line 2858) | def Parallel(self) -> GradientFreeParallelScalarAlgorithms:
  class GradientFreeLeastSquaresAlgorithms (line 2863) | class GradientFreeLeastSquaresAlgorithms(AlgoSelection):
    method Bounded (line 2870) | def Bounded(self) -> BoundedGradientFreeLeastSquaresAlgorithms:
    method Local (line 2874) | def Local(self) -> GradientFreeLeastSquaresLocalAlgorithms:
    method Parallel (line 2878) | def Parallel(self) -> GradientFreeLeastSquaresParallelAlgorithms:
  class GradientFreeParallelAlgorithms (line 2883) | class GradientFreeParallelAlgorithms(AlgoSelection):
    method Bounded (line 2913) | def Bounded(self) -> BoundedGradientFreeParallelAlgorithms:
    method Global (line 2917) | def Global(self) -> GlobalGradientFreeParallelAlgorithms:
    method LeastSquares (line 2921) | def LeastSquares(self) -> GradientFreeLeastSquaresParallelAlgorithms:
    method Local (line 2925) | def Local(self) -> GradientFreeLocalParallelAlgorithms:
    method NonlinearConstrained (line 2929) | def NonlinearConstrained(
    method Scalar (line 2935) | def Scalar(self) -> GradientFreeParallelScalarAlgorithms:
  class BoundedGlobalAlgorithms (line 2940) | class BoundedGlobalAlgorithms(AlgoSelection):
    method GradientBased (line 3005) | def GradientBased(self) -> BoundedGlobalGradientBasedAlgorithms:
    method GradientFree (line 3009) | def GradientFree(self) -> BoundedGlobalGradientFreeAlgorithms:
    method NonlinearConstrained (line 3013) | def NonlinearConstrained(self) -> BoundedGlobalNonlinearConstrainedAlg...
    method Parallel (line 3017) | def Parallel(self) -> BoundedGlobalParallelAlgorithms:
    method Scalar (line 3021) | def Scalar(self) -> BoundedGlobalScalarAlgorithms:
  class GlobalNonlinearConstrainedAlgorithms (line 3026) | class GlobalNonlinearConstrainedAlgorithms(AlgoSelection):
    method Bounded (line 3034) | def Bounded(self) -> BoundedGlobalNonlinearConstrainedAlgorithms:
    method GradientBased (line 3038) | def GradientBased(self) -> GlobalGradientBasedNonlinearConstrainedAlgo...
    method GradientFree (line 3042) | def GradientFree(self) -> GlobalGradientFreeNonlinearConstrainedAlgori...
    method Parallel (line 3046) | def Parallel(self) -> GlobalNonlinearConstrainedParallelAlgorithms:
    method Scalar (line 3050) | def Scalar(self) -> GlobalNonlinearConstrainedScalarAlgorithms:
  class GlobalScalarAlgorithms (line 3055) | class GlobalScalarAlgorithms(AlgoSelection):
    method Bounded (line 3120) | def Bounded(self) -> BoundedGlobalScalarAlgorithms:
    method GradientBased (line 3124) | def GradientBased(self) -> GlobalGradientBasedScalarAlgorithms:
    method GradientFree (line 3128) | def GradientFree(self) -> GlobalGradientFreeScalarAlgorithms:
    method NonlinearConstrained (line 3132) | def NonlinearConstrained(self) -> GlobalNonlinearConstrainedScalarAlgo...
    method Parallel (line 3136) | def Parallel(self) -> GlobalParallelScalarAlgorithms:
  class GlobalParallelAlgorithms (line 3141) | class GlobalParallelAlgorithms(AlgoSelection):
    method Bounded (line 3167) | def Bounded(self) -> BoundedGlobalParallelAlgorithms:
    method GradientFree (line 3171) | def GradientFree(self) -> GlobalGradientFreeParallelAlgorithms:
    method NonlinearConstrained (line 3175) | def NonlinearConstrained(self) -> GlobalNonlinearConstrainedParallelAl...
    method Scalar (line 3179) | def Scalar(self) -> GlobalParallelScalarAlgorithms:
  class BoundedLocalAlgorithms (line 3184) | class BoundedLocalAlgorithms(AlgoSelection):
    method GradientBased (line 3215) | def GradientBased(self) -> BoundedGradientBasedLocalAlgorithms:
    method GradientFree (line 3219) | def GradientFree(self) -> BoundedGradientFreeLocalAlgorithms:
    method LeastSquares (line 3223) | def LeastSquares(self) -> BoundedLeastSquaresLocalAlgorithms:
    method NonlinearConstrained (line 3227) | def NonlinearConstrained(self) -> BoundedLocalNonlinearConstrainedAlgo...
    method Parallel (line 3231) | def Parallel(self) -> BoundedLocalParallelAlgorithms:
    method Scalar (line 3235) | def Scalar(self) -> BoundedLocalScalarAlgorithms:
  class LocalNonlinearConstrainedAlgorithms (line 3240) | class LocalNonlinearConstrainedAlgorithms(AlgoSelection):
    method Bounded (line 3250) | def Bounded(self) -> BoundedLocalNonlinearConstrainedAlgorithms:
    method GradientBased (line 3254) | def GradientBased(self) -> GradientBasedLocalNonlinearConstrainedAlgor...
    method GradientFree (line 3258) | def GradientFree(self) -> GradientFreeLocalNonlinearConstrainedAlgorit...
    method Scalar (line 3262) | def Scalar(self) -> LocalNonlinearConstrainedScalarAlgorithms:
  class LocalScalarAlgorithms (line 3267) | class LocalScalarAlgorithms(AlgoSelection):
    method Bounded (line 3298) | def Bounded(self) -> BoundedLocalScalarAlgorithms:
    method GradientBased (line 3302) | def GradientBased(self) -> GradientBasedLocalScalarAlgorithms:
    method GradientFree (line 3306) | def GradientFree(self) -> GradientFreeLocalScalarAlgorithms:
    method NonlinearConstrained (line 3310) | def NonlinearConstrained(self) -> LocalNonlinearConstrainedScalarAlgor...
    method Parallel (line 3314) | def Parallel(self) -> LocalParallelScalarAlgorithms:
  class LeastSquaresLocalAlgorithms (line 3319) | class LeastSquaresLocalAlgorithms(AlgoSelection):
    method Bounded (line 3329) | def Bounded(self) -> BoundedLeastSquaresLocalAlgorithms:
    method GradientBased (line 3333) | def GradientBased(self) -> GradientBasedLeastSquaresLocalAlgorithms:
    method GradientFree (line 3337) | def GradientFree(self) -> GradientFreeLeastSquaresLocalAlgorithms:
    method Parallel (line 3341) | def Parallel(self) -> LeastSquaresLocalParallelAlgorithms:
  class LikelihoodLocalAlgorithms (line 3346) | class LikelihoodLocalAlgorithms(AlgoSelection):
    method GradientBased (line 3350) | def GradientBased(self) -> GradientBasedLikelihoodLocalAlgorithms:
  class LocalParallelAlgorithms (line 3355) | class LocalParallelAlgorithms(AlgoSelection):
    method Bounded (line 3362) | def Bounded(self) -> BoundedLocalParallelAlgorithms:
    method GradientFree (line 3366) | def GradientFree(self) -> GradientFreeLocalParallelAlgorithms:
    method LeastSquares (line 3370) | def LeastSquares(self) -> LeastSquaresLocalParallelAlgorithms:
    method Scalar (line 3374) | def Scalar(self) -> LocalParallelScalarAlgorithms:
  class BoundedNonlinearConstrainedAlgorithms (line 3379) | class BoundedNonlinearConstrainedAlgorithms(AlgoSelection):
    method Global (line 3393) | def Global(self) -> BoundedGlobalNonlinearConstrainedAlgorithms:
    method GradientBased (line 3397) | def GradientBased(self) -> BoundedGradientBasedNonlinearConstrainedAlg...
    method GradientFree (line 3401) | def GradientFree(self) -> BoundedGradientFreeNonlinearConstrainedAlgor...
    method Local (line 3405) | def Local(self) -> BoundedLocalNonlinearConstrainedAlgorithms:
    method Parallel (line 3409) | def Parallel(self) -> BoundedNonlinearConstrainedParallelAlgorithms:
    method Scalar (line 3413) | def Scalar(self) -> BoundedNonlinearConstrainedScalarAlgorithms:
  class BoundedScalarAlgorithms (line 3418) | class BoundedScalarAlgorithms(AlgoSelection):
    method Global (line 3505) | def Global(self) -> BoundedGlobalScalarAlgorithms:
    method GradientBased (line 3509) | def GradientBased(self) -> BoundedGradientBasedScalarAlgorithms:
    method GradientFree (line 3513) | def GradientFree(self) -> BoundedGradientFreeScalarAlgorithms:
    method Local (line 3517) | def Local(self) -> BoundedLocalScalarAlgorithms:
    method NonlinearConstrained (line 3521) | def NonlinearConstrained(self) -> BoundedNonlinearConstrainedScalarAlg...
    method Parallel (line 3525) | def Parallel(self) -> BoundedParallelScalarAlgorithms:
  class BoundedLeastSquaresAlgorithms (line 3530) | class BoundedLeastSquaresAlgorithms(AlgoSelection):
    method GradientBased (line 3539) | def GradientBased(self) -> BoundedGradientBasedLeastSquaresAlgorithms:
    method GradientFree (line 3543) | def GradientFree(self) -> BoundedGradientFreeLeastSquaresAlgorithms:
    method Local (line 3547) | def Local(self) -> BoundedLeastSquaresLocalAlgorithms:
    method Parallel (line 3551) | def Parallel(self) -> BoundedLeastSquaresParallelAlgorithms:
  class BoundedParallelAlgorithms (line 3556) | class BoundedParallelAlgorithms(AlgoSelection):
    method Global (line 3585) | def Global(self) -> BoundedGlobalParallelAlgorithms:
    method GradientFree (line 3589) | def GradientFree(self) -> BoundedGradientFreeParallelAlgorithms:
    method LeastSquares (line 3593) | def LeastSquares(self) -> BoundedLeastSquaresParallelAlgorithms:
    method Local (line 3597) | def Local(self) -> BoundedLocalParallelAlgorithms:
    method NonlinearConstrained (line 3601) | def NonlinearConstrained(self) -> BoundedNonlinearConstrainedParallelA...
    method Scalar (line 3605) | def Scalar(self) -> BoundedParallelScalarAlgorithms:
  class NonlinearConstrainedScalarAlgorithms (line 3610) | class NonlinearConstrainedScalarAlgorithms(AlgoSelection):
    method Bounded (line 3625) | def Bounded(self) -> BoundedNonlinearConstrainedScalarAlgorithms:
    method Global (line 3629) | def Global(self) -> GlobalNonlinearConstrainedScalarAlgorithms:
    method GradientBased (line 3633) | def GradientBased(self) -> GradientBasedNonlinearConstrainedScalarAlgo...
    method GradientFree (line 3637) | def GradientFree(self) -> GradientFreeNonlinearConstrainedScalarAlgori...
    method Local (line 3641) | def Local(self) -> LocalNonlinearConstrainedScalarAlgorithms:
    method Parallel (line 3645) | def Parallel(self) -> NonlinearConstrainedParallelScalarAlgorithms:
  class NonlinearConstrainedParallelAlgorithms (line 3650) | class NonlinearConstrainedParallelAlgorithms(AlgoSelection):
    method Bounded (line 3656) | def Bounded(self) -> BoundedNonlinearConstrainedParallelAlgorithms:
    method Global (line 3660) | def Global(self) -> GlobalNonlinearConstrainedParallelAlgorithms:
    method GradientFree (line 3664) | def GradientFree(self) -> GradientFreeNonlinearConstrainedParallelAlgo...
    method Scalar (line 3668) | def Scalar(self) -> NonlinearConstrainedParallelScalarAlgorithms:
  class ParallelScalarAlgorithms (line 3673) | class ParallelScalarAlgorithms(AlgoSelection):
    method Bounded (line 3701) | def Bounded(self) -> BoundedParallelScalarAlgorithms:
    method Global (line 3705) | def Global(self) -> GlobalParallelScalarAlgorithms:
    method GradientFree (line 3709) | def GradientFree(self) -> GradientFreeParallelScalarAlgorithms:
    method Local (line 3713) | def Local(self) -> LocalParallelScalarAlgorithms:
    method NonlinearConstrained (line 3717) | def NonlinearConstrained(self) -> NonlinearConstrainedParallelScalarAl...
  class LeastSquaresParallelAlgorithms (line 3722) | class LeastSquaresParallelAlgorithms(AlgoSelection):
    method Bounded (line 3727) | def Bounded(self) -> BoundedLeastSquaresParallelAlgorithms:
    method GradientFree (line 3731) | def GradientFree(self) -> GradientFreeLeastSquaresParallelAlgorithms:
    method Local (line 3735) | def Local(self) -> LeastSquaresLocalParallelAlgorithms:
  class GradientBasedAlgorithms (line 3740) | class GradientBasedAlgorithms(AlgoSelection):
    method Bounded (line 3766) | def Bounded(self) -> BoundedGradientBasedAlgorithms:
    method Global (line 3770) | def Global(self) -> GlobalGradientBasedAlgorithms:
    method LeastSquares (line 3774) | def LeastSquares(self) -> GradientBasedLeastSquaresAlgorithms:
    method Likelihood (line 3778) | def Likelihood(self) -> GradientBasedLikelihoodAlgorithms:
    method Local (line 3782) | def Local(self) -> GradientBasedLocalAlgorithms:
    method NonlinearConstrained (line 3786) | def NonlinearConstrained(self) -> GradientBasedNonlinearConstrainedAlg...
    method Scalar (line 3790) | def Scalar(self) -> GradientBasedScalarAlgorithms:
  class GradientFreeAlgorithms (line 3795) | class GradientFreeAlgorithms(AlgoSelection):
    method Bounded (line 3873) | def Bounded(self) -> BoundedGradientFreeAlgorithms:
    method Global (line 3877) | def Global(self) -> GlobalGradientFreeAlgorithms:
    method LeastSquares (line 3881) | def LeastSquares(self) -> GradientFreeLeastSquaresAlgorithms:
    method Local (line 3885) | def Local(self) -> GradientFreeLocalAlgorithms:
    method NonlinearConstrained (line 3889) | def NonlinearConstrained(self) -> GradientFreeNonlinearConstrainedAlgo...
    method Parallel (line 3893) | def Parallel(self) -> GradientFreeParallelAlgorithms:
    method Scalar (line 3897) | def Scalar(self) -> GradientFreeScalarAlgorithms:
  class GlobalAlgorithms (line 3902) | class GlobalAlgorithms(AlgoSelection):
    method Bounded (line 3967) | def Bounded(self) -> BoundedGlobalAlgorithms:
    method GradientBased (line 3971) | def GradientBased(self) -> GlobalGradientBasedAlgorithms:
    method GradientFree (line 3975) | def GradientFree(self) -> GlobalGradientFreeAlgorithms:
    method NonlinearConstrained (line 3979) | def NonlinearConstrained(self) -> GlobalNonlinearConstrainedAlgorithms:
    method Parallel (line 3983) | def Parallel(self) -> GlobalParallelAlgorithms:
    method Scalar (line 3987) | def Scalar(self) -> GlobalScalarAlgorithms:
  class LocalAlgorithms (line 3992) | class LocalAlgorithms(AlgoSelection):
    method Bounded (line 4031) | def Bounded(self) -> BoundedLocalAlgorithms:
    method GradientBased (line 4035) | def GradientBased(self) -> GradientBasedLocalAlgorithms:
    method GradientFree (line 4039) | def GradientFree(self) -> GradientFreeLocalAlgorithms:
    method LeastSquares (line 4043) | def LeastSquares(self) -> LeastSquaresLocalAlgorithms:
    method Likelihood (line 4047) | def Likelihood(self) -> LikelihoodLocalAlgorithms:
    method NonlinearConstrained (line 4051) | def NonlinearConstrained(self) -> LocalNonlinearConstrainedAlgorithms:
    method Parallel (line 4055) | def Parallel(self) -> LocalParallelAlgorithms:
    method Scalar (line 4059) | def Scalar(self) -> LocalScalarAlgorithms:
  class BoundedAlgorithms (line 4064) | class BoundedAlgorithms(AlgoSelection):
    method Global (line 4157) | def Global(self) -> BoundedGlobalAlgorithms:
    method GradientBased (line 4161) | def GradientBased(self) -> BoundedGradientBasedAlgorithms:
    method GradientFree (line 4165) | def GradientFree(self) -> BoundedGradientFreeAlgorithms:
    method LeastSquares (line 4169) | def LeastSquares(self) -> BoundedLeastSquaresAlgorithms:
    method Local (line 4173) | def Local(self) -> BoundedLocalAlgorithms:
    method NonlinearConstrained (line 4177) | def NonlinearConstrained(self) -> BoundedNonlinearConstrainedAlgorithms:
    method Parallel (line 4181) | def Parallel(self) -> BoundedParallelAlgorithms:
    method Scalar (line 4185) | def Scalar(self) -> BoundedScalarAlgorithms:
  class NonlinearConstrainedAlgorithms (line 4190) | class NonlinearConstrainedAlgorithms(AlgoSelection):
    method Bounded (line 4205) | def Bounded(self) -> BoundedNonlinearConstrainedAlgorithms:
    method Global (line 4209) | def Global(self) -> GlobalNonlinearConstrainedAlgorithms:
    method GradientBased (line 4213) | def GradientBased(self) -> GradientBasedNonlinearConstrainedAlgorithms:
    method GradientFree (line 4217) | def GradientFree(self) -> GradientFreeNonlinearConstrainedAlgorithms:
    method Local (line 4221) | def Local(self) -> LocalNonlinearConstrainedAlgorithms:
    method Parallel (line 4225) | def Parallel(self) -> NonlinearConstrainedParallelAlgorithms:
    method Scalar (line 4229) | def Scalar(self) -> NonlinearConstrainedScalarAlgorithms:
  class ScalarAlgorithms (line 4234) | class ScalarAlgorithms(AlgoSelection):
    method Bounded (line 4327) | def Bounded(self) -> BoundedScalarAlgorithms:
    method Global (line 4331) | def Global(self) -> GlobalScalarAlgorithms:
    method GradientBased (line 4335) | def GradientBased(self) -> GradientBasedScalarAlgorithms:
    method GradientFree (line 4339) | def GradientFree(self) -> GradientFreeScalarAlgorithms:
    method Local (line 4343) | def Local(self) -> LocalScalarAlgorithms:
    method NonlinearConstrained (line 4347) | def NonlinearConstrained(self) -> NonlinearConstrainedScalarAlgorithms:
    method Parallel (line 4351) | def Parallel(self) -> ParallelScalarAlgorithms:
  class LeastSquaresAlgorithms (line 4356) | class LeastSquaresAlgorithms(AlgoSelection):
    method Bounded (line 4366) | def Bounded(self) -> BoundedLeastSquaresAlgorithms:
    method GradientBased (line 4370) | def GradientBased(self) -> GradientBasedLeastSquaresAlgorithms:
    method GradientFree (line 4374) | def GradientFree(self) -> GradientFreeLeastSquaresAlgorithms:
    method Local (line 4378) | def Local(self) -> LeastSquaresLocalAlgorithms:
    method Parallel (line 4382) | def Parallel(self) -> LeastSquaresParallelAlgorithms:
  class LikelihoodAlgorithms (line 4387) | class LikelihoodAlgorithms(AlgoSelection):
    method GradientBased (line 4391) | def GradientBased(self) -> GradientBasedLikelihoodAlgorithms:
    method Local (line 4395) | def Local(self) -> LikelihoodLocalAlgorithms:
  class ParallelAlgorithms (line 4400) | class ParallelAlgorithms(AlgoSelection):
    method Bounded (line 4430) | def Bounded(self) -> BoundedParallelAlgorithms:
    method Global (line 4434) | def Global(self) -> GlobalParallelAlgorithms:
    method GradientFree (line 4438) | def GradientFree(self) -> GradientFreeParallelAlgorithms:
    method LeastSquares (line 4442) | def LeastSquares(self) -> LeastSquaresParallelAlgorithms:
    method Local (line 4446) | def Local(self) -> LocalParallelAlgorithms:
    method NonlinearConstrained (line 4450) | def NonlinearConstrained(self) -> NonlinearConstrainedParallelAlgorithms:
    method Scalar (line 4454) | def Scalar(self) -> ParallelScalarAlgorithms:
  class Algorithms (line 4459) | class Algorithms(AlgoSelection):
    method Bounded (line 4560) | def Bounded(self) -> BoundedAlgorithms:
    method Global (line 4564) | def Global(self) -> GlobalAlgorithms:
    method GradientBased (line 4568) | def GradientBased(self) -> GradientBasedAlgorithms:
    method GradientFree (line 4572) | def GradientFree(self) -> GradientFreeAlgorithms:
    method LeastSquares (line 4576) | def LeastSquares(self) -> LeastSquaresAlgorithms:
    method Likelihood (line 4580) | def Likelihood(self) -> LikelihoodAlgorithms:
    method Local (line 4584) | def Local(self) -> LocalAlgorithms:
    method NonlinearConstrained (line 4588) | def NonlinearConstrained(self) -> NonlinearConstrainedAlgorithms:
    method Parallel (line 4592) | def Parallel(self) -> ParallelAlgorithms:
    method Scalar (line 4596) | def Scalar(self) -> ScalarAlgorithms:

FILE: src/optimagic/batch_evaluators.py
  function pathos_mp_batch_evaluator (line 28) | def pathos_mp_batch_evaluator(
  function joblib_batch_evaluator (line 97) | def joblib_batch_evaluator(
  function threading_batch_evaluator (line 152) | def threading_batch_evaluator(
  function _check_inputs (line 225) | def _check_inputs(
  function process_batch_evaluator (line 263) | def process_batch_evaluator(

FILE: src/optimagic/benchmarking/benchmark_reports.py
  function convergence_report (line 9) | def convergence_report(
  function rank_report (line 55) | def rank_report(
  function traceback_report (line 128) | def traceback_report(problems, results, return_type="dataframe"):
  function _get_success_info (line 201) | def _get_success_info(results, converged_info):
  function _get_problem_dimensions (line 227) | def _get_problem_dimensions(problems):

FILE: src/optimagic/benchmarking/cartis_roberts.py
  function njit (line 30) | def njit(func):
  function luksan11 (line 43) | def luksan11(x):
  function luksan12 (line 52) | def luksan12(x):
  function luksan13 (line 67) | def luksan13(x):
  function luksan14 (line 85) | def luksan14(x):
  function luksan15 (line 106) | def luksan15(x):
  function luksan16 (line 128) | def luksan16(x):
  function luksan17 (line 149) | def luksan17(x):
  function luksan21 (line 170) | def luksan21(x):
  function luksan22 (line 190) | def luksan22(x):
  function morebvne (line 203) | def morebvne(x):
  function flosp2 (line 220) | def flosp2(x, a, b, ra=1.0e7):
  function oscigrne (line 332) | def oscigrne(x):
  function spmsqrt (line 348) | def spmsqrt(x):
  function semicon2 (line 423) | def semicon2(x):
  function qr3d (line 470) | def qr3d(x, m=5):
  function qr3dbd (line 512) | def qr3dbd(x, m=5):
  function eigen (line 560) | def eigen(x, param):
  function powell_singular (line 570) | def powell_singular(x):
  function hydcar (line 582) | def hydcar(
  function methane (line 703) | def methane(x):
  function argtrig (line 1086) | def argtrig(x):
  function artif (line 1097) | def artif(x):
  function arwhdne (line 1110) | def arwhdne(x):
  function bdvalues (line 1120) | def bdvalues(x):
  function bratu_2d (line 1138) | def bratu_2d(x, alpha):
  function bratu_3d (line 1160) | def bratu_3d(x, alpha):
  function broydn_3d (line 1186) | def broydn_3d(x):
  function broydn_bd (line 1199) | def broydn_bd(x):
  function cbratu_2d (line 1216) | def cbratu_2d(x):
  function chandheq (line 1249) | def chandheq(x):
  function chemrcta (line 1262) | def chemrcta(x):
  function chemrctb (line 1305) | def chemrctb(x):
  function chnrsbne (line 1332) | def chnrsbne(x):
  function drcavty (line 1396) | def drcavty(x, r):
  function freurone (line 1451) | def freurone(x):
  function hatfldg (line 1461) | def hatfldg(x):
  function integreq (line 1472) | def integreq(x):
  function msqrta (line 1502) | def msqrta(x):
  function penalty_1 (line 1520) | def penalty_1(x, a=1e-5):
  function penalty_2 (line 1527) | def penalty_2(x, a=1e-10):
  function vardimne (line 1541) | def vardimne(x):
  function yatpsq_1 (line 1551) | def yatpsq_1(x, dim_in):
  function yatpsq_2 (line 1574) | def yatpsq_2(x, dim_in):
  function get_start_points_msqrta (line 1591) | def get_start_points_msqrta(dim_in, flag=1):
  function get_start_points_bdvalues (line 1602) | def get_start_points_bdvalues(n, a=1):
  function get_start_points_spmsqrt (line 1610) | def get_start_points_spmsqrt(m):
  function get_start_points_qr3d (line 1639) | def get_start_points_qr3d(m):
  function get_start_points_qr3dbd (line 1646) | def get_start_points_qr3dbd(m):
  function get_start_points_hydcar20 (line 1655) | def get_start_points_hydcar20():
  function get_start_points_hydcar6 (line 1721) | def get_start_points_hydcar6():
  function get_start_points_methanb8 (line 1745) | def get_start_points_methanb8():
  function get_start_points_methanl8 (line 1781) | def get_start_points_methanl8():

FILE: src/optimagic/benchmarking/get_benchmark_problems.py
  function get_benchmark_problems (line 14) | def get_benchmark_problems(
  function _get_raw_problems (line 134) | def _get_raw_problems(name):
  function _step_func (line 212) | def _step_func(x, raw_func):
  function _create_problem_inputs (line 216) | def _create_problem_inputs(
  function _create_problem_solution (line 250) | def _create_problem_solution(specification, scaling_options):
  function _get_scaling_factor (line 269) | def _get_scaling_factor(x, options):
  function _internal_criterion_template (line 273) | def _internal_criterion_template(
  function _get_combined_noise (line 293) | def _get_combined_noise(fval, additive_options, multiplicative_options, ...
  function _sample_from_distribution (line 316) | def _sample_from_distribution(distribution, mean, std, size, rng, correl...
  function _process_noise_options (line 328) | def _process_noise_options(options, is_multiplicative):
  function _clip_away_from_zero (line 365) | def _clip_away_from_zero(a, clipval):

FILE: src/optimagic/benchmarking/more_wild.py
  function linear_full_rank (line 32) | def linear_full_rank(x, dim_out):
  function linear_rank_one (line 40) | def linear_rank_one(x, dim_out):
  function linear_rank_one_zero_columns_rows (line 48) | def linear_rank_one_zero_columns_rows(x, dim_out):
  function rosenbrock (line 57) | def rosenbrock(x):
  function helical_valley (line 65) | def helical_valley(x):
  function powell_singular (line 81) | def powell_singular(x):
  function freudenstein_roth (line 91) | def freudenstein_roth(x):
  function bard (line 99) | def bard(x, y):
  function kowalik_osborne (line 111) | def kowalik_osborne(x, y1, y2):
  function meyer (line 119) | def meyer(x, y):
  function watson (line 128) | def watson(x):
  function box_3d (line 142) | def box_3d(x, dim_out):
  function jennrich_sampson (line 154) | def jennrich_sampson(x, dim_out):
  function brown_dennis (line 164) | def brown_dennis(x, dim_out):
  function chebyquad (line 175) | def chebyquad(x, dim_out):
  function brown_almost_linear (line 195) | def brown_almost_linear(x):
  function osborne_one (line 205) | def osborne_one(x, y):
  function osborne_two (line 214) | def osborne_two(x, y):
  function bdqrtic (line 226) | def bdqrtic(x):
  function cube (line 243) | def cube(x):
  function mancino (line 250) | def mancino(x):
  function heart_eight (line 263) | def heart_eight(x, y):
  function get_start_points_mancino (line 302) | def get_start_points_mancino(n, a=1):

FILE: src/optimagic/benchmarking/noise_distributions.py
  function _standard_logistic (line 4) | def _standard_logistic(size, rng):
  function _standard_uniform (line 9) | def _standard_uniform(size, rng):
  function _standard_normal (line 15) | def _standard_normal(size, rng):
  function _standard_gumbel (line 19) | def _standard_gumbel(size, rng):
  function _standard_laplace (line 26) | def _standard_laplace(size, rng):

FILE: src/optimagic/benchmarking/process_benchmark_results.py
  function process_benchmark_results (line 5) | def process_benchmark_results(
  function _process_one_result (line 75) | def _process_one_result(
  function _check_convergence (line 164) | def _check_convergence(values, threshold):
  function _aggregate_idxs_with_and (line 175) | def _aggregate_idxs_with_and(x, y):
  function _aggregate_idxs_with_or (line 183) | def _aggregate_idxs_with_or(x, y):

FILE: src/optimagic/benchmarking/run_benchmark.py
  function run_benchmark (line 20) | def run_benchmark(
  function _process_optimize_options (line 105) | def _process_optimize_options(raw_options, max_evals, disable_convergence):
  function _get_optimization_arguments_and_keys (line 145) | def _get_optimization_arguments_and_keys(problems, opt_options):
  function _process_one_result (line 172) | def _process_one_result(optimize_result, problem):

FILE: src/optimagic/config.py
  function _is_installed (line 32) | def _is_installed(module_name: str) -> bool:

FILE: src/optimagic/constraints.py
  class Constraint (line 16) | class Constraint(ABC):
    method _to_dict (line 20) | def _to_dict(self) -> dict[str, Any]:
  function identity_selector (line 24) | def identity_selector(x: PyTree) -> PyTree:
  class FixedConstraint (line 29) | class FixedConstraint(Constraint):
    method _to_dict (line 43) | def _to_dict(self) -> dict[str, Any]:
    method __post_init__ (line 46) | def __post_init__(self) -> None:
  class IncreasingConstraint (line 52) | class IncreasingConstraint(Constraint):
    method _to_dict (line 66) | def _to_dict(self) -> dict[str, Any]:
    method __post_init__ (line 69) | def __post_init__(self) -> None:
  class DecreasingConstraint (line 75) | class DecreasingConstraint(Constraint):
    method _to_dict (line 89) | def _to_dict(self) -> dict[str, Any]:
    method __post_init__ (line 92) | def __post_init__(self) -> None:
  class EqualityConstraint (line 98) | class EqualityConstraint(Constraint):
    method _to_dict (line 112) | def _to_dict(self) -> dict[str, Any]:
    method __post_init__ (line 115) | def __post_init__(self) -> None:
  class ProbabilityConstraint (line 121) | class ProbabilityConstraint(Constraint):
    method _to_dict (line 138) | def _to_dict(self) -> dict[str, Any]:
    method __post_init__ (line 141) | def __post_init__(self) -> None:
  class PairwiseEqualityConstraint (line 147) | class PairwiseEqualityConstraint(Constraint):
    method _to_dict (line 163) | def _to_dict(self) -> dict[str, Any]:
    method __post_init__ (line 166) | def __post_init__(self) -> None:
  class FlatCovConstraint (line 175) | class FlatCovConstraint(Constraint):
    method _to_dict (line 196) | def _to_dict(self) -> dict[str, Any]:
    method __post_init__ (line 203) | def __post_init__(self) -> None:
  class FlatSDCorrConstraint (line 214) | class FlatSDCorrConstraint(Constraint):
    method _to_dict (line 238) | def _to_dict(self) -> dict[str, Any]:
    method __post_init__ (line 245) | def __post_init__(self) -> None:
  class LinearConstraint (line 256) | class LinearConstraint(Constraint):
    method _to_dict (line 288) | def _to_dict(self) -> dict[str, Any]:
    method __post_init__ (line 300) | def __post_init__(self) -> None:
  class NonlinearConstraint (line 334) | class NonlinearConstraint(Constraint):
    method _to_dict (line 370) | def _to_dict(self) -> dict[str, Any]:
    method __post_init__ (line 385) | def __post_init__(self) -> None:
  function _all_none (line 411) | def _all_none(*args: Any) -> bool:
  function _select_non_none (line 415) | def _select_non_none(**kwargs: Any) -> dict[str, Any]:

FILE: src/optimagic/decorators.py
  function catch (line 24) | def catch(
  function unpack (line 93) | def unpack(func=None, symbol=None):
  function deprecated (line 121) | def deprecated(func, msg):

FILE: src/optimagic/deprecations.py
  function throw_criterion_future_warning (line 25) | def throw_criterion_future_warning():
  function throw_criterion_kwargs_future_warning (line 34) | def throw_criterion_kwargs_future_warning():
  function throw_derivative_future_warning (line 44) | def throw_derivative_future_warning():
  function throw_derivative_kwargs_future_warning (line 55) | def throw_derivative_kwargs_future_warning():
  function throw_criterion_and_derivative_future_warning (line 66) | def throw_criterion_and_derivative_future_warning():
  function throw_criterion_and_derivative_kwargs_future_warning (line 78) | def throw_criterion_and_derivative_kwargs_future_warning():
  function throw_scaling_options_future_warning (line 90) | def throw_scaling_options_future_warning():
  function throw_multistart_options_future_warning (line 99) | def throw_multistart_options_future_warning():
  function throw_derivatives_step_ratio_future_warning (line 110) | def throw_derivatives_step_ratio_future_warning():
  function throw_derivatives_n_steps_future_warning (line 118) | def throw_derivatives_n_steps_future_warning():
  function throw_derivatives_return_info_future_warning (line 126) | def throw_derivatives_return_info_future_warning():
  function throw_derivatives_return_func_value_future_warning (line 134) | def throw_derivatives_return_func_value_future_warning():
  function throw_numdiff_result_func_evals_future_warning (line 142) | def throw_numdiff_result_func_evals_future_warning():
  function throw_numdiff_result_derivative_candidates_future_warning (line 150) | def throw_numdiff_result_derivative_candidates_future_warning():
  function throw_numdiff_options_deprecated_in_estimate_ml_future_warning (line 158) | def throw_numdiff_options_deprecated_in_estimate_ml_future_warning():
  function throw_numdiff_options_deprecated_in_estimate_msm_future_warning (line 168) | def throw_numdiff_options_deprecated_in_estimate_msm_future_warning():
  function throw_dict_access_future_warning (line 177) | def throw_dict_access_future_warning(attribute, obj_name):
  function throw_none_valued_batch_evaluator_warning (line 186) | def throw_none_valued_batch_evaluator_warning():
  function throw_make_subplot_kwargs_in_slice_plot_future_warning (line 195) | def throw_make_subplot_kwargs_in_slice_plot_future_warning():
  function replace_and_warn_about_deprecated_algo_options (line 204) | def replace_and_warn_about_deprecated_algo_options(algo_options):
  function replace_and_warn_about_deprecated_bounds (line 241) | def replace_and_warn_about_deprecated_bounds(
  function convert_dict_to_function_value (line 273) | def convert_dict_to_function_value(candidate):
  function is_dict_output (line 295) | def is_dict_output(candidate):
  function throw_dict_output_warning (line 301) | def throw_dict_output_warning():
  function infer_problem_type_from_dict_output (line 314) | def infer_problem_type_from_dict_output(output):
  function replace_dict_output (line 327) | def replace_dict_output(func: Callable[P, Any]) -> Callable[P, Any]:
  function throw_key_warning_in_derivatives (line 353) | def throw_key_warning_in_derivatives():
  function throw_dict_constraints_future_warning_if_required (line 364) | def throw_dict_constraints_future_warning_if_required(
  function replace_and_warn_about_deprecated_multistart_options (line 405) | def replace_and_warn_about_deprecated_multistart_options(options):
  function replace_and_warn_about_deprecated_base_steps (line 468) | def replace_and_warn_about_deprecated_base_steps(
  function replace_and_warn_about_deprecated_derivatives (line 488) | def replace_and_warn_about_deprecated_derivatives(candidate, name):
  function handle_log_options_throw_deprecated_warning (line 513) | def handle_log_options_throw_deprecated_warning(
  function pre_process_constraints (line 555) | def pre_process_constraints(

FILE: src/optimagic/differentiation/derivatives.py
  class NumdiffResult (line 30) | class NumdiffResult:
    method func_evals (line 66) | def func_evals(self) -> pd.DataFrame | dict[str, pd.DataFrame | None] ...
    method derivative_candidates (line 71) | def derivative_candidates(self) -> pd.DataFrame | None:
    method __getitem__ (line 75) | def __getitem__(self, key: str) -> Any:
  class Evals (line 80) | class Evals(NamedTuple):
  function first_derivative (line 85) | def first_derivative(
  function second_derivative (line 388) | def second_derivative(
  function _is_1d_array (line 724) | def _is_1d_array(candidate: Any) -> bool:
  function _reshape_one_step_evals (line 728) | def _reshape_one_step_evals(raw_evals_one_step, n_steps, dim_x):
  function _process_unpacker (line 749) | def _process_unpacker(
  function _process_scalar_or_array_argument (line 770) | def _process_scalar_or_array_argument(candidate, x, name):
  function _reshape_two_step_evals (line 791) | def _reshape_two_step_evals(raw_evals_two_step, n_steps, dim_x):
  function _reshape_cross_step_evals (line 816) | def _reshape_cross_step_evals(raw_evals_cross_step, n_steps, dim_x, f0):
  function _convert_evaluation_data_to_frame (line 847) | def _convert_evaluation_data_to_frame(steps, evals):
  function _convert_richardson_candidates_to_frame (line 895) | def _convert_richardson_candidates_to_frame(jac, err):
  function _convert_evals_to_numpy (line 923) | def _convert_evals_to_numpy(
  function _consolidate_one_step_derivatives (line 973) | def _consolidate_one_step_derivatives(candidates, preference_order):
  function _consolidate_extrapolated (line 993) | def _consolidate_extrapolated(candidates):
  function _compute_richardson_candidates (line 1034) | def _compute_richardson_candidates(jac_candidates, steps, n_steps):
  function _select_minimizer_along_axis (line 1074) | def _select_minimizer_along_axis(derivative, errors):
  function _nan_skipping_batch_evaluator (line 1110) | def _nan_skipping_batch_evaluator(
  function _split_into_str_and_int (line 1158) | def _split_into_str_and_int(s):
  function _collect_additional_info (line 1178) | def _collect_additional_info(steps, evals, updated_candidates, target):
  function _is_scalar_nan (line 1203) | def _is_scalar_nan(value):
  function _unflatten_if_not_nan (line 1207) | def _unflatten_if_not_nan(leaves, treedef, registry):

FILE: src/optimagic/differentiation/finite_differences.py
  class Evals (line 17) | class Evals(NamedTuple):
  function jacobian (line 22) | def jacobian(evals, steps, f0, method):
  function hessian (line 61) | def hessian(evals, steps, f0, method):
  function _calculate_outer_product_steps (line 142) | def _calculate_outer_product_steps(signed_steps, n_steps, dim_x):

FILE: src/optimagic/differentiation/generate_steps.py
  class Steps (line 9) | class Steps(NamedTuple):
  function generate_steps (line 14) | def generate_steps(
  function _calculate_or_validate_base_steps (line 134) | def _calculate_or_validate_base_steps(base_steps, x, target, min_steps, ...
  function _set_unused_side_to_nan (line 187) | def _set_unused_side_to_nan(
  function _rescale_to_accomodate_bounds (line 233) | def _rescale_to_accomodate_bounds(
  function _fillna (line 273) | def _fillna(x, val):

FILE: src/optimagic/differentiation/numdiff_options.py
  class NumdiffOptions (line 14) | class NumdiffOptions:
    method __post_init__ (line 44) | def __post_init__(self) -> None:
  class NumdiffOptionsDict (line 48) | class NumdiffOptionsDict(TypedDict):
  function pre_process_numdiff_options (line 59) | def pre_process_numdiff_options(
  function _validate_attribute_types_and_values (line 99) | def _validate_attribute_types_and_values(options: NumdiffOptions) -> None:
  class NumdiffPurpose (line 152) | class NumdiffPurpose(str, Enum):
  function get_default_numdiff_options (line 158) | def get_default_numdiff_options(

FILE: src/optimagic/differentiation/richardson_extrapolation.py
  function richardson_extrapolation (line 7) | def richardson_extrapolation(sequence, steps, method="central", num_term...
  function _richardson_coefficients (line 88) | def _richardson_coefficients(num_terms, step_ratio, exponentiation_step,...
  function _estimate_error (line 143) | def _estimate_error(new_seq, old_seq, richardson_coef):
  function _get_order_and_exponentiation_step (line 193) | def _get_order_and_exponentiation_step(method):
  function _compute_step_ratio (line 257) | def _compute_step_ratio(steps):

FILE: src/optimagic/examples/criterion_functions.py
  function trid_scalar (line 27) | def trid_scalar(params: PyTree) -> float:
  function trid_gradient (line 34) | def trid_gradient(params: PyTree) -> PyTree:
  function trid_fun_and_gradient (line 46) | def trid_fun_and_gradient(params: PyTree) -> tuple[float, PyTree]:
  function rhe_scalar (line 54) | def rhe_scalar(params: PyTree) -> float:
  function rhe_gradient (line 64) | def rhe_gradient(params: PyTree) -> PyTree:
  function rhe_fun_and_gradient (line 72) | def rhe_fun_and_gradient(params: PyTree) -> tuple[float, PyTree]:
  function rhe_ls (line 80) | def rhe_ls(params: PyTree) -> NDArray[np.float64]:
  function rhe_function_value (line 91) | def rhe_function_value(params: PyTree) -> FunctionValue:
  function rosenbrock_scalar (line 99) | def rosenbrock_scalar(params: PyTree) -> float:
  function rosenbrock_gradient (line 105) | def rosenbrock_gradient(params: PyTree) -> PyTree:
  function rosenbrock_fun_and_gradient (line 118) | def rosenbrock_fun_and_gradient(params: PyTree) -> tuple[float, PyTree]:
  function rosenbrock_ls (line 124) | def rosenbrock_ls(params: PyTree) -> NDArray[np.float64]:
  function rosenbrock_function_value (line 135) | def rosenbrock_function_value(params: PyTree) -> FunctionValue:
  function sos_ls (line 141) | def sos_ls(params: PyTree) -> NDArray[np.float64]:
  function sos_ls_with_pd_objects (line 147) | def sos_ls_with_pd_objects(params: PyTree) -> pd.Series[float]:
  function sos_scalar (line 153) | def sos_scalar(params: PyTree) -> float:
  function sos_gradient (line 159) | def sos_gradient(params: PyTree) -> PyTree:
  function sos_likelihood (line 166) | def sos_likelihood(params: PyTree) -> NDArray[np.float64]:
  function sos_likelihood_jacobian (line 171) | def sos_likelihood_jacobian(params: PyTree) -> PyTree:
  function sos_ls_jacobian (line 180) | def sos_ls_jacobian(params: PyTree) -> PyTree:
  function sos_fun_and_gradient (line 189) | def sos_fun_and_gradient(params: PyTree) -> tuple[float, PyTree]:
  function sos_likelihood_fun_and_jac (line 195) | def sos_likelihood_fun_and_jac(
  function sos_ls_fun_and_jac (line 203) | def sos_ls_fun_and_jac(
  function _get_x (line 213) | def _get_x(params: PyTree) -> NDArray[np.float64]:
  function _unflatten_gradient (line 222) | def _unflatten_gradient(flat: NDArray[np.float64], params: PyTree) -> Py...

FILE: src/optimagic/examples/numdiff_functions.py
  function logit_loglike (line 22) | def logit_loglike(params, y, x):
  function logit_loglikeobs (line 26) | def logit_loglikeobs(params, y, x):
  function logit_loglike_gradient (line 31) | def logit_loglike_gradient(params, y, x):
  function logit_loglikeobs_jacobian (line 36) | def logit_loglikeobs_jacobian(params, y, x):
  function logit_loglike_hessian (line 41) | def logit_loglike_hessian(params, y, x):  # noqa: ARG001
  function probit_loglike (line 51) | def probit_loglike(params, y, x):
  function probit_loglikeobs (line 55) | def probit_loglikeobs(params, y, x):
  function probit_loglike_gradient (line 60) | def probit_loglike_gradient(params, y, x):
  function probit_loglikeobs_jacobian (line 67) | def probit_loglikeobs_jacobian(params, y, x):
  function probit_loglike_hessian (line 74) | def probit_loglike_hessian(params, y, x):

FILE: src/optimagic/exceptions.py
  class OptimagicError (line 5) | class OptimagicError(Exception):
  class TableExistsError (line 9) | class TableExistsError(OptimagicError):
  class InvalidFunctionError (line 13) | class InvalidFunctionError(OptimagicError):
  class UserFunctionRuntimeError (line 22) | class UserFunctionRuntimeError(OptimagicError):
  class MissingInputError (line 26) | class MissingInputError(OptimagicError):
  class AliasError (line 30) | class AliasError(OptimagicError):
  class InvalidKwargsError (line 34) | class InvalidKwargsError(OptimagicError):
  class InvalidParamsError (line 38) | class InvalidParamsError(OptimagicError):
  class InvalidConstraintError (line 42) | class InvalidConstraintError(OptimagicError):
  class InvalidBoundsError (line 46) | class InvalidBoundsError(OptimagicError):
  class IncompleteBoundsError (line 50) | class IncompleteBoundsError(OptimagicError):
  class InvalidScalingError (line 54) | class InvalidScalingError(OptimagicError):
  class InvalidMultistartError (line 58) | class InvalidMultistartError(OptimagicError):
  class InvalidNumdiffOptionsError (line 62) | class InvalidNumdiffOptionsError(OptimagicError):
  class NotInstalledError (line 66) | class NotInstalledError(OptimagicError):
  class NotAvailableError (line 70) | class NotAvailableError(OptimagicError):
  class InvalidAlgoOptionError (line 74) | class InvalidAlgoOptionError(OptimagicError):
  class InvalidAlgoInfoError (line 78) | class InvalidAlgoInfoError(OptimagicError):
  class InvalidPlottingBackendError (line 82) | class InvalidPlottingBackendError(OptimagicError):
  class StopOptimizationError (line 86) | class StopOptimizationError(OptimagicError):
    method __init__ (line 87) | def __init__(self, message, current_status):
    method __reduce__ (line 92) | def __reduce__(self):
  function get_traceback (line 97) | def get_traceback():

FILE: src/optimagic/logging/base.py
  class _KeyValueStore (line 17) | class _KeyValueStore(Generic[InputType, OutputType], ABC):
    method __init__ (line 34) | def __init__(
    method primary_key (line 56) | def primary_key(self) -> str:
    method insert (line 66) | def insert(self, value: InputType) -> None:
    method _select_by_key (line 74) | def _select_by_key(self, key: int) -> list[OutputType]:
    method _select_all (line 78) | def _select_all(self) -> list[OutputType]:
    method select (line 81) | def select(self, key: int | None = None) -> list[OutputType]:
    method select_last_rows (line 98) | def select_last_rows(self, n_rows: int) -> list[OutputType]:
    method to_df (line 109) | def to_df(self) -> pd.DataFrame:
  class UpdatableKeyValueStore (line 120) | class UpdatableKeyValueStore(_KeyValueStore[InputType, OutputType], ABC):
    method update (line 128) | def update(self, key: int, value: InputType | dict[str, Any]) -> None:
    method _update (line 143) | def _update(self, key: int, value: InputType | dict[str, Any]) -> None:
    method _check_fields (line 146) | def _check_fields(self, value: InputType | dict[str, Any]) -> None:
  class NonUpdatableKeyValueStore (line 156) | class NonUpdatableKeyValueStore(_KeyValueStore[InputType, OutputType], A...
    method __getattr__ (line 157) | def __getattr__(self, name: str) -> Any:
  class RobustPickler (line 168) | class RobustPickler:
    method loads (line 170) | def loads(
    method dumps (line 207) | def dumps(

FILE: src/optimagic/logging/logger.py
  class LogOptions (line 43) | class LogOptions:
    method __init_subclass__ (line 52) | def __init_subclass__(
    method available_option_types (line 60) | def available_option_types(cls) -> list[Type[LogOptions]]:
  class LogReader (line 67) | class LogReader(Generic[_LogOptionsType], ABC):
    method problem_df (line 81) | def problem_df(self) -> pd.DataFrame:
    method from_options (line 85) | def from_options(cls, log_options: LogOptions) -> LogReader[_LogOption...
    method _create (line 99) | def _create(cls, log_options: _LogOptionsType) -> LogReader[_LogOption...
    method read_iteration (line 102) | def read_iteration(self, iteration: int) -> IterationStateWithId:
    method read_history (line 139) | def read_history(self) -> IterationHistory:
    method _normalize_direction (line 163) | def _normalize_direction(
    method _build_history_dataframe (line 170) | def _build_history_dataframe(self) -> pd.DataFrame:
    method _split_exploration_and_optimization (line 204) | def _split_exploration_and_optimization(
    method _sort_exploration (line 216) | def _sort_exploration(
    method _extract_best_history (line 227) | def _extract_best_history(
    method read_multistart_history (line 265) | def read_multistart_history(
    method read_start_params (line 294) | def read_start_params(self) -> PyTree:
  class LogStore (line 307) | class LogStore(Generic[_LogOptionsType, _LogReaderType], ABC):
    method __init__ (line 320) | def __init__(
    method from_options (line 335) | def from_options(
    method create (line 351) | def create(
  class SQLiteLogOptions (line 357) | class SQLiteLogOptions(SQLAlchemyConfig, LogOptions):
    method __init__ (line 378) | def __init__(
    method path (line 394) | def path(self) -> str | Path:
    method create_engine (line 397) | def create_engine(self) -> Engine:
    method _configure_engine (line 402) | def _configure_engine(self, engine: Engine) -> None:
  class SQLiteLogReader (line 439) | class SQLiteLogReader(LogReader[SQLiteLogOptions]):
    method __init__ (line 451) | def __init__(self, path: str | Path):
    method _create (line 463) | def _create(cls, log_options: SQLiteLogOptions) -> SQLiteLogReader:
  class _SQLiteLogStore (line 477) | class _SQLiteLogStore(LogStore[SQLiteLogOptions, SQLiteLogReader]):
    method _handle_existing_database (line 488) | def _handle_existing_database(
    method create (line 516) | def create(cls, log_options: SQLiteLogOptions) -> _SQLiteLogStore:

FILE: src/optimagic/logging/read_log.py
  class OptimizeLogReader (line 22) | class OptimizeLogReader:
    method __new__ (line 23) | def __new__(cls, *args, **kwargs):  # type: ignore

FILE: src/optimagic/logging/sqlalchemy.py
  class SQLAlchemyConfig (line 32) | class SQLAlchemyConfig:
    method __init__ (line 43) | def __init__(
    method metadata (line 50) | def metadata(self) -> MetaData:
    method create_engine (line 63) | def create_engine(self) -> Engine:
    method _configure_reflect (line 73) | def _configure_reflect() -> None:
  class TableConfig (line 89) | class TableConfig:
    method column_names (line 107) | def column_names(self) -> list[str]:
    method create_table (line 110) | def create_table(self, metadata: MetaData, engine: Engine) -> sql.Table:
  class _SQLAlchemyStoreMixin (line 129) | class _SQLAlchemyStoreMixin:
    method __init__ (line 141) | def __init__(self, db_config: SQLAlchemyConfig, table_config: TableCon...
    method column_names (line 148) | def column_names(self) -> list[str]:
    method table_name (line 152) | def table_name(self) -> str:
    method table (line 156) | def table(self) -> sql.Table:
    method engine (line 160) | def engine(self) -> Engine:
    method _select_row_by_key (line 163) | def _select_row_by_key(self, key: int) -> list[Any]:
    method _select_all_rows (line 169) | def _select_all_rows(self) -> list[Any]:
    method _select_last_rows (line 173) | def _select_last_rows(self, n_rows: int) -> list[Any]:
    method _insert (line 182) | def _insert(self, insert_values: dict[str, Any]) -> None:
    method _execute_read_statement (line 186) | def _execute_read_statement(self, statement: Executable) -> list[Any]:
    method _execute_write_statement (line 190) | def _execute_write_statement(self, statement: Executable) -> None:
  class SQLAlchemySimpleStore (line 203) | class SQLAlchemySimpleStore(
    method __init__ (line 222) | def __init__(
    method __reduce__ (line 239) | def __reduce__(
    method insert (line 253) | def insert(self, value: InputType) -> None:
    method _select_by_key (line 262) | def _select_by_key(self, key: int) -> list[OutputType]:
    method _select_all (line 266) | def _select_all(self) -> list[OutputType]:
    method select_last_rows (line 270) | def select_last_rows(self, n_rows: int) -> list[OutputType]:
    method _post_process (line 283) | def _post_process(self, results: Sequence[sql.Row]) -> list[OutputType...
  class SQLAlchemyTableStore (line 292) | class SQLAlchemyTableStore(
    method __init__ (line 308) | def __init__(
    method __reduce__ (line 318) | def __reduce__(
    method insert (line 331) | def insert(self, value: InputType) -> None:
    method _update (line 340) | def _update(self, key: int, value: InputType | dict[str, Any]) -> None:
    method _select_by_key (line 352) | def _select_by_key(self, key: int) -> list[OutputType]:
    method _select_all (line 356) | def _select_all(self) -> list[OutputType]:
    method select_last_rows (line 360) | def select_last_rows(self, n_rows: int) -> list[OutputType]:
    method _post_process (line 373) | def _post_process(self, results: Sequence[sql.Row]) -> list[OutputType...
  class IterationStore (line 380) | class IterationStore(SQLAlchemySimpleStore[IterationState, IterationStat...
    method __init__ (line 391) | def __init__(
  class StepStore (line 404) | class StepStore(SQLAlchemyTableStore[StepResult, StepResultWithId]):
    method __init__ (line 415) | def __init__(
  class ProblemStore (line 441) | class ProblemStore(
    method __init__ (line 456) | def __init__(

FILE: src/optimagic/logging/types.py
  class StepStatus (line 14) | class StepStatus(str, Enum):
  class StepType (line 34) | class StepType(str, Enum):
  class ExistenceStrategy (line 50) | class ExistenceStrategy(str, Enum):
  class IterationState (line 69) | class IterationState(DictLikeAccess):
    method combine (line 93) | def combine(self, other: "IterationState") -> "IterationState":
  class IterationStateWithId (line 123) | class IterationStateWithId(IterationState):
    method __post_init__ (line 136) | def __post_init__(self) -> None:
  class StepResult (line 142) | class StepResult(DictLikeAccess):
    method __post_init__ (line 158) | def __post_init__(self) -> None:
  class StepResultWithId (line 166) | class StepResultWithId(StepResult):
    method __post_init__ (line 179) | def __post_init__(self) -> None:
  class ProblemInitialization (line 186) | class ProblemInitialization(DictLikeAccess):
  class ProblemInitializationWithId (line 201) | class ProblemInitializationWithId(ProblemInitialization):
    method __post_init__ (line 214) | def __post_init__(self) -> None:

FILE: src/optimagic/mark.py
  function scalar (line 14) | def scalar(func: ScalarFuncT) -> ScalarFuncT:
  function least_squares (line 31) | def least_squares(func: VectorFuncT) -> VectorFuncT:
  function likelihood (line 48) | def likelihood(func: VectorFuncT) -> VectorFuncT:
  function minimizer (line 69) | def minimizer(

FILE: src/optimagic/optimization/algo_options.py
  function get_population_size (line 161) | def get_population_size(population_size, x, lower_bound=10):

FILE: src/optimagic/optimization/algorithm.py
  class AlgoInfo (line 22) | class AlgoInfo:
    method __post_init__ (line 38) | def __post_init__(self) -> None:
  class InternalOptimizeResult (line 76) | class InternalOptimizeResult:
    method __post_init__ (line 115) | def __post_init__(self) -> None:
  class AlgorithmMeta (line 174) | class AlgorithmMeta(ABCMeta):
    method __repr__ (line 177) | def __repr__(self) -> str:
    method name (line 185) | def name(self) -> str:
    method algo_info (line 193) | def algo_info(self) -> AlgoInfo:
  class Algorithm (line 205) | class Algorithm(ABC, metaclass=AlgorithmMeta):
    method _solve_internal_problem (line 214) | def _solve_internal_problem(
    method __post_init__ (line 219) | def __post_init__(self) -> None:
    method with_option (line 237) | def with_option(self, **kwargs: Any) -> Self:
    method with_stopping (line 248) | def with_stopping(self, **kwargs: Any) -> Self:
    method with_convergence (line 259) | def with_convergence(self, **kwargs: Any) -> Self:
    method solve_internal_problem (line 270) | def solve_internal_problem(
    method with_option_if_applicable (line 301) | def with_option_if_applicable(self, **kwargs: Any) -> Self:
    method name (line 316) | def name(self) -> str:
    method algo_info (line 324) | def algo_info(self) -> AlgoInfo:

FILE: src/optimagic/optimization/convergence_report.py
  function get_convergence_report (line 7) | def get_convergence_report(history: History) -> dict[str, dict[str, floa...
  function _get_max_f_changes (line 36) | def _get_max_f_changes(critvals: NDArray[np.float64]) -> tuple[float, fl...
  function _get_max_x_changes (line 48) | def _get_max_x_changes(params: NDArray[np.float64]) -> tuple[float, float]:

FILE: src/optimagic/optimization/create_optimization_problem.py
  class OptimizationProblem (line 52) | class OptimizationProblem:
  function create_optimization_problem (line 91) | def create_optimization_problem(
  function pre_process_derivatives (line 560) | def pre_process_derivatives(candidate, name, solver_type):
  function pre_process_user_algorithm (line 584) | def pre_process_user_algorithm(

FILE: src/optimagic/optimization/error_penalty.py
  function _scalar_penalty (line 16) | def _scalar_penalty(
  function _likelihood_penalty (line 28) | def _likelihood_penalty(
  function _penalty_residuals (line 42) | def _penalty_residuals(
  function get_error_penalty_function (line 61) | def get_error_penalty_function(
  function _process_error_penalty (line 116) | def _process_error_penalty(

FILE: src/optimagic/optimization/fun_value.py
  class FunctionValue (line 17) | class FunctionValue:
  class SpecificFunctionValue (line 22) | class SpecificFunctionValue(FunctionValue, ABC):
    method internal_value (line 24) | def internal_value(
  class ScalarFunctionValue (line 31) | class ScalarFunctionValue(SpecificFunctionValue):
    method __post_init__ (line 35) | def __post_init__(self) -> None:
    method internal_value (line 45) | def internal_value(self, solver_type: AggregationLevel) -> float:
  class LeastSquaresFunctionValue (line 57) | class LeastSquaresFunctionValue(SpecificFunctionValue):
    method __post_init__ (line 61) | def __post_init__(self) -> None:
    method internal_value (line 71) | def internal_value(
  class LikelihoodFunctionValue (line 88) | class LikelihoodFunctionValue(SpecificFunctionValue):
    method __post_init__ (line 92) | def __post_init__(self) -> None:
    method internal_value (line 101) | def internal_value(
  function _get_flat_value (line 120) | def _get_flat_value(value: PyTree) -> NDArray[np.float64]:
  function convert_fun_output_to_function_value (line 134) | def convert_fun_output_to_function_value(
  function _convert_output_to_scalar_function_value (line 147) | def _convert_output_to_scalar_function_value(
  function _convert_output_to_least_squares_function_value (line 159) | def _convert_output_to_least_squares_function_value(
  function _convert_output_to_likelihood_function_value (line 171) | def _convert_output_to_likelihood_function_value(
  function enforce_return_type (line 186) | def enforce_return_type(
  function enforce_return_type_with_jac (line 231) | def enforce_return_type_with_jac(

FILE: src/optimagic/optimization/history.py
  class HistoryEntry (line 17) | class HistoryEntry:
  class History (line 25) | class History:
    method __init__ (line 27) | def __init__(
    method add_entry (line 61) | def add_entry(self, entry: HistoryEntry, batch_id: int | None = None) ...
    method add_batch (line 71) | def add_batch(
    method _get_next_batch_id (line 88) | def _get_next_batch_id(self) -> int:
    method fun_data (line 102) | def fun_data(self, cost_model: CostModel, monotone: bool = False) -> p...
    method fun (line 154) | def fun(self) -> list[float | None]:
    method monotone_fun (line 158) | def monotone_fun(self) -> NDArray[np.float64]:
    method is_accepted (line 170) | def is_accepted(self) -> NDArray[np.bool_]:
    method params_data (line 188) | def params_data(
    method params (line 259) | def params(self) -> list[PyTree]:
    method flat_params (line 263) | def flat_params(self) -> list[list[float]]:
    method flat_param_names (line 267) | def flat_param_names(self) -> list[str]:
    method _get_total_timings (line 273) | def _get_total_timings(
    method _get_timings_per_task (line 304) | def _get_timings_per_task(
    method start_time (line 332) | def start_time(self) -> list[float]:
    method stop_time (line 336) | def stop_time(self) -> list[float]:
    method batches (line 343) | def batches(self) -> list[int]:
    method _is_serial (line 346) | def _is_serial(self) -> bool:
    method task (line 353) | def task(self) -> list[EvalTask]:
    method time (line 361) | def time(self) -> list[float]:
    method criterion (line 371) | def criterion(self) -> list[float | None]:
    method runtime (line 377) | def runtime(self) -> list[float]:
    method __getitem__ (line 385) | def __getitem__(self, key: str) -> Any:
  function _get_flat_params (line 396) | def _get_flat_params(params: list[PyTree]) -> list[list[float]]:
  function _get_flat_param_names (line 407) | def _get_flat_param_names(param: PyTree) -> list[str]:
  function _is_1d_array (line 418) | def _is_1d_array(param: PyTree) -> bool:
  function _calculate_monotone_sequence (line 422) | def _calculate_monotone_sequence(
  function _validate_args_are_all_none_or_lists_of_same_length (line 444) | def _validate_args_are_all_none_or_lists_of_same_length(
  function _task_to_categorical (line 461) | def _task_to_categorical(task: list[EvalTask]) -> "pd.Series[str]":
  function _apply_reduction_to_batches (line 466) | def _apply_reduction_to_batches(
  function _get_batch_starts_and_stops (line 525) | def _get_batch_starts_and_stops(batch_ids: list[int]) -> tuple[list[int]...

FILE: src/optimagic/optimization/internal_optimization_problem.py
  class InternalBounds (line 37) | class InternalBounds(Bounds):
  class InternalOptimizationProblem (line 44) | class InternalOptimizationProblem:
    method __init__ (line 45) | def __init__(
    method fun (line 87) | def fun(self, x: NDArray[np.float64]) -> float | NDArray[np.float64]:
    method jac (line 102) | def jac(self, x: NDArray[np.float64]) -> NDArray[np.float64]:
    method fun_and_jac (line 118) | def fun_and_jac(
    method batch_fun (line 130) | def batch_fun(
    method batch_jac (line 164) | def batch_jac(
    method batch_fun_and_jac (line 198) | def batch_fun_and_jac(
    method exploration_fun (line 233) | def exploration_fun(
    method with_new_history (line 253) | def with_new_history(self) -> Self:
    method with_error_handling (line 258) | def with_error_handling(self, error_handling: ErrorHandling) -> Self:
    method with_step_id (line 263) | def with_step_id(self, step_id: int) -> Self:
    method bounds (line 273) | def bounds(self) -> InternalBounds:
    method converter (line 278) | def converter(self) -> Converter:
    method linear_constraints (line 329) | def linear_constraints(self) -> list[dict[str, Any]] | None:
    method nonlinear_constraints (line 334) | def nonlinear_constraints(self) -> list[dict[str, Any]] | None:
    method direction (line 358) | def direction(self) -> Direction:
    method history (line 363) | def history(self) -> History:
    method logger (line 368) | def logger(self) -> LogStore[Any, Any] | None:
    method _evaluate_fun (line 378) | def _evaluate_fun(
    method _evaluate_jac (line 388) | def _evaluate_jac(
    method _evaluate_exploration_fun (line 410) | def _evaluate_exploration_fun(
    method _evaluate_fun_and_jac (line 420) | def _evaluate_fun_and_jac(
    method _pure_evaluate_fun (line 446) | def _pure_evaluate_fun(
    method _pure_evaluate_jac (line 509) | def _pure_evaluate_jac(
    method _pure_evaluate_numerical_fun_and_jac (line 570) | def _pure_evaluate_numerical_fun_and_jac(
    method _pure_exploration_fun (line 657) | def _pure_exploration_fun(
    method _pure_evaluate_fun_and_jac (line 715) | def _pure_evaluate_fun_and_jac(
  function _assert_finite_jac (line 792) | def _assert_finite_jac(
  function _process_fun_value (line 830) | def _process_fun_value(
  function _process_jac_value (line 858) | def _process_jac_value(
  class SphereExampleInternalOptimizationProblem (line 882) | class SphereExampleInternalOptimizationProblem(InternalOptimizationProbl...
    method __init__ (line 892) | def __init__(
  class SphereExampleInternalOptimizationProblemWithConverter (line 964) | class SphereExampleInternalOptimizationProblemWithConverter(
    method __init__ (line 990) | def __init__(

FILE: src/optimagic/optimization/multistart.py
  function run_multistart_optimization (line 37) | def run_multistart_optimization(
  function determine_steps (line 184) | def determine_steps(n_samples, stopping_maxopt):
  function _draw_exploration_sample (line 217) | def _draw_exploration_sample(
  class _InternalExplorationResult (line 292) | class _InternalExplorationResult:
  function run_explorations (line 306) | def run_explorations(
  function get_batched_optimization_sample (line 360) | def get_batched_optimization_sample(sorted_sample, stopping_maxopt, batc...
  function update_convergence_state (line 390) | def update_convergence_state(

FILE: src/optimagic/optimization/multistart_options.py
  class MultistartOptions (line 20) | class MultistartOptions:
    method __post_init__ (line 84) | def __post_init__(self) -> None:
  class MultistartOptionsDict (line 88) | class MultistartOptionsDict(TypedDict):
  function pre_process_multistart (line 114) | def pre_process_multistart(
  function _validate_attribute_types_and_values (line 162) | def _validate_attribute_types_and_values(options: MultistartOptions) -> ...
  function _tiktak_weights (line 286) | def _tiktak_weights(
  function _linear_weights (line 292) | def _linear_weights(
  class InternalMultistartOptions (line 307) | class InternalMultistartOptions:
    method __post_init__ (line 330) | def __post_init__(self) -> None:
  function get_internal_multistart_options_from_public (line 350) | def get_internal_multistart_options_from_public(

FILE: src/optimagic/optimization/optimization_logging.py
  function log_scheduled_steps_and_get_ids (line 7) | def log_scheduled_steps_and_get_ids(

FILE: src/optimagic/optimization/optimize.py
  function maximize (line 89) | def maximize(
  function minimize (line 286) | def minimize(
  function _optimize (line 483) | def _optimize(problem: OptimizationProblem) -> OptimizeResult:

FILE: src/optimagic/optimization/optimize_result.py
  class OptimizeResult (line 17) | class OptimizeResult:
    method criterion (line 75) | def criterion(self) -> float:
    method start_criterion (line 81) | def start_criterion(self) -> float:
    method n_criterion_evaluations (line 90) | def n_criterion_evaluations(self) -> int | None:
    method n_derivative_evaluations (line 99) | def n_derivative_evaluations(self) -> int | None:
    method x (line 112) | def x(self) -> PyTree:
    method x0 (line 116) | def x0(self) -> PyTree:
    method nfev (line 120) | def nfev(self) -> int | None:
    method nit (line 124) | def nit(self) -> int | None:
    method njev (line 128) | def njev(self) -> int | None:
    method nhev (line 132) | def nhev(self) -> int | None:
    method __getitem__ (line 136) | def __getitem__(self, key):
    method __repr__ (line 139) | def __repr__(self) -> str:
    method to_pickle (line 195) | def to_pickle(self, path):
  class MultistartInfo (line 206) | class MultistartInfo:
    method __getitem__ (line 223) | def __getitem__(self, key):
    method n_optimizations (line 228) | def n_optimizations(self) -> int:
  function _format_convergence_report (line 232) | def _format_convergence_report(report, algorithm):
  function _create_stars (line 259) | def _create_stars(sr):
  function _format_float (line 269) | def _format_float(number):

FILE: src/optimagic/optimization/process_results.py
  class ExtraResultFields (line 16) | class ExtraResultFields:
  function process_single_result (line 26) | def process_single_result(
  function process_multistart_result (line 75) | def process_multistart_result(
  function _process_multistart_info (line 134) | def _process_multistart_info(
  function _dummy_result_from_traceback (line 175) | def _dummy_result_from_traceback(
  function _sum_or_none (line 191) | def _sum_or_none(summands: list[int | None | float]) -> int | None:

FILE: src/optimagic/optimization/scipy_aliases.py
  function map_method_to_algorithm (line 7) | def map_method_to_algorithm(method):
  function split_fun_and_jac (line 49) | def split_fun_and_jac(fun_and_jac, target="fun"):

FILE: src/optimagic/optimizers/_pounders/_conjugate_gradient.py
  function minimize_trust_cg (line 6) | def minimize_trust_cg(
  function _update_vectors_for_next_iteration (line 69) | def _update_vectors_for_next_iteration(
  function _get_distance_to_trustregion_boundary (line 100) | def _get_distance_to_trustregion_boundary(candidate, direction, radius):

FILE: src/optimagic/optimizers/_pounders/_steihaug_toint.py
  function minimize_trust_stcg (line 6) | def minimize_trust_stcg(model_gradient, model_hessian, trustregion_radius):
  function _update_candidate_vector_and_iteration_number (line 149) | def _update_candidate_vector_and_iteration_number(
  function _take_step_to_trustregion_boundary (line 183) | def _take_step_to_trustregion_boundary(x_candidate, p, dp, radius_sq, no...
  function _check_convergence (line 191) | def _check_convergence(

FILE: src/optimagic/optimizers/_pounders/_trsbox.py
  function minimize_trust_trsbox (line 6) | def minimize_trust_trsbox(
  function _perform_alternative_trustregion_step (line 197) | def _perform_alternative_trustregion_step(
  function _apply_bounds_to_candidate_vector (line 354) | def _apply_bounds_to_candidate_vector(
  function _take_unconstrained_step_up_to_boundary (line 368) | def _take_unconstrained_step_up_to_boundary(
  function _update_candidate_vectors_and_reduction (line 387) | def _update_candidate_vectors_and_reduction(
  function _take_constrained_step_up_to_boundary (line 435) | def _take_constrained_step_up_to_boundary(
  function _calc_upper_bound_on_tangent (line 459) | def _calc_upper_bound_on_tangent(
  function _calc_greatest_criterion_reduction (line 518) | def _calc_greatest_criterion_reduction(
  function _update_candidate_vectors_and_reduction_alt_step (line 562) | def _update_candidate_vectors_and_reduction_alt_step(
  function _compute_new_search_direction_and_norm (line 600) | def _compute_new_search_direction_and_norm(
  function _calc_new_reduction (line 616) | def _calc_new_reduction(tangent, sine, s_hess_s, x_hess_x, x_hess_s, x_g...
  function _update_tangent (line 624) | def _update_tangent(

FILE: src/optimagic/optimizers/_pounders/bntr.py
  class ActiveBounds (line 19) | class ActiveBounds(NamedTuple):
  function bntr (line 27) | def bntr(
  function _take_preliminary_gradient_descent_step_and_check_for_solution (line 243) | def _take_preliminary_gradient_descent_step_and_check_for_solution(
  function _compute_conjugate_gradient_step (line 390) | def _compute_conjugate_gradient_step(
  function _compute_predicted_reduction_from_conjugate_gradient_step (line 515) | def _compute_predicted_reduction_from_conjugate_gradient_step(
  function _perform_gradient_descent_step (line 545) | def _perform_gradient_descent_step(
  function _update_trustregion_radius_conjugate_gradient (line 613) | def _update_trustregion_radius_conjugate_gradient(
  function _get_information_on_active_bounds (line 669) | def _get_information_on_active_bounds(
  function _find_hessian_submatrix_where_bounds_inactive (line 693) | def _find_hessian_submatrix_where_bounds_inactive(model, active_bounds_i...
  function _check_for_convergence (line 702) | def _check_for_convergence(
  function _apply_bounds_to_x_candidate (line 758) | def _apply_bounds_to_x_candidate(x, lower_bounds, upper_bounds, bound_to...
  function _project_gradient_onto_feasible_set (line 766) | def _project_gradient_onto_feasible_set(gradient_unprojected, active_bou...
  function _apply_bounds_to_conjugate_gradient_step (line 776) | def _apply_bounds_to_conjugate_gradient_step(
  function _update_trustregion_radius_and_gradient_descent (line 805) | def _update_trustregion_radius_and_gradient_descent(
  function _get_fischer_burmeister_direction_vector (line 893) | def _get_fischer_burmeister_direction_vector(x, gradient, lower_bounds, ...
  function _get_fischer_burmeister_scalar (line 907) | def _get_fischer_burmeister_scalar(a, b):
  function _evaluate_model_criterion (line 929) | def _evaluate_model_criterion(

FILE: src/optimagic/optimizers/_pounders/gqtpar.py
  class HessianInfo (line 11) | class HessianInfo(NamedTuple):
  class DampingFactors (line 17) | class DampingFactors(NamedTuple):
  function gqtpar (line 23) | def gqtpar(model, x_candidate, *, k_easy=0.1, k_hard=0.2, maxiter=200):
  function _get_initial_guess_for_lambdas (line 149) | def _get_initial_guess_for_lambdas(
  function add_lambda_and_factorize_hessian (line 213) | def add_lambda_and_factorize_hessian(main_model, hessian_info, lambdas):
  function _find_new_candidate_and_update_parameters (line 263) | def _find_new_candidate_and_update_parameters(
  function _check_for_interior_convergence_and_update (line 317) | def _check_for_interior_convergence_and_update(
  function _update_lambdas_when_factorization_unsuccessful (line 350) | def _update_lambdas_when_factorization_unsuccessful(
  function _get_new_lambda_candidate (line 373) | def _get_new_lambda_candidate(lower_bound, upper_bound):
  function _compute_gershgorin_bounds (line 392) | def _compute_gershgorin_bounds(main_model):
  function _compute_newton_step (line 423) | def _compute_newton_step(lambdas, p_norm, w_norm):
  function _update_candidate_and_parameters_when_candidate_within_trustregion (line 441) | def _update_candidate_and_parameters_when_candidate_within_trustregion(
  function _update_lambdas_when_candidate_outside_trustregion (line 497) | def _update_lambdas_when_candidate_outside_trustregion(
  function _compute_smallest_step_len_for_candidate_vector (line 511) | def _compute_smallest_step_len_for_candidate_vector(x_candidate, z_min):
  function _solve_scalar_quadratic_equation (line 532) | def _solve_scalar_quadratic_equation(z, d):
  function _compute_terms_to_make_leading_submatrix_singular (line 571) | def _compute_terms_to_make_leading_submatrix_singular(hessian_info, k):

FILE: src/optimagic/optimizers/_pounders/linear_subsolvers.py
  class LinearModel (line 8) | class LinearModel(NamedTuple):
  function minimize_trsbox_linear (line 13) | def minimize_trsbox_linear(
  function improve_geomtery_trsbox_linear (line 94) | def improve_geomtery_trsbox_linear(
  function _find_next_active_bound (line 182) | def _find_next_active_bound(
  function _take_constrained_step_up_to_boundary (line 234) | def _take_constrained_step_up_to_boundary(
  function _take_unconstrained_step_up_to_boundary (line 266) | def _take_unconstrained_step_up_to_boundary(
  function _get_distance_to_trustregion_boundary (line 290) | def _get_distance_to_trustregion_boundary(

FILE: src/optimagic/optimizers/_pounders/pounders_auxiliary.py
  class ResidualModel (line 16) | class ResidualModel(NamedTuple):
  class MainModel (line 22) | class MainModel(NamedTuple):
  function create_initial_residual_model (line 27) | def create_initial_residual_model(history, accepted_index, delta):
  function update_residual_model (line 69) | def update_residual_model(residual_model, coefficients_to_add, delta, de...
  function create_main_from_residual_model (line 102) | def create_main_from_residual_model(
  function update_main_model_with_new_accepted_x (line 137) | def update_main_model_with_new_accepted_x(main_model, x_candidate):
  function update_residual_model_with_new_accepted_x (line 155) | def update_residual_model_with_new_accepted_x(residual_model, x_candidate):
  function solve_subproblem (line 186) | def solve_subproblem(
  function find_affine_points (line 315) | def find_affine_points(
  function add_geomtery_points_to_make_main_model_fully_linear (line 389) | def add_geomtery_points_to_make_main_model_fully_linear(
  function evaluate_residual_model (line 470) | def evaluate_residual_model(
  function get_feature_matrices_residual_model (line 515) | def get_feature_matrices_residual_model(
  function fit_residual_model (line 632) | def fit_residual_model(
  function update_trustregion_radius (line 714) | def update_trustregion_radius(
  function get_last_model_indices_and_check_for_repeated_model (line 736) | def get_last_model_indices_and_check_for_repeated_model(
  function add_accepted_point_to_residual_model (line 758) | def add_accepted_point_to_residual_model(model_indices, accepted_index, ...
  function _get_monomial_basis (line 766) | def _get_monomial_basis(x):

FILE: src/optimagic/optimizers/_pounders/pounders_history.py
  class LeastSquaresHistory (line 6) | class LeastSquaresHistory:
    method __init__ (line 26) | def __init__(self):
    method add_entries (line 36) | def add_entries(self, xs, residuals):
    method add_centered_entries (line 67) | def add_centered_entries(self, xs, residuals, center_info):
    method get_entries (line 86) | def get_entries(self, index=None):
    method get_xs (line 109) | def get_xs(self, index=None):
    method get_residuals (line 125) | def get_residuals(self, index=None):
    method get_critvals (line 141) | def get_critvals(self, index=None):
    method get_centered_entries (line 157) | def get_centered_entries(self, center_info, index=None):
    method get_centered_xs (line 180) | def get_centered_xs(self, center_info, index=None):
    method get_centered_residuals (line 198) | def get_centered_residuals(self, center_info, index=None):
    method get_centered_critvals (line 216) | def get_centered_critvals(self, center_info, index=None):
    method get_n_fun (line 235) | def get_n_fun(self):
    method get_best_index (line 238) | def get_best_index(self):
    method get_best_entries (line 241) | def get_best_entries(self):
    method get_best_x (line 244) | def get_best_x(self):
    method get_best_residuals (line 247) | def get_best_residuals(self):
    method get_best_critval (line 250) | def get_best_critval(self):
    method get_best_centered_entries (line 253) | def get_best_centered_entries(self, center_info):
  function _add_entries_to_array (line 257) | def _add_entries_to_array(arr, new, position):

FILE: src/optimagic/optimizers/bayesian_optimizer.py
  class BayesOpt (line 51) | class BayesOpt(Algorithm):
    method _solve_internal_problem (line 206) | def _solve_internal_problem(
    method _process_constraints (line 278) | def _process_constraints(
  function _process_bounds (line 294) | def _process_bounds(bounds: InternalBounds) -> dict[str, tuple[float, fl...
  function _extract_params_from_kwargs (line 324) | def _extract_params_from_kwargs(params_dict: dict[str, Any]) -> NDArray[...
  function _process_acquisition_function (line 337) | def _process_acquisition_function(
  function _process_bayes_opt_result (line 462) | def _process_bayes_opt_result(

FILE: src/optimagic/optimizers/bhhh.py
  class BHHH (line 33) | class BHHH(Algorithm):
    method _solve_internal_problem (line 38) | def _solve_internal_problem(
  function bhhh_internal (line 54) | def bhhh_internal(

FILE: src/optimagic/optimizers/fides.py
  class Fides (line 49) | class Fides(Algorithm):
    method _solve_internal_problem (line 82) | def _solve_internal_problem(
  function fides_internal (line 114) | def fides_internal(
  function _process_fides_res (line 213) | def _process_fides_res(raw_res, opt):
  function _process_exitflag (line 234) | def _process_exitflag(exitflag):
  function _create_hessian_updater_from_user_input (line 252) | def _create_hessian_updater_from_user_input(hessian_update_strategy):

FILE: src/optimagic/optimizers/gfo_optimizers.py
  class GFOCommonOptions (line 40) | class GFOCommonOptions:
  class GFOHillClimbing (line 138) | class GFOHillClimbing(GFOCommonOptions, Algorithm):
    method _solve_internal_problem (line 181) | def _solve_internal_problem(
  class GFOStochasticHillClimbing (line 219) | class GFOStochasticHillClimbing(Algorithm, GFOCommonOptions):
    method _solve_internal_problem (line 275) | def _solve_internal_problem(
  class GFORepulsingHillClimbing (line 314) | class GFORepulsingHillClimbing(Algorithm, GFOCommonOptions):
    method _solve_internal_problem (line 354) | def _solve_internal_problem(
  class GFOSimulatedAnnealing (line 394) | class GFOSimulatedAnnealing(Algorithm, GFOCommonOptions):
    method _solve_internal_problem (line 442) | def _solve_internal_problem(
  class GFODownhillSimplex (line 482) | class GFODownhillSimplex(Algorithm, GFOCommonOptions):
    method _solve_internal_problem (line 509) | def _solve_internal_problem(
  class GFOPowellsMethod (line 547) | class GFOPowellsMethod(Algorithm, GFOCommonOptions):
    method _solve_internal_problem (line 571) | def _solve_internal_problem(
  class GFOParticleSwarmOptimization (line 612) | class GFOParticleSwarmOptimization(Algorithm, GFOCommonOptions):
    method _solve_internal_problem (line 651) | def _solve_internal_problem(
  class GFOParallelTempering (line 696) | class GFOParallelTempering(Algorithm, GFOCommonOptions):
    method _solve_internal_problem (line 726) | def _solve_internal_problem(
  class GFOSpiralOptimization (line 769) | class GFOSpiralOptimization(Algorithm, GFOCommonOptions):
    method _solve_internal_problem (line 816) | def _solve_internal_problem(
  class GFOGeneticAlgorithm (line 858) | class GFOGeneticAlgorithm(Algorithm, GFOCommonOptions):
    method _solve_internal_problem (line 926) | def _solve_internal_problem(
  class GFOEvolutionStrategy (line 971) | class GFOEvolutionStrategy(Algorithm, GFOCommonOptions):
    method _solve_internal_problem (line 1016) | def _solve_internal_problem(
  class GFODifferentialEvolution (line 1060) | class GFODifferentialEvolution(Algorithm, GFOCommonOptions):
    method _solve_internal_problem (line 1122) | def _solve_internal_problem(
  function _gfo_internal (line 1154) | def _gfo_internal(
  function _get_search_space_gfo (line 1217) | def _get_search_space_gfo(
  function _get_gfo_constraints (line 1246) | def _get_gfo_constraints() -> list[Any]:
  function _get_initialize_gfo (line 1251) | def _get_initialize_gfo(
  function _process_result_gfo (line 1282) | def _process_result_gfo(opt: "BaseOptimizer") -> InternalOptimizeResult:
  function _value2para (line 1305) | def _value2para(x: NDArray[np.float64]) -> dict[str, float]:

FILE: src/optimagic/optimizers/iminuit_migrad.py
  class IminuitMigrad (line 44) | class IminuitMigrad(Algorithm):
    method _solve_internal_problem (line 84) | def _solve_internal_problem(
  function _process_minuit_result (line 118) | def _process_minuit_result(minuit_result: Minuit) -> InternalOptimizeRes...
  function _convert_bounds_to_minuit_limits (line 140) | def _convert_bounds_to_minuit_limits(

FILE: src/optimagic/optimizers/ipopt.py
  class Ipopt (line 50) | class Ipopt(Algorithm):
    method _solve_internal_problem (line 346) | def _solve_internal_problem(
  function _get_scipy_bounds (line 653) | def _get_scipy_bounds(bounds: InternalBounds) -> ScipyBounds:
  function _convert_bool_to_str (line 657) | def _convert_bool_to_str(var, name):
  function _convert_none_to_str (line 681) | def _convert_none_to_str(var):

FILE: src/optimagic/optimizers/nag_optimizers.py
  class NagDFOLS (line 347) | class NagDFOLS(Algorithm):
    method _solve_internal_problem (line 397) | def _solve_internal_problem(
  function nag_dfols_internal (line 436) | def nag_dfols_internal(
  class NagPyBOBYQA (line 652) | class NagPyBOBYQA(Algorithm):
    method _solve_internal_problem (line 699) | def _solve_internal_problem(
  function nag_pybobyqa_internal (line 740) | def nag_pybobyqa_internal(
  function _process_nag_result (line 866) | def _process_nag_result(nag_result_obj, len_x):
  function _create_nag_advanced_options (line 911) | def _create_nag_advanced_options(
  function _change_evals_per_point_interface (line 1012) | def _change_evals_per_point_interface(func):
  function _build_options_dict (line 1037) | def _build_options_dict(user_input, default_options):
  function _get_fast_start_method (line 1062) | def _get_fast_start_method(user_value):

FILE: src/optimagic/optimizers/neldermead.py
  class NelderMeadParallel (line 43) | class NelderMeadParallel(Algorithm):
    method _solve_internal_problem (line 93) | def _solve_internal_problem(
  function neldermead_parallel (line 122) | def neldermead_parallel(
  function _init_algo_params (line 323) | def _init_algo_params(adaptive, j):
  function _init_simplex (line 343) | def _init_simplex(x):
  function _pfeffer (line 355) | def _pfeffer(x):
  function _nash (line 370) | def _nash(x):
  function _gao_han (line 383) | def _gao_han(x):
  function _varadhan_borchers (line 408) | def _varadhan_borchers(x):

FILE: src/optimagic/optimizers/nevergrad_optimizers.py
  class NevergradPSO (line 62) | class NevergradPSO(Algorithm):
    method _solve_internal_problem (line 142) | def _solve_internal_problem(
  class NevergradCMAES (line 191) | class NevergradCMAES(Algorithm):
    method _solve_internal_problem (line 341) | def _solve_internal_problem(
  class NevergradOnePlusOne (line 415) | class NevergradOnePlusOne(Algorithm):
    method _solve_internal_problem (line 539) | def _solve_internal_problem(
  class NevergradDifferentialEvolution (line 591) | class NevergradDifferentialEvolution(Algorithm):
    method _solve_internal_problem (line 665) | def _solve_internal_problem(
  class NevergradBayesOptim (line 713) | class NevergradBayesOptim(Algorithm):
    method _solve_internal_problem (line 752) | def _solve_internal_problem(
  class NevergradEMNA (line 796) | class NevergradEMNA(Algorithm):
    method _solve_internal_problem (line 846) | def _solve_internal_problem(
  class NevergradCGA (line 890) | class NevergradCGA(Algorithm):
    method _solve_internal_problem (line 913) | def _solve_internal_problem(
  class NevergradEDA (line 952) | class NevergradEDA(Algorithm):
    method _solve_internal_problem (line 976) | def _solve_internal_problem(
  class NevergradTBPSA (line 1015) | class NevergradTBPSA(Algorithm):
    method _solve_internal_problem (line 1054) | def _solve_internal_problem(
  class NevergradRandomSearch (line 1096) | class NevergradRandomSearch(Algorithm):
    method _solve_internal_problem (line 1144) | def _solve_internal_problem(
  class NevergradSamplingSearch (line 1190) | class NevergradSamplingSearch(Algorithm):
    method _solve_internal_problem (line 1246) | def _solve_internal_problem(
  class NevergradNGOpt (line 1293) | class NevergradNGOpt(Algorithm):
    method _solve_internal_problem (line 1375) | def _solve_internal_problem(
  class NevergradMeta (line 1415) | class NevergradMeta(Algorithm):
    method _solve_internal_problem (line 1482) | def _solve_internal_problem(
  function _nevergrad_internal (line 1506) | def _nevergrad_internal(

FILE: src/optimagic/optimizers/nlopt_optimizers.py
  class NloptBOBYQA (line 55) | class NloptBOBYQA(Algorithm):
    method _solve_internal_problem (line 62) | def _solve_internal_problem(
  class NloptNelderMead (line 96) | class NloptNelderMead(Algorithm):
    method _solve_internal_problem (line 102) | def _solve_internal_problem(
  class NloptPRAXIS (line 135) | class NloptPRAXIS(Algorithm):
    method _solve_internal_problem (line 142) | def _solve_internal_problem(
  class NloptCOBYLA (line 176) | class NloptCOBYLA(Algorithm):
    method _solve_internal_problem (line 183) | def _solve_internal_problem(
  class NloptSbplx (line 217) | class NloptSbplx(Algorithm):
    method _solve_internal_problem (line 224) | def _solve_internal_problem(
  class NloptNEWUOA (line 258) | class NloptNEWUOA(Algorithm):
    method _solve_internal_problem (line 265) | def _solve_internal_problem(
  class NloptTNewton (line 307) | class NloptTNewton(Algorithm):
    method _solve_internal_problem (line 314) | def _solve_internal_problem(
  class NloptLBFGSB (line 348) | class NloptLBFGSB(Algorithm):
    method _solve_internal_problem (line 355) | def _solve_internal_problem(
  class NloptCCSAQ (line 389) | class NloptCCSAQ(Algorithm):
    method _solve_internal_problem (line 396) | def _solve_internal_problem(
  class NloptMMA (line 430) | class NloptMMA(Algorithm):
    method _solve_internal_problem (line 437) | def _solve_internal_problem(
  class NloptVAR (line 476) | class NloptVAR(Algorithm):
    method _solve_internal_problem (line 484) | def _solve_internal_problem(
  class NloptSLSQP (line 522) | class NloptSLSQP(Algorithm):
    method _solve_internal_problem (line 529) | def _solve_internal_problem(
  class NloptDirect (line 563) | class NloptDirect(Algorithm):
    method _solve_internal_problem (line 573) | def _solve_internal_problem(
  class NloptESCH (line 626) | class NloptESCH(Algorithm):
    method _solve_internal_problem (line 633) | def _solve_internal_problem(
  class NloptISRES (line 667) | class NloptISRES(Algorithm):
    method _solve_internal_problem (line 674) | def _solve_internal_problem(
  class NloptCRS2LM (line 708) | class NloptCRS2LM(Algorithm):
    method _solve_internal_problem (line 716) | def _solve_internal_problem(
  function _minimize_nlopt (line 739) | def _minimize_nlopt(
  function _process_nlopt_results (line 792) | def _process_nlopt_results(nlopt_obj, solution_x, is_global):
  function _get_nlopt_constraints (line 828) | def _get_nlopt_constraints(constraints, filter_type):
  function _internal_to_nlopt_constaint (line 835) | def _internal_to_nlopt_constaint(c):

FILE: src/optimagic/optimizers/pounders.py
  class Pounders (line 57) | class Pounders(Algorithm):
    method _solve_internal_problem (line 83) | def _solve_internal_problem(
  function internal_solve_pounders (line 165) | def internal_solve_pounders(
  function _check_for_convergence (line 595) | def _check_for_convergence(

FILE: src/optimagic/optimizers/pygad_optimizer.py
  class ParentSelectionFunction (line 43) | class ParentSelectionFunction(Protocol):
    method __call__ (line 58) | def __call__(
  class CrossoverFunction (line 64) | class CrossoverFunction(Protocol):
    method __call__ (line 78) | def __call__(
  class MutationFunction (line 87) | class MutationFunction(Protocol):
    method __call__ (line 99) | def __call__(
  class GeneConstraintFunction (line 105) | class GeneConstraintFunction(Protocol):
    method __call__ (line 124) | def __call__(
  class _BuiltinMutation (line 132) | class _BuiltinMutation:
    method to_pygad_params (line 146) | def to_pygad_params(self) -> dict[str, Any]:
  class RandomMutation (line 166) | class RandomMutation(_BuiltinMutation):
    method to_pygad_params (line 216) | def to_pygad_params(self) -> dict[str, Any]:
  class SwapMutation (line 228) | class SwapMutation(_BuiltinMutation):
  class InversionMutation (line 243) | class InversionMutation(_BuiltinMutation):
  class ScrambleMutation (line 258) | class ScrambleMutation(_BuiltinMutation):
  class AdaptiveMutation (line 272) | class AdaptiveMutation(_BuiltinMutation):
    method to_pygad_params (line 351) | def to_pygad_params(self) -> dict[str, Any]:
  class Pygad (line 394) | class Pygad(Algorithm):
    method _solve_internal_problem (line 603) | def _solve_internal_problem(
  function _convert_mutation_to_pygad_params (line 741) | def _convert_mutation_to_pygad_params(mutation: Any) -> dict[str, Any]:
  function _get_default_mutation_params (line 776) | def _get_default_mutation_params(mutation_type: Any = "random") -> dict[...
  function _create_mutation_from_string (line 787) | def _create_mutation_from_string(mutation_type: str) -> _BuiltinMutation:
  function _determine_effective_batch_size (line 814) | def _determine_effective_batch_size(batch_size: int | None, n_cores: int...
  function _build_stop_criteria (line 851) | def _build_stop_criteria(
  function _validate_user_defined_functions (line 881) | def _validate_user_defined_functions(
  function _validate_string_choice (line 946) | def _validate_string_choice(value: str, valid_choices: list[str], name: ...
  function _validate_protocol_function (line 952) | def _validate_protocol_function(
  function _process_pygad_result (line 960) | def _process_pygad_result(ga_instance: Any) -> InternalOptimizeResult:

FILE: src/optimagic/optimizers/pygmo_optimizers.py
  class PygmoGaco (line 70) | class PygmoGaco(Algorithm):
    method _solve_internal_problem (line 87) | def _solve_internal_problem(
  class PygmoBeeColony (line 138) | class PygmoBeeColony(Algorithm):
    method _solve_internal_problem (line 145) | def _solve_internal_problem(
  class PygmoDe (line 186) | class PygmoDe(Algorithm):
    method _solve_internal_problem (line 210) | def _solve_internal_problem(
  class PygmoSea (line 271) | class PygmoSea(Algorithm):
    method _solve_internal_problem (line 279) | def _solve_internal_problem(
  class PygmoSga (line 319) | class PygmoSga(Algorithm):
    method _solve_internal_problem (line 347) | def _solve_internal_problem(
  class PygmoSade (line 465) | class PygmoSade(Algorithm):
    method _solve_internal_problem (line 495) | def _solve_internal_problem(
  class PygmoCmaes (line 563) | class PygmoCmaes(Algorithm):
    method _solve_internal_problem (line 582) | def _solve_internal_problem(
  class PygmoSimulatedAnnealing (line 637) | class PygmoSimulatedAnnealing(Algorithm):
    method _solve_internal_problem (line 653) | def _solve_internal_problem(
  class PygmoPso (line 698) | class PygmoPso(Algorithm):
    method _solve_internal_problem (line 728) | def _solve_internal_problem(
  class PygmoPsoGen (line 805) | class PygmoPsoGen(Algorithm):
    method _solve_internal_problem (line 836) | def _solve_internal_problem(
  class PygmoMbh (line 912) | class PygmoMbh(Algorithm):
    method _solve_internal_problem (line 921) | def _solve_internal_problem(
  class PygmoXnes (line 965) | class PygmoXnes(Algorithm):
    method _solve_internal_problem (line 982) | def _solve_internal_problem(
  class PygmoGwo (line 1044) | class PygmoGwo(Algorithm):
    method _solve_internal_problem (line 1050) | def _solve_internal_problem(
  class PygmoCompassSearch (line 1088) | class PygmoCompassSearch(Algorithm):
    method _solve_internal_problem (line 1100) | def _solve_internal_problem(
  class PygmoIhs (line 1150) | class PygmoIhs(Algorithm):
    method _solve_internal_problem (line 1164) | def _solve_internal_problem(
  class PygmoDe1220 (line 1211) | class PygmoDe1220(Algorithm):
    method _solve_internal_problem (line 1222) | def _solve_internal_problem(
  function _minimize_pygmo (line 1282) | def _minimize_pygmo(
  function _create_pygmo_problem (line 1320) | def _create_pygmo_problem(
  function _create_algorithm (line 1345) | def _create_algorithm(
  function _create_population (line 1365) | def _create_population(
  function _process_pygmo_result (line 1388) | def _process_pygmo_result(evolved: pg.population) -> InternalOptimizeRes...
  function _convert_str_to_int (line 1401) | def _convert_str_to_int(str_to_int, value):

FILE: src/optimagic/optimizers/pyswarms_optimizers.py
  class Topology (line 48) | class Topology:
  class StarTopology (line 53) | class StarTopology(Topology):
  class RingTopology (line 62) | class RingTopology(Topology):
  class VonNeumannTopology (line 85) | class VonNeumannTopology(Topology):
  class PyramidTopology (line 100) | class PyramidTopology(Topology):
  class RandomTopology (line 113) | class RandomTopology(Topology):
  class PSOCommonOptions (line 138) | class PSOCommonOptions:
  class PySwarmsGlobalBestPSO (line 235) | class PySwarmsGlobalBestPSO(Algorithm, PSOCommonOptions):
    method _solve_internal_problem (line 274) | def _solve_internal_problem(
  class PySwarmsLocalBestPSO (line 316) | class PySwarmsLocalBestPSO(Algorithm, PSOCommonOptions):
    method _solve_internal_problem (line 363) | def _solve_internal_problem(
  class PySwarmsGeneralPSO (line 411) | class PySwarmsGeneralPSO(Algorithm, PSOCommonOptions):
    method _solve_internal_problem (line 464) | def _solve_internal_problem(
  function _pyswarms_internal (line 496) | def _pyswarms_internal(
  function _resolve_topology_config (line 576) | def _resolve_topology_config(
  function _build_velocity_clamp (line 618) | def _build_velocity_clamp(
  function _get_pyswarms_bounds (line 628) | def _get_pyswarms_bounds(
  function _create_initial_positions (line 645) | def _create_initial_positions(
  function _create_batch_objective (line 684) | def _create_batch_objective(
  function _process_pyswarms_result (line 709) | def _process_pyswarms_result(

FILE: src/optimagic/optimizers/scipy_optimizers.py
  class ScipyLBFGSB (line 105) | class ScipyLBFGSB(Algorithm):
    method _solve_internal_problem (line 169) | def _solve_internal_problem(
  class ScipySLSQP (line 208) | class ScipySLSQP(Algorithm):
    method _solve_internal_problem (line 213) | def _solve_internal_problem(
  class ScipyNelderMead (line 250) | class ScipyNelderMead(Algorithm):
    method _solve_internal_problem (line 258) | def _solve_internal_problem(
  class ScipyPowell (line 297) | class ScipyPowell(Algorithm):
    method _solve_internal_problem (line 304) | def _solve_internal_problem(
  class ScipyBFGS (line 341) | class ScipyBFGS(Algorithm):
    method _solve_internal_problem (line 350) | def _solve_internal_problem(
  class ScipyConjugateGradient (line 385) | class ScipyConjugateGradient(Algorithm):
    method _solve_internal_problem (line 391) | def _solve_internal_problem(
  class ScipyNewtonCG (line 423) | class ScipyNewtonCG(Algorithm):
    method _solve_internal_problem (line 428) | def _solve_internal_problem(
  class ScipyCOBYLA (line 463) | class ScipyCOBYLA(Algorithm):
    method _solve_internal_problem (line 469) | def _solve_internal_problem(
  class ScipyLSTRF (line 517) | class ScipyLSTRF(Algorithm):
    method _solve_internal_problem (line 525) | def _solve_internal_problem(
  class ScipyLSDogbox (line 570) | class ScipyLSDogbox(Algorithm):
    method _solve_internal_problem (line 578) | def _solve_internal_problem(
  class ScipyLSLM (line 623) | class ScipyLSLM(Algorithm):
    method _solve_internal_problem (line 629) | def _solve_internal_problem(
  class ScipyTruncatedNewton (line 663) | class ScipyTruncatedNewton(Algorithm):
    method _solve_internal_problem (line 677) | def _solve_internal_problem(
  class ScipyTrustConstr (line 722) | class ScipyTrustConstr(Algorithm):
    method _solve_internal_problem (line 730) | def _solve_internal_problem(
  function process_scipy_result (line 764) | def process_scipy_result(scipy_res: ScipyOptimizeResult) -> InternalOpti...
  function _int_if_not_none (line 786) | def _int_if_not_none(value: SupportsInt | None) -> int | None:
  function _get_scipy_constraints (line 792) | def _get_scipy_constraints(constraints):
  function _internal_to_scipy_constraint (line 802) | def _internal_to_scipy_constraint(c):
  class ScipyBasinhopping (line 828) | class ScipyBasinhopping(Algorithm):
    method _solve_internal_problem (line 860) | def _solve_internal_problem(
  class ScipyBrute (line 910) | class ScipyBrute(Algorithm):
    method _solve_internal_problem (line 916) | def _solve_internal_problem(
  class ScipyDifferentialEvolution (line 961) | class ScipyDifferentialEvolution(Algorithm):
    method _solve_internal_problem (line 998) | def _solve_internal_problem(
  class ScipySHGO (line 1039) | class ScipySHGO(Algorithm):
    method _solve_internal_problem (line 1075) | def _solve_internal_problem(
  class ScipyDualAnnealing (line 1147) | class ScipyDualAnnealing(Algorithm):
    method _solve_internal_problem (line 1181) | def _solve_internal_problem(
  class ScipyDirect (line 1229) | class ScipyDirect(Algorithm):
    method _solve_internal_problem (line 1242) | def _solve_internal_problem(
  function _get_workers (line 1261) | def _get_workers(n_cores, batch_evaluator):
  function _get_scipy_bounds (line 1271) | def _get_scipy_bounds(bounds: InternalBounds) -> ScipyBounds | None:
  function process_scipy_result_old (line 1280) | def process_scipy_result_old(scipy_results_obj):

FILE: src/optimagic/optimizers/tao_optimizers.py
  class TAOPounders (line 42) | class TAOPounders(Algorithm):
    method _solve_internal_problem (line 51) | def _solve_internal_problem(
  function tao_pounders (line 86) | def tao_pounders(
  function _initialise_petsc_array (line 208) | def _initialise_petsc_array(len_or_array):
  function _max_iters (line 231) | def _max_iters(max_iterations, tao):
  function _gatol_conv (line 238) | def _gatol_conv(absolute_gradient_tolerance, tao):
  function _grtol_conv (line 245) | def _grtol_conv(relative_gradient_tolerance, tao):
  function _grtol_gatol_conv (line 258) | def _grtol_gatol_conv(relative_gradient_tolerance, absolute_gradient_tol...
  function _translate_tao_convergence_reason (line 274) | def _translate_tao_convergence_reason(tao_resaon):
  function _process_pounders_results (line 292) | def _process_pounders_results(residuals_out, tao):

FILE: src/optimagic/optimizers/tranquilo.py
  class Tranquilo (line 69) | class Tranquilo(Algorithm):
    method _solve_internal_problem (line 179) | def _solve_internal_problem(
  class TranquiloLS (line 258) | class TranquiloLS(Algorithm):
    method _solve_internal_problem (line 366) | def _solve_internal_problem(

FILE: src/optimagic/parameters/block_trees.py
  function matrix_to_block_tree (line 11) | def matrix_to_block_tree(matrix, outer_tree, inner_tree):
  function hessian_to_block_tree (line 70) | def hessian_to_block_tree(hessian, f_tree, params_tree):
  function block_tree_to_matrix (line 132) | def block_tree_to_matrix(block_tree, outer_tree, inner_tree):
  function block_tree_to_hessian (line 181) | def block_tree_to_hessian(block_hessian, f_tree, params_tree):
  function _convert_to_numpy (line 240) | def _convert_to_numpy(obj, only_pandas=True):
  function _convert_pandas_objects_to_numpy (line 248) | def _convert_pandas_objects_to_numpy(obj):
  function _convert_raw_block_to_pandas (line 260) | def _convert_raw_block_to_pandas(raw_block, leaf_outer, leaf_inner):
  function _select_non_none (line 296) | def _select_non_none(first, second):
  function _reshape_list (line 308) | def _reshape_list(list_to_reshape, shapes):
  function _is_pd_object (line 327) | def _is_pd_object(obj):
  function _check_dimensions_matrix (line 331) | def _check_dimensions_matrix(matrix, outer_tree, inner_tree):
  function _check_dimensions_hessian (line 344) | def _check_dimensions_hessian(hessian, f_tree, params_tree):

FILE: src/optimagic/parameters/bounds.py
  class Bounds (line 19) | class Bounds:
  function pre_process_bounds (line 26) | def pre_process_bounds(
  function _process_bounds_sequence (line 63) | def _process_bounds_sequence(bounds: Sequence[tuple[float, float]]) -> B...
  function get_internal_bounds (line 75) | def get_internal_bounds(
  function _update_bounds_and_flatten (line 162) | def _update_bounds_and_flatten(
  function _is_fast_path (line 217) | def _is_fast_path(params: PyTree, bounds: Bounds, add_soft_bounds: bool)...
  function _is_1d_array (line 231) | def _is_1d_array(candidate: Any) -> bool:
  function _get_fast_path_bounds (line 235) | def _get_fast_path_bounds(

FILE: src/optimagic/parameters/check_constraints.py
  function check_constraints_are_satisfied (line 16) | def check_constraints_are_satisfied(flat_constraints, param_values, para...
  function _get_message (line 100) | def _get_message(constraint, param_names, explanation=""):
  function check_types (line 122) | def check_types(constraints):
  function check_for_incompatible_overlaps (line 150) | def check_for_incompatible_overlaps(transformations, parnames):
  function check_fixes_and_bounds (line 181) | def check_fixes_and_bounds(constr_info, transformations, parnames):
  function _iloc (line 258) | def _iloc(dictionary, positions):

FILE: src/optimagic/parameters/consolidate_constraints.py
  function consolidate_constraints (line 20) | def consolidate_constraints(
  function _consolidate_equality_constraints (line 120) | def _consolidate_equality_constraints(equality_constraints):
  function _join_overlapping_lists (line 150) | def _join_overlapping_lists(candidates):
  function _unite_first_with_all_intersecting_elements (line 174) | def _unite_first_with_all_intersecting_elements(indices):
  function _consolidate_fixes_with_equality_constraints (line 193) | def _consolidate_fixes_with_equality_constraints(
  function _consolidate_bounds_with_equality_constraints (line 226) | def _consolidate_bounds_with_equality_constraints(
  function _split_constraints (line 254) | def _split_constraints(constraints, type_):
  function simplify_covariance_and_sdcorr_constraints (line 265) | def simplify_covariance_and_sdcorr_constraints(
  function _plug_equality_constraints_into_selectors (line 311) | def _plug_equality_constraints_into_selectors(
  function _consolidate_linear_constraints (line 359) | def _consolidate_linear_constraints(
  function _transform_linear_constraints_to_pandas_objects (line 430) | def _transform_linear_constraints_to_pandas_objects(linear_constranits, ...
  function _plug_equality_constraints_into_linear_weights (line 461) | def _plug_equality_constraints_into_linear_weights(weights, post_replace...
  function _plug_fixes_into_linear_weights_and_rhs (line 486) | def _plug_fixes_into_linear_weights_and_rhs(
  function _express_bounds_as_linear_constraints (line 518) | def _express_bounds_as_linear_constraints(weights, rhs, lower, upper):
  function _rescale_linear_constraints (line 562) | def _rescale_linear_constraints(weights, rhs):
  function _drop_redundant_linear_constraints (line 591) | def _drop_redundant_linear_constraints(weights, rhs):
  function _check_consolidated_weights (line 636) | def _check_consolidated_weights(weights, param_names):
  function _get_kernel_transformation_matrices (line 666) | def _get_kernel_transformation_matrices(weights):
  function _is_redundant (line 697) | def _is_redundant(candidate, others):
  function _unique_values (line 714) | def _unique_values(arr, dropna=True):

FILE: src/optimagic/parameters/constraint_tools.py
  function count_free_params (line 6) | def count_free_params(
  function check_constraints (line 54) | def check_constraints(

FILE: src/optimagic/parameters/conversion.py
  function get_converter (line 15) | def get_converter(
  class Converter (line 150) | class Converter:
  function _fast_params_from_internal (line 157) | def _fast_params_from_internal(x, return_type="tree"):
  function _get_fast_path_converter (line 165) | def _get_fast_path_converter(params, bounds, solver_type):
  function _is_fast_path (line 201) | def _is_fast_path(
  function _is_fast_deriv_eval (line 226) | def _is_fast_deriv_eval(d, solver_type):
  function _is_1d_arr (line 241) | def _is_1d_arr(candidate):
  function _is_2d_arr (line 245) | def _is_2d_arr(candidate):

FILE: src/optimagic/parameters/kernel_transformations.py
  function covariance_to_internal (line 44) | def covariance_to_internal(external_values, constr):
  function covariance_to_internal_jacobian (line 51) | def covariance_to_internal_jacobian(external_values, constr):
  function covariance_from_internal (line 83) | def covariance_from_internal(internal_values, constr):
  function covariance_from_internal_jacobian (line 90) | def covariance_from_internal_jacobian(internal_values, constr):
  function sdcorr_to_internal (line 142) | def sdcorr_to_internal(external_values, constr):
  function sdcorr_to_internal_jacobian (line 149) | def sdcorr_to_internal_jacobian(external_values, constr):
  function sdcorr_from_internal (line 183) | def sdcorr_from_internal(internal_values, constr):
  function sdcorr_from_internal_jacobian (line 190) | def sdcorr_from_internal_jacobian(internal_values, constr):
  function probability_to_internal (line 274) | def probability_to_internal(external_values, constr):
  function probability_to_internal_jacobian (line 279) | def probability_to_internal_jacobian(external_values, constr):
  function probability_from_internal (line 313) | def probability_from_internal(internal_values, constr):
  function probability_from_internal_jacobian (line 318) | def probability_from_internal_jacobian(internal_values, constr):
  function linear_to_internal (line 348) | def linear_to_internal(external_values, constr):
  function linear_to_internal_jacobian (line 353) | def linear_to_internal_jacobian(external_values, constr):
  function linear_from_internal (line 357) | def linear_from_internal(internal_values, constr):
  function linear_from_internal_jacobian (line 362) | def linear_from_internal_jacobian(internal_values, constr):
  function _elimination_matrix (line 366) | def _elimination_matrix(dim):
  function _duplication_matrix (line 408) | def _duplication_matrix(dim):
  function _transformation_matrix (line 447) | def _transformation_matrix(dim):
  function _commutation_matrix (line 503) | def _commutation_matrix(dim):
  function _unit_vector_or_zeros (line 538) | def _unit_vector_or_zeros(index, size):

FILE: src/optimagic/parameters/nonlinear_constraints.py
  function process_nonlinear_constraints (line 16) | def process_nonlinear_constraints(
  function _process_nonlinear_constraint (line 93) | def _process_nonlinear_constraint(
  function equality_as_inequality_constraints (line 235) | def equality_as_inequality_constraints(nonlinear_constraints):
  function _equality_to_inequality (line 241) | def _equality_to_inequality(c):
  function vector_as_list_of_scalar_constraints (line 267) | def vector_as_list_of_scalar_constraints(nonlinear_constraints):
  function _vector_to_list_of_scalar (line 280) | def _vector_to_list_of_scalar(constraint):
  function _get_components (line 295) | def _get_components(fun, jac, idx):
  function _process_selector (line 318) | def _process_selector(c):
  function _compose_funcs (line 336) | def _compose_funcs(f, g):
  function _identity (line 340) | def _identity(x):
  function _extend_jacobian (line 349) | def _extend_jacobian(jac_mat, selection_indices, n_params):
  function _get_selection_indices (line 362) | def _get_selection_indices(params, selector):
  function _get_transformation (line 381) | def _get_transformation(lower_bounds, upper_bounds):
  function _get_transformation_type (line 409) | def _get_transformation_type(lower_bounds, upper_bounds):
  function _check_validity_and_return_evaluation (line 430) | def _check_validity_and_return_evaluation(c, params, skip_checks):

FILE: src/optimagic/parameters/process_constraints.py
  function process_constraints (line 31) | def process_constraints(
  function _replace_pairwise_equality_by_equality (line 120) | def _replace_pairwise_equality_by_equality(constraints):
  function _process_linear_weights (line 143) | def _process_linear_weights(constraints):
  function _replace_increasing_and_decreasing_by_linear (line 181) | def _replace_increasing_and_decreasing_by_linear(constraints):
  function _create_internal_bounds (line 216) | def _create_internal_bounds(lower, upper, constraints):
  function _create_internal_free (line 259) | def _create_internal_free(is_fixed_to_value, is_fixed_to_other, constrai...
  function _create_pre_replacements (line 285) | def _create_pre_replacements(internal_free):
  function _create_internal_fixed_value (line 306) | def _create_internal_fixed_value(fixed_values, constraints):

FILE: src/optimagic/parameters/process_selectors.py
  function process_selectors (line 13) | def process_selectors(constraints, params, tree_converter, param_names):
  function _get_selection_field (line 98) | def _get_selection_field(constraint, selector_case, params_case):
  function _get_selection_evaluator (line 139) | def _get_selection_evaluator(field, constraint, params_case, registry):
  function _get_params_case (line 192) | def _get_params_case(params):
  function _get_selector_case (line 204) | def _get_selector_case(constraint):
  function _fail_if_duplicates (line 212) | def _fail_if_duplicates(
  function _fail_if_selections_are_incompatible (line 226) | def _fail_if_selections_are_incompatible(selected, constraint):
  function _find_duplicates (line 244) | def _find_duplicates(list_):

FILE: src/optimagic/parameters/scale_conversion.py
  class ScaleConverter (line 11) | class ScaleConverter:
    method params_to_internal (line 15) | def params_to_internal(self, vec: NDArray[np.float64]) -> NDArray[np.f...
    method params_from_internal (line 23) | def params_from_internal(self, vec: NDArray[np.float64]) -> NDArray[np...
    method derivative_to_internal (line 31) | def derivative_to_internal(
    method derivative_from_internal (line 39) | def derivative_from_internal(
  function get_scale_converter (line 48) | def get_scale_converter(
  function calculate_scaling_factor_and_offset (line 108) | def calculate_scaling_factor_and_offset(

FILE: src/optimagic/parameters/scaling.py
  class ScalingOptions (line 10) | class ScalingOptions:
    method __post_init__ (line 31) | def __post_init__(self) -> None:
  class ScalingOptionsDict (line 35) | class ScalingOptionsDict(TypedDict):
  function pre_process_scaling (line 41) | def pre_process_scaling(
  function _validate_attribute_types_and_values (line 83) | def _validate_attribute_types_and_values(options: ScalingOptions) -> None:

FILE: src/optimagic/parameters/space_conversion.py
  function get_space_converter (line 46) | def get_space_converter(
  class SpaceConverter (line 154) | class SpaceConverter:
  function reparametrize_to_internal (line 161) | def reparametrize_to_internal(
  function reparametrize_from_internal (line 192) | def reparametrize_from_internal(
  function convert_external_derivative_to_internal (line 236) | def convert_external_derivative_to_internal(
  function _multiply_from_left (line 326) | def _multiply_from_left(mat_list):
  function _multiply_from_right (line 339) | def _multiply_from_right(mat_list):
  function pre_replace (line 352) | def pre_replace(internal_values, fixed_values, pre_replacements):
  function pre_replace_jacobian (line 385) | def pre_replace_jacobian(pre_replacements, dim_in):
  function transformation_jacobian (line 424) | def transformation_jacobian(transformations, pre_replaced):
  function post_replace (line 453) | def post_replace(external_values, post_replacements):
  function post_replace_jacobian (line 481) | def post_replace_jacobian(post_replacements):
  class InternalParams (line 515) | class InternalParams:

FILE: src/optimagic/parameters/tree_conversion.py
  function get_tree_converter (line 13) | def get_tree_converter(
  function _get_params_flatten (line 100) | def _get_params_flatten(registry):
  function _get_params_unflatten (line 107) | def _get_params_unflatten(registry, treedef):
  function _get_best_key_and_aggregator (line 114) | def _get_best_key_and_aggregator(needed_key, available_keys):
  function _get_derivative_flatten (line 141) | def _get_derivative_flatten(registry, solver_type, params, func_eval, de...
  class TreeConverter (line 174) | class TreeConverter(NamedTuple):
  class FlatParams (line 180) | class FlatParams(NamedTuple):

FILE: src/optimagic/parameters/tree_registry.py
  function get_registry (line 11) | def get_registry(extended=False, data_col="value"):
  function _flatten_df (line 47) | def _flatten_df(df, data_col):
  function _unflatten_df (line 61) | def _unflatten_df(aux_data, leaves, data_col):
  function _get_df_names (line 73) | def _get_df_names(df):
  function _index_element_to_string (line 83) | def _index_element_to_string(element):

FILE: src/optimagic/shared/check_option_dicts.py
  function check_optimization_options (line 4) | def check_optimization_options(options, usage, algorithm_mandatory=True):

FILE: src/optimagic/shared/compat.py
  function pd_df_map (line 9) | def pd_df_map(df, func, na_action=None, **kwargs):

FILE: src/optimagic/shared/process_user_function.py
  function partial_func_of_params (line 16) | def partial_func_of_params(func, kwargs, name="your function", skip_chec...
  function filter_kwargs (line 72) | def filter_kwargs(func, kwargs):
  function get_unpartialled_arguments (line 82) | def get_unpartialled_arguments(func):
  function get_arguments_without_default (line 92) | def get_arguments_without_default(func):
  function get_kwargs_from_args (line 104) | def get_kwargs_from_args(args, func, offset=0):
  function infer_aggregation_level (line 121) | def infer_aggregation_level(func):

FILE: src/optimagic/timing.py
  class CostModel (line 6) | class CostModel:
    method __post_init__ (line 13) | def __post_init__(self) -> None:

FILE: src/optimagic/type_conversion.py
  function _process_float_like (line 12) | def _process_float_like(value: Any) -> float:
  function _process_int_like (line 17) | def _process_int_like(value: Any) -> int:
  function _process_positive_int_like (line 27) | def _process_positive_int_like(value: Any) -> PositiveInt:
  function _process_non_negative_int_like (line 35) | def _process_non_negative_int_like(value: Any) -> NonNegativeInt:
  function _process_positive_float_like (line 43) | def _process_positive_float_like(value: Any) -> PositiveFloat:
  function _process_non_negative_float_like (line 51) | def _process_non_negative_float_like(value: Any) -> NonNegativeFloat:
  function _process_gt_one_float_like (line 59) | def _process_gt_one_float_like(value: Any) -> GtOneFloat:
  function _process_bool_like (line 67) | def _process_bool_like(value: Any) -> bool:

FILE: src/optimagic/typing.py
  class AggregationLevel (line 27) | class AggregationLevel(Enum):
  class Direction (line 35) | class Direction(str, Enum):
  class DictLikeAccess (line 43) | class DictLikeAccess:
    method __getitem__ (line 49) | def __getitem__(self, key: str) -> Any:
    method __iter__ (line 55) | def __iter__(self) -> Iterator[str]:
    method _dict_repr (line 58) | def _dict_repr(self) -> dict[str, Any]:
    method keys (line 61) | def keys(self) -> KeysView[str]:
    method items (line 64) | def items(self) -> ItemsView[str, Any]:
    method values (line 67) | def values(self) -> ValuesView[str]:
  class TupleLikeAccess (line 72) | class TupleLikeAccess:
    method __getitem__ (line 77) | def __getitem__(self, index: int | slice) -> Any:
    method __len__ (line 81) | def __len__(self) -> int:
    method __iter__ (line 84) | def __iter__(self) -> Iterator[str]:
  class ErrorHandling (line 89) | class ErrorHandling(Enum):
  class EvalTask (line 97) | class EvalTask(Enum):
  class BatchEvaluator (line 106) | class BatchEvaluator(Protocol):
    method __call__ (line 107) | def __call__(
  class IterationHistory (line 147) | class IterationHistory(DictLikeAccess):
  class MultiStartIterationHistory (line 163) | class MultiStartIterationHistory(TupleLikeAccess):

FILE: src/optimagic/utilities.py
  function fast_numpy_full (line 15) | def fast_numpy_full(length: int, fill_value: float) -> NDArray[np.float64]:
  function chol_params_to_lower_triangular_matrix (line 27) | def chol_params_to_lower_triangular_matrix(params):
  function cov_params_to_matrix (line 34) | def cov_params_to_matrix(cov_params):
  function cov_matrix_to_params (line 50) | def cov_matrix_to_params(cov):
  function sdcorr_params_to_sds_and_corr (line 54) | def sdcorr_params_to_sds_and_corr(sdcorr_params):
  function sds_and_corr_to_cov (line 63) | def sds_and_corr_to_cov(sds, corr):
  function cov_to_sds_and_corr (line 68) | def cov_to_sds_and_corr(cov):
  function sdcorr_params_to_matrix (line 75) | def sdcorr_params_to_matrix(sdcorr_params):
  function cov_matrix_to_sdcorr_params (line 91) | def cov_matrix_to_sdcorr_params(cov):
  function number_of_triangular_elements_to_dimension (line 98) | def number_of_triangular_elements_to_dimension(num):
  function dimension_to_number_of_triangular_elements (line 114) | def dimension_to_number_of_triangular_elements(dim):
  function propose_alternatives (line 124) | def propose_alternatives(requested, possibilities, number=3):
  function robust_cholesky (line 154) | def robust_cholesky(matrix, threshold=None, return_info=False):
  function robust_inverse (line 193) | def robust_inverse(matrix, msg=""):
  function _internal_robust_cholesky (line 220) | def _internal_robust_cholesky(matrix, threshold):
  function _make_cholesky_unique (line 265) | def _make_cholesky_unique(chol):
  function hash_array (line 279) | def hash_array(arr):
  function calculate_trustregion_initial_radius (line 286) | def calculate_trustregion_initial_radius(x):
  function to_pickle (line 302) | def to_pickle(obj, path):
  function read_pickle (line 307) | def read_pickle(path):
  function isscalar (line 311) | def isscalar(element):
  function get_rng (line 319) | def get_rng(seed):
  function list_of_dicts_to_dict_of_lists (line 339) | def list_of_dicts_to_dict_of_lists(list_of_dicts):
  function dict_of_lists_to_list_of_dicts (line 356) | def dict_of_lists_to_list_of_dicts(dict_of_lists):

FILE: src/optimagic/visualization/backends.py
  class LinePlotFunction (line 22) | class LinePlotFunction(Protocol):
    method __call__ (line 23) | def __call__(
  class GridLinePlotFunction (line 55) | class GridLinePlotFunction(Protocol):
    method __call__ (line 56) | def __call__(
  function _line_plot_plotly (line 88) | def _line_plot_plotly(
  function _grid_line_plot_plotly (line 182) | def _grid_line_plot_plotly(
  function _line_plot_matplotlib (line 255) | def _line_plot_matplotlib(
  function _grid_line_plot_matplotlib (line 345) | def _grid_line_plot_matplotlib(
  function _line_plot_bokeh (line 426) | def _line_plot_bokeh(
  function _grid_line_plot_bokeh (line 529) | def _grid_line_plot_bokeh(
  function _line_plot_altair (line 619) | def _line_plot_altair(
  function _grid_line_plot_altair (line 729) | def _grid_line_plot_altair(
  function line_plot (line 868) | def line_plot(
  function grid_line_plot (line 931) | def grid_line_plot(
  function _get_plot_function (line 1035) | def _get_plot_function(
  function _get_plot_function (line 1042) | def _get_plot_function(
  function _get_plot_function (line 1048) | def _get_plot_function(

FILE: src/optimagic/visualization/convergence_plot.py
  function convergence_plot (line 62) | def convergence_plot(
  function _extract_convergence_plot_lines (line 244) | def _extract_convergence_plot_lines(
  function _check_only_allowed_subset_provided (line 305) | def _check_only_allowed_subset_provided(

FILE: src/optimagic/visualization/deviation_plot.py
  function deviation_plot (line 10) | def deviation_plot(

FILE: src/optimagic/visualization/history_plots.py
  function criterion_plot (line 42) | def criterion_plot(
  function _harmonize_inputs_to_dict (line 116) | def _harmonize_inputs_to_dict(
  function _convert_key_to_str (line 150) | def _convert_key_to_str(key: Any) -> str:
  function params_plot (line 160) | def params_plot(
  class _PlottingMultistartHistory (line 227) | class _PlottingMultistartHistory:
  function _retrieve_optimization_data_from_results (line 243) | def _retrieve_optimization_data_from_results(
  function _retrieve_optimization_data_from_single_result (line 267) | def _retrieve_optimization_data_from_single_result(
  function _retrieve_optimization_data_from_result_object (line 316) | def _retrieve_optimization_data_from_result_object(
  function _retrieve_optimization_data_from_database (line 385) | def _retrieve_optimization_data_from_database(
  function _get_stacked_local_histories (line 447) | def _get_stacked_local_histories(
  function _extract_criterion_plot_lines (line 485) | def _extract_criterion_plot_lines(
  function _extract_params_plot_lines (line 558) | def _extract_params_plot_lines(

FILE: src/optimagic/visualization/plotting_utilities.py
  class LineData (line 16) | class LineData:
  class MarkerData (line 36) | class MarkerData:
  function combine_plots (line 53) | def combine_plots(
  function create_grid_plot (line 172) | def create_grid_plot(
  function create_ind_dict (line 249) | def create_ind_dict(
  function _clean_legend_duplicates (line 316) | def _clean_legend_duplicates(fig):
  function get_make_subplot_kwargs (line 330) | def get_make_subplot_kwargs(sharex, sharey, kwrgs, plots_per_row, plots):
  function get_layout_kwargs (line 353) | def get_layout_kwargs(layout_kwargs, legend_kwargs, title_kwargs, templa...
  function _ensure_array_from_plotly_data (line 377) | def _ensure_array_from_plotly_data(data: Any) -> np.ndarray:
  function _decode_base64_data (line 403) | def _decode_base64_data(b64data: str, dtype: str) -> np.ndarray:
  function get_palette_cycle (line 408) | def get_palette_cycle(palette: list[str] | str) -> "itertools.cycle[str]":

FILE: src/optimagic/visualization/profile_plot.py
  function profile_plot (line 37) | def profile_plot(
  function _extract_profile_plot_lines (line 158) | def _extract_profile_plot_lines(
  function create_solution_times (line 205) | def create_solution_times(
  function _determine_alpha_grid (line 249) | def _determine_alpha_grid(solution_times: pd.DataFrame) -> list[np.float...
  function _find_switch_points (line 259) | def _find_switch_points(solution_times: pd.DataFrame) -> NDArray[np.floa...
  function _get_profile_plot_xlabel (line 280) | def _get_profile_plot_xlabel(runtime_measure: str, normalize_runtime: bo...

FILE: src/optimagic/visualization/slice_plot.py
  function slice_plot (line 34) | def slice_plot(
  function _get_processed_func_and_func_eval (line 198) | def _get_processed_func_and_func_eval(
  function _get_plot_data (line 229) | def _get_plot_data(
  function _retrieve_func_values (line 300) | def _retrieve_func_values(
  function _extract_slice_plot_lines_and_labels (line 325) | def _extract_slice_plot_lines_and_labels(
  function _get_axis_limits (line 369) | def _get_axis_limits(

FILE: src/optimagic/visualization/slice_plot_3d.py
  function slice_plot_3d (line 28) | def slice_plot_3d(  # type: ignore[no-untyped-def]
  function generate_evaluation_points (line 363) | def generate_evaluation_points(  # type: ignore[no-untyped-def]
  function plot_data_cache (line 416) | def plot_data_cache(  # type: ignore[no-untyped-def]
  function plot_line (line 474) | def plot_line(  # type: ignore[no-untyped-def]
  function plot_surface (line 528) | def plot_surface(  # type: ignore[no-untyped-def]
  function plot_contour (line 570) | def plot_contour(  # type: ignore[no-untyped-def]
  class ProjectionConfig (line 612) | class ProjectionConfig(str, Enum):
    method validate (line 620) | def validate(cls, value):  # type: ignore[no-untyped-def]
    method is_univariate (line 631) | def is_univariate(self) -> bool:
    method is_surface (line 635) | def is_surface(self) -> bool:
    method is_contour (line 639) | def is_contour(self) -> bool:
  class Projection (line 643) | class Projection:
    method __init__ (line 652) | def __init__(self, value):  # type: ignore[no-untyped-def]
    method _parse (line 659) | def _parse(self, value):  # type: ignore[no-untyped-def]
    method is_univariate (line 679) | def is_univariate(self) -> bool:
    method is_dict (line 683) | def is_dict(self) -> bool:
    method get_config (line 686) | def get_config(self):  # type: ignore[no-untyped-def]
  function compute_yaxis_range (line 692) | def compute_yaxis_range(y: list[float], expand_yrange: float) -> list[fl...
  function combine_plots (line 699) | def combine_plots(  # type: ignore[no-untyped-def]
  function _get_subplot_spec (line 811) | def _get_subplot_spec(  # type: ignore[no-untyped-def]
  function evaluate_plot_kwargs (line 835) | def evaluate_plot_kwargs(plot_kwargs):  # type: ignore[no-untyped-def]
  function evaluate_make_subplot_kwargs (line 865) | def evaluate_make_subplot_kwargs(  # type: ignore[no-untyped-def]
  function evaluate_layout_kwargs (line 919) | def evaluate_layout_kwargs(  # type: ignore[no-untyped-def]

FILE: tests/conftest.py
  function fresh_directory (line 11) | def fresh_directory(tmp_path):  # noqa: PT004
  function logit_inputs (line 17) | def logit_inputs():
  function logit_object (line 30) | def logit_object():
  function close_mpl_figures (line 38) | def close_mpl_figures():

FILE: tests/estimagic/examples/test_logit.py
  function test_logit_loglikes (line 8) | def test_logit_loglikes(logit_inputs, logit_object):
  function test_logit_jac (line 16) | def test_logit_jac(logit_inputs, logit_object):
  function test_logit_grad (line 25) | def test_logit_grad(logit_inputs, logit_object):
  function test_logit_hessian (line 32) | def test_logit_hessian(logit_inputs, logit_object):

FILE: tests/estimagic/test_bootstrap.py
  function aaae (line 10) | def aaae(obj1, obj2, decimal=6):
  function setup (line 17) | def setup():
  function expected (line 33) | def expected():
  function seaborn_example (line 66) | def seaborn_example():
  function _outcome_func (line 84) | def _outcome_func(data, shift=0):
  function _outcome_ols (line 101) | def _outcome_ols(data):
  function test_bootstrap_with_outcome_kwargs (line 110) | def test_bootstrap_with_outcome_kwargs(shift, setup):
  function test_bootstrap_existing_outcomes (line 122) | def test_bootstrap_existing_outcomes(setup):
  function test_bootstrap_from_outcomes (line 138) | def test_bootstrap_from_outcomes(setup, expected):
  function test_bootstrap_from_outcomes_private_methods (line 161) | def test_bootstrap_from_outcomes_private_methods(setup, expected):
  function test_bootstrap_from_outcomes_single_outcome (line 178) | def test_bootstrap_from_outcomes_single_outcome(setup, expected):
  function test_outcome_not_callable (line 188) | def test_outcome_not_callable(setup):
  function test_existing_result_wrong_input_type (line 198) | def test_existing_result_wrong_input_type(input_type, setup):
  function test_cov_correct_return_type (line 212) | def test_cov_correct_return_type(return_type, setup):
  function test_cov_wrong_return_type (line 220) | def test_cov_wrong_return_type(setup):
  function test_existing_result (line 234) | def test_existing_result(seaborn_example):

FILE: tests/estimagic/test_bootstrap_ci.py
  function aaae (line 14) | def aaae(obj1, obj2, decimal=6):
  function setup (line 21) | def setup():
  function expected (line 35) | def expected():
  function _outcome_fun_series (line 52) | def _outcome_fun_series(data):
  function _outcome_func_dict (line 56) | def _outcome_func_dict(data):
  function _outcome_func_arr (line 60) | def _outcome_func_arr(data):
  function test_ci (line 71) | def test_ci(outcome, method, setup, expected):
  function test_check_inputs_data (line 84) | def test_check_inputs_data():
  function test_check_inputs_weight_by (line 93) | def test_check_inputs_weight_by(setup):
  function test_get_bootstrap_indices_heterogeneous_weights (line 99) | def test_get_bootstrap_indices_heterogeneous_weights():
  function test_check_inputs_cluster_by (line 116) | def test_check_inputs_cluster_by(setup):
  function test_check_inputs_ci_method (line 125) | def test_check_inputs_ci_method(setup):
  function test_check_inputs_ci_level (line 138) | def test_check_inputs_ci_level(setup):

FILE: tests/estimagic/test_bootstrap_outcomes.py
  function data (line 17) | def data():
  function _mean_return_series (line 22) | def _mean_return_series(data):
  function _mean_return_dict (line 27) | def _mean_return_dict(data):
  function _mean_return_array (line 32) | def _mean_return_array(data):
  function test_get_bootstrap_estimates_runs (line 46) | def test_get_bootstrap_estimates_runs(outcome, data):
  function test_bootstrap_estimates_from_indices_without_errors (line 56) | def test_bootstrap_estimates_from_indices_without_errors(data):
  function test_get_bootstrap_estimates_with_error_and_raise (line 70) | def test_get_bootstrap_estimates_with_error_and_raise(data):
  function test_get_bootstrap_estimates_with_all_errors_and_continue (line 86) | def test_get_bootstrap_estimates_with_all_errors_and_continue(data):
  function test_get_bootstrap_estimates_with_some_errors_and_continue (line 103) | def test_get_bootstrap_estimates_with_some_errors_and_continue(data):

FILE: tests/estimagic/test_bootstrap_samples.py
  function data (line 19) | def data():
  function test_get_bootstrap_indices_randomization_works_without_clustering (line 27) | def test_get_bootstrap_indices_randomization_works_without_clustering(da...
  function test_get_bootstrap_indices_radomization_works_with_clustering (line 33) | def test_get_bootstrap_indices_radomization_works_with_clustering(data):
  function test_get_bootstrap_indices_randomization_works_with_weights (line 39) | def test_get_bootstrap_indices_randomization_works_with_weights(data):
  function test_get_bootstrap_indices_randomization_works_with_weights_and_clustering (line 45) | def test_get_bootstrap_indices_randomization_works_with_weights_and_clus...
  function test_get_bootstrap_indices_randomization_works_with_and_without_weights (line 53) | def test_get_bootstrap_indices_randomization_works_with_and_without_weig...
  function test_get_boostrap_indices_randomization_works_with_extreme_case (line 61) | def test_get_boostrap_indices_randomization_works_with_extreme_case(data):
  function test_clustering_leaves_households_intact (line 70) | def test_clustering_leaves_households_intact(data):
  function test_convert_cluster_ids_to_indices (line 81) | def test_convert_cluster_ids_to_indices():
  function test_get_bootstrap_samples_from_indices (line 89) | def test_get_bootstrap_samples_from_indices():
  function test_get_bootstrap_samples_runs (line 97) | def test_get_bootstrap_samples_runs(data):
  function sample_data (line 103) | def sample_data():
  function test_no_weights_no_clusters (line 107) | def test_no_weights_no_clusters(sample_data):
  function test_weights_no_clusters (line 112) | def test_weights_no_clusters(sample_data):
  function test_weights_and_clusters (line 118) | def test_weights_and_clusters(sample_data):
  function test_invalid_weight_column (line 126) | def test_invalid_weight_column():
  function test_invalid_cluster_column (line 132) | def test_invalid_cluster_column(sample_data):
  function test_empty_dataframe (line 137) | def test_empty_dataframe():
  function test_some_zero_weights_with_clusters (line 143) | def test_some_zero_weights_with_clusters():

FILE: tests/estimagic/test_estimate_ml.py
  function aaae (line 25) | def aaae(obj1, obj2, decimal=3):
  function multivariate_normal_loglike (line 37) | def multivariate_normal_loglike(params, data):
  function multivariate_normal_example (line 45) | def multivariate_normal_example():
  function test_estimate_ml_with_constraints (line 61) | def test_estimate_ml_with_constraints(multivariate_normal_example):
  function logit_np_inputs (line 99) | def logit_np_inputs():
  function fitted_logit_model (line 113) | def fitted_logit_model(logit_object):
  function test_estimate_ml_with_logit_no_constraints (line 145) | def test_estimate_ml_with_logit_no_constraints(
  function test_estimate_ml_with_logit_constraints (line 250) | def test_estimate_ml_with_logit_constraints(
  function test_estimate_ml_optimize_options_false (line 329) | def test_estimate_ml_optimize_options_false(fitted_logit_model, logit_np...
  function test_estimate_ml_algorithm_type (line 354) | def test_estimate_ml_algorithm_type(logit_np_inputs):
  function test_estimate_ml_algorithm (line 368) | def test_estimate_ml_algorithm(logit_np_inputs):
  function normal_loglike (line 388) | def normal_loglike(params, y):
  function normal_inputs (line 393) | def normal_inputs():
  function test_estimate_ml_general_pytree (line 403) | def test_estimate_ml_general_pytree(normal_inputs):
  function test_to_pickle (line 434) | def test_to_pickle(normal_inputs, tmp_path):
  function test_caching (line 452) | def test_caching(normal_inputs):

FILE: tests/estimagic/test_estimate_msm.py
  function _sim_pd (line 19) | def _sim_pd(params):
  function _sim_np (line 23) | def _sim_np(params):
  function _sim_dict_pd (line 27) | def _sim_dict_pd(params):
  function _sim_dict_np (line 31) | def _sim_dict_np(params):
  function test_estimate_msm (line 48) | def test_estimate_msm(simulate_moments, moments_cov, optimize_options):
  function test_check_and_process_optimize_options_with_invalid_entries (line 104) | def test_check_and_process_optimize_options_with_invalid_entries():
  function test_estimate_msm_ls (line 121) | def test_estimate_msm_ls(simulate_moments, moments_cov, optimize_options):
  function test_estimate_msm_with_jacobian (line 142) | def test_estimate_msm_with_jacobian():
  function test_estimate_msm_with_algorithm_type (line 165) | def test_estimate_msm_with_algorithm_type():
  function test_estimate_msm_with_algorithm (line 182) | def test_estimate_msm_with_algorithm():
  function test_to_pickle (line 199) | def test_to_pickle(tmp_path):
  function test_caching (line 218) | def test_caching():

FILE: tests/estimagic/test_estimate_msm_dict_params_and_moments.py
  function test_estimate_msm_dict_params_and_moments (line 12) | def test_estimate_msm_dict_params_and_moments():
  function assert_almost_equal (line 96) | def assert_almost_equal(x, y, decimal=6):

FILE: tests/estimagic/test_estimation_table.py
  function _get_models_multiindex (line 36) | def _get_models_multiindex():
  function _get_models_single_index (line 50) | def _get_models_single_index():
  function _get_models_multiindex_multi_column (line 62) | def _get_models_multiindex_multi_column():
  function _read_csv_string (line 77) | def _read_csv_string(string, index_cols=None):
  function test_estimation_table (line 95) | def test_estimation_table():
  function test_one_and_stage_rendering_are_equal (line 141) | def test_one_and_stage_rendering_are_equal(return_type, render_func, mod...
  function test_process_model_stats_model (line 155) | def test_process_model_stats_model():
  function test_convert_model_to_series_with_ci (line 187) | def test_convert_model_to_series_with_ci():
  function test_convert_model_to_series_with_se (line 215) | def test_convert_model_to_series_with_se():
  function test_convert_model_to_series_without_inference (line 234) | def test_convert_model_to_series_without_inference():
  function test_create_statistics_sr (line 251) | def test_create_statistics_sr():
  function test_process_frame_indices_index (line 282) | def test_process_frame_indices_index():
  function test_process_frame_indices_columns (line 312) | def test_process_frame_indices_columns():
  function test_apply_number_format_tuple (line 330) | def test_apply_number_format_tuple():
  function test_apply_number_format_int (line 340) | def test_apply_number_format_int():
  function test_apply_number_format_callable (line 350) | def test_apply_number_format_callable():
  function test_get_digits_after_decimal (line 362) | def test_get_digits_after_decimal():
  function test_create_group_to_col_position (line 371) | def test_create_group_to_col_position():
  function test_get_model_names (line 385) | def test_get_model_names():
  function test_get_default_column_names_and_groups (line 395) | def test_get_default_column_names_and_groups():
  function test_get_default_column_names_and_groups_undefined_groups (line 404) | def test_get_default_column_names_and_groups_undefined_groups():
  function test_customize_col_groups (line 412) | def test_customize_col_groups():
  function test_customize_col_names_dict (line 420) | def test_customize_col_names_dict():
  function test_customize_col_names_list (line 428) | def test_customize_col_names_list():
  function test_get_params_frames_with_common_index (line 436) | def test_get_params_frames_with_common_index():
  function test_get_params_frames_with_common_index_multiindex (line 458) | def test_get_params_frames_with_common_index_multiindex():
  function test_check_order_of_model_names_raises_error (line 471) | def test_check_order_of_model_names_raises_error():
  function test_manual_extra_info (line 477) | def test_manual_extra_info():

FILE: tests/estimagic/test_lollipop_plot.py
  function test_lollipop_plot_runs (line 7) | def test_lollipop_plot_runs():

FILE: tests/estimagic/test_ml_covs.py
  function jac (line 23) | def jac():
  function hess (line 37) | def hess():
  function design_options (line 50) | def design_options():
  function test_clustering (line 64) | def test_clustering(jac, design_options):
  function test_stratification (line 77) | def test_stratification(jac, design_options):
  function test_sandwich_step (line 91) | def test_sandwich_step(hess):
  function test_cov_robust (line 105) | def test_cov_robust(jac, hess):
  function test_cov_cluster_robust (line 119) | def test_cov_cluster_robust(jac, hess, design_options):
  function test_cov_strata_robust (line 138) | def test_cov_strata_robust(jac, hess, design_options):
  function test_cov_hessian (line 156) | def test_cov_hessian(hess):
  function test_cov_jacobian (line 170) | def test_cov_jacobian(jac):
  function get_expected_covariance (line 186) | def get_expected_covariance(model, cov_method):
  function get_input (line 203) | def get_input(model, input_types):
  function test_cov_function_against_statsmodels (line 231) | def test_cov_function_against_statsmodels(model, method):

FILE: tests/estimagic/test_msm_covs.py
  function test_cov_robust_and_cov_optimal_are_equivalent_in_special_case (line 24) | def test_cov_robust_and_cov_optimal_are_equivalent_in_special_case(jac, ...

FILE: tests/estimagic/test_msm_sensitivity.py
  function simulate_aggregated_moments (line 20) | def simulate_aggregated_moments(params, x, y):
  function simulate_moment_contributions (line 28) | def simulate_moment_contributions(params, x, y):
  function moments_cov (line 52) | def moments_cov(params, func_kwargs):
  function params (line 60) | def params():
  function func_kwargs (line 70) | def func_kwargs():
  function jac (line 79) | def jac(params, func_kwargs):
  function weights (line 91) | def weights(moments_cov):
  function params_cov_opt (line 96) | def params_cov_opt(jac, weights):
  function test_sensitivity_to_bias (line 100) | def test_sensitivity_to_bias(jac, weights, params):
  function test_fundamental_sensitivity_to_noise (line 114) | def test_fundamental_sensitivity_to_noise(
  function test_actual_sensitivity_to_noise (line 135) | def test_actual_sensitivity_to_noise(jac, weights, moments_cov, params_c...
  function test_actual_sensitivity_to_removal (line 155) | def test_actual_sensitivity_to_removal(
  function test_fundamental_sensitivity_to_removal (line 174) | def test_fundamental_sensitivity_to_removal(jac, moments_cov, params_cov...
  function test_sensitivity_to_weighting (line 191) | def test_sensitivity_to_weighting(jac, weights, moments_cov, params_cov_...

FILE: tests/estimagic/test_msm_sensitivity_via_estimate_msm.py
  function simulate_aggregated_moments (line 11) | def simulate_aggregated_moments(params, x, y):
  function simulate_moment_contributions (line 19) | def simulate_moment_contributions(params, x, y):
  function moments_cov (line 43) | def moments_cov(params, func_kwargs):
  function params (line 51) | def params():
  function func_kwargs (line 61) | def func_kwargs():
  function msm_res (line 70) | def msm_res(params, moments_cov, func_kwargs):
  function test_sensitivity_to_bias (line 84) | def test_sensitivity_to_bias(msm_res):
  function test_fundamental_sensitivity_to_noise (line 97) | def test_fundamental_sensitivity_to_noise(msm_res):
  function test_actual_sensitivity_to_noise (line 110) | def test_actual_sensitivity_to_noise(msm_res):
  function test_actual_sensitivity_to_removal (line 123) | def test_actual_sensitivity_to_removal(msm_res):
  function test_fundamental_sensitivity_to_removal (line 137) | def test_fundamental_sensitivity_to_removal(msm_res):
  function test_sensitivity_to_weighting (line 151) | def test_sensitivity_to_weighting(msm_res):

FILE: tests/estimagic/test_msm_weighting.py
  function expected_values (line 18) | def expected_values():
  function test_get_weighting_matrix (line 30) | def test_get_weighting_matrix(moments_cov, method):
  function test_assemble_block_diagonal_matrix_pd (line 50) | def test_assemble_block_diagonal_matrix_pd(expected_values):
  function test_assemble_block_diagonal_matrix_mixed (line 62) | def test_assemble_block_diagonal_matrix_mixed(expected_values):
  function test_get_moments_cov_runs_with_pytrees (line 69) | def test_get_moments_cov_runs_with_pytrees():
  function test_get_moments_cov_passes_bootstrap_kwargs_to_bootstrap (line 95) | def test_get_moments_cov_passes_bootstrap_kwargs_to_bootstrap():

FILE: tests/estimagic/test_shared.py
  function inputs (line 23) | def inputs():
  function test_process_pandas_arguments_all_pd (line 32) | def test_process_pandas_arguments_all_pd(inputs):
  function test_process_pandas_arguments_incompatible_names (line 43) | def test_process_pandas_arguments_incompatible_names(inputs):
  function _from_internal (line 50) | def _from_internal(x, return_type="flat"):  # noqa: ARG001
  class FakeConverter (line 54) | class FakeConverter(NamedTuple):
  class FakeInternalParams (line 59) | class FakeInternalParams(NamedTuple):
  function test_transform_covariance_no_bounds (line 66) | def test_transform_covariance_no_bounds():
  function test_transform_covariance_with_clipping (line 89) | def test_transform_covariance_with_clipping():
  function test_transform_covariance_invalid_bounds (line 113) | def test_transform_covariance_invalid_bounds():
  class FakeFreeParams (line 134) | class FakeFreeParams(NamedTuple):
  function test_transform_free_cov_to_cov_pytree (line 140) | def test_transform_free_cov_to_cov_pytree():
  function test_transform_free_cov_to_cov_array (line 155) | def test_transform_free_cov_to_cov_array():
  function test_transform_free_cov_to_cov_dataframe (line 168) | def test_transform_free_cov_to_cov_dataframe():
  function test_transform_free_cov_to_cov_invalid (line 184) | def test_transform_free_cov_to_cov_invalid():
  function test_transform_free_values_to_params_tree (line 194) | def test_transform_free_values_to_params_tree():
  function test_get_derivative_case (line 206) | def test_get_derivative_case():
  function test_to_numpy_invalid (line 212) | def test_to_numpy_invalid():
  function test_calculate_estimation_summary (line 217) | def test_calculate_estimation_summary():

FILE: tests/optimagic/benchmarking/test_benchmark_reports.py
  function benchmark_example (line 16) | def benchmark_example():
  function test_convergence_report (line 162) | def test_convergence_report(options, benchmark_example):
  function test_rank_report (line 188) | def test_rank_report(options, benchmark_example):
  function test_traceback_report (line 206) | def test_traceback_report(return_type, benchmark_example):

FILE: tests/optimagic/benchmarking/test_cartis_roberts.py
  function test_cartis_roberts_function_at_start_x (line 13) | def test_cartis_roberts_function_at_start_x(name, specification):  # noq...
  function test_cartis_roberts_function_at_solution_x (line 25) | def test_cartis_roberts_function_at_solution_x(name, specification):  # ...
  function test_get_start_points_bdvalues (line 37) | def test_get_start_points_bdvalues():
  function test_get_start_points_msqrta (line 43) | def test_get_start_points_msqrta():

FILE: tests/optimagic/benchmarking/test_get_benchmark_problems.py
  function test_get_problems (line 20) | def test_get_problems(name, additive_noise, multiplicative_noise, scaling):
  function test_step_func (line 46) | def test_step_func():

FILE: tests/optimagic/benchmarking/test_more_wild.py
  function test_more_wild_function_at_start_x (line 11) | def test_more_wild_function_at_start_x(name, specification):  # noqa: AR...
  function test_get_start_points_mancino (line 29) | def test_get_start_points_mancino():

FILE: tests/optimagic/benchmarking/test_noise_distributions.py
  function test_sample_from_distribution (line 11) | def test_sample_from_distribution(distribution):

FILE: tests/optimagic/benchmarking/test_run_benchmark.py
  function test_run_benchmark_dict_options (line 7) | def test_run_benchmark_dict_options():
  function test_run_benchmark_list_options (line 35) | def test_run_benchmark_list_options():
  function test_run_benchmark_failing (line 55) | def test_run_benchmark_failing():

FILE: tests/optimagic/differentiation/test_compare_derivatives_with_jax.py
  function _tree_equal_numpy_leaves (line 28) | def _tree_equal_numpy_leaves(tree1, tree2):
  function _compute_testable_optimagic_and_jax_derivatives (line 33) | def _compute_testable_optimagic_and_jax_derivatives(func, params, func_j...
  function test_scalar_input_scalar_output (line 57) | def test_scalar_input_scalar_output():
  function test_array_input_scalar_output (line 69) | def test_array_input_scalar_output():
  function test_dict_input_scalar_output (line 81) | def test_dict_input_scalar_output():
  function test_array_dict_input_scalar_output (line 93) | def test_array_dict_input_scalar_output():
  function test_array_input_array_output (line 108) | def test_array_input_array_output():
  function test_array_dict_input_array_output (line 123) | def test_array_dict_input_array_output():
  function test_array_dict_input_dict_output (line 138) | def test_array_dict_input_dict_output():

FILE: tests/optimagic/differentiation/test_derivatives.py
  function binary_choice_inputs (line 40) | def binary_choice_inputs():
  function test_first_derivative_jacobian (line 51) | def test_first_derivative_jacobian(binary_choice_inputs, method):
  function test_first_derivative_jacobian_works_at_defaults (line 76) | def test_first_derivative_jacobian_works_at_defaults(binary_choice_inputs):
  function test_first_derivative_gradient (line 85) | def test_first_derivative_gradient(binary_choice_inputs, method):
  function test_second_derivative_hessian (line 103) | def test_second_derivative_hessian(binary_choice_inputs, method):
  function test_first_derivative_scalar (line 122) | def test_first_derivative_scalar(method):  # noqa: ARG001
  function test_second_derivative_scalar (line 132) | def test_second_derivative_scalar(method):  # noqa: ARG001
  function test_nan_skipping_batch_evaluator (line 142) | def test_nan_skipping_batch_evaluator():
  function test_consolidate_one_step_derivatives (line 165) | def test_consolidate_one_step_derivatives():
  function example_function_gradient_fixtures (line 178) | def example_function_gradient_fixtures():
  function example_function_jacobian_fixtures (line 195) | def example_function_jacobian_fixtures():
  function test_first_derivative_gradient_richardson (line 212) | def test_first_derivative_gradient_richardson(example_function_gradient_...
  function test_first_derivative_jacobian_richardson (line 226) | def test_first_derivative_jacobian_richardson(example_function_jacobian_...
  function test_convert_evaluation_data_to_frame (line 239) | def test_convert_evaluation_data_to_frame():
  function test__convert_richardson_candidates_to_frame (line 261) | def test__convert_richardson_candidates_to_frame():
  function test__select_minimizer_along_axis (line 288) | def test__select_minimizer_along_axis():
  function test_reshape_one_step_evals (line 296) | def test_reshape_one_step_evals():
  function test_reshape_two_step_evals (line 318) | def test_reshape_two_step_evals():
  function test_reshape_cross_step_evals (line 330) | def test_reshape_cross_step_evals():
  function test_is_scalar_nan (line 346) | def test_is_scalar_nan():
  class MyOutput (line 353) | class MyOutput:
  function test_first_derivative_with_unpacking (line 358) | def test_first_derivative_with_unpacking():
  function test_second_derivative_with_unpacking (line 372) | def test_second_derivative_with_unpacking():
  function test_numdiff_result_getitem (line 387) | def test_numdiff_result_getitem():
  function test_first_and_second_derivative_have_same_type_hints (line 400) | def test_first_and_second_derivative_have_same_type_hints():
  function test_first_derivative_pytree_step_size (line 412) | def test_first_derivative_pytree_step_size():
  function test_second_derivative_pytree_step_size (line 424) | def test_second_derivative_pytree_step_size():
  function test_first_derivative_pytree_min_steps (line 437) | def test_first_derivative_pytree_min_steps():
  function test_second_derivative_pytree_min_steps (line 455) | def test_second_derivative_pytree_min_steps():

FILE: tests/optimagic/differentiation/test_finite_differences.py
  function jacobian_inputs (line 11) | def jacobian_inputs():
  function test_jacobian_finite_differences (line 39) | def test_jacobian_finite_differences(jacobian_inputs, method):

FILE: tests/optimagic/differentiation/test_generate_steps.py
  function test_scalars_as_base_steps (line 15) | def test_scalars_as_base_steps():
  function test_scalars_as_min_steps (line 27) | def test_scalars_as_min_steps():
  function test_calculate_or_validate_base_steps_invalid_too_small (line 43) | def test_calculate_or_validate_base_steps_invalid_too_small():
  function test_calculate_or_validate_base_steps_wrong_shape (line 52) | def test_calculate_or_validate_base_steps_wrong_shape():
  function test_calculate_or_validate_base_steps_jacobian (line 61) | def test_calculate_or_validate_base_steps_jacobian():
  function test_calculate_or_validate_base_steps_jacobian_with_scaling_factor (line 70) | def test_calculate_or_validate_base_steps_jacobian_with_scaling_factor():
  function test_calculate_or_validate_base_steps_binding_min_step (line 79) | def test_calculate_or_validate_base_steps_binding_min_step():
  function test_calculate_or_validate_base_steps_hessian (line 89) | def test_calculate_or_validate_base_steps_hessian():
  function test_set_unused_side_to_nan_forward (line 98) | def test_set_unused_side_to_nan_forward():
  function test_set_unused_side_to_nan_backward (line 117) | def test_set_unused_side_to_nan_backward():
  function test_fillna (line 136) | def test_fillna():
  function test_rescale_to_accomodate_bounds (line 141) | def test_rescale_to_accomodate_bounds():
  function test_rescale_to_accomodate_bounds_binding_min_step (line 160) | def test_rescale_to_accomodate_bounds_binding_min_step():
  function test_generate_steps_binding_min_step (line 179) | def test_generate_steps_binding_min_step():
  function test_generate_steps_min_step_equals_base_step (line 199) | def test_generate_steps_min_step_equals_base_step():

FILE: tests/optimagic/differentiation/test_numdiff_options.py
  function test_pre_process_numdiff_options_trivial_case (line 10) | def test_pre_process_numdiff_options_trivial_case():
  function test_pre_process_numdiff_options_none_case (line 22) | def test_pre_process_numdiff_options_none_case():
  function test_pre_process_numdiff_options_dict_case (line 26) | def test_pre_process_numdiff_options_dict_case():
  function test_pre_process_numdiff_options_invalid_type (line 35) | def test_pre_process_numdiff_options_invalid_type():
  function test_pre_process_numdiff_options_invalid_dict_key (line 40) | def test_pre_process_numdiff_options_invalid_dict_key():
  function test_pre_process_numdiff_options_invalid_dict_value (line 45) | def test_pre_process_numdiff_options_invalid_dict_value():
  function test_numdiff_options_invalid_method (line 50) | def test_numdiff_options_invalid_method():
  function test_numdiff_options_invalid_step_size (line 55) | def test_numdiff_options_invalid_step_size():
  function test_numdiff_options_invalid_scaling_factor (line 62) | def test_numdiff_options_invalid_scaling_factor():
  function test_numdiff_options_invalid_min_steps (line 69) | def test_numdiff_options_invalid_min_steps():
  function test_numdiff_options_invalid_n_cores (line 76) | def test_numdiff_options_invalid_n_cores():
  function test_numdiff_options_invalid_batch_evaluator (line 81) | def test_numdiff_options_invalid_batch_evaluator():

FILE: tests/optimagic/examples/test_criterion_functions.py
  function input_params (line 38) | def input_params():
  function test_trid_scalar (line 43) | def test_trid_scalar(input_params):
  function test_trid_gradient (line 48) | def test_trid_gradient(input_params):
  function test_trid_fun_and_gradient (line 53) | def test_trid_fun_and_gradient(input_params):
  function test_rhe_scalar (line 58) | def test_rhe_scalar(input_params):
  function test_rhe_gradient (line 63) | def test_rhe_gradient(input_params):
  function test_rhe_fun_and_gradient (line 68) | def test_rhe_fun_and_gradient(input_params):
  function test_rosenbrock_scalar (line 73) | def test_rosenbrock_scalar(input_params):
  function test_rosenbrock_gradient (line 78) | def test_rosenbrock_gradient(input_params):
  function test_rosenbrock_fun_and_gradient (line 83) | def test_rosenbrock_fun_and_gradient(input_params):
  function test_rhe_function_value (line 88) | def test_rhe_function_value(input_params):
  function test_rosenbrock_function_value (line 95) | def test_rosenbrock_function_value(input_params):
  function test_sos_ls (line 107) | def test_sos_ls():
  function test_sos_ls_with_pd_objects (line 112) | def test_sos_ls_with_pd_objects():
  function test_sos_scalar (line 118) | def test_sos_scalar():
  function test_sos_gradient (line 123) | def test_sos_gradient():
  function test_sos_likelihood_jacobian (line 128) | def test_sos_likelihood_jacobian():
  function test_sos_ls_jacobian (line 135) | def test_sos_ls_jacobian():
  function test_sos_fun_and_gradient (line 142) | def test_sos_fun_and_gradient():
  function test_sos_likelihood_fun_and_jac (line 148) | def test_sos_likelihood_fun_and_jac():
  function test_sos_ls_fun_and_jac (line 155) | def test_sos_ls_fun_and_jac():

FILE: tests/optimagic/logging/test_base.py
  function test_key_value_store_raise_errors (line 9) | def test_key_value_store_raise_errors():

FILE: tests/optimagic/logging/test_logger.py
  function example_db (line 21) | def example_db(tmp_path):
  function test_read_start_params (line 37) | def test_read_start_params(example_db):
  function test_log_reader_read_start_params (line 42) | def test_log_reader_read_start_params(example_db):
  function test_log_reader_read_iteration (line 48) | def test_log_reader_read_iteration(example_db):
  function test_log_reader_index_exception (line 60) | def test_log_reader_index_exception(example_db):
  function test_log_reader_read_history (line 68) | def test_log_reader_read_history(example_db):
  function test_log_reader_read_multistart_history (line 76) | def test_log_reader_read_multistart_history(example_db):
  function test_read_steps_table (line 91) | def test_read_steps_table(example_db):
  function test_read_optimization_problem_table (line 99) | def test_read_optimization_problem_table(example_db):
  function test_non_existing_database_raises_error (line 104) | def test_non_existing_database_raises_error(tmp_path):
  function test_available_log_options (line 109) | def test_available_log_options():
  function test_no_registered (line 115) | def test_no_registered():

FILE: tests/optimagic/logging/test_sqlalchemy.py
  class TestIterationStore (line 20) | class TestIterationStore:
    method store (line 22) | def store(self, tmp_path):
    method create_test_point (line 27) | def create_test_point(i: int):
    method test_table_creation (line 38) | def test_table_creation(self, store):
    method test_insert_and_query (line 42) | def test_insert_and_query(self, store):
    method test_update_raise (line 50) | def test_update_raise(self, store):
    method test_serialization (line 75) | def test_serialization(self, store):
    method test_parallel_insert (line 90) | def test_parallel_insert(self, store, executor_factory):
    method test_db_replacement_error (line 111) | def test_db_replacement_error(self, store):
    method test_db_existence_raise (line 121) | def test_db_existence_raise(self, store):
  class TestStepStore (line 131) | class TestStepStore:
    method store (line 133) | def store(self, tmp_path):
    method create_test_point (line 138) | def create_test_point(i: int):
    method test_table_creation (line 143) | def test_table_creation(self, store):
    method test_insert_and_query (line 147) | def test_insert_and_query(self, store):
    method test_insert_string (line 155) | def test_insert_string(self, store):
    method test_update (line 163) | def test_update(self, store):
    method test_serialization (line 192) | def test_serialization(self, store):
    method test_parallel_insert (line 207) | def test_parallel_insert(self, store, executor_factory):
    method test_parallel_update (line 232) | def test_parallel_update(self, store, executor_factory):

FILE: tests/optimagic/logging/test_types.py
  function test_raise_on_missing_id (line 10) | def test_raise_on_missing_id():

FILE: tests/optimagic/optimization/test_algorithm.py
  function test_algo_info_validation (line 39) | def test_algo_info_validation(kwargs):
  function test_internal_optimize_result_validation (line 85) | def test_internal_optimize_result_validation(kwargs):
  class DummyAlgorithm (line 114) | class DummyAlgorithm(Algorithm):
    method _solve_internal_problem (line 120) | def _solve_internal_problem(self, problem, x0):
  function test_with_option (line 131) | def test_with_option():
  function test_with_option_invalid_key (line 139) | def test_with_option_invalid_key():
  function test_with_stopping (line 145) | def test_with_stopping():
  function test_with_stopping_with_full_option_name (line 152) | def test_with_stopping_with_full_option_name():
  function test_with_stopping_invalid_key (line 159) | def test_with_stopping_invalid_key():
  function test_with_convergence (line 165) | def test_with_convergence():
  function test_with_convergence_with_full_option_name (line 172) | def test_with_convergence_with_full_option_name():
  function test_with_convergence_invalid_key (line 179) | def test_with_convergence_invalid_key():
  function test_with_option_if_applicable (line 185) | def test_with_option_if_applicable():
  function test_algorithm_does_type_conversion (line 201) | def test_algorithm_does_type_conversion():
  function test_algorithm_does_type_conversion_in_with_option (line 219) | def test_algorithm_does_type_conversion_in_with_option():
  function test_error_with_negative_radius (line 232) | def test_error_with_negative_radius():

FILE: tests/optimagic/optimization/test_convergence_report.py
  function test_get_convergence_report_minimize (line 10) | def test_get_convergence_report_minimize():
  function test_get_convergence_report_maximize (line 27) | def test_get_convergence_report_maximize():
  function test_history_is_too_short (line 44) | def test_history_is_too_short():

FILE: tests/optimagic/optimization/test_create_optimization_problem.py
  function test_pre_process_user_algorithm_valid_string (line 9) | def test_pre_process_user_algorithm_valid_string():
  function test_pre_process_user_algorithm_invalid_string (line 14) | def test_pre_process_user_algorithm_invalid_string():
  function test_pre_process_user_algorithm_valid_instance (line 19) | def test_pre_process_user_algorithm_valid_instance():
  function test_pre_process_user_algorithm_valid_class (line 24) | def test_pre_process_user_algorithm_valid_class():

FILE: tests/optimagic/optimization/test_error_penalty.py
  function test_penalty_aggregations (line 24) | def test_penalty_aggregations(seed):
  function test_penalty_derivatives (line 48) | def test_penalty_derivatives(func, solver_type):
  function test_penalty_aggregations_via_get_error_penalty (line 69) | def test_penalty_aggregations_via_get_error_penalty(seed):

FILE: tests/optimagic/optimization/test_fun_value.py
  function test_values_for_scalar_optimizers (line 32) | def test_values_for_scalar_optimizers(value):
  function test_values_for_least_squares_optimizers (line 39) | def test_values_for_least_squares_optimizers(value):
  function test_values_for_likelihood_optimizers (line 47) | def test_values_for_likelihood_optimizers(value):
  function test_invalid_values_for_least_squares_optimizers (line 55) | def test_invalid_values_for_least_squares_optimizers(value):
  function test_invalid_values_for_likelihood_optimizers (line 61) | def test_invalid_values_for_likelihood_optimizers(value):
  function test_enforce_scalar_with_scalar_return (line 66) | def test_enforce_scalar_with_scalar_return():
  function test_enforce_scalar_with_function_value_return (line 76) | def test_enforce_scalar_with_function_value_return():
  function test_enforce_scalar_trivial_case (line 86) | def test_enforce_scalar_trivial_case():
  function test_enforce_scalar_invalid_return (line 96) | def test_enforce_scalar_invalid_return():
  function test_enforce_least_squares_with_vector_return (line 105) | def test_enforce_least_squares_with_vector_return():
  function test_enforce_least_squares_with_function_value_return (line 115) | def test_enforce_least_squares_with_function_value_return():
  function test_enforce_least_squares_trivial_case (line 125) | def test_enforce_least_squares_trivial_case():
  function test_enforce_least_squares_invalid_return (line 135) | def test_enforce_least_squares_invalid_return():
  function test_enforce_likelihood_with_vector_return (line 144) | def test_enforce_likelihood_with_vector_return():
  function test_enforce_likelihood_with_function_value_return (line 154) | def test_enforce_likelihood_with_function_value_return():
  function test_enforce_likelihood_trivial_case (line 164) | def test_enforce_likelihood_trivial_case():
  function test_enforce_likelihood_invalid_return (line 174) | def test_enforce_likelihood_invalid_return():
  function test_enforce_scalar_with_jac_with_scalar_return (line 183) | def test_enforce_scalar_with_jac_with_scalar_return():
  function test_enforce_scalar_with_jac_with_function_value_return (line 194) | def test_enforce_scalar_with_jac_with_function_value_return():
  function test_enforce_scalar_with_jac_trivial_case (line 205) | def test_enforce_scalar_with_jac_trivial_case():
  function test_enforce_scalar_with_jac_invalid_return (line 216) | def test_enforce_scalar_with_jac_invalid_return():
  function test_enforce_least_squares_with_jac_with_vector_return (line 225) | def test_enforce_least_squares_with_jac_with_vector_return():
  function test_enforce_least_squares_with_jac_with_function_value_return (line 236) | def test_enforce_least_squares_with_jac_with_function_value_return():
  function test_enforce_least_squares_with_jac_trivial_case (line 247) | def test_enforce_least_squares_with_jac_trivial_case():
  function test_enforce_least_squares_with_jac_invalid_return (line 258) | def test_enforce_least_squares_with_jac_invalid_return():
  function test_enforce_likelihood_with_jac_with_vector_return (line 267) | def test_enforce_likelihood_with_jac_with_vector_return():
  function test_enforce_likelihood_with_jac_with_function_value_return (line 278) | def test_enforce_likelihood_with_jac_with_function_value_return():
  function test_enforce_likelihood_with_jac_trivial_case (line 289) | def test_enforce_likelihood_with_jac_trivial_case():
  function test_enforce_likelihood_with_jac_invalid_return (line 300) | def test_enforce_likelihood_with_jac_invalid_return():

FILE: tests/optimagic/optimization/test_function_formats_ls.py
  function sos_ls (line 24) | def sos_ls(x):
  function typed_sos_ls (line 28) | def typed_sos_ls(x: np.ndarray) -> LeastSquaresFunctionValue:
  function sos_ls_with_info (line 33) | def sos_ls_with_info(x):
  function jac (line 44) | def jac(x):
  function jac_ls (line 49) | def jac_ls(x):
  function test_least_squares_minimize (line 63) | def test_least_squares_minimize(fun, jac, use_fun_and_jac, algorithm):
  function dict_jac (line 93) | def dict_jac(params):
  function dict_jac_ls (line 98) | def dict_jac_ls(params):
  function test_least_squares_minimize_dict (line 118) | def test_least_squares_minimize_dict(fun, jac, use_fun_and_jac, algorithm):
  function test_maximize_with_ls_problems_raises_error (line 153) | def test_maximize_with_ls_problems_raises_error(algorithm):
  function invalid_sos_ls (line 163) | def invalid_sos_ls(x):
  function invalid_sos_ls_with_info (line 168) | def invalid_sos_ls_with_info(x):
  function test_invalid_least_squares_minimize (line 180) | def test_invalid_least_squares_minimize(fun, algorithm):
  function invalid_jac_ls (line 192) | def invalid_jac_ls(x):
  function invalid_jac_ls_2 (line 197) | def invalid_jac_ls_2(x):
  function test_least_squares_minimize_with_invalid_jac (line 205) | def test_least_squares_minimize_with_invalid_jac(jac):
  function invalid_fun_and_jac_value (line 216) | def invalid_fun_and_jac_value(x):
  function invalid_fun_and_jac_derivative (line 221) | def invalid_fun_and_jac_derivative(x):
  function test_least_squares_minimize_with_invalid_fun_and_jac (line 229) | def test_least_squares_minimize_with_invalid_fun_and_jac(fun_and_jac):

FILE: tests/optimagic/optimization/test_function_formats_scalar.py
  function sos (line 17) | def sos(x):
  function marked_sos (line 22) | def marked_sos(x):
  function typed_sos_float (line 26) | def typed_sos_float(x: np.ndarray) -> float:
  function typed_sos_value (line 30) | def typed_sos_value(x: np.ndarray) -> ScalarFunctionValue:
  function sos_with_info (line 34) | def sos_with_info(x):
  function jac (line 47) | def jac(x):
  function marked_jac (line 52) | def marked_jac(x):
  function test_minimize_with_numpy_inputs (line 64) | def test_minimize_with_numpy_inputs(fun, jac, fun_and_jac_case):
  function neg_sos (line 92) | def neg_sos(x):
  function marked_neg_sos (line 97) | def marked_neg_sos(x):
  function typed_neg_sos_float (line 101) | def typed_neg_sos_float(x: np.ndarray) -> float:
  function typed_neg_sos_value (line 105) | def typed_neg_sos_value(x: np.ndarray) -> ScalarFunctionValue:
  function neg_sos_with_info (line 109) | def neg_sos_with_info(x):
  function neg_jac (line 122) | def neg_jac(x):
  function marked_neg_jac (line 127) | def marked_neg_jac(x):
  function test_maximize_with_numpy_inputs (line 137) | def test_maximize_with_numpy_inputs(fun, jac, fun_and_jac_case):
  function sos_dict (line 165) | def sos_dict(params):
  function marked_sos_dict (line 171) | def marked_sos_dict(params):
  function typed_sos_dict_float (line 176) | def typed_sos_dict_float(params: dict) -> float:
  function typed_sos_dict_value (line 181) | def typed_sos_dict_value(params: dict) -> ScalarFunctionValue:
  function sos_dict_with_info (line 186) | def sos_dict_with_info(params):
  function jac_dict (line 200) | def jac_dict(params):
  function marked_jac_dict (line 205) | def marked_jac_dict(params):
  function test_minimize_with_dict_inputs (line 215) | def test_minimize_with_dict_inputs(fun, jac, fun_and_jac_case):
  function neg_sos_dict (line 244) | def neg_sos_dict(params):
  function marked_neg_sos_dict (line 250) | def marked_neg_sos_dict(params):
  function typed_neg_sos_dict_float (line 255) | def typed_neg_sos_dict_float(params: dict) -> float:
  function typed_neg_sos_dict_value (line 260) | def typed_neg_sos_dict_value(params: dict) -> ScalarFunctionValue:
  function neg_sos_dict_with_info (line 265) | def neg_sos_dict_with_info(params):
  function neg_jac_dict (line 279) | def neg_jac_dict(params):
  function marked_neg_jac_dict (line 284) | def marked_neg_jac_dict(params):
  function test_maximize_with_dict_inputs (line 294) | def test_maximize_with_dict_inputs(fun, jac, fun_and_jac_case):
  function test_invalid_marker_for_jac_in_minimize (line 324) | def test_invalid_marker_for_jac_in_minimize():
  function test_invalid_marker_for_fun_and_jac_in_minimize (line 338) | def test_invalid_marker_for_fun_and_jac_in_minimize():
  function invalid_sos (line 352) | def invalid_sos(x):
  function invalid_marked_sos (line 357) | def invalid_marked_sos(x):
  function invalid_typed_sos_array (line 361) | def invalid_typed_sos_array(x: np.ndarray) -> NDArray[np.float64]:
  function invalid_typed_sos_value (line 365) | def invalid_typed_sos_value(x: np.ndarray) -> ScalarFunctionValue:
  function invalid_sos_with_info (line 369) | def invalid_sos_with_info(x):
  function test_minimize_with_invalid_fun (line 383) | def test_minimize_with_invalid_fun(fun):
  function invalid_jac (line 392) | def invalid_jac(x):
  function invalid_marked_jac (line 397) | def invalid_marked_jac(x):
  function test_minimize_with_invalid_jac (line 405) | def test_minimize_with_invalid_jac(jac):
  function invalid_fun_and_jac (line 415) | def invalid_fun_and_jac(x):
  function invalid_marked_fun_and_jac (line 420) | def invalid_marked_fun_and_jac(x):
  function test_minimize_with_invalid_fun_and_jac (line 428) | def test_minimize_with_invalid_fun_and_jac(fun_and_jac):

FILE: tests/optimagic/optimization/test_history.py
  function history_entries (line 30) | def history_entries():
  function test_history_add_entry (line 56) | def test_history_add_entry(history_entries):
  function test_history_add_batch (line 80) | def test_history_add_batch(history_entries):
  function test_history_from_data (line 103) | def test_history_from_data():
  function params (line 139) | def params():
  function history_data (line 148) | def history_data(params):
  function history (line 167) | def history(history_data):
  function history_parallel (line 172) | def history_parallel(history_data):
  function test_history_fun_data_with_fun_evaluations_cost_model (line 182) | def test_history_fun_data_with_fun_evaluations_cost_model(history: Histo...
  function test_history_fun_data_with_fun_evaluations_cost_model_and_monotone (line 204) | def test_history_fun_data_with_fun_evaluations_cost_model_and_monotone(
  function test_history_fun_data_with_fun_batches_cost_model (line 228) | def test_history_fun_data_with_fun_batches_cost_model(history_parallel: ...
  function test_history_fun_data_with_evaluation_time_cost_model (line 248) | def test_history_fun_data_with_evaluation_time_cost_model(history: Histo...
  function test_fun_property (line 270) | def test_fun_property(history: History):
  function test_monotone_fun_property (line 274) | def test_monotone_fun_property(history: History):
  function test_is_accepted_property (line 282) | def test_is_accepted_property(history: History):
  function test_params_data_fun_evaluations_cost_model (line 292) | def test_params_data_fun_evaluations_cost_model(history: History):
  function test_params_data_fun_evaluations_cost_model_parallel (line 338) | def test_params_data_fun_evaluations_cost_model_parallel(history_paralle...
  function test_params_data_fun_evaluations_cost_model_parallel_collapse_batches (line 384) | def test_params_data_fun_evaluations_cost_model_parallel_collapse_batches(
  function test_params_property (line 412) | def test_params_property(history, params):
  function test_flat_params_property (line 416) | def test_flat_params_property(history: History):
  function test_flat_param_names (line 421) | def test_flat_param_names(history: History):
  function test_get_total_timings_per_task_fun (line 429) | def test_get_total_timings_per_task_fun(history: History):
  function test_get_total_timings_per_task_jac_cost_factor_none (line 435) | def test_get_total_timings_per_task_jac_cost_factor_none(history: History):
  function test_get_total_timings_per_task_fun_and_jac (line 441) | def test_get_total_timings_per_task_fun_and_jac(history: History):
  function test_get_total_timings_custom_cost_model (line 447) | def test_get_total_timings_custom_cost_model(history: History):
  function test_get_total_timings_fun_evaluations (line 465) | def test_get_total_timings_fun_evaluations(history: History):
  function test_get_total_timings_fun_batches (line 471) | def test_get_total_timings_fun_batches(history: History):
  function test_get_total_timings_fun_batches_parallel (line 477) | def test_get_total_timings_fun_batches_parallel(history_parallel: History):
  function test_get_total_timings_evaluation_time (line 483) | def test_get_total_timings_evaluation_time(history: History):
  function test_get_total_timings_wall_time (line 489) | def test_get_total_timings_wall_time(history: History):
  function test_get_total_timings_invalid_cost_model (line 495) | def test_get_total_timings_invalid_cost_model(history: History):
  function test_start_time_property (line 502) | def test_start_time_property(history: History):
  function test_stop_time_property (line 506) | def test_stop_time_property(history: History):
  function test_batches_property (line 514) | def test_batches_property(history: History):
  function test_task_property (line 522) | def test_task_property(history: History):
  function test_is_1d_array (line 538) | def test_is_1d_array():
  function test_get_flat_params_pytree (line 544) | def test_get_flat_params_pytree():
  function test_get_flat_params_fast_path (line 557) | def test_get_flat_params_fast_path():
  function test_get_flat_param_names_pytree (line 564) | def test_get_flat_param_names_pytree():
  function test_get_flat_param_names_fast_path (line 570) | def test_get_flat_param_names_fast_path():
  function test_calculate_monotone_sequence_maximize (line 576) | def test_calculate_monotone_sequence_maximize():
  function test_calculate_monotone_sequence_minimize (line 583) | def test_calculate_monotone_sequence_minimize():
  function test_validate_args_are_all_none_or_lists_of_same_length (line 590) | def test_validate_args_are_all_none_or_lists_of_same_length():
  function test_task_as_categorical (line 601) | def test_task_as_categorical():
  function test_get_batch_starts_and_stops (line 608) | def test_get_batch_starts_and_stops():
  function test_apply_to_batch_sum (line 615) | def test_apply_to_batch_sum():
  function test_apply_to_batch_max (line 623) | def test_apply_to_batch_max():
  function test_apply_to_batch_broken_func (line 631) | def test_apply_to_batch_broken_func():
  function test_apply_to_batch_func_with_non_scalar_return (line 638) | def test_apply_to_batch_func_with_non_scalar_return():

FILE: tests/optimagic/optimization/test_history_collection.py
  function test_history_collection_with_parallelization (line 30) | def test_history_collection_with_parallelization(algorithm, tmp_path):
  class DummyOptimizer (line 75) | class DummyOptimizer(Algorithm):
    method _solve_internal_problem (line 79) | def _solve_internal_problem(self, problem, x0):
  function _get_fake_history (line 108) | def _get_fake_history(batch_size):
  function _fake_criterion (line 127) | def _fake_criterion(x):
  function test_history_collection_with_dummy_optimizer (line 136) | def test_history_collection_with_dummy_optimizer(n_cores, batch_size):

FILE: tests/optimagic/optimization/test_infinite_and_incomplete_bounds.py
  function sos (line 11) | def sos(x):
  function test_no_bounds_with_nevergrad (line 19) | def test_no_bounds_with_nevergrad():

FILE: tests/optimagic/optimization/test_internal_optimization_problem.py
  function base_problem (line 27) | def base_problem():
  function test_base_problem_fun (line 87) | def test_base_problem_fun(base_problem):
  function test_base_problem_jac (line 93) | def test_base_problem_jac(base_problem):
  function test_base_problem_fun_and_jac (line 99) | def test_base_problem_fun_and_jac(base_problem):
  function test_fun_and_jac_is_called_for_jac_if_jac_is_not_given (line 106) | def test_fun_and_jac_is_called_for_jac_if_jac_is_not_given(base_problem):
  function test_jac_is_called_for_fun_and_jac_if_fun_is_not_given (line 121) | def test_jac_is_called_for_fun_and_jac_if_fun_is_not_given(base_problem):
  function test_base_problem_jac_via_numdiff (line 137) | def test_base_problem_jac_via_numdiff(base_problem):
  function test_base_problem_fun_and_jac_via_numdiff (line 146) | def test_base_problem_fun_and_jac_via_numdiff(base_problem):
  function test_error_in_fun_with_error_handling_raise (line 156) | def test_error_in_fun_with_error_handling_raise(base_problem):
  function test_error_in_fun_during_numdiff_with_error_handling_raise (line 166) | def test_error_in_fun_during_numdiff_with_error_handling_raise(base_prob...
  function test_base_problem_different_jac_versions (line 178) | def test_base_problem_different_jac_versions(base_problem):
  function test_base_problem_fun_for_ls_optimizer (line 190) | def test_base_problem_fun_for_ls_optimizer(base_problem):
  function test_base_problem_exploration_fun (line 198) | def test_base_problem_exploration_fun(base_problem):
  function test_history_with_fun (line 211) | def test_history_with_fun(base_problem):
  function test_history_with_batch_fun (line 221) | def test_history_with_batch_fun(base_problem):
  function test_history_with_jac (line 233) | def test_history_with_jac(base_problem):
  function test_history_with_batch_jac (line 243) | def test_history_with_batch_jac(base_problem):
  function test_history_with_fun_and_jac (line 255) | def test_history_with_fun_and_jac(base_problem):
  function test_history_with_batch_fun_and_jac (line 265) | def test_history_with_batch_fun_and_jac(base_problem):
  function test_history_with_exploration_fun (line 277) | def test_history_with_exploration_fun(base_problem):
  function test_with_history_copy_constructor (line 289) | def test_with_history_copy_constructor(base_problem):
  function test_batch_fun (line 303) | def test_batch_fun(base_problem, n_cores):
  function test_batch_jac (line 312) | def test_batch_jac(base_problem, n_cores):
  function test_batch_fun_and_jac (line 322) | def test_batch_fun_and_jac(base_problem, n_cores):
  function max_problem (line 340) | def max_problem(base_problem):
  function test_max_problem_fun (line 366) | def test_max_problem_fun(max_problem):
  function test_max_problem_jac (line 372) | def test_max_problem_jac(max_problem):
  function test_max_problem_fun_and_jac (line 378) | def test_max_problem_fun_and_jac(max_problem):
  function test_jac_via_numdiff (line 385) | def test_jac_via_numdiff(max_problem):
  function test_fun_and_jac_via_numdiff (line 394) | def test_fun_and_jac_via_numdiff(max_problem):
  function test_max_problem_exploration_fun (line 404) | def test_max_problem_exploration_fun(max_problem):
  function pytree_problem (line 418) | def pytree_problem(base_problem):
  function test_pytree_problem_fun (line 489) | def test_pytree_problem_fun(pytree_problem):
  function test_pytree_problem_fun_scalar_output (line 495) | def test_pytree_problem_fun_scalar_output(pytree_problem):
  function test_pytree_problem_jac (line 502) | def test_pytree_problem_jac(pytree_problem):
  function test_pytree_problem_fun_and_jac (line 508) | def test_pytree_problem_fun_and_jac(pytree_problem):
  function test_pytree_problem_exploration_fun (line 515) | def test_pytree_problem_exploration_fun(pytree_problem):
  function test_numerical_jac_for_pytree_problem (line 523) | def test_numerical_jac_for_pytree_problem(pytree_problem):
  function test_numerical_fun_and_jac_for_pytree_problem (line 532) | def test_numerical_fun_and_jac_for_pytree_problem(pytree_problem):
  function error_min_problem (line 548) | def error_min_problem():
  function test_error_in_fun_minimize (line 613) | def test_error_in_fun_minimize(error_min_problem):
  function test_error_in_jac_minimize (line 619) | def test_error_in_jac_minimize(error_min_problem):
  function test_error_in_fun_and_jac_minimize (line 625) | def test_error_in_fun_and_jac_minimize(error_min_problem):
  function test_error_in_numerical_jac_minimize (line 635) | def test_error_in_numerical_jac_minimize(error_min_problem):
  function test_error_in_exploration_fun_minimize (line 644) | def test_error_in_exploration_fun_minimize(error_min_problem):
  function error_max_problem (line 658) | def error_max_problem(error_min_problem):
  function test_error_in_fun_maximize (line 674) | def test_error_in_fun_maximize(error_max_problem):
  function test_error_in_jac_maximize (line 680) | def test_error_in_jac_maximize(error_max_problem):
  function test_error_in_fun_and_jac_maximize (line 686) | def test_error_in_fun_and_jac_maximize(error_max_problem):
  function test_error_in_numerical_jac_maximize (line 696) | def test_error_in_numerical_jac_maximize(error_max_problem):
  function test_error_in_exploration_fun_maximize (line 705) | def test_error_in_exploration_fun_maximize(error_max_problem):
  function test_sphere_example_internal_optimization_problem (line 718) | def test_sphere_example_internal_optimization_problem():
  function test_sphere_example_internal_optimization_problem_with_converter (line 727) | def test_sphere_example_internal_optimization_problem_with_converter():

FILE: tests/optimagic/optimization/test_invalid_jacobian_value.py
  function params (line 18) | def params():
  function sphere (line 22) | def sphere(params):
  function sphere_gradient (line 26) | def sphere_gradient(params):
  function sphere_and_gradient (line 33) | def sphere_and_gradient(params):
  function params_norm (line 37) | def params_norm(params):
  function get_invalid_jac (line 42) | def get_invalid_jac(invalid_jac_value):
  function get_invalid_fun_and_jac (line 54) | def get_invalid_fun_and_jac(invalid_jac_value):
  function test_minimize_with_invalid_jac (line 80) | def test_minimize_with_invalid_jac(invalid_jac_value, params):
  function test_minimize_with_invalid_fun_and_jac (line 102) | def test_minimize_with_invalid_fun_and_jac(invalid_jac_value, params):

FILE: tests/optimagic/optimization/test_jax_derivatives.py
  function test_scipy_conference_example (line 14) | def test_scipy_conference_example():
  function test_params_is_jax_scalar (line 43) | def test_params_is_jax_scalar():
  function params_is_1d_array (line 59) | def params_is_1d_array():
  function test_dict_output_works (line 76) | def test_dict_output_works(algorithm):
  function test_least_squares_optimizer_pytree (line 103) | def test_least_squares_optimizer_pytree():

FILE: tests/optimagic/optimization/test_many_algorithms.py
  function algo (line 38) | def algo(algorithm):
  function _get_options (line 42) | def _get_options(algo):
  function _get_required_decimals (line 54) | def _get_required_decimals(algorithm, algo):
  function sos (line 66) | def sos(x):
  function _get_params_and_binding_bounds (line 70) | def _get_params_and_binding_bounds(algo):
  function test_sum_of_squares_with_binding_bounds (line 92) | def test_sum_of_squares_with_binding_bounds(algorithm, algo):
  function _get_params_and_bounds_on_local (line 110) | def _get_params_and_bounds_on_local(algo):
  function test_sum_of_squares_on_local_algorithms (line 121) | def test_sum_of_squares_on_local_algorithms(algorithm, algo):
  function _get_params_and_bounds_on_global_and_bounded (line 139) | def _get_params_and_bounds_on_global_and_bounded(algo):
  function test_sum_of_squares_on_global_and_bounded_algorithms (line 160) | def test_sum_of_squares_on_global_and_bounded_algorithms(algorithm, algo):

FILE: tests/optimagic/optimization/test_multistart.py
  function params (line 19) | def params():
  function constraints (line 28) | def constraints():
  function test_draw_exploration_sample (line 41) | def test_draw_exploration_sample(dist, rule, lower, upper):
  function test_run_explorations (line 62) | def test_run_explorations():
  function test_get_batched_optimization_sample (line 91) | def test_get_batched_optimization_sample():
  function current_state (line 111) | def current_state():
  function starts (line 126) | def starts():
  function results (line 131) | def results():
  function test_update_state_converged (line 139) | def test_update_state_converged(current_state, starts, results):
  function test_update_state_not_converged (line 162) | def test_update_state_not_converged(current_state, starts, results):

FILE: tests/optimagic/optimization/test_multistart_options.py
  function test_pre_process_multistart_trivial_case (line 14) | def test_pre_process_multistart_trivial_case():
  function test_pre_process_multistart_none_case (line 20) | def test_pre_process_multistart_none_case():
  function test_pre_process_multistart_false_case (line 24) | def test_pre_process_multistart_false_case():
  function test_pre_process_multistart_dict_case (line 28) | def test_pre_process_multistart_dict_case():
  function test_pre_process_multistart_invalid_type (line 41) | def test_pre_process_multistart_invalid_type():
  function test_pre_process_multistart_invalid_dict_key (line 46) | def test_pre_process_multistart_invalid_dict_key():
  function test_pre_process_multistart_invalid_dict_value (line 51) | def test_pre_process_multistart_invalid_dict_value():
  function test_multistart_options_invalid_n_samples_value (line 57) | def test_multistart_options_invalid_n_samples_value(value):
  function test_multistart_options_invalid_stopping_maxopt (line 63) | def test_multistart_options_invalid_stopping_maxopt(value):
  function test_multistart_options_stopping_maxopt_less_than_n_samples (line 68) | def test_multistart_options_stopping_maxopt_less_than_n_samples():
  function test_multistart_options_invalid_sampling_distribution (line 73) | def test_multistart_options_invalid_sampling_distribution():
  function test_multistart_options_invalid_sampling_method (line 78) | def test_multistart_options_invalid_sampling_method():
  function test_multistart_options_invalid_mixing_weight_method (line 83) | def test_multistart_options_invalid_mixing_weight_method():
  function test_multistart_options_invalid_mixing_weight_bounds (line 89) | def test_multistart_options_invalid_mixing_weight_bounds(value):
  function test_multistart_options_invalid_convergence_xtol_rel (line 94) | def test_multistart_options_invalid_convergence_xtol_rel():
  function test_multistart_options_invalid_convergence_max_discoveries (line 100) | def test_multistart_options_invalid_convergence_max_discoveries(value):
  function test_multistart_options_invalid_n_cores (line 106) | def test_multistart_options_invalid_n_cores(value):
  function test_multistart_options_invalid_batch_size (line 112) | def test_multistart_options_invalid_batch_size(value):
  function test_multistart_options_batch_size_smaller_than_n_cores (line 117) | def test_multistart_options_batch_size_smaller_than_n_cores():
  function test_multistart_options_invalid_batch_evaluator (line 122) | def test_multistart_options_invalid_batch_evaluator():
  function test_multistart_options_invalid_seed (line 127) | def test_multistart_options_invalid_seed():
  function test_multistart_options_invalid_error_handling (line 132) | def test_multistart_options_invalid_error_handling():
  function test_linear_weights (line 137) | def test_linear_weights():
  function test_tiktak_weights (line 143) | def test_tiktak_weights():
  function test_get_internal_multistart_options_from_public_defaults (line 148) | def test_get_internal_multistart_options_from_public_defaults():

FILE: tests/optimagic/optimization/test_optimize.py
  function test_sign_is_switched_back_after_maximization (line 13) | def test_sign_is_switched_back_after_maximization():
  function test_scipy_lbfgsb_actually_calls_criterion_and_derivative (line 25) | def test_scipy_lbfgsb_actually_calls_criterion_and_derivative():
  function test_with_invalid_numdiff_options (line 40) | def test_with_invalid_numdiff_options():
  function test_with_optional_fun_argument (line 51) | def test_with_optional_fun_argument():
  function test_fun_and_jac_list (line 61) | def test_fun_and_jac_list():

FILE: tests/optimagic/optimization/test_optimize_result.py
  function convergence_report (line 10) | def convergence_report():
  function base_inputs (line 32) | def base_inputs():
  function test_optimize_result_runs (line 51) | def test_optimize_result_runs(base_inputs, convergence_report):
  function test_create_stars (line 59) | def test_create_stars():
  function test_to_pickle (line 66) | def test_to_pickle(base_inputs, convergence_report, tmp_path):
  function test_dict_access (line 74) | def test_dict_access(base_inputs):

FILE: tests/optimagic/optimization/test_params_versions.py
  function test_tree_params_numerical_derivative_scalar_criterion (line 31) | def test_tree_params_numerical_derivative_scalar_criterion(params):
  function test_tree_params_scalar_criterion (line 45) | def test_tree_params_scalar_criterion(params):
  function test_tree_params_numerical_derivative_sos_ls (line 66) | def test_tree_params_numerical_derivative_sos_ls(params, algorithm):
  function test_tree_params_sos_ls (line 80) | def test_tree_params_sos_ls(params, algorithm):

FILE: tests/optimagic/optimization/test_process_result.py
  function test_sum_or_none (line 4) | def test_sum_or_none():

FILE: tests/optimagic/optimization/test_scipy_aliases.py
  function test_x0_works_in_minimize (line 9) | def test_x0_works_in_minimize():
  function test_x0_works_in_maximize (line 18) | def test_x0_works_in_maximize():
  function test_x0_and_params_do_not_work_together_in_minimize (line 27) | def test_x0_and_params_do_not_work_together_in_minimize():
  function test_x0_and_params_do_not_work_together_in_maximize (line 37) | def test_x0_and_params_do_not_work_together_in_maximize():
  function test_method_works_in_minimize (line 62) | def test_method_works_in_minimize(method):
  function test_method_works_in_maximize (line 72) | def test_method_works_in_maximize(method):
  function test_method_and_algorithm_do_not_work_together_in_minimize (line 81) | def test_method_and_algorithm_do_not_work_together_in_minimize():
  function test_method_and_algorithm_do_not_work_together_in_maximize (line 91) | def test_method_and_algorithm_do_not_work_together_in_maximize():
  function test_exception_for_hess (line 101) | def test_exception_for_hess():
  function test_exception_for_hessp (line 112) | def test_exception_for_hessp():
  function test_exception_for_callback (line 123) | def test_exception_for_callback():
  function test_exception_for_options (line 134) | def test_exception_for_options():
  function test_exception_for_tol (line 145) | def test_exception_for_tol():
  function test_args_works_in_minimize (line 156) | def test_args_works_in_minimize():
  function test_args_works_in_maximize (line 166) | def test_args_works_in_maximize():
  function test_args_does_not_work_with_together_with_any_kwargs (line 176) | def test_args_does_not_work_with_together_with_any_kwargs():
  function test_jac_equal_true_works_in_minimize (line 187) | def test_jac_equal_true_works_in_minimize():
  function test_jac_equal_true_works_in_maximize (line 197) | def test_jac_equal_true_works_in_maximize():

FILE: tests/optimagic/optimization/test_useful_exceptions.py
  function test_missing_criterion_kwargs (line 13) | def test_missing_criterion_kwargs():
  function test_missing_derivative_kwargs (line 23) | def test_missing_derivative_kwargs():
  function test_missing_criterion_and_derivative_kwargs (line 36) | def test_missing_criterion_and_derivative_kwargs():
  function test_typo_in_criterion_kwarg (line 55) | def test_typo_in_criterion_kwarg():
  function test_criterion_with_runtime_error_derivative_free (line 66) | def test_criterion_with_runtime_error_derivative_free():
  function test_criterion_with_runtime_error_during_numerical_derivative (line 80) | def test_criterion_with_runtime_error_during_numerical_derivative():
  function test_criterion_fails_at_start_values (line 94) | def test_criterion_fails_at_start_values():

FILE: tests/optimagic/optimization/test_with_advanced_constraints.py
  function test_with_covariance_constraint_bounds_distance (line 57) | def test_with_covariance_constraint_bounds_distance(derivative, constr_n...

FILE: tests/optimagic/optimization/test_with_bounds.py
  function test_minimize_with_scipy_bounds (line 7) | def test_minimize_with_scipy_bounds():
  function test_minimize_with_sequence_bounds (line 16) | def test_minimize_with_sequence_bounds():
  function test_maximize_with_scipy_bounds (line 25) | def test_maximize_with_scipy_bounds():
  function test_maximize_with_sequence_bounds (line 34) | def test_maximize_with_sequence_bounds():

FILE: tests/optimagic/optimization/test_with_constraints.py
  function logit_loglike (line 38) | def logit_loglike(params, y, x):
  function test_constrained_minimization (line 183) | def test_constrained_minimization(
  function test_fix_that_differs_from_start_value_raises_an_error (line 215) | def test_fix_that_differs_from_start_value_raises_an_error():
  function test_three_independent_constraints (line 228) | def test_three_independent_constraints():
  function test_incompatible_constraints_raise_errors (line 266) | def test_incompatible_constraints_raise_errors(constraints):
  function test_bug_from_copenhagen_presentation (line 278) | def test_bug_from_copenhagen_presentation():
  function test_constraint_inheritance (line 307) | def test_constraint_inheritance():
  function test_invalid_start_params (line 333) | def test_invalid_start_params():
  function test_covariance_constraint_in_2_by_2_case (line 348) | def test_covariance_constraint_in_2_by_2_case():

FILE: tests/optimagic/optimization/test_with_logging.py
  function flexible_sos_ls (line 28) | def flexible_sos_ls(params):
  function test_optimization_with_valid_logging (line 43) | def test_optimization_with_valid_logging(algorithm, params):
  function test_optimization_with_existing_exsting_database (line 55) | def test_optimization_with_existing_exsting_database():

FILE: tests/optimagic/optimization/test_with_multistart.py
  function params (line 22) | def params():
  function _switch_sign (line 37) | def _switch_sign(func):
  function test_multistart_optimization_with_sum_of_squares_at_defaults (line 62) | def test_multistart_optimization_with_sum_of_squares_at_defaults(
  function test_multistart_with_existing_sample (line 92) | def test_multistart_with_existing_sample(params):
  function test_convergence_via_max_discoveries_works (line 111) | def test_convergence_via_max_discoveries_works(params):
  function test_steps_are_logged_as_skipped_if_convergence (line 127) | def test_steps_are_logged_as_skipped_if_convergence(tmp_path, params):
  function test_all_steps_occur_in_optimization_iterations_if_no_convergence (line 147) | def test_all_steps_occur_in_optimization_iterations_if_no_convergence(pa...
  function test_with_non_transforming_constraints (line 169) | def test_with_non_transforming_constraints(params):
  function test_error_is_raised_with_transforming_constraints (line 181) | def test_error_is_raised_with_transforming_constraints(params):
  function test_multistart_with_numpy_params (line 192) | def test_multistart_with_numpy_params():
  function test_multistart_with_rng_seed (line 204) | def test_multistart_with_rng_seed():
  function test_with_invalid_bounds (line 218) | def test_with_invalid_bounds():
  function test_with_scaling (line 228) | def test_with_scaling():
  function test_with_ackley (line 244) | def test_with_ackley():
  function test_multistart_with_least_squares_optimizers (line 274) | def test_multistart_with_least_squares_optimizers():
  function test_with_ackley_using_dict_options (line 286) | def test_with_ackley_using_dict_options():
  function test_with_batch_evaluator (line 317) | def test_with_batch_evaluator(params):

FILE: tests/optimagic/optimization/test_with_nonlinear_constraints.py
  function nlc_2d_example (line 22) | def nlc_2d_example():
  function test_nonlinear_optimization (line 106) | def test_nonlinear_optimization(nlc_2d_example, algorithm, constr_type):
  function criterion (line 137) | def criterion(params):
  function test_documentation_example (line 144) | def test_documentation_example(algorithm):
  function general_example (line 174) | def general_example():
  function test_general_example (line 226) | def test_general_example(general_example, algorithm, skip_checks):

FILE: tests/optimagic/optimization/test_with_scaling.py
  function test_minimize_with_scaling_options (line 9) | def test_minimize_with_scaling_options():
  function test_minimize_with_scaling_options_dict (line 21) | def test_minimize_with_scaling_options_dict():
  function test_minimize_with_scaling_true (line 33) | def test_minimize_with_scaling_true():
  function test_maximize_with_scaling_options (line 45) | def test_maximize_with_scaling_options():
  function test_maximize_with_scaling_options_dict (line 57) | def test_maximize_with_scaling_options_dict():
  function test_maximize_with_scaling_true (line 69) | def test_maximize_with_scaling_true():
  function test_minimize_with_scaling_options_with_bounds (line 81) | def test_minimize_with_scaling_options_with_bounds():
  function test_minimize_with_scaling_options_dict_with_bounds (line 94) | def test_minimize_with_scaling_options_dict_with_bounds():
  function test_minimize_with_scaling_true_with_bounds (line 107) | def test_minimize_with_scaling_true_with_bounds():

FILE: tests/optimagic/optimizers/_pounders/test_linear_subsolvers.py
  function test_trsbox_linear (line 70) | def test_trsbox_linear(model_gradient, lower_bounds, upper_bounds, delta...
  function test_trsbox_geometry (line 145) | def test_trsbox_geometry(

FILE: tests/optimagic/optimizers/_pounders/test_pounders_history.py
  function test_add_entries_not_initialized (line 22) | def test_add_entries_not_initialized(entries, is_center):
  function test_add_entries_initialized_with_space (line 48) | def test_add_entries_initialized_with_space(entries, is_center):
  function test_add_entries_initialized_extension_needed (line 74) | def test_add_entries_initialized_extension_needed():
  function test_add_centered_entries (line 97) | def test_add_centered_entries():
  function test_get_centered_entries (line 117) | def test_get_centered_entries():

FILE: tests/optimagic/optimizers/_pounders/test_pounders_unit.py
  function read_yaml (line 30) | def read_yaml(path):
  function criterion (line 43) | def criterion():
  function data_create_initial_residual_model (line 56) | def data_create_initial_residual_model():
  function data_update_residual_model (line 82) | def data_update_residual_model():
  function data_update_main_from_residual_model (line 115) | def data_update_main_from_residual_model():
  function data_update_residual_model_with_new_accepted_x (line 138) | def data_update_residual_model_with_new_accepted_x():
  function data_update_main_model_with_new_accepted_x (line 170) | def data_update_main_model_with_new_accepted_x():
  function data_find_affine_points (line 204) | def data_find_affine_points(request):
  function data_add_points_until_main_model_fully_linear (line 233) | def data_add_points_until_main_model_fully_linear(request, criterion):
  function data_get_interpolation_matrices_residual_model (line 281) | def data_get_interpolation_matrices_residual_model():
  function data_evaluate_residual_model (line 322) | def data_evaluate_residual_model(request):
  function data_fit_residual_model (line 369) | def data_fit_residual_model():
  function test_update_initial_residual_model (line 403) | def test_update_initial_residual_model(data_update_initial_residual_model):
  function test_update_residual_model (line 412) | def test_update_residual_model(data_update_residual_model):
  function test_update_main_from_residual_model (line 427) | def test_update_main_from_residual_model(data_update_main_from_residual_...
  function test_update_residual_model_with_new_accepted_x (line 445) | def test_update_residual_model_with_new_accepted_x(
  function test_update_main_model_with_new_accepted_x (line 460) | def test_update_main_model_with_new_accepted_x(
  function test_find_affine_points (line 473) | def test_find_affine_points(data_find_affine_points):
  function test_add_points_until_main_model_fully_linear (line 492) | def test_add_points_until_main_model_fully_linear(
  function test_get_interpolation_matrices_residual_model (line 511) | def test_get_interpolation_matrices_residual_model(
  function test_evaluate_residual_model (line 530) | def test_evaluate_residual_model(data_evaluate_residual_model):
  function test_fit_residual_model (line 537) | def test_fit_residual_model(data_fit_residual_model):

FILE: tests/optimagic/optimizers/_pounders/test_quadratic_subsolvers.py
  function test_bounded_newton_trustregion (line 448) | def test_bounded_newton_trustregion(
  function test_gqtpar_quadratic (line 508) | def test_gqtpar_quadratic(linear_terms, square_terms, x_expected, criter...
  function test_trustregion_conjugate_gradient (line 711) | def test_trustregion_conjugate_gradient(
  function test_trustregion_steihaug_toint (line 724) | def test_trustregion_steihaug_toint(gradient, hessian, trustregion_radiu...
  function test_trustregion_trsbox (line 734) | def test_trustregion_trsbox(linear_terms, square_terms, trustregion_radi...

FILE: tests/optimagic/optimizers/test_bayesian_optimizer.py
  function test_extract_params_from_kwargs (line 19) | def test_extract_params_from_kwargs():
  function test_process_bounds_valid (line 26) | def test_process_bounds_valid():
  function test_process_bounds_none (line 34) | def test_process_bounds_none():
  function test_process_bounds_infinite (line 43) | def test_process_bounds_infinite():
  function test_process_acquisition_function_none (line 56) | def test_process_acquisition_function_none():
  function test_process_acquisition_function_string (line 83) | def test_process_acquisition_function_string(acq_name, expected_class):
  function test_process_acquisition_function_invalid_string (line 99) | def test_process_acquisition_function_invalid_string():
  function test_process_acquisition_function_instance (line 115) | def test_process_acquisition_function_instance():
  function test_process_acquisition_function_class (line 132) | def test_process_acquisition_function_class():
  function test_process_acquisition_function_invalid_type (line 148) | def test_process_acquisition_function_invalid_type():

FILE: tests/optimagic/optimizers/test_bhhh.py
  function generate_test_data (line 16) | def generate_test_data():
  function _cdf_logit (line 33) | def _cdf_logit(x):
  function get_loglikelihood_logit (line 37) | def get_loglikelihood_logit(endog, exog, x):
  function get_score_logit (line 44) | def get_score_logit(endog, exog, x):
  function get_loglikelihood_probit (line 50) | def get_loglikelihood_probit(endog, exog, x):
  function get_score_probit (line 57) | def get_score_probit(endog, exog, x):
  function criterion_and_derivative_logit (line 68) | def criterion_and_derivative_logit(x):
  function criterion_and_derivative_probit (line 85) | def criterion_and_derivative_probit(x):
  function result_statsmodels_logit (line 104) | def result_statsmodels_logit():
  function result_statsmodels_probit (line 112) | def result_statsmodels_probit():
  function test_maximum_likelihood (line 126) | def test_maximum_likelihood(criterion_and_derivative, result_statsmodels...
  function test_maximum_likelihood_external_interfaace (line 148) | def test_maximum_likelihood_external_interfaace(

FILE: tests/optimagic/optimizers/test_fides_options.py
  function criterion_and_derivative (line 43) | def criterion_and_derivative(x):
  function criterion (line 47) | def criterion(x):
  function test_fides_correct_algo_options (line 53) | def test_fides_correct_algo_options(algo_options):
  function test_fides_unimplemented_algo_options (line 77) | def test_fides_unimplemented_algo_options(algo_options):
  function test_fides_stop_after_one_iteration (line 92) | def test_fides_stop_after_one_iteration():

FILE: tests/optimagic/optimizers/test_gfo_optimizers.py
  function test_get_gfo_constraints (line 21) | def test_get_gfo_constraints():
  function test_get_initialize_gfo (line 27) | def test_get_initialize_gfo():
  function test_get_search_space_gfo (line 45) | def test_get_search_space_gfo():
  function test_value2para (line 61) | def test_value2para():
  function test_gfo_internal (line 68) | def test_gfo_internal():

FILE: tests/optimagic/optimizers/test_iminuit_migrad.py
  function sphere (line 15) | def sphere(x):
  function sphere_grad (line 19) | def sphere_grad(x):
  function test_convert_bounds_unbounded (line 23) | def test_convert_bounds_unbounded():
  function test_convert_bounds_lower_only (line 34) | def test_convert_bounds_lower_only():
  function test_convert_bounds_upper_only (line 45) | def test_convert_bounds_upper_only():
  function test_convert_bounds_two_sided (line 56) | def test_convert_bounds_two_sided():
  function test_convert_bounds_mixed (line 67) | def test_convert_bounds_mixed():
  function test_iminuit_migrad (line 80) | def test_iminuit_migrad():

FILE: tests/optimagic/optimizers/test_ipopt_options.py
  function criterion (line 201) | def criterion(x):
  function derivative (line 205) | def derivative(x):
  function test_ipopt_algo_options (line 211) | def test_ipopt_algo_options(algo_options):

FILE: tests/optimagic/optimizers/test_nag_optimizers.py
  function test_change_evals_per_point_interface_none (line 16) | def test_change_evals_per_point_interface_none():
  function test_change_evals_per_point_interface_func (line 21) | def test_change_evals_per_point_interface_func():
  function test_get_fast_start_method_auto (line 38) | def test_get_fast_start_method_auto():
  function test_get_fast_start_method_jacobian (line 43) | def test_get_fast_start_method_jacobian():
  function test_get_fast_start_method_trust (line 48) | def test_get_fast_start_method_trust():
  function test_get_fast_start_method_error (line 53) | def test_get_fast_start_method_error():
  function test_build_options_dict_none (line 58) | def test_build_options_dict_none():
  function test_build_options_dict_override (line 63) | def test_build_options_dict_override():
  function test_build_options_dict_invalid_key (line 71) | def test_build_options_dict_invalid_key():
  function sos (line 79) | def sos(x):
  function test_nag_dfols_starting_at_optimum (line 87) | def test_nag_dfols_starting_at_optimum():

FILE: tests/optimagic/optimizers/test_neldermead.py
  function sphere (line 16) | def sphere(x, *args, **kwargs):  # noqa: ARG001
  function test_init_algo_params (line 21) | def test_init_algo_params():
  function test_init_simplex (line 35) | def test_init_simplex():
  function test_pfeffer (line 48) | def test_pfeffer():
  function test_nash (line 61) | def test_nash():
  function test_gao_han (line 74) | def test_gao_han():
  function test_varadhan_borchers (line 87) | def test_varadhan_borchers():
  function test_neldermead_correct_algo_options (line 118) | def test_neldermead_correct_algo_options(algo_options):
  function test_fides_stop_after_one_iteration (line 128) | def test_fides_stop_after_one_iteration():

FILE: tests/optimagic/optimizers/test_nevergrad.py
  function sos (line 19) | def sos(x):
  function test_meta_optimizers_are_valid (line 76) | def test_meta_optimizers_are_valid():
  function test_ngopt_optimizers_are_valid (line 87) | def test_ngopt_optimizers_are_valid():
  function test_meta_optimizers_with_stochastic_global_algorithm_on_sum_of_squares (line 107) | def test_meta_optimizers_with_stochastic_global_algorithm_on_sum_of_squa...
  function test_ngopt_optimizers_with_stochastic_global_algorithm_on_sum_of_squares (line 124) | def test_ngopt_optimizers_with_stochastic_global_algorithm_on_sum_of_squ...

FILE: tests/optimagic/optimizers/test_pounders_integration.py
  function load_history (line 16) | def load_history(start_vec, solver_sub):
  function criterion (line 34) | def criterion():
  function pounders_options (line 47) | def pounders_options():
  function trustregion_subproblem_options (line 68) | def trustregion_subproblem_options():
  function test_bntr (line 99) | def test_bntr(
  function test_gqtpar (line 145) | def test_gqtpar(start_vec, criterion, pounders_options, trustregion_subp...

FILE: tests/optimagic/optimizers/test_pygad_optimizer.py
  function test_determine_effective_batch_size_return_values (line 34) | def test_determine_effective_batch_size_return_values(batch_size, n_core...
  function test_determine_effective_batch_size_warnings (line 52) | def test_determine_effective_batch_size_warnings(batch_size, n_cores, sh...
  function test_get_default_mutation_params (line 94) | def test_get_default_mutation_params(mutation_type, expected):
  function test_create_mutation_from_string_valid (line 110) | def test_create_mutation_from_string_valid(mutation_type, expected_class):
  function test_create_mutation_from_string_invalid (line 115) | def test_create_mutation_from_string_invalid():
  function test_convert_mutation_none (line 121) | def test_convert_mutation_none():
  function test_convert_mutation_string (line 137) | def test_convert_mutation_string(mutation_string):
  function test_convert_mutation_class (line 156) | def test_convert_mutation_class(mutation_class):
  function test_convert_mutation_instance (line 165) | def test_convert_mutation_instance():
  function test_convert_mutation_custom_function (line 185) | def test_convert_mutation_custom_function():
  function test_convert_mutation_invalid_type (line 193) | def test_convert_mutation_invalid_type():
  function test_random_mutation_default (line 199) | def test_random_mutation_default():
  function test_random_mutation_with_parameters (line 209) | def test_random_mutation_with_parameters():
  function test_simple_mutations (line 229) | def test_simple_mutations(mutation_class, expected_type):
  function test_adaptive_mutation_default (line 239) | def test_adaptive_mutation_default():
  function test_adaptive_mutation_with_probabilities (line 249) | def test_adaptive_mutation_with_probabilities():
  function test_adaptive_mutation_with_num_genes (line 259) | def test_adaptive_mutation_with_num_genes():
  function test_adaptive_mutation_with_percent_genes (line 269) | def test_adaptive_mutation_with_percent_genes():
  function test_mutation_type_class_variables (line 279) | def test_mutation_type_class_variables():

FILE: tests/optimagic/optimizers/test_pygmo_optimizers.py
  function test_determine_population_size (line 20) | def test_determine_population_size(popsize, x, lower_bound, expected):
  function test_convert_str_to_int (line 25) | def test_convert_str_to_int():

FILE: tests/optimagic/optimizers/test_pyswarms_optimizers.py
  function test_build_velocity_clamp_both_values (line 25) | def test_build_velocity_clamp_both_values():
  function test_build_velocity_clamp_partial_values (line 31) | def test_build_velocity_clamp_partial_values():
  function test_build_velocity_clamp_none_values (line 40) | def test_build_velocity_clamp_none_values():
  function test_get_pyswarms_bounds_with_both (line 47) | def test_get_pyswarms_bounds_with_both():
  function test_get_pyswarms_bounds_with_none (line 59) | def test_get_pyswarms_bounds_with_none():
  function test_get_pyswarms_bounds_partial_bounds (line 67) | def test_get_pyswarms_bounds_partial_bounds():
  function test_get_pyswarms_bounds_with_infinite (line 80) | def test_get_pyswarms_bounds_with_infinite():
  function test_create_initial_positions_basic (line 92) | def test_create_initial_positions_basic(center):
  function test_create_initial_positions_no_bounds (line 111) | def test_create_initial_positions_no_bounds():
  function test_resolve_topology_config_by_string (line 141) | def test_resolve_topology_config_by_string(
  function test_resolve_topology_config_by_instance (line 166) | def test_resolve_topology_config_by_instance(
  function test_resolve_topology_config_invalid_string (line 181) | def test_resolve_topology_config_invalid_string():
  function test_resolve_topology_config_invalid_type (line 188) | def test_resolve_topology_config_invalid_type():

FILE: tests/optimagic/optimizers/test_tao_optimizers.py
  function get_random_params (line 21) | def get_random_params(
  function test_robustness (line 40) | def test_robustness():
  function test_box_constr (line 61) | def test_box_constr():
  function test_max_iters (line 78) | def test_max_iters():
  function test_grtol (line 98) | def test_grtol():
  function test_gatol (line 124) | def test_gatol():
  function test_gttol (line 150) | def test_gttol():
  function test_tol (line 176) | def test_tol():
  function _ols_criterion (line 198) | def _ols_criterion(x, endog, exog):
  function _simulate_ols_sample (line 202) | def _simulate_ols_sample(num_agents, paras):

FILE: tests/optimagic/optimizers/test_tranquilo.py
  function mock_problem (line 9) | def mock_problem():
  function test_tranquilo_raises_if_version_too_old (line 25) | def test_tranquilo_raises_if_version_too_old(monkeypatch, mock_problem):
  function test_tranquilo_ls_raises_if_version_too_old (line 39) | def test_tranquilo_ls_raises_if_version_too_old(monkeypatch, mock_problem):

FILE: tests/optimagic/parameters/test_block_trees.py
  function test_matrix_to_block_tree_array_and_scalar (line 18) | def test_matrix_to_block_tree_array_and_scalar():
  function test_matrix_to_block_tree_only_params_dfs (line 30) | def test_matrix_to_block_tree_only_params_dfs():
  function test_matrix_to_block_tree_single_element (line 62) | def test_matrix_to_block_tree_single_element():
  function test_block_tree_to_matrix_array_and_scalar (line 78) | def test_block_tree_to_matrix_array_and_scalar():
  function test_block_tree_to_matrix_only_params_dfs (line 96) | def test_block_tree_to_matrix_only_params_dfs():
  function test_block_tree_to_hessian_bijection (line 128) | def test_block_tree_to_hessian_bijection():
  function test_hessian_to_block_tree_bijection (line 142) | def test_hessian_to_block_tree_bijection():
  function test_block_tree_to_matrix_valueerror (line 154) | def test_block_tree_to_matrix_valueerror():
  function _tree_equal_up_to_dtype (line 163) | def _tree_equal_up_to_dtype(left, right):
  function _frame_equal (line 168) | def _frame_equal(left, right):

FILE: tests/optimagic/parameters/test_bounds.py
  function pytree_params (line 16) | def pytree_params():
  function array_params (line 28) | def array_params():
  function test_pre_process_bounds_trivial_case (line 32) | def test_pre_process_bounds_trivial_case():
  function test_pre_process_bounds_none_case (line 38) | def test_pre_process_bounds_none_case():
  function test_pre_process_bounds_sequence (line 42) | def test_pre_process_bounds_sequence():
  function test_pre_process_bounds_invalid_type (line 49) | def test_pre_process_bounds_invalid_type():
  function test_get_bounds_subdataframe (line 54) | def test_get_bounds_subdataframe(pytree_params):
  function test_get_bounds_error (line 80) | def test_get_bounds_error(pytree_params, bounds):
  function test_get_bounds_no_arguments (line 85) | def test_get_bounds_no_arguments(pytree_params):
  function test_get_bounds_with_lower_bounds (line 94) | def test_get_bounds_with_lower_bounds(pytree_params):
  function test_get_bounds_with_upper_bounds (line 107) | def test_get_bounds_with_upper_bounds(pytree_params):
  function test_get_bounds_numpy (line 121) | def test_get_bounds_numpy(array_params):
  function test_get_bounds_numpy_error (line 128) | def test_get_bounds_numpy_error(array_params):
  function test_get_fast_path_bounds_both_none (line 138) | def test_get_fast_path_bounds_both_none():
  function test_get_fast_path_bounds_lower_none (line 144) | def test_get_fast_path_bounds_lower_none():

FILE: tests/optimagic/parameters/test_check_constraints.py
  function test_iloc (line 10) | def test_iloc():
  function test_check_constraints_are_satisfied_type_equality (line 31) | def test_check_constraints_are_satisfied_type_equality():
  function test_check_constraints_are_satisfied_type_increasing (line 39) | def test_check_constraints_are_satisfied_type_increasing():
  function test_check_constraints_are_satisfied_type_decreasing (line 47) | def test_check_constraints_are_satisfied_type_decreasing():
  function test_check_constraints_are_satisfied_type_pairwise_equality (line 55) | def test_check_constraints_are_satisfied_type_pairwise_equality():
  function test_check_constraints_are_satisfied_type_probability (line 65) | def test_check_constraints_are_satisfied_type_probability():
  function test_check_constraints_are_satisfied_type_linear_lower_bound (line 73) | def test_check_constraints_are_satisfied_type_linear_lower_bound():
  function test_check_constraints_are_satisfied_type_linear_upper_bound (line 83) | def test_check_constraints_are_satisfied_type_linear_upper_bound():
  function test_check_constraints_are_satisfied_type_linear_value (line 93) | def test_check_constraints_are_satisfied_type_linear_value():
  function test_check_constraints_are_satisfied_type_covariance (line 103) | def test_check_constraints_are_satisfied_type_covariance():
  function test_check_constraints_are_satisfied_type_sdcorr (line 111) | def test_check_constraints_are_satisfied_type_sdcorr():

FILE: tests/optimagic/parameters/test_constraint_tools.py
  function test_count_free_params_no_constraints (line 8) | def test_count_free_params_no_constraints():
  function test_count_free_params_with_constraints (line 13) | def test_count_free_params_with_constraints():
  function test_check_constraints (line 19) | def test_check_constraints():

FILE: tests/optimagic/parameters/test_conversion.py
  function test_get_converter_fast_case (line 15) | def test_get_converter_fast_case():
  function test_get_converter_with_constraints_and_bounds (line 37) | def test_get_converter_with_constraints_and_bounds():
  function test_get_converter_with_scaling (line 63) | def test_get_converter_with_scaling():
  function test_get_converter_with_trees (line 90) | def test_get_converter_with_trees():
  function fast_kwargs (line 114) | def fast_kwargs():
  function test_is_fast_path_when_true (line 133) | def test_is_fast_path_when_true(fast_kwargs, name, value):
  function test_is_fast_path_when_false (line 151) | def test_is_fast_path_when_false(fast_kwargs, name, value):
  function test_is_fast_deriv_eval_true (line 169) | def test_is_fast_deriv_eval_true(key, f):
  function test_is_fast_deriv_eval_false (line 185) | def test_is_fast_deriv_eval_false(key, f):

FILE: tests/optimagic/parameters/test_kernel_transformations.py
  function get_internal_cholesky (line 16) | def get_internal_cholesky(dim, seed=0):
  function get_external_covariance (line 24) | def get_external_covariance(dim, seed=0):
  function get_internal_probability (line 33) | def get_internal_probability(dim, seed=0):
  function get_external_probability (line 40) | def get_external_probability(dim, seed=0):
  function get_external_sdcorr (line 47) | def get_external_sdcorr(dim, seed=0):
  function test_covariance_from_internal_jacobian (line 57) | def test_covariance_from_internal_jacobian(dim, seed):  # noqa: ARG001
  function test_covariance_to_internal_jacobian (line 68) | def test_covariance_to_internal_jacobian(dim, seed):  # noqa: ARG001
  function test_probability_from_internal_jacobian (line 79) | def test_probability_from_internal_jacobian(dim, seed):  # noqa: ARG001
  function test_probability_to_internal_jacobian (line 90) | def test_probability_to_internal_jacobian(dim, seed):  # noqa: ARG001
  function test_sdcorr_from_internal_jacobian (line 101) | def test_sdcorr_from_internal_jacobian(dim, seed):  # noqa: ARG001
  function test_sdcorr_to_internal_jacobian (line 112) | def test_sdcorr_to_internal_jacobian(dim, seed):  # noqa: ARG001

FILE: tests/optimagic/parameters/test_nonlinear_constraints.py
  class Converter (line 29) | class Converter:
    method params_from_internal (line 30) | def params_from_internal(self, x):
    method params_to_internal (line 33) | def params_to_internal(self, params):
  function test_get_transformation_type (line 51) | def test_get_transformation_type(lower_bounds, upper_bounds, expected):
  function test_get_positivity_transform (line 72) | def test_get_positivity_transform(lower_bounds, upper_bounds, case, expe...
  function test_get_selection_indices (line 85) | def test_get_selection_indices():
  function test_process_selector (line 111) | def test_process_selector(constraint, params, expected):
  function test_check_validity_nonlinear_constraint (line 152) | def test_check_validity_nonlinear_constraint(constraint, params):
  function test_check_validity_nonlinear_constraint_correct_example (line 157) | def test_check_validity_nonlinear_constraint_correct_example():
  function test_equality_as_inequality_constraints (line 206) | def test_equality_as_inequality_constraints(constraints, expected):
  function test_process_nonlinear_constraints (line 222) | def test_process_nonlinear_constraints():
  function test_get_components (line 272) | def test_get_components():
  function test_vector_to_list_of_scalar (line 283) | def test_vector_to_list_of_scalar():
  function test_vector_as_list_of_scalar_constraints (line 297) | def test_vector_as_list_of_scalar_constraints():

FILE: tests/optimagic/parameters/test_process_constraints.py
  function test_replace_pairwise_equality_by_equality (line 16) | def test_replace_pairwise_equality_by_equality():
  function test_empty_constraints_work (line 30) | def test_empty_constraints_work():
  function test_to_many_bounds_in_increasing_constraint_raise_good_error (line 40) | def test_to_many_bounds_in_increasing_constraint_raise_good_error():

FILE: tests/optimagic/parameters/test_process_selectors.py
  function test_process_selectors_no_constraint (line 14) | def test_process_selectors_no_constraint(constraints):
  function tree_params (line 26) | def tree_params():
  function tree_params_converter (line 33) | def tree_params_converter(tree_params):
  function np_params_converter (line 50) | def np_params_converter():
  function df_params (line 60) | def df_params():
  function df_params_converter (line 67) | def df_params_converter(df_params):
  function test_process_selectors_tree_selector (line 76) | def test_process_selectors_tree_selector(tree_params, tree_params_conver...
  function test_process_selectors_tree_selectors (line 86) | def test_process_selectors_tree_selectors(tree_params, tree_params_conve...
  function test_process_selectors_numpy_array_loc (line 103) | def test_process_selectors_numpy_array_loc(np_params_converter):
  function test_process_selectors_numpy_array_locs (line 114) | def test_process_selectors_numpy_array_locs(np_params_converter):
  function test_process_selectors_dataframe_loc (line 132) | def test_process_selectors_dataframe_loc(df_params, df_params_converter):
  function test_process_selectors_dataframe_query (line 145) | def test_process_selectors_dataframe_query(df_params, df_params_converter):
  function test_process_selectors_dataframe_locs (line 159) | def test_process_selectors_dataframe_locs(df_params, df_params_converter):
  function test_process_selectors_dataframe_queries (line 173) | def test_process_selectors_dataframe_queries(df_params, df_params_conver...
  function test_process_selectors_numpy_array_invalid_fields (line 189) | def test_process_selectors_numpy_array_invalid_fields(field, np_params_c...
  function test_process_selectors_dataframe_invalid_fields (line 200) | def test_process_selectors_dataframe_invalid_fields(
  function test_process_selectors_tree_invalid_fields (line 213) | def test_process_selectors_tree_invalid_fields(
  function test_process_selectors_duplicates (line 225) | def test_process_selectors_duplicates(np_params_converter):
  function test_process_selectors_differen_length_in_multiple_selectors (line 241) | def test_process_selectors_differen_length_in_multiple_selectors(np_para...

FILE: tests/optimagic/parameters/test_scale_conversion.py
  function test_get_scale_converter_active (line 31) | def test_get_scale_converter_active(method, expected):
  function test_scale_conversion_fast_path (line 65) | def test_scale_conversion_fast_path():

FILE: tests/optimagic/parameters/test_scaling.py
  function test_pre_process_scaling_trivial_case (line 10) | def test_pre_process_scaling_trivial_case():
  function test_pre_process_scaling_none_case (line 20) | def test_pre_process_scaling_none_case():
  function test_pre_process_scaling_false_case (line 24) | def test_pre_process_scaling_false_case():
  function test_pre_process_scaling_true_case (line 28) | def test_pre_process_scaling_true_case():
  function test_pre_process_scaling_dict_case (line 33) | def test_pre_process_scaling_dict_case():
  function test_pre_process_scaling_invalid_type (line 40) | def test_pre_process_scaling_invalid_type():
  function test_pre_process_scaling_invalid_dict_key (line 45) | def test_pre_process_scaling_invalid_dict_key():
  function test_pre_process_scaling_invalid_dict_value (line 50) | def test_pre_process_scaling_invalid_dict_value():
  function test_scaling_options_invalid_method_value (line 55) | def test_scaling_options_invalid_method_value():
  function test_scaling_options_invalid_clipping_value_type (line 60) | def test_scaling_options_invalid_clipping_value_type():
  function test_scaling_options_invalid_magnitude_value_type (line 65) | def test_scaling_options_invalid_magnitude_value_type():
  function test_scaling_options_invalid_magnitude_value_range (line 70) | def test_scaling_options_invalid_magnitude_value_range():

FILE: tests/optimagic/parameters/test_space_conversion.py
  function _get_test_case_no_constraint (line 15) | def _get_test_case_no_constraint():
  function _get_test_case_fixed (line 28) | def _get_test_case_fixed(with_value):
  function _get_test_case_increasing (line 50) | def _get_test_case_increasing(as_one):
  function _get_test_case_decreasing (line 76) | def _get_test_case_decreasing(as_one):
  function _get_test_case_equality (line 102) | def _get_test_case_equality(as_one):
  function _get_test_case_probability (line 128) | def _get_test_case_probability():
  function _get_test_case_uncorrelated_covariance (line 148) | def _get_test_case_uncorrelated_covariance():
  function _get_test_case_covariance (line 171) | def _get_test_case_covariance():
  function _get_test_case_normalized_covariance (line 207) | def _get_test_case_normalized_covariance():
  function _get_test_case_sdcorr (line 230) | def _get_test_case_sdcorr():
  function test_space_converter_with_params (line 275) | def test_space_converter_with_params(constraints, params, expected_inter...
  function test_multiply_from_left_and_right (line 301) | def test_multiply_from_left_and_right(seed):

FILE: tests/optimagic/parameters/test_tree_conversion.py
  function params (line 12) | def params():
  function upper_bounds (line 19) | def upper_bounds():
  function test_tree_converter_scalar_solver (line 36) | def test_tree_converter_scalar_solver(params, upper_bounds, func_eval):
  function test_tree_conversion_fast_path (line 72) | def test_tree_conversion_fast_path(solver_type):

FILE: tests/optimagic/parameters/test_tree_registry.py
  function value_df (line 11) | def value_df():
  function other_df (line 21) | def other_df():
  function test_flatten_df_with_value_column (line 28) | def test_flatten_df_with_value_column(value_df):
  function test_unflatten_df_with_value_column (line 34) | def test_unflatten_df_with_value_column(value_df):
  function test_leaf_names_df_with_value_column (line 41) | def test_leaf_names_df_with_value_column(value_df):
  function test_flatten_partially_numeric_df (line 47) | def test_flatten_partially_numeric_df(other_df):
  function test_unflatten_partially_numeric_df (line 53) | def test_unflatten_partially_numeric_df(other_df):
  function test_leaf_names_partially_numeric_df (line 61) | def test_leaf_names_partially_numeric_df(other_df):

FILE: tests/optimagic/shared/test_process_user_functions.py
  function test_partial_func_of_params (line 20) | def test_partial_func_of_params():
  function test_partial_func_of_params_too_many_kwargs (line 29) | def test_partial_func_of_params_too_many_kwargs():
  function test_partial_func_of_params_too_few_kwargs (line 37) | def test_partial_func_of_params_too_few_kwargs():
  function test_get_kwargs_from_args (line 45) | def test_get_kwargs_from_args():
  function test_infer_aggregation_level_no_decorator (line 55) | def test_infer_aggregation_level_no_decorator():
  function test_infer_aggregation_level_scalar_decorator (line 62) | def test_infer_aggregation_level_scalar_decorator():
  function test_infer_aggregation_level_scalar_anotation (line 70) | def test_infer_aggregation_level_scalar_anotation():
  function test_infer_aggregation_level_least_squares_decorator (line 77) | def test_infer_aggregation_level_least_squares_decorator():
  function test_infer_aggregation_level_least_squares_anotation (line 85) | def test_infer_aggregation_level_least_squares_anotation():
  function test_infer_aggregation_level_likelihood_decorator (line 92) | def test_infer_aggregation_level_likelihood_decorator():
  function test_infer_aggregation_level_likelihood_anotation (line 100) | def test_infer_aggregation_level_likelihood_anotation():

FILE: tests/optimagic/test_algo_selection.py
  function test_dfols_is_present (line 4) | def test_dfols_is_present():
  function test_scipy_cobyla_is_present (line 14) | def test_scipy_cobyla_is_present():
  function test_algorithm_lists (line 29) | def test_algorithm_lists():

FILE: tests/optimagic/test_batch_evaluators.py
  function double (line 15) | def double(x):
  function buggy_func (line 19) | def buggy_func(x):  # noqa: ARG001
  function add_x_and_y (line 23) | def add_x_and_y(x, y):
  function test_batch_evaluator_without_exceptions (line 29) | def test_batch_evaluator_without_exceptions(batch_evaluator, n_cores):
  function test_batch_evaluator_with_unhandled_exceptions (line 45) | def test_batch_evaluator_with_unhandled_exceptions(batch_evaluator, n_co...
  function test_batch_evaluator_with_handled_exceptions (line 58) | def test_batch_evaluator_with_handled_exceptions(batch_evaluator, n_cores):
  function test_batch_evaluator_with_list_unpacking (line 76) | def test_batch_evaluator_with_list_unpacking(batch_evaluator, n_cores):
  function test_batch_evaluator_with_dict_unpacking (line 90) | def test_batch_evaluator_with_dict_unpacking(batch_evaluator, n_cores):
  function test_get_batch_evaluator_invalid_value (line 102) | def test_get_batch_evaluator_invalid_value():
  function test_get_batch_evaluator_invalid_type (line 107) | def test_get_batch_evaluator_invalid_type():
  function test_get_batch_evaluator_with_callable (line 112) | def test_get_batch_evaluator_with_callable():

FILE: tests/optimagic/test_constraints.py
  function dummy_func (line 22) | def dummy_func():
  function test_fixed_constraint (line 26) | def test_fixed_constraint(dummy_func):
  function test_increasing_constraint (line 33) | def test_increasing_constraint(dummy_func):
  function test_decreasing_constraint (line 40) | def test_decreasing_constraint(dummy_func):
  function test_equality_constraint (line 47) | def test_equality_constraint(dummy_func):
  function test_pairwise_equality_constraint (line 54) | def test_pairwise_equality_constraint(dummy_func):
  function test_probability_constraint (line 61) | def test_probability_constraint(dummy_func):
  function test_covariance_constraint (line 68) | def test_covariance_constraint(dummy_func):
  function test_sdcorr_constraint (line 75) | def test_sdcorr_constraint(dummy_func):
  function test_linear_constraint_with_value (line 82) | def test_linear_constraint_with_value(dummy_func):
  function test_linear_constraint_with_bounds (line 94) | def test_linear_constraint_with_bounds(dummy_func):
  function test_linear_constraint_with_bounds_and_value (line 108) | def test_linear_constraint_with_bounds_and_value(dummy_func):
  function test_linear_constraint_with_nothing (line 120) | def test_linear_constraint_with_nothing(dummy_func):
  function test_nonlinear_constraint_with_value (line 126) | def test_nonlinear_constraint_with_value(dummy_func):
  function test_nonlinear_constraint_with_bounds (line 139) | def test_nonlinear_constraint_with_bounds(dummy_func):
  function test_nonlinear_constraint_with_bounds_and_value (line 154) | def test_nonlinear_constraint_with_bounds_and_value(dummy_func):
  function test_nonlinear_constraint_with_nothing (line 166) | def test_nonlinear_constraint_with_nothing(dummy_func):
  function test_all_none (line 172) | def test_all_none():
  function test_select_non_none (line 177) | def test_select_non_none():

FILE: tests/optimagic/test_decorators.py
  function test_catch_at_defaults (line 9) | def test_catch_at_defaults():
  function test_catch_with_reraise (line 25) | def test_catch_with_reraise():
  function test_unpack_decorator_none (line 34) | def test_unpack_decorator_none():
  function test_unpack_decorator_one_star (line 42) | def test_unpack_decorator_one_star():
  function test_unpack_decorator_two_stars (line 50) | def test_unpack_decorator_two_stars():

FILE: tests/optimagic/test_deprecations.py
  function test_estimagic_minimize_is_deprecated (line 60) | def test_estimagic_minimize_is_deprecated():
  function test_estimagic_maximize_is_deprecated (line 65) | def test_estimagic_maximize_is_deprecated():
  function test_estimagic_first_derivative_is_deprecated (line 70) | def test_estimagic_first_derivative_is_deprecated():
  function test_estimagic_second_derivative_is_deprecated (line 76) | def test_estimagic_second_derivative_is_deprecated():
  function test_estimagic_benchmarking_functions_are_deprecated (line 82) | def test_estimagic_benchmarking_functions_are_deprecated():
  function test_estimagic_slice_plot_is_deprecated (line 114) | def test_estimagic_slice_plot_is_deprecated():
  function test_estimagic_check_constraints_is_deprecated (line 124) | def test_estimagic_check_constraints_is_deprecated():
  function test_estimagic_count_free_params_is_deprecated (line 133) | def test_estimagic_count_free_params_is_deprecated():
  function example_db (line 143) | def example_db(tmp_path):
  function test_estimagic_log_reader_is_deprecated (line 159) | def test_estimagic_log_reader_is_deprecated(example_db):
  function test_estimagic_optimize_result_is_deprecated (line 166) | def test_estimagic_optimize_result_is_deprecated():
  function test_estimagic_chol_params_to_lower_triangular_matrix_is_deprecated (line 182) | def test_estimagic_chol_params_to_lower_triangular_matrix_is_deprecated():
  function test_estimagic_cov_params_to_matrix_is_deprecated (line 188) | def test_estimagic_cov_params_to_matrix_is_deprecated():
  function test_estimagic_cov_matrix_to_params_is_deprecated (line 194) | def test_estimagic_cov_matrix_to_params_is_deprecated():
  function test_estimagic_sdcorr_params_to_sds_and_corr_is_deprecated (line 200) | def test_estimagic_sdcorr_params_to_sds_and_corr_is_deprecated():
  function test_estimagic_sds_and_corr_to_cov_is_deprecated (line 206) | def test_estimagic_sds_and_corr_to_cov_is_deprecated():
  function test_estimagic_cov_to_sds_and_corr_is_deprecated (line 212) | def test_estimagic_cov_to_sds_and_corr_is_deprecated():
  function test_estimagic_sdcorr_params_to_matrix_is_deprecated (line 218) | def test_estimagic_sdcorr_params_to_matrix_is_deprecated():
  function test_estimagic_cov_matrix_to_sdcorr_params_is_deprecated (line 224) | def test_estimagic_cov_matrix_to_sdcorr_params_is_deprecated():
  function test_estimagic_number_of_triangular_elements_to_dimension_is_deprecated (line 230) | def test_estimagic_number_of_triangular_elements_to_dimension_is_depreca...
  function test_estimagic_dimension_to_number_of_triangular_elements_is_deprecated (line 236) | def test_estimagic_dimension_to_number_of_triangular_elements_is_depreca...
  function test_estimagic_propose_alternatives_is_deprecated (line 242) | def test_estimagic_propose_alternatives_is_deprecated():
  function test_estimagic_robust_cholesky_is_deprecated (line 248) | def test_estimagic_robust_cholesky_is_deprecated():
  function test_estimagic_robust_inverse_is_deprecated (line 254) | def test_estimagic_robust_inverse_is_deprecated():
  function test_estimagic_hash_array_is_deprecated (line 260) | def test_estimagic_hash_array_is_deprecated():
  function test_estimagic_calculate_trustregion_initial_radius_is_deprecated (line 266) | def test_estimagic_calculate_trustregion_initial_radius_is_deprecated():
  function test_estimagic_pickle_functions_are_deprecated (line 272) | def test_estimagic_pickle_functions_are_deprecated(tmp_path):
  function test_estimagic_isscalar_is_deprecated (line 282) | def test_estimagic_isscalar_is_deprecated():
  function test_estimagic_get_rng_is_deprecated (line 288) | def test_estimagic_get_rng_is_deprecated():
  function test_estimagic_criterion_plot_is_deprecated (line 294) | def test_estimagic_criterion_plot_is_deprecated():
  function test_estimagic_params_plot_is_deprecated (line 301) | def test_estimagic_params_plot_is_deprecated():
  function test_criterion_is_depracated (line 308) | def test_criterion_is_depracated():
  function test_criterion_kwargs_is_deprecated (line 318) | def test_criterion_kwargs_is_deprecated():
  function test_derivative_is_deprecated (line 329) | def test_derivative_is_deprecated():
  function test_derivative_kwargs_is_deprecated (line 340) | def test_derivative_kwargs_is_deprecated():
  function test_criterion_and_derivative_is_deprecated (line 352) | def test_criterion_and_derivative_is_deprecated():
  function test_criterion_and_derivative_kwargs_is_deprecated (line 363) | def test_criterion_and_derivative_kwargs_is_deprecated():
  function test_old_convergence_criteria_are_deprecated (line 389) | def test_old_convergence_criteria_are_deprecated(algo_option):
  function test_deprecated_attributes_of_optimize_result (line 402) | def test_deprecated_attributes_of_optimize_result():
  function test_old_bounds_are_deprecated_in_minimize (line 432) | def test_old_bounds_are_deprecated_in_minimize(bounds_kwargs):
  function test_old_bounds_are_deprecated_in_maximize (line 444) | def test_old_bounds_are_deprecated_in_maximize(bounds_kwargs):
  function test_old_bounds_are_deprecated_in_first_derivative (line 456) | def test_old_bounds_are_deprecated_in_first_derivative(bounds_kwargs):
  function test_old_bounds_are_deprecated_in_second_derivative (line 467) | def test_old_bounds_are_deprecated_in_second_derivative(bounds_kwargs):
  function test_old_bounds_are_deprecated_in_estimate_ml (line 478) | def test_old_bounds_are_deprecated_in_estimate_ml(bounds_kwargs):
  function test_numdiff_options_is_deprecated_in_estimate_ml (line 494) | def test_numdiff_options_is_deprecated_in_estimate_ml():
  function test_old_bounds_are_deprecated_in_estimate_msm (line 511) | def test_old_bounds_are_deprecated_in_estimate_msm(bounds_kwargs):
  function test_numdiff_options_is_deprecated_in_estimate_msm (line 524) | def test_numdiff_options_is_deprecated_in_estimate_msm():
  function test_old_bounds_are_deprecated_in_count_free_params (line 538) | def test_old_bounds_are_deprecated_in_count_free_params(bounds_kwargs):
  function test_old_bounds_are_deprecated_in_check_constraints (line 549) | def test_old_bounds_are_deprecated_in_check_constraints(bounds_kwargs):
  function test_old_bounds_are_deprecated_in_slice_plot (line 559) | def test_old_bounds_are_deprecated_in_slice_plot():
  function test_is_dict_output (line 570) | def test_is_dict_output():
  function test_infer_problem_type_from_dict_output (line 575) | def test_infer_problem_type_from_dict_output():
  function test_convert_value_dict_to_function_value (line 587) | def test_convert_value_dict_to_function_value():
  function test_convert_root_contributions_dict_to_function_value (line 593) | def test_convert_root_contributions_dict_to_function_value():
  function test_convert_contributions_dict_to_function_value (line 599) | def test_convert_contributions_dict_to_function_value():
  function test_old_scaling_options_are_deprecated_in_minimize (line 605) | def test_old_scaling_options_are_deprecated_in_minimize():
  function test_old_scaling_options_are_deprecated_in_maximize (line 616) | def test_old_scaling_options_are_deprecated_in_maximize():
  function test_old_multistart_options_are_deprecated_in_minimize (line 627) | def test_old_multistart_options_are_deprecated_in_minimize():
  function test_old_multistart_options_are_deprecated_in_maximize (line 638) | def test_old_multistart_options_are_deprecated_in_maximize():
  function test_multistart_option_share_optimization_option_is_deprecated (line 649) | def test_multistart_option_share_optimization_option_is_deprecated():
  function test_multistart_option_convergence_relative_params_tolerance_option_is_deprecated (line 661) | def test_multistart_option_convergence_relative_params_tolerance_option_...
  function test_multistart_option_optimization_error_handling_option_is_deprecated (line 673) | def test_multistart_option_optimization_error_handling_option_is_depreca...
  function test_multistart_option_exploration_error_handling_option_is_deprecated (line 685) | def test_multistart_option_exploration_error_handling_option_is_deprecat...
  function test_deprecated_dict_access_of_multistart_info (line 697) | def test_deprecated_dict_access_of_multistart_info():
  function test_base_steps_in_first_derivatives_is_deprecated (line 710) | def test_base_steps_in_first_derivatives_is_deprecated():
  function test_step_ratio_in_first_derivatives_is_deprecated (line 716) | def test_step_ratio_in_first_derivatives_is_deprecated():
  function test_n_steps_in_first_derivatives_is_deprecated (line 722) | def test_n_steps_in_first_derivatives_is_deprecated():
  function test_return_info_in_first_derivatives_is_deprecated (line 728) | def test_return_info_in_first_derivatives_is_deprecated():
  function test_return_func_value_in_first_derivatives_is_deprecated (line 734) | def test_return_func_value_in_first_derivatives_is_deprecated():
  function test_base_steps_in_second_derivatives_is_deprecated (line 740) | def test_base_steps_in_second_derivatives_is_deprecated():
  function test_step_ratio_in_second_derivatives_is_deprecated (line 746) | def test_step_ratio_in_second_derivatives_is_deprecated():
  function test_n_steps_in_second_derivatives_is_deprecated (line 752) | def test_n_steps_in_second_derivatives_is_deprecated():
  function test_return_func_value_in_second_derivatives_is_deprecated (line 758) | def test_return_func_value_in_second_derivatives_is_deprecated():
  function test_return_info_in_second_derivatives_is_deprecated (line 764) | def test_return_info_in_second_derivatives_is_deprecated():
  function test_numdiff_result_func_evals_is_deprecated (line 770) | def test_numdiff_result_func_evals_is_deprecated():
  function test_numdiff_result_derivative_candidates_is_deprecated (line 777) | def test_numdiff_result_derivative_candidates_is_deprecated():
  function test_numdiff_result_dict_access_is_deprecated (line 784) | def test_numdiff_result_dict_access_is_deprecated():
  function test_key_argument_is_deprecated_in_first_derivative (line 791) | def test_key_argument_is_deprecated_in_first_derivative():
  function test_key_argument_is_deprecated_in_second_derivative (line 796) | def test_key_argument_is_deprecated_in_second_derivative():
  function test_jac_dicts_are_deprecated_in_minimize (line 801) | def test_jac_dicts_are_deprecated_in_minimize():
  function test_jac_dicts_are_deprecated_in_maximize (line 813) | def test_jac_dicts_are_deprecated_in_maximize():
  function test_fun_and_jac_dicts_are_deprecated_in_minimize (line 825) | def test_fun_and_jac_dicts_are_deprecated_in_minimize():
  function test_fun_and_jac_dicts_are_deprecated_in_maximize (line 837) | def test_fun_and_jac_dicts_are_deprecated_in_maximize():
  function test_fun_with_dict_return_is_deprecated_in_minimize (line 849) | def test_fun_with_dict_return_is_deprecated_in_minimize():
  function test_fun_with_dict_return_is_deprecated_in_slice_plot (line 860) | def test_fun_with_dict_return_is_deprecated_in_slice_plot():
  function test_handle_log_options (line 870) | def test_handle_log_options():
  function test_log_options_are_deprecated_in_estimate_ml (line 907) | def test_log_options_are_deprecated_in_estimate_ml(tmp_path):
  function test_log_options_are_deprecated_in_estimate_msm (line 937) | def test_log_options_are_deprecated_in_estimate_msm(tmp_path):
  function test_log_options_are_deprecated_in_minimize (line 971) | def test_log_options_are_deprecated_in_minimize(tmp_path):
  function test_log_options_are_deprecated_in_maximize (line 991) | def test_log_options_are_deprecated_in_maximize(tmp_path):
  function test_dict_constraints_are_deprecated_in_minimize (line 1011) | def test_dict_constraints_are_deprecated_in_minimize():
  function test_dict_constraints_are_deprecated_in_maximize (line 1022) | def test_dict_constraints_are_deprecated_in_maximize():
  function test_dict_constraints_are_deprecated_in_estimate_ml (line 1033) | def test_dict_constraints_are_deprecated_in_estimate_ml():
  function test_dict_constraints_are_deprecated_in_estimate_msm (line 1049) | def test_dict_constraints_are_deprecated_in_estimate_msm():
  function dummy_func (line 1063) | def dummy_func():
  function test_pre_process_constraints_trivial_case (line 1067) | def test_pre_process_constraints_trivial_case(dummy_func):
  function test_pre_process_constraints_list_of_constraints (line 1073) | def test_pre_process_constraints_list_of_constraints(dummy_func):
  function test_pre_process_constraints_none_case (line 1085) | def test_pre_process_constraints_none_case():
  function test_pre_process_constraints_mixed_case (line 1089) | def test_pre_process_constraints_mixed_case(dummy_func):
  function test_pre_process_constraints_dict_case (line 1101) | def test_pre_process_constraints_dict_case(dummy_func):
  function test_pre_process_constraints_invalid_case (line 1107) | def test_pre_process_constraints_invalid_case():
  function test_pre_process_constraints_invalid_mixed_case (line 1114) | def test_pre_process_constraints_invalid_mixed_case():
  function test_deprecated_log_reader (line 1125) | def test_deprecated_log_reader(example_db):
  function test_estimagic_joblib_batch_evaluator_is_deprecated (line 1132) | def test_estimagic_joblib_batch_evaluator_is_deprecated():
  function test_estimagic_process_batch_evaluator_is_deprecated (line 1138) | def test_estimagic_process_batch_evaluator_is_deprecated():

FILE: tests/optimagic/test_mark.py
  function f (line 11) | def f(x):
  class ImmutableF (line 16) | class ImmutableF:
    method __call__ (line 17) | def __call__(self, x):
  function _g (line 21) | def _g(x, y):
  function test_scalar (line 32) | def test_scalar(func):
  function test_least_squares (line 39) | def test_least_squares(func):
  function test_likelihood (line 46) | def test_likelihood(func):
  function test_mark_minimizer (line 52) | def test_mark_minimizer():

FILE: tests/optimagic/test_timing.py
  function test_invalid_aggregate_batch_time (line 6) | def test_invalid_aggregate_batch_time():

FILE: tests/optimagic/test_type_conversion.py
  function test_int_conversion (line 15) | def test_int_conversion(candidate):
  function test_positive_int_conversion (line 22) | def test_positive_int_conversion(candidate):
  function test_non_negative_int_conversion (line 29) | def test_non_negative_int_conversion(candidate):
  function test_positive_int_conversion_fail (line 36) | def test_positive_int_conversion_fail(candidate):
  function test_non_negative_int_conversion_fail (line 42) | def test_non_negative_int_conversion_fail(candidate):
  function test_float_conversion (line 48) | def test_float_conversion(candidate):
  function test_positive_float_conversion (line 55) | def test_positive_float_conversion(candidate):
  function test_non_negative_float_conversion (line 62) | def test_non_negative_float_conversion(candidate):
  function test_positive_float_conversion_fail (line 69) | def test_positive_float_conversion_fail(candidate):
  function test_non_negative_float_conversion_fail (line 75) | def test_non_negative_float_conversion_fail(candidate):
  function test_bool_conversion_true (line 81) | def test_bool_conversion_true(candidate):
  function test_bool_conversion_false (line 87) | def test_bool_conversion_false(candidate):
  function test_gt_one_float (line 93) | def test_gt_one_float(candidate):
  function test_gt_one_float_fail (line 100) | def test_gt_one_float_fail(candidate):

FILE: tests/optimagic/test_typed_dicts_consistency.py
  function assert_attributes_and_type_hints_are_equal (line 11) | def assert_attributes_and_type_hints_are_equal(dataclass, typed_dict):
  function test_scaling_options_and_dict_have_same_attributes (line 37) | def test_scaling_options_and_dict_have_same_attributes():
  function test_multistart_options_and_dict_have_same_attributes (line 41) | def test_multistart_options_and_dict_have_same_attributes():
  function test_numdiff_options_and_dict_have_same_attributes (line 45) | def test_numdiff_options_and_dict_have_same_attributes():

FILE: tests/optimagic/test_utilities.py
  function test_chol_params_to_lower_triangular_matrix (line 33) | def test_chol_params_to_lower_triangular_matrix():
  function test_cov_params_to_matrix (line 39) | def test_cov_params_to_matrix():
  function test_cov_matrix_to_params (line 46) | def test_cov_matrix_to_params():
  function test_sdcorr_params_to_sds_and_corr (line 53) | def test_sdcorr_params_to_sds_and_corr():
  function test_sdcorr_params_to_matrix (line 62) | def test_sdcorr_params_to_matrix():
  function test_cov_matrix_to_sdcorr_params (line 71) | def test_cov_matrix_to_sdcorr_params():
  function test_sds_and_corr_to_cov (line 80) | def test_sds_and_corr_to_cov():
  function test_cov_to_sds_and_corr (line 89) | def test_cov_to_sds_and_corr():
  function test_number_of_triangular_elements_to_dimension (line 99) | def test_number_of_triangular_elements_to_dimension():
  function test_dimension_to_number_of_triangular_elements (line 106) | def test_dimension_to_number_of_triangular_elements():
  function random_cov (line 113) | def random_cov(dim, seed):
  function test_robust_cholesky_with_zero_variance (line 132) | def test_robust_cholesky_with_zero_variance(dim, seed):
  function test_robust_cholesky_with_extreme_cases (line 139) | def test_robust_cholesky_with_extreme_cases():
  function test_robust_inverse_nonsingular (line 145) | def test_robust_inverse_nonsingular():
  function test_robust_inverse_singular (line 152) | def test_robust_inverse_singular():
  function test_hash_array (line 160) | def test_hash_array():
  function test_initial_trust_radius_small_x (line 169) | def test_initial_trust_radius_small_x():
  function test_initial_trust_radius_large_x (line 176) | def test_initial_trust_radius_large_x():
  function test_pickling (line 183) | def test_pickling(tmp_path):
  function test_isscalar_true (line 195) | def test_isscalar_true(element):
  function test_isscalar_false (line 203) | def test_isscalar_false(element):
  function tets_isscalar_jax_true (line 208) | def tets_isscalar_jax_true():
  function test_isscalar_jax_false (line 215) | def test_isscalar_jax_false():
  function test_get_rng_correct_input (line 232) | def test_get_rng_correct_input(seed):
  function test_get_rng_wrong_input (line 241) | def test_get_rng_wrong_input(seed):
  function test_propose_alternatives (line 246) | def test_propose_alternatives():

FILE: tests/optimagic/visualization/test_backends.py
  function sample_lines (line 13) | def sample_lines():
  function test_line_plot_all_backends (line 22) | def test_line_plot_all_backends(sample_lines, backend, close_mpl_figures):
  function test_line_plot_invalid_backend (line 26) | def test_line_plot_invalid_backend(sample_lines):
  function test_line_plot_unavailable_backend (line 31) | def test_line_plot_unavailable_backend(sample_lines, monkeypatch):

FILE: tests/optimagic/visualization/test_convergence_plot.py
  function benchmark_results (line 14) | def benchmark_results():
  function test_convergence_plot_default_options (line 32) | def test_convergence_plot_default_options(benchmark_results):
  function test_convergence_plot_options (line 63) | def test_convergence_plot_options(options, grid, benchmark_results, clos...
  function test_convergence_plot_stopping_criterion_none (line 75) | def test_convergence_plot_stopping_criterion_none(benchmark_results):
  function test_check_only_allowed_subset_provided_none (line 87) | def test_check_only_allowed_subset_provided_none():
  function test_check_only_allowed_subset_provided_all_included (line 92) | def test_check_only_allowed_subset_provided_all_included():
  function test_check_only_allowed_subset_provided_missing (line 97) | def test_check_only_allowed_subset_provided_missing():
  function test_extract_convergence_plot_lines (line 103) | def test_extract_convergence_plot_lines(benchmark_results):

FILE: tests/optimagic/visualization/test_deviation_plot.py
  function test_convergence_plot_options (line 21) | def test_convergence_plot_options(options):

FILE: tests/optimagic/visualization/test_history_plots.py
  function minimize_result (line 29) | def minimize_result():
  function test_params_plot_multistart (line 69) | def test_params_plot_multistart(
  function test_criterion_plot_list_input (line 92) | def test_criterion_plot_list_input(
  function test_criterion_plot_name_input (line 105) | def test_criterion_plot_name_input(minimize_result):
  function test_criterion_plot_wrong_results (line 110) | def test_criterion_plot_wrong_results():
  function test_criterion_plot_different_input_types (line 115) | def test_criterion_plot_different_input_types():
  function test_criterion_plot_wrong_inputs (line 145) | def test_criterion_plot_wrong_inputs():
  function test_criterion_plot_different_backends (line 154) | def test_criterion_plot_different_backends(minimize_result, backend, clo...
  function test_params_plot_different_backends (line 160) | def test_params_plot_different_backends(minimize_result, backend, close_...
  function test_harmonize_inputs_to_dict_single_result (line 165) | def test_harmonize_inputs_to_dict_single_result():
  function test_harmonize_inputs_to_dict_single_result_with_name (line 170) | def test_harmonize_inputs_to_dict_single_result_with_name():
  function test_harmonize_inputs_to_dict_list_results (line 175) | def test_harmonize_inputs_to_dict_list_results():
  function test_harmonize_inputs_to_dict_dict_input (line 184) | def test_harmonize_inputs_to_dict_dict_input():
  function test_harmonize_inputs_to_dict_dict_input_with_names (line 192) | def test_harmonize_inputs_to_dict_dict_input_with_names():
  function test_harmonize_inputs_to_dict_invalid_names (line 200) | def test_harmonize_inputs_to_dict_invalid_names():
  function test_harmonize_inputs_to_dict_str_input (line 207) | def test_harmonize_inputs_to_dict_str_input():
  function test_harmonize_inputs_to_dict_path_input (line 211) | def test_harmonize_inputs_to_dict_path_input():
  function _compare_plotting_multistart_history_with_result (line 216) | def _compare_plotting_multistart_history_with_result(
  function test_retrieve_data_from_result (line 225) | def test_retrieve_data_from_result(minimize_result):
  function test_retrieve_data_from_logged_result (line 240) | def test_retrieve_data_from_logged_result(tmp_path):
  function test_retrieve_data_from_multistart_result (line 261) | def test_retrieve_data_from_multistart_result(minimize_result, stack_mul...
  function test_extract_criterion_plot_lines (line 286) | def test_extract_criterion_plot_lines(minimize_result):
  function test_extract_params_plot_lines (line 317) | def test_extract_params_plot_lines(minimize_result):

FILE: tests/optimagic/visualization/test_plotting_utilities.py
  function test_decode_base64_data (line 13) | def test_decode_base64_data():
  function test_ensure_array_from_plotly_data_case_array (line 20) | def test_ensure_array_from_plotly_data_case_array():
  function test_ensure_array_from_plotly_data_case_list (line 26) | def test_ensure_array_from_plotly_data_case_list():
  function test_ensure_array_from_plotly_data_case_base64 (line 32) | def test_ensure_array_from_plotly_data_case_base64():
  function test_ensure_array_from_plotly_data_case_invalid (line 48) | def test_ensure_array_from_plotly_data_case_invalid(invalid_input):

FILE: tests/optimagic/visualization/test_profile_plot.py
  function performance_ratios (line 20) | def performance_ratios():
  function test_find_switch_points (line 28) | def test_find_switch_points(performance_ratios):
  function test_determine_alpha_grid (line 34) | def test_determine_alpha_grid(performance_ratios):
  function test_create_solution_times_n_evaluations (line 40) | def test_create_solution_times_n_evaluations():
  function test_create_solution_times_n_batches (line 75) | def test_create_solution_times_n_batches():
  function test_create_solution_times_walltime (line 108) | def test_create_solution_times_walltime():
  function test_extract_profile_plot_lines (line 141) | def test_extract_profile_plot_lines():
  function test_profile_plot_options (line 190) | def test_profile_plot_options(options, close_mpl_figures):

FILE: tests/optimagic/visualization/test_slice_plot.py
  function fixed_inputs (line 17) | def fixed_inputs():
  function sphere_loglike (line 32) | def sphere_loglike(params):
  function sphere (line 37) | def sphere(params):
  function test_slice_plot (line 59) | def test_slice_plot(fixed_inputs, func, backend, kwargs, close_mpl_figur...
  function test_extract_slice_plot_lines (line 68) | def test_extract_slice_plot_lines(fixed_inputs):

FILE: tests/optimagic/visualization/test_slice_plot_3d.py
  function fixed_inputs (line 16) | def fixed_inputs():
  function sphere_loglike (line 26) | def sphere_loglike(params):
  function sphere (line 31) | def sphere(params):
  function test_slice_plot_3d (line 109) | def test_slice_plot_3d(fixed_inputs, func, kwargs):
  function test_generate_evaluation_points (line 237) | def test_generate_evaluation_points(
  function test_evaluate_function_values (line 333) | def test_evaluate_function_values(