SYMBOL INDEX (182 symbols across 32 files)

FILE: docs/source/conf.py
  function setup (line 96) | def setup(app):

FILE: examples/scipy_benchmark.py
  function print_header (line 24) | def print_header(title, num_breaks=1):
  function main (line 30) | def main():

FILE: examples/train_mnist_Minimizer.py
  function MLPClassifier (line 11) | def MLPClassifier(input_size, hidden_sizes, num_classes):
  function evaluate (line 24) | def evaluate(model):
  function closure (line 84) | def closure():

FILE: tests/conftest.py
  function random_seed (line 9) | def random_seed():
  function least_squares_problem (line 26) | def least_squares_problem():
  function rosenbrock_problem (line 72) | def rosenbrock_problem():
  function device (line 94) | def device(request):

FILE: tests/test_imports.py
  function test_import_main_package (line 5) | def test_import_main_package():
  function test_import_core_functions (line 11) | def test_import_core_functions():
  function test_import_benchmarks (line 16) | def test_import_benchmarks():
  function test_method_available (line 32) | def test_method_available(method):

FILE: tests/torchmin/test_bounds.py
  function test_equivalent_bounds (line 13) | def test_equivalent_bounds(method):
  function test_invalid_bounds (line 49) | def test_invalid_bounds():

FILE: tests/torchmin/test_minimize.py
  function problem (line 42) | def problem(request):
  function test_minimize (line 58) | def test_minimize(method, problem):

FILE: tests/torchmin/test_minimize_constr.py
  function rosen_start (line 28) | def rosen_start():
  function rosen_unconstrained_solution (line 34) | def rosen_unconstrained_solution(rosen_start):
  function sum_constraint (line 51) | def sum_constraint(x):
  function norm_constraint (line 56) | def norm_constraint(x):
  class TestUnconstrainedBaseline (line 65) | class TestUnconstrainedBaseline:
    method test_rosen_unconstrained (line 68) | def test_rosen_unconstrained(self, rosen_start):
  class TestInactiveConstraints (line 81) | class TestInactiveConstraints:
    method test_loose_constraints (line 93) | def test_loose_constraints(
  class TestActiveConstraints (line 120) | class TestActiveConstraints:
    method test_tight_constraints (line 132) | def test_tight_constraints(self, rosen_start, constraint_fun, ub):
  function test_frankwolfe_birkhoff_polytope (line 150) | def test_frankwolfe_birkhoff_polytope():
  function test_frankwolfe_tracenorm (line 173) | def test_frankwolfe_tracenorm():
  function test_lbfgsb_simple_quadratic (line 202) | def test_lbfgsb_simple_quadratic():
  function test_lbfgsb_rosenbrock (line 243) | def test_lbfgsb_rosenbrock():
  function test_lbfgsb_active_constraints (line 279) | def test_lbfgsb_active_constraints():

FILE: torchmin/benchmarks.py
  function rosen (line 11) | def rosen(x, reduce=True):
  function rosen_der (line 20) | def rosen_der(x):
  function rosen_hess (line 32) | def rosen_hess(x):
  function rosen_hess_prod (line 43) | def rosen_hess_prod(x, p):

FILE: torchmin/bfgs.py
  class HessianUpdateStrategy (line 11) | class HessianUpdateStrategy(ABC):
    method __init__ (line 12) | def __init__(self):
    method solve (line 16) | def solve(self, grad):
    method _update (line 20) | def _update(self, s, y, rho_inv):
    method update (line 23) | def update(self, s, y):
  class L_BFGS (line 32) | class L_BFGS(HessianUpdateStrategy):
    method __init__ (line 33) | def __init__(self, x, history_size=100):
    method solve (line 42) | def solve(self, grad):
    method _update (line 55) | def _update(self, s, y, rho_inv):
  class BFGS (line 66) | class BFGS(HessianUpdateStrategy):
    method __init__ (line 67) | def __init__(self, x, inverse=True):
    method solve (line 76) | def solve(self, grad):
    method _update (line 83) | def _update(self, s, y, rho_inv):
  function _minimize_bfgs_core (line 101) | def _minimize_bfgs_core(
  function _minimize_bfgs (line 293) | def _minimize_bfgs(
  function _minimize_lbfgs (line 347) | def _minimize_lbfgs(

FILE: torchmin/cg.py
  function _minimize_cg (line 13) | def _minimize_cg(fun, x0, max_iter=None, gtol=1e-5, normp=float('inf'),

FILE: torchmin/constrained/frankwolfe.py
  function _minimize_frankwolfe (line 16) | def _minimize_frankwolfe(

FILE: torchmin/constrained/lbfgsb.py
  class L_BFGS_B (line 9) | class L_BFGS_B:
    method __init__ (line 15) | def __init__(self, x, history_size=10):
    method solve (line 23) | def solve(self, grad, x, lb, ub, theta=None):
    method update (line 71) | def update(self, s, y):
  function _project_bounds (line 107) | def _project_bounds(x, lb, ub):
  function _gradient_projection (line 112) | def _gradient_projection(x, g, lb, ub):
  function _minimize_lbfgsb (line 132) | def _minimize_lbfgsb(

FILE: torchmin/constrained/trust_constr.py
  function _build_obj (line 12) | def _build_obj(f, x0):
  function _build_constr (line 39) | def _build_constr(constr, x0):
  function _check_bound (line 102) | def _check_bound(val, x0):
  function _build_bounds (line 115) | def _build_bounds(bounds, x0):
  function _minimize_trust_constr (line 127) | def _minimize_trust_constr(

FILE: torchmin/function.py
  class JacobianLinearOperator (line 25) | class JacobianLinearOperator(object):
    method __init__ (line 26) | def __init__(self,
    method mv (line 42) | def mv(self, v: Tensor) -> Tensor:
    method rmv (line 56) | def rmv(self, v: Tensor) -> Tensor:
  function jacobian_linear_operator (line 67) | def jacobian_linear_operator(x, f, symmetric=False):
  class ScalarFunction (line 81) | class ScalarFunction(object):
    method __new__ (line 88) | def __new__(cls, fun, x_shape, hessp=False, hess=False, twice_diffable...
    method __init__ (line 95) | def __init__(self, fun, x_shape, hessp=False, hess=False, twice_diffab...
    method fun (line 104) | def fun(self, x):
    method closure (line 115) | def closure(self, x):
    method dir_evaluate (line 140) | def dir_evaluate(self, x, t, d):
  class VectorFunction (line 156) | class VectorFunction(object):
    method __init__ (line 158) | def __init__(self, fun, x_shape, jacp=False, jac=False):
    method fun (line 166) | def fun(self, x):
    method closure (line 179) | def closure(self, x):

FILE: torchmin/line_search.py
  function _strong_wolfe_extra (line 9) | def _strong_wolfe_extra(
  function strong_wolfe (line 163) | def strong_wolfe(fun, x, t, d, f, g, gtd=None, **kwargs):
  function brent (line 192) | def brent(fun, x, d, bounds=(0,10)):
  function backtracking (line 202) | def backtracking(fun, x, t, d, f, g, mu=0.1, decay=0.98, max_ls=500, tmi...

FILE: torchmin/lstsq/cg.py
  function cg (line 6) | def cg(A, b, x0=None, max_iter=None, tol=1e-5):
  function cgls (line 35) | def cgls(A, b, alpha=0., **kwargs):

FILE: torchmin/lstsq/common.py
  function in_bounds (line 10) | def in_bounds(x, lb, ub):
  function find_active_constraints (line 15) | def find_active_constraints(x, lb, ub, rtol=1e-10):
  function make_strictly_feasible (line 50) | def make_strictly_feasible(x, lb, ub, rstep=1e-10):
  function solve_lsq_trust_region (line 74) | def solve_lsq_trust_region(n, m, uf, s, V, Delta, initial_alpha=None,
  function right_multiplied_operator (line 151) | def right_multiplied_operator(J, d):
  function build_quadratic_1d (line 169) | def build_quadratic_1d(J, g, s, diag=None, s0=None):
  function minimize_quadratic_1d (line 197) | def minimize_quadratic_1d(a, b, lb, ub, c=0):
  function evaluate_quadratic (line 213) | def evaluate_quadratic(J, g, s, diag=None):
  function solve_trust_region_2d (line 232) | def solve_trust_region_2d(B, g, Delta):
  function update_tr_radius (line 273) | def update_tr_radius(Delta, actual_reduction, predicted_reduction,
  function check_termination (line 292) | def check_termination(dF, F, dx_norm, x_norm, ratio, ftol, xtol):

FILE: torchmin/lstsq/least_squares.py
  function prepare_bounds (line 24) | def prepare_bounds(bounds, x0):
  function check_tolerance (line 41) | def check_tolerance(ftol, xtol, gtol, method):
  function check_x_scale (line 65) | def check_x_scale(x_scale, x0):
  function least_squares (line 87) | def least_squares(

FILE: torchmin/lstsq/linear_operator.py
  function jacobian_dense (line 6) | def jacobian_dense(fun, x, vectorize=True):
  function jacobian_linop (line 11) | def jacobian_linop(fun, x, return_f=False):
  class TorchLinearOperator (line 38) | class TorchLinearOperator(object):
    method __init__ (line 40) | def __init__(self, shape, matvec, rmatvec):
    method matvec (line 45) | def matvec(self, x):
    method rmatvec (line 48) | def rmatvec(self, x):
    method matmat (line 51) | def matmat(self, X):
    method transpose (line 57) | def transpose(self):
  function aslinearoperator (line 68) | def aslinearoperator(A):

FILE: torchmin/lstsq/lsmr.py
  function _sym_ortho (line 11) | def _sym_ortho(a, b, out):
  function lsmr (line 19) | def lsmr(A, b, damp=0., atol=1e-6, btol=1e-6, conlim=1e8, maxiter=None,

FILE: torchmin/lstsq/trf.py
  function trf (line 18) | def trf(fun, x0, f0, lb, ub, ftol, xtol, gtol, max_nfev, x_scale,
  function trf_no_bounds (line 32) | def trf_no_bounds(fun, x0, f0=None, ftol=1e-8, xtol=1e-8, gtol=1e-8,

FILE: torchmin/minimize.py
  function minimize (line 22) | def minimize(

FILE: torchmin/minimize_constr.py
  function _maybe_to_number (line 18) | def _maybe_to_number(val):
  function _check_bound (line 27) | def _check_bound(val, x0, numpy=False):
  function _check_bounds (line 57) | def _check_bounds(bounds, x0, method):
  function minimize_constr (line 81) | def minimize_constr(

FILE: torchmin/newton.py
  function _cg_iters (line 15) | def _cg_iters(grad, hess, max_iter, normp=1):
  function _minimize_newton_cg (line 73) | def _minimize_newton_cg(
  function _minimize_newton_exact (line 226) | def _minimize_newton_exact(

FILE: torchmin/optim/minimizer.py
  class LinearOperator (line 6) | class LinearOperator:
    method __init__ (line 8) | def __init__(self, matvec, shape, dtype=torch.float, device=None):
  class Minimizer (line 16) | class Minimizer(Optimizer):
    method __init__ (line 41) | def __init__(self,
    method nfev (line 71) | def nfev(self):
    method _numel (line 74) | def _numel(self):
    method _gather_flat_param (line 79) | def _gather_flat_param(self):
    method _gather_flat_grad (line 89) | def _gather_flat_grad(self):
    method _set_flat_param (line 101) | def _set_flat_param(self, value):
    method closure (line 109) | def closure(self, x):
    method dir_evaluate (line 143) | def dir_evaluate(self, x, t, d):
    method step (line 156) | def step(self, closure):

FILE: torchmin/optim/scipy_minimizer.py
  function _build_bounds (line 13) | def _build_bounds(bounds, params, numel_total):
  function _jacobian (line 55) | def _jacobian(inputs, outputs):
  class ScipyMinimizer (line 93) | class ScipyMinimizer(Optimizer):
    method __init__ (line 131) | def __init__(self,
    method _numel (line 161) | def _numel(self):
    method _bounds (line 166) | def _bounds(self):
    method _gather_flat_param (line 174) | def _gather_flat_param(self):
    method _gather_flat_grad (line 184) | def _gather_flat_grad(self):
    method _set_flat_param (line 196) | def _set_flat_param(self, value):
    method _build_constraints (line 205) | def _build_constraints(self, constraints):
    method step (line 241) | def step(self, closure):

FILE: torchmin/trustregion/base.py
  class BaseQuadraticSubproblem (line 26) | class BaseQuadraticSubproblem(ABC):
    method __init__ (line 32) | def __init__(self, x, closure):
    method __call__ (line 47) | def __call__(self, p):
    method fun (line 51) | def fun(self):
    method jac (line 56) | def jac(self):
    method hess (line 61) | def hess(self):
    method hessp (line 68) | def hessp(self, p):
    method jac_mag (line 78) | def jac_mag(self):
    method get_boundaries_intersections (line 84) | def get_boundaries_intersections(self, z, d, trust_radius):
    method solve (line 105) | def solve(self, trust_radius):
    method hess_prod (line 110) | def hess_prod(self):
  function _minimize_trust_region (line 117) | def _minimize_trust_region(fun, x0, subproblem=None, initial_trust_radiu...

FILE: torchmin/trustregion/dogleg.py
  function _minimize_dogleg (line 15) | def _minimize_dogleg(
  class DoglegSubproblem (line 58) | class DoglegSubproblem(BaseQuadraticSubproblem):
    method cauchy_point (line 62) | def cauchy_point(self):
    method newton_point (line 72) | def newton_point(self):
    method solve (line 82) | def solve(self, trust_radius):

FILE: torchmin/trustregion/exact.py
  function _minimize_trust_exact (line 18) | def _minimize_trust_exact(fun, x0, **trust_region_options):
  function solve_triangular (line 66) | def solve_triangular(A, b, *, upper=True, transpose=False, **kwargs):
  function solve_cholesky (line 77) | def solve_cholesky(A, b, **kwargs):
  function estimate_smallest_singular_value (line 82) | def estimate_smallest_singular_value(U) -> Tuple[Tensor, Tensor]:
  function gershgorin_bounds (line 130) | def gershgorin_bounds(H):
  function singular_leading_submatrix (line 144) | def singular_leading_submatrix(A, U, k):
  class IterativeSubproblem (line 165) | class IterativeSubproblem(BaseQuadraticSubproblem):
    method __init__ (line 174) | def __init__(self, x, fun, k_easy=0.1, k_hard=0.2):
    method _initial_values (line 219) | def _initial_values(self, tr_radius):
    method solve (line 250) | def solve(self, tr_radius):

FILE: torchmin/trustregion/krylov.py
  function _minimize_trust_krylov (line 11) | def _minimize_trust_krylov(fun, x0, **trust_region_options):
  class KrylovSubproblem (line 63) | class KrylovSubproblem(BaseQuadraticSubproblem):
    method __init__ (line 84) | def __init__(self, x, fun, k_easy=0.1, k_hard=0.2, tol=1e-5, ortho=True,
    method tridiag_subproblem (line 94) | def tridiag_subproblem(self, Ta, Tb, tr_radius):
    method solve (line 158) | def solve(self, tr_radius):

FILE: torchmin/trustregion/ncg.py
  function _minimize_trust_ncg (line 15) | def _minimize_trust_ncg(
  class CGSteihaugSubproblem (line 55) | class CGSteihaugSubproblem(BaseQuadraticSubproblem):
    method solve (line 59) | def solve(self, trust_radius):