init( (object)arg1, (Multifunc)score_fxn, (bool)nonmonotone, (int)dim) -> None : core/optimization/LineMinimizer.hh:166

C++ signature :
    void __init__(_object*,core::optimization::Multifunc,bool,unsigned long)

init( (object)arg1, (ArmijoLineMinimization)) -> None : ////////////////////////////////////////////////////// //////////////////////////////////////////////////////

C++ signature :
    void __init__(_object*,core::optimization::ArmijoLineMinimization)

Armijo( (ArmijoLineMinimization)arg1, (float)init_step, (func_1d)func_eval) -> float : core/optimization/LineMinimizer.hh:171

C++ signature : double Armijo(core::optimization::ArmijoLineMinimization {lvalue},double,core::optimization::func_1d {lvalue})

provide_stored_derivatives( (ArmijoLineMinimization)arg1) -> bool : core/optimization/LineMinimizer.hh:169

C++ signature :
    bool provide_stored_derivatives(core::optimization::ArmijoLineMinimization {lvalue})

provide_stored_derivatives( (ArmijoLineMinimization)arg1) -> bool :

C++ signature :
    bool provide_stored_derivatives(ArmijoLineMinimization_exposer_callback {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (ArmijoLineMinimizationAP)arg1) -> ArmijoLineMinimization :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (ArmijoLineMinimizationCAP)arg1) -> ArmijoLineMinimization :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (AtomTreeMinimizer)) -> None : High-level atom tree minimizer class

C++ signature :
    void __init__(_object*,core::optimization::AtomTreeMinimizer)

check_setup( (AtomTreeMinimizer)arg1, (Pose)pose, (MoveMap)move_map, (ScoreFunction)scorefxn, (MinimizerOptions)options) -> None : Do consistency checks for minimizer setup.

C++ signature : void check_setup(core::optimization::AtomTreeMinimizer {lvalue},core::pose::Pose,core::kinematics::MoveMap,core::scoring::ScoreFunction,core::optimization::MinimizerOptions)

deriv_check_result( (AtomTreeMinimizer)arg1) -> NumericalDerivCheckResult : After minimization has concluded, the user may access the deriv-check result, assuming that they have run the AtomTreeMinimizer with deriv_check = true;

C++ signature : boost::shared_ptr deriv_check_result(core::optimization::AtomTreeMinimizer {lvalue})

run( (AtomTreeMinimizer)arg1, (Pose)pose, (MoveMap)move_map, (ScoreFunction)scorefxn, (MinimizerOptions)options) -> float : run minimization and return the final score at minimization's conclusion. Virtual allowing derived classes to mascarade as AtomTreeMinimizers. Non-const so that it can modify its deriv_check_result_ object.

C++ signature :
    double run(core::optimization::AtomTreeMinimizer {lvalue},core::pose::Pose {lvalue},core::kinematics::MoveMap,core::scoring::ScoreFunction,core::optimization::MinimizerOptions)

run( (AtomTreeMinimizer)arg1, (Pose)pose, (MoveMap)move_map, (ScoreFunction)scorefxn, (MinimizerOptions)options) -> float :

C++ signature :
    double run(AtomTreeMinimizer_exposer_callback {lvalue},core::pose::Pose {lvalue},core::kinematics::MoveMap,core::scoring::ScoreFunction,core::optimization::MinimizerOptions)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (AtomTreeMinimizerAP)arg1) -> AtomTreeMinimizer :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (AtomTreeMinimizerCAP)arg1) -> AtomTreeMinimizer :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1, (Pose)pose_in, (MinimizerMap)min_map_in, (ScoreFunction)scorefxn_in [, (bool)deriv_check_in=False [, (bool)deriv_check_verbose_in=False]]) -> None : core/optimization/AtomTreeMultifunc.hh:46

C++ signature :
    void __init__(_object*,core::pose::Pose {lvalue},core::optimization::MinimizerMap {lvalue},core::scoring::ScoreFunction [,bool=False [,bool=False]])

init( (object)arg1, (AtomTreeMultifunc)) -> None : Atom tree multifunction class

C++ signature :
    void __init__(_object*,core::optimization::AtomTreeMultifunc)

abort_min( (AtomTreeMultifunc)arg1, (vector1_Real)) -> bool : Christophe added the following to allow premature end of minimization If you want to abort the minimizer under specific circonstances overload this function and return true if you want to stop, false if you want to continue. FOR THE MOMENT, ONLY IN DFPMIN!

C++ signature :
    bool abort_min(core::optimization::AtomTreeMultifunc {lvalue},utility::vector1<double, std::allocator<double> >)

abort_min( (AtomTreeMultifunc)arg1, (vector1_Real)) -> bool :

C++ signature :
    bool abort_min(AtomTreeMultifunc_exposer_callback {lvalue},utility::vector1<double, std::allocator<double> >)

dfunc( (AtomTreeMultifunc)arg1, (vector1_Real)vars, (vector1_Real)dE_dvars) -> None : core/optimization/AtomTreeMultifunc.hh:61

C++ signature :
    void dfunc(core::optimization::AtomTreeMultifunc {lvalue},utility::vector1<double, std::allocator<double> >,utility::vector1<double, std::allocator<double> > {lvalue})

dfunc( (AtomTreeMultifunc)arg1, (vector1_Real)vars, (vector1_Real)dE_dvars) -> None :

C++ signature :
    void dfunc(AtomTreeMultifunc_exposer_callback {lvalue},utility::vector1<double, std::allocator<double> >,utility::vector1<double, std::allocator<double> > {lvalue})

dump( (AtomTreeMultifunc)arg1, (vector1_Real)vars, (vector1_Real)vars2) -> None : Error state reached -- derivative does not match gradient

C++ signature :
    void dump(core::optimization::AtomTreeMultifunc {lvalue},utility::vector1<double, std::allocator<double> >,utility::vector1<double, std::allocator<double> >)

dump( (AtomTreeMultifunc)arg1, (vector1_Real)vars, (vector1_Real)vars2) -> None :

C++ signature :
    void dump(AtomTreeMultifunc_exposer_callback {lvalue},utility::vector1<double, std::allocator<double> >,utility::vector1<double, std::allocator<double> >)

set_deriv_check_result( (AtomTreeMultifunc)arg1, (NumericalDerivCheckResult)deriv_check_result) -> None : core/optimization/AtomTreeMultifunc.hh:63

C++ signature : void set_deriv_check_result(core::optimization::AtomTreeMultifunc {lvalue},boost::shared_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (AtomTreeMultifuncAP)arg1) -> AtomTreeMultifunc :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (AtomTreeMultifuncCAP)arg1) -> AtomTreeMultifunc :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1, (Multifunc)score_fxn, (int)dim) -> None : core/optimization/LineMinimizer.hh:145

C++ signature :
    void __init__(_object*,core::optimization::Multifunc,unsigned long)

init( (object)arg1, (BrentLineMinimization)) -> None : ////////////////////////////////////////////////////// //////////////////////////////////////////////////////

C++ signature :
    void __init__(_object*,core::optimization::BrentLineMinimization)

BRENT( (BrentLineMinimization)arg1, (float)AX, (float)BX, (float)CX, (float)FA, (float)FB, (float)FC, (float)TOL, (func_1d)func_eval) -> float : core/optimization/LineMinimizer.hh:152

C++ signature : double BRENT(core::optimization::BrentLineMinimization {lvalue},double,double,double,double {lvalue},double {lvalue},double,double,core::optimization::func_1d {lvalue})

MNBRAK( (BrentLineMinimization)arg1, (float)AX, (float)BX, (float)CX, (float)FA, (float)FB, (float)FC, (func_1d)func_eval) -> None : core/optimization/LineMinimizer.hh:150

C++ signature : void MNBRAK(core::optimization::BrentLineMinimization {lvalue},double {lvalue},double {lvalue},double {lvalue},double {lvalue},double {lvalue},double {lvalue},core::optimization::func_1d {lvalue})

provide_stored_derivatives( (BrentLineMinimization)arg1) -> bool : core/optimization/LineMinimizer.hh:113

C++ signature :
    bool provide_stored_derivatives(core::optimization::BrentLineMinimization {lvalue})

provide_stored_derivatives( (BrentLineMinimization)arg1) -> bool :

C++ signature :
    bool provide_stored_derivatives(BrentLineMinimization_exposer_callback {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (BrentLineMinimizationAP)arg1) -> BrentLineMinimization :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (BrentLineMinimizationCAP)arg1) -> BrentLineMinimization :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (CartesianMinimizer)) -> None : High-level atom tree minimizer class

C++ signature :
    void __init__(_object*,core::optimization::CartesianMinimizer)

deriv_check_result( (CartesianMinimizer)arg1) -> NumericalDerivCheckResult : After minimization has concluded, the user may access the deriv-check result, assuming that they have run the CartesianMinimizer with deriv_check = true;

C++ signature : boost::shared_ptr deriv_check_result(core::optimization::CartesianMinimizer {lvalue})

run( (CartesianMinimizer)arg1, (Pose)pose, (MoveMap)move_map, (ScoreFunction)scorefxn, (MinimizerOptions)options) -> float : run minimization and return the final score at minimization's conclusion. Virtual allowing derived classes to mascarade as CartesianMinimizers. Non-const so that it can modify its deriv_check_result_ object.

C++ signature :
    double run(core::optimization::CartesianMinimizer {lvalue},core::pose::Pose {lvalue},core::kinematics::MoveMap,core::scoring::ScoreFunction,core::optimization::MinimizerOptions)

run( (CartesianMinimizer)arg1, (Pose)pose, (MoveMap)move_map, (ScoreFunction)scorefxn, (MinimizerOptions)options) -> float :

C++ signature :
    double run(CartesianMinimizer_exposer_callback {lvalue},core::pose::Pose {lvalue},core::kinematics::MoveMap,core::scoring::ScoreFunction,core::optimization::MinimizerOptions)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (CartesianMinimizerAP)arg1) -> CartesianMinimizer :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (CartesianMinimizerCAP)arg1) -> CartesianMinimizer :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (CartesianMinimizerMap)) -> None : core/optimization/CartesianMinimizerMap.hh:44

C++ signature :
    void __init__(_object*,core::optimization::CartesianMinimizerMap)

add_atom( (CartesianMinimizerMap)arg1, (AtomID)AtomID, (DOF_ID)dof_id) -> None : core/optimization/CartesianMinimizerMap.hh:74

C++ signature :
    void add_atom(core::optimization::CartesianMinimizerMap {lvalue},core::id::AtomID,core::id::DOF_ID)

add_atom( (CartesianMinimizerMap)arg1, (AtomID)AtomID, (DOF_ID)dof_id) -> None :

C++ signature :
    void add_atom(CartesianMinimizerMap_exposer_callback {lvalue},core::id::AtomID,core::id::DOF_ID)

add_torsion( (CartesianMinimizerMap)arg1, (DOF_ID)new_torsion, (DOF_ID)parent) -> None : core/optimization/CartesianMinimizerMap.hh:67

C++ signature :
    void add_torsion(core::optimization::CartesianMinimizerMap {lvalue},core::id::DOF_ID,core::id::DOF_ID)

add_torsion( (CartesianMinimizerMap)arg1, (DOF_ID)new_torsion, (DOF_ID)parent) -> None :

C++ signature :
    void add_torsion(CartesianMinimizerMap_exposer_callback {lvalue},core::id::DOF_ID,core::id::DOF_ID)

atom_derivatives( (CartesianMinimizerMap)arg1, (int)resid) -> object : core/optimization/CartesianMinimizerMap.hh:124

C++ signature : utility::vector1 > {lvalue} atom_derivatives(core::optimization::CartesianMinimizerMap {lvalue},unsigned long)

copy_dofs_from_pose( (CartesianMinimizerMap)arg1, (Pose)pose, (vector1_Real)dofs) -> None : core/optimization/CartesianMinimizerMap.hh:92

C++ signature : void copy_dofs_from_pose(core::optimization::CartesianMinimizerMap {lvalue},core::pose::Pose,utility::vector1 > {lvalue})

copy_dofs_to_pose( (CartesianMinimizerMap)arg1, (Pose)pose, (vector1_Real)dofs) -> None : core/optimization/CartesianMinimizerMap.hh:99

C++ signature : void copy_dofs_to_pose(core::optimization::CartesianMinimizerMap {lvalue},core::pose::Pose {lvalue},utility::vector1 >)

domain_map( (CartesianMinimizerMap)arg1) -> object : core/optimization/CartesianMinimizerMap.hh:57

C++ signature :
    ObjexxFCL::FArray1D<int> domain_map(core::optimization::CartesianMinimizerMap {lvalue})

domain_map( (CartesianMinimizerMap)arg1) -> object :

C++ signature :
    ObjexxFCL::FArray1D<int> domain_map(CartesianMinimizerMap_exposer_callback {lvalue})

get_TorsionID( (CartesianMinimizerMap)arg1, (int)n) -> TorsionID : core/optimization/CartesianMinimizerMap.hh:112

C++ signature : core::id::TorsionID get_TorsionID(core::optimization::CartesianMinimizerMap {lvalue},unsigned long)

get_atom( (CartesianMinimizerMap)arg1, (int)n) -> AtomID : core/optimization/CartesianMinimizerMap.hh:118

C++ signature : core::id::AtomID get_atom(core::optimization::CartesianMinimizerMap {lvalue},unsigned long)

get_atom_index( (CartesianMinimizerMap)arg1, (AtomID)x) -> int : core/optimization/CartesianMinimizerMap.hh:121

C++ signature : unsigned long get_atom_index(core::optimization::CartesianMinimizerMap {lvalue},core::id::AtomID)

get_dof_id( (CartesianMinimizerMap)arg1, (int)n) -> DOF_ID : core/optimization/CartesianMinimizerMap.hh:109

C++ signature : core::id::DOF_ID get_dof_id(core::optimization::CartesianMinimizerMap {lvalue},unsigned long)

natoms( (CartesianMinimizerMap)arg1) -> int : core/optimization/CartesianMinimizerMap.hh:115

C++ signature : int natoms(core::optimization::CartesianMinimizerMap {lvalue})

ndofs( (CartesianMinimizerMap)arg1) -> int : core/optimization/CartesianMinimizerMap.hh:103

C++ signature : int ndofs(core::optimization::CartesianMinimizerMap {lvalue})

ntorsions( (CartesianMinimizerMap)arg1) -> int : core/optimization/CartesianMinimizerMap.hh:106

C++ signature : int ntorsions(core::optimization::CartesianMinimizerMap {lvalue})

reset( (CartesianMinimizerMap)arg1, (Pose)pose) -> None : clears old data+dimensions dof_node_pointer using size data from the pose

C++ signature : void reset(core::optimization::CartesianMinimizerMap {lvalue},core::pose::Pose)

setup( (CartesianMinimizerMap)arg1, (Pose)pose, (MoveMap)move_map) -> None : core/optimization/CartesianMinimizerMap.hh:81

C++ signature : void setup(core::optimization::CartesianMinimizerMap {lvalue},core::pose::Pose {lvalue},core::kinematics::MoveMap)

zero_stored_derivs( (CartesianMinimizerMap)arg1) -> None : core/optimization/CartesianMinimizerMap.hh:129

C++ signature : void zero_stored_derivs(core::optimization::CartesianMinimizerMap {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (CartesianMinimizerMapAP)arg1) -> CartesianMinimizerMap :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (CartesianMinimizerMapCAP)arg1) -> CartesianMinimizerMap :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1, (Pose)pose_in, (CartesianMinimizerMap)min_map_in, (ScoreFunction)scorefxn_in [, (bool)deriv_check_in=False [, (bool)deriv_check_verbose_in=False]]) -> None : core/optimization/CartesianMultifunc.hh:46

C++ signature :
    void __init__(_object*,core::pose::Pose {lvalue},core::optimization::CartesianMinimizerMap {lvalue},core::scoring::ScoreFunction [,bool=False [,bool=False]])

init( (object)arg1, (CartesianMultifunc)) -> None : Atom tree multifunction class

C++ signature :
    void __init__(_object*,core::optimization::CartesianMultifunc)

abort_min( (CartesianMultifunc)arg1, (vector1_Real)) -> bool : Christophe added the following to allow premature end of minimization If you want to abort the minimizer under specific circonstances overload this function and return true if you want to stop, false if you want to continue. FOR THE MOMENT, ONLY IN DFPMIN!

C++ signature :
    bool abort_min(core::optimization::CartesianMultifunc {lvalue},utility::vector1<double, std::allocator<double> >)

abort_min( (CartesianMultifunc)arg1, (vector1_Real)) -> bool :

C++ signature :
    bool abort_min(CartesianMultifunc_exposer_callback {lvalue},utility::vector1<double, std::allocator<double> >)

dfunc( (CartesianMultifunc)arg1, (vector1_Real)vars, (vector1_Real)dE_dvars) -> None : core/optimization/CartesianMultifunc.hh:61

C++ signature :
    void dfunc(core::optimization::CartesianMultifunc {lvalue},utility::vector1<double, std::allocator<double> >,utility::vector1<double, std::allocator<double> > {lvalue})

dfunc( (CartesianMultifunc)arg1, (vector1_Real)vars, (vector1_Real)dE_dvars) -> None :

C++ signature :
    void dfunc(CartesianMultifunc_exposer_callback {lvalue},utility::vector1<double, std::allocator<double> >,utility::vector1<double, std::allocator<double> > {lvalue})

dump( (CartesianMultifunc)arg1, (vector1_Real)vars, (vector1_Real)vars2) -> None : Error state reached -- derivative does not match gradient

C++ signature :
    void dump(core::optimization::CartesianMultifunc {lvalue},utility::vector1<double, std::allocator<double> >,utility::vector1<double, std::allocator<double> >)

dump( (CartesianMultifunc)arg1, (vector1_Real)vars, (vector1_Real)vars2) -> None :

C++ signature :
    void dump(CartesianMultifunc_exposer_callback {lvalue},utility::vector1<double, std::allocator<double> >,utility::vector1<double, std::allocator<double> >)

set_deriv_check_result( (CartesianMultifunc)arg1, (NumericalDerivCheckResult)deriv_check_result) -> None : core/optimization/CartesianMultifunc.hh:63

C++ signature : void set_deriv_check_result(core::optimization::CartesianMultifunc {lvalue},boost::shared_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (CartesianMultifuncAP)arg1) -> CartesianMultifunc :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (CartesianMultifuncCAP)arg1) -> CartesianMultifunc :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (ConvergenceTestAP)arg1) -> ConvergenceTest :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (ConvergenceTestCAP)arg1) -> ConvergenceTest :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1, (float)_tol) -> None : core/optimization/Minimizer.hh:77

C++ signature :
    void __init__(_object*,double)

init( (object)arg1, (DFPMinConvergedAbsolute)) -> None : core/optimization/Minimizer.hh:75

C++ signature :
    void __init__(_object*,core::optimization::DFPMinConvergedAbsolute)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (DFPMinConvergedAbsoluteAP)arg1) -> DFPMinConvergedAbsolute :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (DFPMinConvergedAbsoluteCAP)arg1) -> DFPMinConvergedAbsolute :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1, (float)_tol [, (float)_eps=1e-10]) -> None : core/optimization/Minimizer.hh:66

C++ signature :
    void __init__(_object*,double [,double=1e-10])

init( (object)arg1, (DFPMinConvergedFractional)) -> None : core/optimization/Minimizer.hh:64

C++ signature :
    void __init__(_object*,core::optimization::DFPMinConvergedFractional)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (DFPMinConvergedFractionalAP)arg1) -> DFPMinConvergedFractional :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (DFPMinConvergedFractionalCAP)arg1) -> DFPMinConvergedFractional :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (DOF_DataPoint)) -> None : core/optimization/NumericalDerivCheckResult.hh:132

C++ signature :
    void __init__(_object*,core::optimization::DOF_DataPoint)

init( (object)arg1, (DOF_ID)dof_id, (DOF_ID)parent_id, (int)natoms, (float)num_deriv, (float)ana_deriv, (float)ratio, (float)f11, (float)f00, (float)f22, (float)dof_val) -> None : core/optimization/NumericalDerivCheckResult.hh:156

C++ signature :
    void __init__(_object*,core::id::DOF_ID,core::id::DOF_ID,unsigned long,double,double,double,double,double,double,double)

ana_deriv( (DOF_DataPoint)arg1) -> float : core/optimization/NumericalDerivCheckResult.hh:173

C++ signature : double ana_deriv(core::optimization::DOF_DataPoint {lvalue})

dof_id( (DOF_DataPoint)arg1) -> DOF_ID : core/optimization/NumericalDerivCheckResult.hh:169

C++ signature : core::id::DOF_ID dof_id(core::optimization::DOF_DataPoint {lvalue})

dof_val( (DOF_DataPoint)arg1) -> float : core/optimization/NumericalDerivCheckResult.hh:178

C++ signature : double dof_val(core::optimization::DOF_DataPoint {lvalue})

f00( (DOF_DataPoint)arg1) -> float : core/optimization/NumericalDerivCheckResult.hh:176

C++ signature : double f00(core::optimization::DOF_DataPoint {lvalue})

f11( (DOF_DataPoint)arg1) -> float : core/optimization/NumericalDerivCheckResult.hh:175

C++ signature : double f11(core::optimization::DOF_DataPoint {lvalue})

f22( (DOF_DataPoint)arg1) -> float : core/optimization/NumericalDerivCheckResult.hh:177

C++ signature : double f22(core::optimization::DOF_DataPoint {lvalue})

natoms( (DOF_DataPoint)arg1) -> int : core/optimization/NumericalDerivCheckResult.hh:171

C++ signature : unsigned long natoms(core::optimization::DOF_DataPoint {lvalue})

num_deriv( (DOF_DataPoint)arg1) -> float : core/optimization/NumericalDerivCheckResult.hh:172

C++ signature : double num_deriv(core::optimization::DOF_DataPoint {lvalue})

parent_id( (DOF_DataPoint)arg1) -> DOF_ID : core/optimization/NumericalDerivCheckResult.hh:170

C++ signature : core::id::DOF_ID parent_id(core::optimization::DOF_DataPoint {lvalue})

ratio( (DOF_DataPoint)arg1) -> float : core/optimization/NumericalDerivCheckResult.hh:174

C++ signature : double ratio(core::optimization::DOF_DataPoint {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (DOF_DataPointAP)arg1) -> DOF_DataPoint :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (DOF_DataPointCAP)arg1) -> DOF_DataPoint :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1, (DOF_ID)id_in, (DOF_Node)parent_in) -> None : core/optimization/DOF_Node.hh:160

C++ signature :
    void __init__(_object*,core::id::DOF_ID,boost::shared_ptr<core::optimization::DOF_Node>)

init( (object)arg1, (DOF_Node)) -> None : core/optimization/DOF_Node.hh:40

C++ signature :
    void __init__(_object*,core::optimization::DOF_Node)

F1( (DOF_Node)arg1) -> xyzVector_Real : core/optimization/DOF_Node.hh:53

C++ signature :
    numeric::xyzVector<double> {lvalue} F1(core::optimization::DOF_Node {lvalue})

F1( (DOF_Node)arg1) -> xyzVector_Real : core/optimization/DOF_Node.hh:61

C++ signature :
    numeric::xyzVector<double> F1(core::optimization::DOF_Node {lvalue})

F2( (DOF_Node)arg1) -> xyzVector_Real : core/optimization/DOF_Node.hh:57

C++ signature :
    numeric::xyzVector<double> {lvalue} F2(core::optimization::DOF_Node {lvalue})

F2( (DOF_Node)arg1) -> xyzVector_Real : core/optimization/DOF_Node.hh:65

C++ signature :
    numeric::xyzVector<double> F2(core::optimization::DOF_Node {lvalue})

add_atom( (DOF_Node)arg1, (AtomID)atom) -> None : core/optimization/DOF_Node.hh:113

C++ signature : void add_atom(core::optimization::DOF_Node {lvalue},core::id::AtomID)

atom_id( (DOF_Node)arg1) -> AtomID : core/optimization/DOF_Node.hh:77

C++ signature : core::id::AtomID atom_id(core::optimization::DOF_Node {lvalue})

atomno( (DOF_Node)arg1) -> int : core/optimization/DOF_Node.hh:73

C++ signature : int atomno(core::optimization::DOF_Node {lvalue})

atoms( (DOF_Node)arg1) -> vector1_AtomID : core/optimization/DOF_Node.hh:92

C++ signature : utility::vector1 > atoms(core::optimization::DOF_Node {lvalue})

clear_atoms( (DOF_Node)arg1) -> None : core/optimization/DOF_Node.hh:106

C++ signature : void clear_atoms(core::optimization::DOF_Node {lvalue})

dependent( (DOF_Node)arg1) -> bool : core/optimization/DOF_Node.hh:183

C++ signature :
    bool dependent(core::optimization::DOF_Node {lvalue})

dependent( (DOF_Node)arg1, (bool)setting) -> None : core/optimization/DOF_Node.hh:186

C++ signature :
    void dependent(core::optimization::DOF_Node {lvalue},bool)

depth( (DOF_Node)arg1) -> int : core/optimization/DOF_Node.hh:211

C++ signature : int depth(core::optimization::DOF_Node {lvalue})

dof_id( (DOF_Node)arg1) -> DOF_ID : core/optimization/DOF_Node.hh:85

C++ signature : core::id::DOF_ID dof_id(core::optimization::DOF_Node {lvalue})

link_vectors( (DOF_Node)arg1) -> None : sum derivative contributions down the tree

C++ signature : void link_vectors(core::optimization::DOF_Node {lvalue})

parent( (DOF_Node)arg1) -> DOF_Node : core/optimization/DOF_Node.hh:99

C++ signature : boost::shared_ptr parent(core::optimization::DOF_Node {lvalue})

rsd( (DOF_Node)arg1) -> int : core/optimization/DOF_Node.hh:69

C++ signature : int rsd(core::optimization::DOF_Node {lvalue})

set_id( (DOF_Node)arg1, (DOF_ID)setting) -> None : core/optimization/DOF_Node.hh:171

C++ signature : void set_id(core::optimization::DOF_Node {lvalue},core::id::DOF_ID)

set_parent( (DOF_Node)arg1, (DOF_Node)setting) -> None : core/optimization/DOF_Node.hh:176

C++ signature : void set_parent(core::optimization::DOF_Node {lvalue},boost::shared_ptr)

torsion_id( (DOF_Node)arg1) -> TorsionID : get the rosetta torsion id for this DOF This may not exist, of course. But it's useful to know what it is when calculating derivatives of terms like rama/dunbrack/paa

C++ signature :
    core::id::TorsionID torsion_id(core::optimization::DOF_Node {lvalue})

torsion_id( (DOF_Node)arg1, (TorsionID)id_in) -> None : set the rosetta torsion id for this DOF This may not exist, of course. But it's useful to know what it is when calculating derivatives of terms like rama/dunbrack/paa

C++ signature :
    void torsion_id(core::optimization::DOF_Node {lvalue},core::id::TorsionID)

type( (DOF_Node)arg1) -> DOF_Type : core/optimization/DOF_Node.hh:81

C++ signature : core::id::DOF_Type type(core::optimization::DOF_Node {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (DOF_NodeAP)arg1) -> DOF_Node :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (DOF_NodeCAP)arg1) -> DOF_Node :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (DerivCheckDataPoint)) -> None : core/optimization/NumericalDerivCheckResult.hh:33

C++ signature :
    void __init__(_object*,core::optimization::DerivCheckDataPoint)

init( (object)arg1, (float)num_deriv, (float)ana_deriv, (float)ratio, (float)f11, (float)f00, (float)f22, (float)dof_val) -> None : core/optimization/NumericalDerivCheckResult.hh:53

C++ signature :
    void __init__(_object*,double,double,double,double,double,double,double)

ana_deriv( (DerivCheckDataPoint)arg1) -> float : core/optimization/NumericalDerivCheckResult.hh:64

C++ signature : double ana_deriv(core::optimization::DerivCheckDataPoint {lvalue})

dof_val( (DerivCheckDataPoint)arg1) -> float : core/optimization/NumericalDerivCheckResult.hh:69

C++ signature : double dof_val(core::optimization::DerivCheckDataPoint {lvalue})

f00( (DerivCheckDataPoint)arg1) -> float : core/optimization/NumericalDerivCheckResult.hh:67

C++ signature : double f00(core::optimization::DerivCheckDataPoint {lvalue})

f11( (DerivCheckDataPoint)arg1) -> float : core/optimization/NumericalDerivCheckResult.hh:66

C++ signature : double f11(core::optimization::DerivCheckDataPoint {lvalue})

f22( (DerivCheckDataPoint)arg1) -> float : core/optimization/NumericalDerivCheckResult.hh:68

C++ signature : double f22(core::optimization::DerivCheckDataPoint {lvalue})

num_deriv( (DerivCheckDataPoint)arg1) -> float : core/optimization/NumericalDerivCheckResult.hh:63

C++ signature : double num_deriv(core::optimization::DerivCheckDataPoint {lvalue})

ratio( (DerivCheckDataPoint)arg1) -> float : core/optimization/NumericalDerivCheckResult.hh:65

C++ signature : double ratio(core::optimization::DerivCheckDataPoint {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (DerivCheckDataPointAP)arg1) -> DerivCheckDataPoint :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (DerivCheckDataPointCAP)arg1) -> DerivCheckDataPoint :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1, (Multifunc)) -> None : core/optimization/Minimizer.hh:95

C++ signature :
    void __init__(_object*,core::optimization::Multifunc)

init( (object)arg1, (DescentDirectionAlgorithm)) -> None : core/optimization/Minimizer.hh:93

C++ signature :
    void __init__(_object*,core::optimization::DescentDirectionAlgorithm)

initialize( (DescentDirectionAlgorithm)arg1) -> None : core/optimization/Minimizer.hh:97

C++ signature : void initialize(core::optimization::DescentDirectionAlgorithm {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (DescentDirectionAlgorithmAP)arg1) -> DescentDirectionAlgorithm :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (DescentDirectionAlgorithmCAP)arg1) -> DescentDirectionAlgorithm :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (EItem)) -> None : Inner class for Genetic Algorithm, hold one population with some additional info

C++ signature :
    void __init__(_object*,core::optimization::EItem)

init( (object)arg1, (vector1_Real)vn) -> None : core/optimization/GA_Minimizer.hh:35

C++ signature :
    void __init__(_object*,utility::vector1<double, std::allocator<double> >)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (EItemAP)arg1) -> EItem :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (EItemCAP)arg1) -> EItem :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1, (Multifunc)func_in, (MinimizerOptions)options) -> None : core/optimization/GA_Minimizer.hh:49

C++ signature :
    void __init__(_object*,core::optimization::Multifunc {lvalue},core::optimization::MinimizerOptions)

init( (object)arg1, (GA_Minimizer)) -> None : core/optimization/GA_Minimizer.hh:47

C++ signature :
    void __init__(_object*,core::optimization::GA_Minimizer)

run( (GA_Minimizer)arg1, (vector1_Real)phipsi_inout, (int)max_time) -> float : core/optimization/GA_Minimizer.hh:56

C++ signature : double run(core::optimization::GA_Minimizer {lvalue},utility::vector1 > {lvalue},int)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (GA_MinimizerAP)arg1) -> GA_Minimizer :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (GA_MinimizerCAP)arg1) -> GA_Minimizer :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1, (Multifunc)score_fxn, (LineMinimizationAlgorithm)line_min_alg, (ConvergenceTest)converge_test, (DescentDirectionAlgorithm)desc_dir) -> None : core/optimization/Minimizer.hh:112

C++ signature :
    void __init__(_object*,core::optimization::Multifunc,core::optimization::LineMinimizationAlgorithm {lvalue},core::optimization::ConvergenceTest {lvalue},core::optimization::DescentDirectionAlgorithm {lvalue})

init( (object)arg1, (JJH_Minimizer)) -> None : core/optimization/Minimizer.hh:106

C++ signature :
    void __init__(_object*,core::optimization::JJH_Minimizer)

run( (JJH_Minimizer)arg1, (vector1_Real)angles) -> float : core/optimization/Minimizer.hh:115

C++ signature : double run(core::optimization::JJH_Minimizer {lvalue},utility::vector1 > {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (JJH_MinimizerAP)arg1) -> JJH_Minimizer :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (JJH_MinimizerCAP)arg1) -> JJH_Minimizer :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1, (Multifunc)score_fxn, (int)dimension) -> None : core/optimization/LineMinimizer.hh:107

C++ signature :
    void __init__(_object*,core::optimization::Multifunc,unsigned long)

init( (object)arg1, (LineMinimizationAlgorithm)) -> None : ////////////////////////////////////////////////////// //////////////////////////////////////////////////////

C++ signature :
    void __init__(_object*,core::optimization::LineMinimizationAlgorithm)

cubic_interpolation( (LineMinimizationAlgorithm)arg1, (float)point1, (float)func1, (float)deriv1, (float)point2, (float)func2, (float)deriv2) -> float : core/optimization/LineMinimizer.hh:120

C++ signature : double cubic_interpolation(core::optimization::LineMinimizationAlgorithm {lvalue},double,double,double,double,double,double)

fetch_stored_derivatives( (LineMinimizationAlgorithm)arg1, (vector1_Real)get_derivs) -> None : core/optimization/LineMinimizer.hh:116

C++ signature : void fetch_stored_derivatives(core::optimization::LineMinimizationAlgorithm {lvalue},utility::vector1 > {lvalue})

nonmonotone( (LineMinimizationAlgorithm)arg1) -> bool : core/optimization/LineMinimizer.hh:114

C++ signature : bool nonmonotone(core::optimization::LineMinimizationAlgorithm {lvalue})

provide_stored_derivatives( (LineMinimizationAlgorithm)arg1) -> bool : core/optimization/LineMinimizer.hh:113

C++ signature :
    bool provide_stored_derivatives(core::optimization::LineMinimizationAlgorithm {lvalue})

provide_stored_derivatives( (LineMinimizationAlgorithm)arg1) -> bool :

C++ signature :
    bool provide_stored_derivatives(LineMinimizationAlgorithm_exposer_callback {lvalue})

quadratic_deriv_interpolation( (LineMinimizationAlgorithm)arg1, (float)point1, (float)func1, (float)deriv1, (float)point2, (float)func2, (float)deriv2) -> float : core/optimization/LineMinimizer.hh:118

C++ signature : double quadratic_deriv_interpolation(core::optimization::LineMinimizationAlgorithm {lvalue},double,double,double,double,double,double)

quadratic_interpolation( (LineMinimizationAlgorithm)arg1, (float)point1, (float)func1, (float)deriv1, (float)point2, (float)func2) -> float : core/optimization/LineMinimizer.hh:117

C++ signature : double quadratic_interpolation(core::optimization::LineMinimizationAlgorithm {lvalue},double,double,double,double,double)

secant_interpolation( (LineMinimizationAlgorithm)arg1, (float)point1, (float)deriv1, (float)point2, (float)deriv2) -> float : core/optimization/LineMinimizer.hh:119

C++ signature : double secant_interpolation(core::optimization::LineMinimizationAlgorithm {lvalue},double,double,double,double)

silent( (LineMinimizationAlgorithm)arg1) -> bool : core/optimization/LineMinimizer.hh:122

C++ signature :
    bool silent(core::optimization::LineMinimizationAlgorithm {lvalue})

silent( (LineMinimizationAlgorithm)arg1, (bool)s_in) -> None : core/optimization/LineMinimizer.hh:123

C++ signature :
    void silent(core::optimization::LineMinimizationAlgorithm {lvalue},bool)

store_current_derivatives( (LineMinimizationAlgorithm)arg1, (vector1_Real)curr_derivs) -> None : core/optimization/LineMinimizer.hh:115

C++ signature : void store_current_derivatives(core::optimization::LineMinimizationAlgorithm {lvalue},utility::vector1 > {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (LineMinimizationAlgorithmAP)arg1) -> LineMinimizationAlgorithm :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (LineMinimizationAlgorithmCAP)arg1) -> LineMinimizationAlgorithm :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1, (Multifunc)func_in, (MinimizerOptions)options_in) -> None : core/optimization/Minimizer.hh:142

C++ signature :
    void __init__(_object*,core::optimization::Multifunc {lvalue},core::optimization::MinimizerOptions)

init( (object)arg1, (Minimizer)) -> None : Simple low-level minimizer class

C++ signature :
    void __init__(_object*,core::optimization::Minimizer)

run( (Minimizer)arg1, (vector1_Real)phipsi_inout) -> float : core/optimization/Minimizer.hh:145

C++ signature : double run(core::optimization::Minimizer {lvalue},utility::vector1 > {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (MinimizerAP)arg1) -> Minimizer :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (MinimizerCAP)arg1) -> Minimizer :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (MinimizerMap)) -> None : core/optimization/MinimizerMap.hh:74

C++ signature :
    void __init__(_object*,core::optimization::MinimizerMap)

add_atom( (MinimizerMap)arg1, (AtomID)atom_id, (DOF_ID)dof_id) -> None : core/optimization/MinimizerMap.hh:119

C++ signature :
    void add_atom(core::optimization::MinimizerMap {lvalue},core::id::AtomID,core::id::DOF_ID)

add_atom( (MinimizerMap)arg1, (AtomID)atom_id, (DOF_ID)dof_id) -> None :

C++ signature :
    void add_atom(MinimizerMap_exposer_callback {lvalue},core::id::AtomID,core::id::DOF_ID)

add_torsion( (MinimizerMap)arg1, (DOF_ID)new_torsion, (DOF_ID)parent) -> None : core/optimization/MinimizerMap.hh:111

C++ signature :
    void add_torsion(core::optimization::MinimizerMap {lvalue},core::id::DOF_ID,core::id::DOF_ID)

add_torsion( (MinimizerMap)arg1, (DOF_ID)new_torsion, (DOF_ID)parent) -> None :

C++ signature :
    void add_torsion(MinimizerMap_exposer_callback {lvalue},core::id::DOF_ID,core::id::DOF_ID)

atom_derivatives( (MinimizerMap)arg1, (int)resid) -> object : core/optimization/MinimizerMap.hh:234

C++ signature : utility::vector1 > {lvalue} atom_derivatives(core::optimization::MinimizerMap {lvalue},unsigned long)

begin( (MinimizerMap)arg1) -> object : core/optimization/MinimizerMap.hh:123

C++ signature :
    std::_List_const_iterator<boost::shared_ptr<core::optimization::DOF_Node> > begin(core::optimization::MinimizerMap {lvalue})

begin( (MinimizerMap)arg1) -> object : core/optimization/MinimizerMap.hh:137

C++ signature :
    std::_List_iterator<boost::shared_ptr<core::optimization::DOF_Node> > begin(core::optimization::MinimizerMap {lvalue})

copy_dofs_from_pose( (MinimizerMap)arg1, (Pose)pose, (vector1_Real)dofs) -> None : core/optimization/MinimizerMap.hh:180

C++ signature : void copy_dofs_from_pose(core::optimization::MinimizerMap {lvalue},core::pose::Pose,utility::vector1 > {lvalue})

copy_dofs_to_pose( (MinimizerMap)arg1, (Pose)pose, (vector1_Real)dofs) -> None : core/optimization/MinimizerMap.hh:187

C++ signature : void copy_dofs_to_pose(core::optimization::MinimizerMap {lvalue},core::pose::Pose {lvalue},utility::vector1 >)

dof_node_from_id( (MinimizerMap)arg1, (DOF_ID)id) -> DOF_Node : get a dof_node by its dof_id

C++ signature : boost::shared_ptr dof_node_from_id(core::optimization::MinimizerMap {lvalue},core::id::DOF_ID)

dof_nodes( (MinimizerMap)arg1) -> object : core/optimization/MinimizerMap.hh:151

C++ signature :
    std::list<boost::shared_ptr<core::optimization::DOF_Node>, std::allocator<boost::shared_ptr<core::optimization::DOF_Node> > > dof_nodes(core::optimization::MinimizerMap {lvalue})

dof_nodes( (MinimizerMap)arg1) -> object : core/optimization/MinimizerMap.hh:158

C++ signature :
    std::list<boost::shared_ptr<core::optimization::DOF_Node>, std::allocator<boost::shared_ptr<core::optimization::DOF_Node> > > {lvalue} dof_nodes(core::optimization::MinimizerMap {lvalue})

domain_map( (MinimizerMap)arg1) -> object : core/optimization/MinimizerMap.hh:213

C++ signature :
    ObjexxFCL::FArray1D<int> domain_map(core::optimization::MinimizerMap {lvalue})

domain_map( (MinimizerMap)arg1) -> object :

C++ signature :
    ObjexxFCL::FArray1D<int> domain_map(MinimizerMap_exposer_callback {lvalue})

end( (MinimizerMap)arg1) -> object : core/optimization/MinimizerMap.hh:130

C++ signature :
    std::_List_const_iterator<boost::shared_ptr<core::optimization::DOF_Node> > end(core::optimization::MinimizerMap {lvalue})

end( (MinimizerMap)arg1) -> object : core/optimization/MinimizerMap.hh:144

C++ signature :
    std::_List_iterator<boost::shared_ptr<core::optimization::DOF_Node> > end(core::optimization::MinimizerMap {lvalue})

link_torsion_vectors( (MinimizerMap)arg1) -> None : this will only work if DOF_nodes are sorted!

C++ signature : void link_torsion_vectors(core::optimization::MinimizerMap {lvalue})

nangles( (MinimizerMap)arg1) -> int : core/optimization/MinimizerMap.hh:192

C++ signature : int nangles(core::optimization::MinimizerMap {lvalue})

reset( (MinimizerMap)arg1, (Pose)pose) -> None : clears old data+dimensions dof_node_pointer using size data from the pose

C++ signature : void reset(core::optimization::MinimizerMap {lvalue},core::pose::Pose)

reset_jump_rb_deltas( (MinimizerMap)arg1, (Pose)pose, (vector1_Real)dofs) -> None : core/optimization/MinimizerMap.hh:202

C++ signature : void reset_jump_rb_deltas(core::optimization::MinimizerMap {lvalue},core::pose::Pose {lvalue},utility::vector1 > {lvalue})

setup( (MinimizerMap)arg1, (Pose)pose, (MoveMap)move_map) -> None : core/optimization/MinimizerMap.hh:103

C++ signature : void setup(core::optimization::MinimizerMap {lvalue},core::pose::Pose {lvalue},core::kinematics::MoveMap)

torsion_scale_factor( (MinimizerMap)arg1, (DOF_Node)tor) -> float : core/optimization/MinimizerMap.hh:208

C++ signature : double torsion_scale_factor(core::optimization::MinimizerMap {lvalue},core::optimization::DOF_Node)

zero_torsion_vectors( (MinimizerMap)arg1) -> None : core/optimization/MinimizerMap.hh:169

C++ signature : void zero_torsion_vectors(core::optimization::MinimizerMap {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (MinimizerMapAP)arg1) -> MinimizerMap :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (MinimizerMapCAP)arg1) -> MinimizerMap :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1, (str)min_type_in, (float)minimize_tolerance_in, (bool)use_nblist_in [, (bool)deriv_check_in=False [, (bool)deriv_check_verbose_in=False]]) -> None : //////////////////////////////////////////////////////////////////////////

C++ signature :
    void __init__(_object*,std::string,double,bool [,bool=False [,bool=False]])

init( (object)arg1, (MinimizerOptions)) -> None : core/optimization/MinimizerOptions.hh:31

C++ signature :
    void __init__(_object*,core::optimization::MinimizerOptions)

ax_init( (MinimizerOptions)arg1) -> float : //////////////////////////////////////////////////////////////////////////

C++ signature : double ax_init(core::optimization::MinimizerOptions {lvalue})

brent_abs_tolerance( (MinimizerOptions)arg1) -> float : core/optimization/MinimizerOptions.hh:154

C++ signature : double brent_abs_tolerance(core::optimization::MinimizerOptions {lvalue})

bx_init( (MinimizerOptions)arg1) -> float : core/optimization/MinimizerOptions.hh:149

C++ signature : double bx_init(core::optimization::MinimizerOptions {lvalue})

clone( (MinimizerOptions)arg1) -> MinimizerOptions : core/optimization/MinimizerOptions.hh:51

C++ signature : boost::shared_ptr clone(core::optimization::MinimizerOptions {lvalue})

deriv_check( (MinimizerOptions)arg1, (bool)deriv_check_in) -> None : core/optimization/MinimizerOptions.hh:67

C++ signature :
    void deriv_check(core::optimization::MinimizerOptions {lvalue},bool)

deriv_check( (MinimizerOptions)arg1) -> bool : core/optimization/MinimizerOptions.hh:73

C++ signature :
    bool deriv_check(core::optimization::MinimizerOptions {lvalue})

deriv_check_to_stdout( (MinimizerOptions)arg1, (bool)setting) -> None : core/optimization/MinimizerOptions.hh:70

C++ signature :
    void deriv_check_to_stdout(core::optimization::MinimizerOptions {lvalue},bool)

deriv_check_to_stdout( (MinimizerOptions)arg1) -> bool : core/optimization/MinimizerOptions.hh:79

C++ signature :
    bool deriv_check_to_stdout(core::optimization::MinimizerOptions {lvalue})

deriv_check_verbose( (MinimizerOptions)arg1) -> bool : core/optimization/MinimizerOptions.hh:76

C++ signature : bool deriv_check_verbose(core::optimization::MinimizerOptions {lvalue})

ga_mutation_probability( (MinimizerOptions)arg1) -> float : core/optimization/MinimizerOptions.hh:159

C++ signature :
    double ga_mutation_probability(core::optimization::MinimizerOptions {lvalue})

ga_mutation_probability( (MinimizerOptions)arg1, (float)p) -> None : core/optimization/MinimizerOptions.hh:160

C++ signature :
    void ga_mutation_probability(core::optimization::MinimizerOptions {lvalue},double)

gmax_cutoff_for_convergence( (MinimizerOptions)arg1) -> float : core/optimization/MinimizerOptions.hh:133

C++ signature :
    double gmax_cutoff_for_convergence(core::optimization::MinimizerOptions {lvalue})

gmax_cutoff_for_convergence( (MinimizerOptions)arg1, (float)gmax_in) -> None : core/optimization/MinimizerOptions.hh:136

C++ signature :
    void gmax_cutoff_for_convergence(core::optimization::MinimizerOptions {lvalue},double)

max_iter( (MinimizerOptions)arg1) -> int : core/optimization/MinimizerOptions.hh:156

C++ signature :
    int max_iter(core::optimization::MinimizerOptions {lvalue})

max_iter( (MinimizerOptions)arg1, (int)n) -> None : core/optimization/MinimizerOptions.hh:157

C++ signature :
    void max_iter(core::optimization::MinimizerOptions {lvalue},int)

min_type( (MinimizerOptions)arg1) -> str : //////////////////////////////////////////////////////////////////////////

C++ signature :
    std::string min_type(core::optimization::MinimizerOptions {lvalue})

min_type( (MinimizerOptions)arg1, (str)min_type_in) -> None : core/optimization/MinimizerOptions.hh:61

C++ signature :
    void min_type(core::optimization::MinimizerOptions {lvalue},std::string)

min_type( (MinimizerOptions)arg1) -> str : core/optimization/MinimizerOptions.hh:64

C++ signature :
    std::string {lvalue} min_type(core::optimization::MinimizerOptions {lvalue})

minimize_tolerance( (MinimizerOptions)arg1) -> float : core/optimization/MinimizerOptions.hh:83

C++ signature :
    double minimize_tolerance(core::optimization::MinimizerOptions {lvalue})

minimize_tolerance( (MinimizerOptions)arg1) -> float : core/optimization/MinimizerOptions.hh:86

C++ signature :
    double {lvalue} minimize_tolerance(core::optimization::MinimizerOptions {lvalue})

minimize_tolerance( (MinimizerOptions)arg1, (float)minimize_tolerance_in) -> None : core/optimization/MinimizerOptions.hh:89

C++ signature :
    void minimize_tolerance(core::optimization::MinimizerOptions {lvalue},double)

nblist_auto_update( (MinimizerOptions)arg1) -> bool : core/optimization/MinimizerOptions.hh:121

C++ signature :
    bool nblist_auto_update(core::optimization::MinimizerOptions {lvalue})

nblist_auto_update( (MinimizerOptions)arg1, (bool)setting) -> None : core/optimization/MinimizerOptions.hh:124

C++ signature :
    void nblist_auto_update(core::optimization::MinimizerOptions {lvalue},bool)

silent( (MinimizerOptions)arg1) -> bool : core/optimization/MinimizerOptions.hh:127

C++ signature :
    bool silent(core::optimization::MinimizerOptions {lvalue})

silent( (MinimizerOptions)arg1, (bool)silent_in) -> None : core/optimization/MinimizerOptions.hh:130

C++ signature :
    void silent(core::optimization::MinimizerOptions {lvalue},bool)

use_nblist( (MinimizerOptions)arg1) -> bool : Indicate whether or not a handful of optimizations regarding the neighbor list have been enabled. @copydetails use_nblist()

C++ signature :
    bool use_nblist(core::optimization::MinimizerOptions {lvalue})

use_nblist( (MinimizerOptions)arg1, (bool)use_nblist_in) -> None : Indicate whether or not a handful of optimizations regarding the neighbor list should be enabled. The neighbor list is based on the move map. It includes any atoms that can be moved by the minimizer plus their neighbors. This list is not updated during minimization. All scores for atoms and atom pairs outside the neighbor list are held fixed. All scores for atoms and atom pairs within the list are not cached (usually they would be), since it assumed that they will be changing rapidly. These optimizations are effective when a large number of small moves are being made. You may prefer to enable this option when minimizing in fullatom mode, and to disable it in centroid mode. I wrote this docstring after I reading through a bunch of code to figure out what this option meant, but I don't have any expertise with the minimizer. So the above represents my understanding of this option, but there could very well be errors or misstatements. @see core::scoring::AtomNeighbor

C++ signature :
    void use_nblist(core::optimization::MinimizerOptions {lvalue},bool)

xx_init( (MinimizerOptions)arg1) -> float : core/optimization/MinimizerOptions.hh:146

C++ signature : double xx_init(core::optimization::MinimizerOptions {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (MinimizerOptionsAP)arg1) -> MinimizerOptions :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (MinimizerOptionsCAP)arg1) -> MinimizerOptions :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

abort_min( (Multifunc)arg1, (vector1_Real)) -> bool : Christophe added the following to allow premature end of minimization If you want to abort the minimizer under specific circonstances overload this function and return true if you want to stop, false if you want to continue. FOR THE MOMENT, ONLY IN DFPMIN!

C++ signature : bool abort_min(core::optimization::Multifunc {lvalue},utility::vector1 >)

dfunc( (Multifunc)arg1, (vector1_Real)phipsi, (vector1_Real)dE_dphipsi) -> None : core/optimization/Multifunc.hh:86

C++ signature :
    void dfunc(core::optimization::Multifunc {lvalue},utility::vector1<double, std::allocator<double> >,utility::vector1<double, std::allocator<double> > {lvalue})

dfunc( (Multifunc)arg1, (vector1_Real)arg2, (vector1_Real)arg3) -> None :

C++ signature :
    void dfunc(boost::shared_ptr<core::optimization::Multifunc> {lvalue},utility::vector1<double, std::allocator<double> >,utility::vector1<double, std::allocator<double> > {lvalue})

dump( (Multifunc)arg1, (vector1_Real), (vector1_Real)) -> None : Error state reached -- derivative does not match gradient Derived classes have the oportunity to now output and or analyze the two vars assignments vars, vars+delta where the derivatives are incorrect.

C++ signature : void dump(core::optimization::Multifunc {lvalue},utility::vector1 >,utility::vector1 >)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (MultifuncAP)arg1) -> Multifunc :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (MultifuncCAP)arg1) -> Multifunc :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1, (Multifunc)func_in, (MinimizerOptions)options_in) -> None : core/optimization/NelderMeadSimplex.hh:31

C++ signature :
    void __init__(_object*,core::optimization::Multifunc {lvalue},core::optimization::MinimizerOptions)

init( (object)arg1, (NelderMeadSimplex)) -> None : core/optimization/NelderMeadSimplex.hh:29

C++ signature :
    void __init__(_object*,core::optimization::NelderMeadSimplex)

run( (NelderMeadSimplex)arg1, (vector1_Real)phipsi_inout, (vector1_Real)upperbound) -> float : core/optimization/NelderMeadSimplex.hh:37

C++ signature : double run(core::optimization::NelderMeadSimplex {lvalue},utility::vector1 > {lvalue},utility::vector1 >)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (NelderMeadSimplexAP)arg1) -> NelderMeadSimplex :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (NelderMeadSimplexCAP)arg1) -> NelderMeadSimplex :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1, (int)nangles, (int)nsteps) -> None : core/optimization/NumericalDerivCheckResult.hh:199

C++ signature :
    void __init__(_object*,unsigned long,unsigned long)

init( (object)arg1, (NumDerivCheckData)) -> None : core/optimization/NumericalDerivCheckResult.hh:194

C++ signature :
    void __init__(_object*,core::optimization::NumDerivCheckData)

dof_step_data( (NumDerivCheckData)arg1, (int)dof_ind, (int)step_ind, (DOF_DataPoint)dofdp) -> None : core/optimization/NumericalDerivCheckResult.hh:210

C++ signature :
    void dof_step_data(core::optimization::NumDerivCheckData {lvalue},unsigned long,unsigned long,core::optimization::DOF_DataPoint)

dof_step_data( (NumDerivCheckData)arg1, (int)dof_ind, (int)step_ind) -> DOF_DataPoint : core/optimization/NumericalDerivCheckResult.hh:215

C++ signature :
    core::optimization::DOF_DataPoint dof_step_data(core::optimization::NumDerivCheckData {lvalue},unsigned long,unsigned long)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (NumDerivCheckDataAP)arg1) -> NumDerivCheckData :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (NumDerivCheckDataCAP)arg1) -> NumDerivCheckData :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (NumericalDerivCheckResult)) -> None : core/optimization/NumericalDerivCheckResult.hh:223

C++ signature :
    void __init__(_object*,core::optimization::NumericalDerivCheckResult)

add_deriv_data( (NumericalDerivCheckResult)arg1, (NumDerivCheckData)deriv_check_data) -> None : core/optimization/NumericalDerivCheckResult.hh:236

C++ signature : void add_deriv_data(core::optimization::NumericalDerivCheckResult {lvalue},boost::shared_ptr)

deriv_check_result( (NumericalDerivCheckResult)arg1, (int)ind) -> NumDerivCheckData : core/optimization/NumericalDerivCheckResult.hh:241

C++ signature : core::optimization::NumDerivCheckData deriv_check_result(core::optimization::NumericalDerivCheckResult {lvalue},unsigned long)

n_deriv_check_results( (NumericalDerivCheckResult)arg1) -> int : core/optimization/NumericalDerivCheckResult.hh:238

C++ signature : unsigned long n_deriv_check_results(core::optimization::NumericalDerivCheckResult {lvalue})

send_to_stdout( (NumericalDerivCheckResult)arg1, (bool)setting) -> None : core/optimization/NumericalDerivCheckResult.hh:231

C++ signature :
    void send_to_stdout(core::optimization::NumericalDerivCheckResult {lvalue},bool)

send_to_stdout( (NumericalDerivCheckResult)arg1) -> bool : core/optimization/NumericalDerivCheckResult.hh:232

C++ signature :
    bool send_to_stdout(core::optimization::NumericalDerivCheckResult {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (NumericalDerivCheckResultAP)arg1) -> NumericalDerivCheckResult :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (NumericalDerivCheckResultCAP)arg1) -> NumericalDerivCheckResult :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1, (int)size) -> None : core/optimization/ParticleSwarmMinimizer.hh:37

C++ signature :
    void __init__(_object*,unsigned long)

init( (object)arg1, (Particle)) -> None : Simple data container for PSO algorithm.

C++ signature :
    void __init__(_object*,core::optimization::Particle)

init( (object)arg1, (vector1_Real)p_in) -> None : core/optimization/ParticleSwarmMinimizer.hh:46

C++ signature :
    void __init__(_object*,utility::vector1<double, std::allocator<double> >)

ensure_size( (Particle)arg1, (int)minsize) -> None : Make sure that all arrays are large enough -- prevents index-out-of-bound errors.

C++ signature : void ensure_size(core::optimization::Particle {lvalue},unsigned long)

fitness_pbest( (Particle)arg1) -> float : core/optimization/ParticleSwarmMinimizer.hh:100

C++ signature : double fitness_pbest(core::optimization::Particle {lvalue})

pbest( (Particle)arg1) -> vector1_Real : This is why data should be private: you get to ensure it's valid when you read it.

C++ signature : utility::vector1 > pbest(core::optimization::Particle {lvalue})

score( (Particle)arg1, (Multifunc)f) -> float : core/optimization/ParticleSwarmMinimizer.hh:57

C++ signature : double score(core::optimization::Particle {lvalue},core::optimization::Multifunc {lvalue})

set_score( (Particle)arg1, (float)new_score) -> float : core/optimization/ParticleSwarmMinimizer.hh:70

C++ signature : double set_score(core::optimization::Particle {lvalue},double {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (ParticleAP)arg1) -> Particle :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (ParticleCAP)arg1) -> Particle :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1, (vector1_Real)p_min, (vector1_Real)p_max) -> None : core/optimization/ParticleSwarmMinimizer.hh:137

C++ signature :
    void __init__(_object*,utility::vector1<double, std::allocator<double> >,utility::vector1<double, std::allocator<double> >)

init( (object)arg1, (ParticleSwarmMinimizer)) -> None : Particle Swarm Optimization engine. Algorithm details based heavily on Chen, Liu, Huang, Hwang, Ho (2006). "SODOCK: Swarm Optimization for Highly Flexible Protein-Ligand Docking" J Comput Chem 28: 612-623, 2007 Also on http://en.wikipedia.org/wiki/Particle_swarm_optimization http://www.swarmintelligence.org/ One can imagine writing another version that distributed the work via MPI...

C++ signature :
    void __init__(_object*,core::optimization::ParticleSwarmMinimizer)

print_particles( (ParticleSwarmMinimizer)arg1, (object)particles, (str)header) -> None : core/optimization/ParticleSwarmMinimizer.hh:143

C++ signature : void print_particles(core::optimization::ParticleSwarmMinimizer {lvalue},utility::vector1, std::allocator > > {lvalue},std::string)

run( (ParticleSwarmMinimizer)arg1, (int)num_cycles, (Multifunc)f_fitness [, (int)num_part=50]) -> object : core/optimization/ParticleSwarmMinimizer.hh:140

C++ signature :
    utility::vector1<boost::shared_ptr<core::optimization::Particle>, std::allocator<boost::shared_ptr<core::optimization::Particle> > > run(core::optimization::ParticleSwarmMinimizer {lvalue},unsigned long,core::optimization::Multifunc {lvalue} [,unsigned long=50])

run( (ParticleSwarmMinimizer)arg1, (int)num_cycles, (Multifunc)f_fitness, (int)num_part, (vector1_Real)init_values) -> object : core/optimization/ParticleSwarmMinimizer.hh:141

C++ signature :
    utility::vector1<boost::shared_ptr<core::optimization::Particle>, std::allocator<boost::shared_ptr<core::optimization::Particle> > > run(core::optimization::ParticleSwarmMinimizer {lvalue},unsigned long,core::optimization::Multifunc {lvalue},unsigned long,utility::vector1<double, std::allocator<double> >)

run( (ParticleSwarmMinimizer)arg1, (int)num_cycles, (Multifunc)f_fitness, (object)particles) -> None : core/optimization/ParticleSwarmMinimizer.hh:142

C++ signature :
    void run(core::optimization::ParticleSwarmMinimizer {lvalue},unsigned long,core::optimization::Multifunc {lvalue},utility::vector1<boost::shared_ptr<core::optimization::Particle>, std::allocator<boost::shared_ptr<core::optimization::Particle> > > {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (ParticleSwarmMinimizerAP)arg1) -> ParticleSwarmMinimizer :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (ParticleSwarmMinimizerCAP)arg1) -> ParticleSwarmMinimizer :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1, (int)nangles, (int)nsteps) -> None : core/optimization/NumericalDerivCheckResult.hh:85

C++ signature :
    void __init__(_object*,unsigned long,unsigned long)

init( (object)arg1, (SimpleDerivCheckResult)) -> None : core/optimization/NumericalDerivCheckResult.hh:81

C++ signature :
    void __init__(_object*,core::optimization::SimpleDerivCheckResult)

abs_deriv_dev( (SimpleDerivCheckResult)arg1, (int)dof_ind, (float)val) -> None : core/optimization/NumericalDerivCheckResult.hh:98

C++ signature :
    void abs_deriv_dev(core::optimization::SimpleDerivCheckResult {lvalue},unsigned long,double)

abs_deriv_dev( (SimpleDerivCheckResult)arg1, (int)dof_ind) -> float : core/optimization/NumericalDerivCheckResult.hh:108

C++ signature :
    double abs_deriv_dev(core::optimization::SimpleDerivCheckResult {lvalue},unsigned long)

best_abs_log_norm_ratio( (SimpleDerivCheckResult)arg1, (float)val) -> None : core/optimization/NumericalDerivCheckResult.hh:102

C++ signature :
    void best_abs_log_norm_ratio(core::optimization::SimpleDerivCheckResult {lvalue},double)

best_abs_log_norm_ratio( (SimpleDerivCheckResult)arg1) -> float : core/optimization/NumericalDerivCheckResult.hh:112

C++ signature :
    double best_abs_log_norm_ratio(core::optimization::SimpleDerivCheckResult {lvalue})

best_cos_theta( (SimpleDerivCheckResult)arg1, (float)val) -> None : core/optimization/NumericalDerivCheckResult.hh:101

C++ signature :
    void best_cos_theta(core::optimization::SimpleDerivCheckResult {lvalue},double)

best_cos_theta( (SimpleDerivCheckResult)arg1) -> float : core/optimization/NumericalDerivCheckResult.hh:111

C++ signature :
    double best_cos_theta(core::optimization::SimpleDerivCheckResult {lvalue})

best_norm_analytic( (SimpleDerivCheckResult)arg1, (float)val) -> None : core/optimization/NumericalDerivCheckResult.hh:103

C++ signature :
    void best_norm_analytic(core::optimization::SimpleDerivCheckResult {lvalue},double)

best_norm_analytic( (SimpleDerivCheckResult)arg1) -> float : core/optimization/NumericalDerivCheckResult.hh:113

C++ signature :
    double best_norm_analytic(core::optimization::SimpleDerivCheckResult {lvalue})

best_norm_numeric( (SimpleDerivCheckResult)arg1, (float)val) -> None : core/optimization/NumericalDerivCheckResult.hh:104

C++ signature :
    void best_norm_numeric(core::optimization::SimpleDerivCheckResult {lvalue},double)

best_norm_numeric( (SimpleDerivCheckResult)arg1) -> float : core/optimization/NumericalDerivCheckResult.hh:114

C++ signature :
    double best_norm_numeric(core::optimization::SimpleDerivCheckResult {lvalue})

nangles( (SimpleDerivCheckResult)arg1) -> int : core/optimization/NumericalDerivCheckResult.hh:95

C++ signature : unsigned long nangles(core::optimization::SimpleDerivCheckResult {lvalue})

nsteps( (SimpleDerivCheckResult)arg1) -> int : core/optimization/NumericalDerivCheckResult.hh:96

C++ signature : unsigned long nsteps(core::optimization::SimpleDerivCheckResult {lvalue})

rel_deriv_dev( (SimpleDerivCheckResult)arg1, (int)dof_ind, (float)val) -> None : core/optimization/NumericalDerivCheckResult.hh:99

C++ signature :
    void rel_deriv_dev(core::optimization::SimpleDerivCheckResult {lvalue},unsigned long,double)

rel_deriv_dev( (SimpleDerivCheckResult)arg1, (int)dof_ind) -> float : core/optimization/NumericalDerivCheckResult.hh:109

C++ signature :
    double rel_deriv_dev(core::optimization::SimpleDerivCheckResult {lvalue},unsigned long)

step_data( (SimpleDerivCheckResult)arg1, (int)dof_ind, (int)step_ind, (DerivCheckDataPoint)dp) -> None : core/optimization/NumericalDerivCheckResult.hh:106

C++ signature :
    void step_data(core::optimization::SimpleDerivCheckResult {lvalue},unsigned long,unsigned long,core::optimization::DerivCheckDataPoint)

step_data( (SimpleDerivCheckResult)arg1, (int)dof_ind, (int)step_ind) -> DerivCheckDataPoint : core/optimization/NumericalDerivCheckResult.hh:116

C++ signature :
    core::optimization::DerivCheckDataPoint step_data(core::optimization::SimpleDerivCheckResult {lvalue},unsigned long,unsigned long)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (SimpleDerivCheckResultAP)arg1) -> SimpleDerivCheckResult :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (SimpleDerivCheckResultCAP)arg1) -> SimpleDerivCheckResult :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1, (Pose)pose_in, (int)rsd_id_in, (MinimizerMap)min_map_in, (ScoreFunction)scorefxn_in, (CPP_Graph)packer_neighbor_graph_in [, (bool)deriv_check_in=False [, (bool)deriv_check_verbose_in=False]]) -> None : core/optimization/SingleResidueMultifunc.hh:56

C++ signature :
    void __init__(_object*,core::pose::Pose {lvalue},unsigned long,core::optimization::MinimizerMap {lvalue},core::scoring::ScoreFunction,boost::shared_ptr<core::graph::Graph const> [,bool=False [,bool=False]])

init( (object)arg1, (SingleResidueMultifunc)) -> None : A streamlined AtomTreeMultifunc designed specifically for RTMIN. Evaluates only the energies between the specified residue and the rest of the Pose, assuming the nbr_atoms do not move (as in rotamer trials and repacking). Could probably be sped up further with a customized dfunc(). DFPMIN seems to spend most of its time in func() rather than dfunc(), so there's not as much to gain there anyway.

C++ signature :
    void __init__(_object*,core::optimization::SingleResidueMultifunc)

abort_min( (SingleResidueMultifunc)arg1, (vector1_Real)) -> bool : Christophe added the following to allow premature end of minimization If you want to abort the minimizer under specific circonstances overload this function and return true if you want to stop, false if you want to continue. FOR THE MOMENT, ONLY IN DFPMIN!

C++ signature :
    bool abort_min(core::optimization::SingleResidueMultifunc {lvalue},utility::vector1<double, std::allocator<double> >)

abort_min( (SingleResidueMultifunc)arg1, (vector1_Real)) -> bool :

C++ signature :
    bool abort_min(SingleResidueMultifunc_exposer_callback {lvalue},utility::vector1<double, std::allocator<double> >)

dfunc( (SingleResidueMultifunc)arg1, (vector1_Real)vars, (vector1_Real)dE_dvars) -> None : core/optimization/AtomTreeMultifunc.hh:61

C++ signature :
    void dfunc(core::optimization::SingleResidueMultifunc {lvalue},utility::vector1<double, std::allocator<double> >,utility::vector1<double, std::allocator<double> > {lvalue})

dfunc( (SingleResidueMultifunc)arg1, (vector1_Real)vars, (vector1_Real)dE_dvars) -> None :

C++ signature :
    void dfunc(SingleResidueMultifunc_exposer_callback {lvalue},utility::vector1<double, std::allocator<double> >,utility::vector1<double, std::allocator<double> > {lvalue})

dump( (SingleResidueMultifunc)arg1, (vector1_Real)vars, (vector1_Real)vars2) -> None : Error state reached -- derivative does not match gradient

C++ signature :
    void dump(core::optimization::SingleResidueMultifunc {lvalue},utility::vector1<double, std::allocator<double> >,utility::vector1<double, std::allocator<double> >)

dump( (SingleResidueMultifunc)arg1, (vector1_Real)vars, (vector1_Real)vars2) -> None :

C++ signature :
    void dump(SingleResidueMultifunc_exposer_callback {lvalue},utility::vector1<double, std::allocator<double> >,utility::vector1<double, std::allocator<double> >)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (SingleResidueMultifuncAP)arg1) -> SingleResidueMultifunc :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (SingleResidueMultifuncCAP)arg1) -> SingleResidueMultifunc :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1, (Multifunc)score_fxn, (bool)nonmonotone, (int)dim) -> None : core/optimization/LineMinimizer.hh:184

C++ signature :
    void __init__(_object*,core::optimization::Multifunc,bool,unsigned long)

init( (object)arg1, (StrongWolfeLineMinimization)) -> None : ////////////////////////////////////////////////////// //////////////////////////////////////////////////////

C++ signature :
    void __init__(_object*,core::optimization::StrongWolfeLineMinimization)

StrongWolfe( (StrongWolfeLineMinimization)arg1, (float)init_step, (func_1d)func_eval) -> float : core/optimization/LineMinimizer.hh:190

C++ signature : double StrongWolfe(core::optimization::StrongWolfeLineMinimization {lvalue},double,core::optimization::func_1d {lvalue})

provide_stored_derivatives( (StrongWolfeLineMinimization)arg1) -> bool : core/optimization/LineMinimizer.hh:188

C++ signature :
    bool provide_stored_derivatives(core::optimization::StrongWolfeLineMinimization {lvalue})

provide_stored_derivatives( (StrongWolfeLineMinimization)arg1) -> bool :

C++ signature :
    bool provide_stored_derivatives(StrongWolfeLineMinimization_exposer_callback {lvalue})

zoom( (StrongWolfeLineMinimization)arg1, (float)alpha_low, (float)func_low, (float)deriv_low, (float)alpha_high, (float)func_high, (float)deriv_high, (float)func_zero, (float)deriv_zero, (float)func_return, (func_1d)func_eval) -> float : core/optimization/LineMinimizer.hh:192

C++ signature : double zoom(core::optimization::StrongWolfeLineMinimization {lvalue},double,double,double,double,double,double,double,double,double {lvalue},core::optimization::func_1d {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (StrongWolfeLineMinimizationAP)arg1) -> StrongWolfeLineMinimization :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (StrongWolfeLineMinimizationCAP)arg1) -> StrongWolfeLineMinimization :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1, (vector1_Real)start, (vector1_Real)dir, (Multifunc)score_fxn) -> None : core/optimization/LineMinimizer.hh:51

C++ signature :
    void __init__(_object*,utility::vector1<double, std::allocator<double> > {lvalue},utility::vector1<double, std::allocator<double> > {lvalue},core::optimization::Multifunc)

init( (object)arg1, (func_1d)) -> None : core/optimization/LineMinimizer.hh:38

C++ signature :
    void __init__(_object*,core::optimization::func_1d)

dfunc( (func_1d)arg1, (float)displacement) -> float : core/optimization/LineMinimizer.hh:77

C++ signature : double dfunc(core::optimization::func_1d {lvalue},double)

dump( (func_1d)arg1, (float)displacement) -> None : Error condition wherein the computed gradient does not match the actual gradient; invokes the Multifunc::dump( vars, vars2 ) method.

C++ signature : void dump(core::optimization::func_1d {lvalue},double)

get_deriv_count( (func_1d)arg1) -> int : core/optimization/LineMinimizer.hh:93

C++ signature : int get_deriv_count(core::optimization::func_1d {lvalue})

get_eval_count( (func_1d)arg1) -> int : core/optimization/LineMinimizer.hh:92

C++ signature : int get_eval_count(core::optimization::func_1d {lvalue})

reset_eval_count( (func_1d)arg1) -> None : core/optimization/LineMinimizer.hh:91

C++ signature : void reset_eval_count(core::optimization::func_1d {lvalue})

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (func_1dAP)arg1) -> func_1d :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (func_1dCAP)arg1) -> func_1d :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (lbfgs_iteration_dataAP)arg1) -> lbfgs_iteration_data :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

get( (lbfgs_iteration_dataCAP)arg1) -> lbfgs_iteration_data :

C++ signature : boost::shared_ptr get(boost::weak_ptr)