enhanace KNITRO implementation

Author: eminyouskn

include/pyoptinterface/knitro_model.hpp

@@ -475,6 +475,14 @@ class KNITROModel : public OnesideLinearConstraintMixin<KNITROModel>,
 	double get_mip_relative_gap() const;
 	double get_solve_time() const;
 
+	// Model state
+	bool dirty() const;
+	bool empty() const;
+
+	// Solve status
+	int get_solve_status() const;
+
+	// Parameter management
 	template <typename T>
 	void set_raw_parameter(const std::string &name, T value)
 	{
@@ -539,31 +547,33 @@ class KNITROModel : public OnesideLinearConstraintMixin<KNITROModel>,
 
 	// Internal helpers
 	void _check_error(int error) const;
+	void _mark_dirty();
+	void _unmark_dirty();
 	void _check_dirty() const;
 	KNINT _variable_index(const VariableIndex &variable) const;
 	KNINT _constraint_index(const ConstraintIndex &constraint) const;
 
-	// Member variables
-	std::shared_ptr<LM_context> m_lm = nullptr;
-	std::unique_ptr<KN_context, KNITROFreeProblemT> m_kc = nullptr;
-
 	size_t n_vars = 0;
 	size_t n_cons = 0;
 	size_t n_lincons = 0;
 	size_t n_quadcons = 0;
 	size_t n_coniccons = 0;
 	size_t n_nlcons = 0;
 
+  private:
+	// Member variables
+	std::shared_ptr<LM_context> m_lm = nullptr;
+	std::unique_ptr<KN_context, KNITROFreeProblemT> m_kc = nullptr;
+
 	std::unordered_map<KNINT, std::variant<KNINT, std::pair<KNINT, KNINT>>> m_soc_aux_cons;
 	std::unordered_map<KNINT, uint8_t> m_con_sense_flags;
 	uint8_t m_obj_flag = 0;
 
 	std::unordered_map<ExpressionGraph *, Outputs> m_pending_outputs;
 	std::vector<std::unique_ptr<CallbackEvaluator<double>>> m_evaluators;
 	bool m_need_to_add_callbacks = false;
-
-	bool m_is_dirty = true;
 	int m_solve_status = 0;
+	bool m_is_dirty = true;
 
   private:
 	void _init();
@@ -590,19 +600,6 @@ class KNITROModel : public OnesideLinearConstraintMixin<KNITROModel>,
 	void _solve();
 	void _post_solve();
 
-	template <typename F>
-	void _init_impl(const F &ctor)
-	{
-		if (!knitro::is_library_loaded())
-		{
-			throw std::runtime_error("KNITRO library not loaded");
-		}
-		KN_context *kc = nullptr;
-		int error = ctor(&kc);
-		_check_error(error);
-		m_kc = std::unique_ptr<KN_context, KNITROFreeProblemT>(kc);
-	}
-
 	template <typename F>
 	ConstraintIndex _add_constraint_impl(ConstraintType type,
 	                                     const std::tuple<double, double> &interval,

lib/knitro_model.cpp

@@ -184,7 +184,7 @@ VariableIndex KNITROModel::add_variable(VariableDomain domain, double lb, double
 	}
 
 	n_vars++;
-	m_is_dirty = true;
+	_mark_dirty();
 
 	return variable;
 }
@@ -267,7 +267,7 @@ void KNITROModel::set_variable_domain(const VariableIndex &variable, VariableDom
 		_set_value<KNINT, double>(knitro::KN_set_var_upbnd, indexVar, ub);
 	}
 
-	m_is_dirty = true;
+	_mark_dirty();
 }
 
 double KNITROModel::get_variable_rc(const VariableIndex &variable) const
@@ -285,7 +285,7 @@ void KNITROModel::delete_variable(const VariableIndex &variable)
 	_set_value<KNINT, double>(knitro::KN_set_var_lobnd, indexVar, -get_infinity());
 	_set_value<KNINT, double>(knitro::KN_set_var_upbnd, indexVar, get_infinity());
 	n_vars--;
-	m_is_dirty = true;
+	_mark_dirty();
 }
 
 std::string KNITROModel::pprint_variable(const VariableIndex &variable) const
@@ -535,7 +535,7 @@ void KNITROModel::delete_constraint(const ConstraintIndex &constraint)
 		m_soc_aux_cons.erase(it);
 	}
 
-	m_is_dirty = true;
+	_mark_dirty();
 }
 
 void KNITROModel::set_constraint_name(const ConstraintIndex &constraint, const std::string &name)
@@ -580,7 +580,7 @@ void KNITROModel::set_normalized_rhs(const ConstraintIndex &constraint, double r
 		_set_value<KNINT, double>(knitro::KN_set_con_upbnd, indexCon, rhs);
 	}
 
-	m_is_dirty = true;
+	_mark_dirty();
 }
 
 double KNITROModel::get_normalized_rhs(const ConstraintIndex &constraint) const
@@ -611,7 +611,7 @@ void KNITROModel::set_normalized_coefficient(const ConstraintIndex &constraint,
 	_update();
 	int error = knitro::KN_chg_con_linear_term(m_kc.get(), indexCon, indexVar, coefficient);
 	_check_error(error);
-	m_is_dirty = true;
+	_mark_dirty();
 }
 
 void KNITROModel::_set_linear_constraint(const ConstraintIndex &constraint,
@@ -708,7 +708,7 @@ void KNITROModel::set_objective_coefficient(const VariableIndex &variable, doubl
 	_update();
 	int error = knitro::KN_chg_obj_linear_term(m_kc.get(), indexVar, coefficient);
 	_check_error(error);
-	m_is_dirty = true;
+	_mark_dirty();
 }
 
 void KNITROModel::add_single_nl_objective(ExpressionGraph &graph, const ExpressionHandle &result)
@@ -719,7 +719,7 @@ void KNITROModel::add_single_nl_objective(ExpressionGraph &graph, const Expressi
 	m_pending_outputs[&graph].obj_idxs.push_back(i);
 	m_need_to_add_callbacks = true;
 	m_obj_flag |= OBJ_NONLINEAR;
-	m_is_dirty = true;
+	_mark_dirty();
 }
 
 void KNITROModel::set_obj_sense(ObjectiveSense sense)
@@ -927,7 +927,7 @@ void KNITROModel::optimize()
 	_pre_solve();
 	_solve();
 	_post_solve();
-	m_is_dirty = false;
+	_unmark_dirty();
 }
 
 // Solve information
@@ -963,10 +963,38 @@ double KNITROModel::get_solve_time() const
 	return _get_value<double>(knitro::KN_get_solve_time_real);
 }
 
+// Dirty state management
+void KNITROModel::_mark_dirty()
+{
+	m_is_dirty = true;
+}
+
+void KNITROModel::_unmark_dirty()
+{
+	m_is_dirty = false;
+}
+
+bool KNITROModel::dirty() const
+{
+	return m_is_dirty;
+}
+
+// Model state
+bool KNITROModel::empty() const
+{
+	return m_kc == nullptr;
+}
+
+int KNITROModel::get_solve_status() const
+{
+	_check_dirty();
+	return m_solve_status;
+}
+
 // Internal helpers
 void KNITROModel::_check_dirty() const
 {
-	if (m_is_dirty)
+	if (dirty())
 	{
 		throw std::runtime_error("Model has been modified since last solve. Call optimize()...");
 	}
@@ -987,7 +1015,7 @@ void KNITROModel::_reset_state()
 	m_pending_outputs.clear();
 	m_evaluators.clear();
 	m_need_to_add_callbacks = false;
-	m_is_dirty = true;
+	_mark_dirty();
 	m_solve_status = 0;
 }
 

lib/knitro_model_ext.cpp

@@ -232,8 +232,15 @@ NB_MODULE(knitro_model_ext, m)
 	        },
 	        nb::arg("param_id"))
 
-	    .def_rw("m_is_dirty", &KNITROModel::m_is_dirty)
-	    .def_ro("m_solve_status", &KNITROModel::m_solve_status);
+	    // clang-format off
+		BIND_F(dirty)
+		BIND_F(empty)
+	    // clang-format on
+
+		// clang-format off
+		BIND_F(get_solve_status)
+		// clang-format on
+	    ;
 
 #undef BIND_F
 }