Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-10-04 08:28:39 +03:00
Code Issues Actions 6 Packages Projects Releases Wiki Activity

netlist solvers: fix some bad design. (nw)

Browse Source
This commit is contained in:
couriersud 2019-10-30 20:42:49 +01:00
parent c18a414fcc
commit 7c6fdaf499
13 changed files with 215 additions and 264 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/lib/netlist/solver/nld_matrix_solver.cpp
View File

@ -42,6 +42,7 @@ namespace devices
// ----------------------------------------------------------------------------------------
matrix_solver_t::matrix_solver_t(netlist_state_t &anetlist, const pstring &name,
const analog_net_t::list_t &nets,
const solver_parameters_t *params)
: device_t(anetlist, name)
, m_params(*params)
@ -56,9 +57,10 @@ namespace devices
, m_ops(0)
{
connect_post_start(m_fb_sync, m_Q_sync);
setup_base(nets);
}
void matrix_solver_t::setup_base(analog_net_t::list_t &nets)
void matrix_solver_t::setup_base(const analog_net_t::list_t &nets)
{
log().debug("New solver setup\n");

14
src/lib/netlist/solver/nld_matrix_solver.h
View File

@ -162,11 +162,6 @@ namespace devices
public:
using list_t = std::vector<matrix_solver_t *>;
void setup(analog_net_t::list_t &nets)
{
vsetup(nets);
}
void solve_base();
/* after every call to solve, update inputs must be called.
@ -206,14 +201,13 @@ namespace devices
protected:
matrix_solver_t(netlist_state_t &anetlist, const pstring &name,
const analog_net_t::list_t &nets,
const solver_parameters_t *params);
void sort_terms(matrix_sort_type_e sort);
void setup_base(analog_net_t::list_t &nets);
void update_dynamic();
virtual void vsetup(analog_net_t::list_t &nets) = 0;
virtual unsigned vsolve_non_dynamic(const bool newton_raphson) = 0;
netlist_time compute_next_timestep(const double cur_ts);
@ -391,9 +385,6 @@ namespace devices
state_var<int> m_iterative_fail;
state_var<int> m_iterative_total;
private:
state_var<netlist_time> m_last_step;
@ -403,6 +394,9 @@ namespace devices
logic_input_t m_fb_sync;
logic_output_t m_Q_sync;
/* base setup - called from constructor */
void setup_base(const analog_net_t::list_t &nets);
/* calculate matrix */
void setup_matrix();

42
src/lib/netlist/solver/nld_ms_direct.h
View File

@ -29,9 +29,10 @@ namespace devices
using float_type = FT;
matrix_solver_direct_t(netlist_state_t &anetlist, const pstring &name, const solver_parameters_t *params, const std::size_t size);
matrix_solver_direct_t(netlist_state_t &anetlist, const pstring &name,
const analog_net_t::list_t &nets,
const solver_parameters_t *params, const std::size_t size);
void vsetup(analog_net_t::list_t &nets) override;
void reset() override { matrix_solver_t::reset(); }
protected:
@ -65,25 +66,6 @@ namespace devices
// matrix_solver_direct
// ----------------------------------------------------------------------------------------
template <typename FT, int SIZE>
void matrix_solver_direct_t<FT, SIZE>::vsetup(analog_net_t::list_t &nets)
{
matrix_solver_t::setup_base(nets);
/* add RHS element */
for (std::size_t k = 0; k < size(); k++)
{
terms_for_net_t & t = m_terms[k];
if (!plib::container::contains(t.m_nzrd, static_cast<unsigned>(size())))
t.m_nzrd.push_back(static_cast<unsigned>(size()));
}
// FIXME: This shouldn't be necessary ...
for (std::size_t k = 0; k < size(); k++)
state().save(*this, RHS(k), this->name(), plib::pfmt("RHS.{1}")(k));
}
template <typename FT, int SIZE>
void matrix_solver_direct_t<FT, SIZE>::LE_solve()
{
@ -210,13 +192,27 @@ namespace devices
template <typename FT, int SIZE>
matrix_solver_direct_t<FT, SIZE>::matrix_solver_direct_t(netlist_state_t &anetlist, const pstring &name,
const solver_parameters_t *params, const std::size_t size)
: matrix_solver_t(anetlist, name, params)
const analog_net_t::list_t &nets,
const solver_parameters_t *params,
const std::size_t size)
: matrix_solver_t(anetlist, name, nets, params)
, m_new_V(size)
, m_dim(size)
, m_pitch(m_pitch_ABS ? m_pitch_ABS : (((m_dim + 1) + 7) / 8) * 8)
, m_A(size, m_pitch)
{
/* add RHS element */
for (std::size_t k = 0; k < this->size(); k++)
{
terms_for_net_t & t = m_terms[k];
if (!plib::container::contains(t.m_nzrd, static_cast<unsigned>(this->size())))
t.m_nzrd.push_back(static_cast<unsigned>(this->size()));
}
// FIXME: This shouldn't be necessary ...
for (std::size_t k = 0; k < this->size(); k++)
state().save(*this, RHS(k), this->name(), plib::pfmt("RHS.{1}")(k));
}
} // namespace devices

6
src/lib/netlist/solver/nld_ms_direct1.h
View File

@ -23,8 +23,10 @@ namespace devices
using float_type = FT;
using base_type = matrix_solver_direct_t<FT, 1>;
matrix_solver_direct1_t(netlist_state_t &anetlist, const pstring &name, const solver_parameters_t *params)
: matrix_solver_direct_t<FT, 1>(anetlist, name, params, 1)
matrix_solver_direct1_t(netlist_state_t &anetlist, const pstring &name,
const analog_net_t::list_t &nets,
const solver_parameters_t *params)
: matrix_solver_direct_t<FT, 1>(anetlist, name, nets, params, 1)
{}
// ----------------------------------------------------------------------------------------

6
src/lib/netlist/solver/nld_ms_direct2.h
View File

@ -27,8 +27,10 @@ namespace devices
using float_type = FT;
matrix_solver_direct2_t(netlist_state_t &anetlist, const pstring &name, const solver_parameters_t *params)
: matrix_solver_direct_t<double, 2>(anetlist, name, params, 2)
matrix_solver_direct2_t(netlist_state_t &anetlist, const pstring &name,
const analog_net_t::list_t &nets,
const solver_parameters_t *params)
: matrix_solver_direct_t<FT, 2>(anetlist, name, nets, params, 2)
{}
unsigned vsolve_non_dynamic(const bool newton_raphson) override
{

67
src/lib/netlist/solver/nld_ms_gcr.h
View File

@ -35,50 +35,15 @@ namespace devices
static constexpr const std::size_t storage_N = 100;
matrix_solver_GCR_t(netlist_state_t &anetlist, const pstring &name,
const analog_net_t::list_t &nets,
const solver_parameters_t *params, const std::size_t size)
: matrix_solver_t(anetlist, name, params)
: matrix_solver_t(anetlist, name, nets, params)
, m_dim(size)
, RHS(size)
, new_V(size)
, mat(static_cast<typename mat_type::index_type>(size))
, m_proc()
{
}
constexpr std::size_t N() const { return m_dim; }
void vsetup(analog_net_t::list_t &nets) override;
unsigned vsolve_non_dynamic(const bool newton_raphson) override;
std::pair<pstring, pstring> create_solver_code() override;
private:
using mat_index_type = typename plib::pmatrix_cr_t<FT, SIZE>::index_type;
void generate_code(plib::putf8_fmt_writer &strm);
pstring static_compile_name();
const std::size_t m_dim;
plib::parray<FT, SIZE> RHS;
plib::parray<FT, SIZE> new_V;
mat_type mat;
plib::dynproc<void, double * , double * , double * > m_proc;
};
// ----------------------------------------------------------------------------------------
// matrix_solver - GCR
// ----------------------------------------------------------------------------------------
template <typename FT, int SIZE>
void matrix_solver_GCR_t<FT, SIZE>::vsetup(analog_net_t::list_t &nets)
{
setup_base(nets);
const std::size_t iN = this->N();
/* build the final matrix */
@ -146,6 +111,34 @@ namespace devices
}
}
constexpr std::size_t N() const { return m_dim; }
unsigned vsolve_non_dynamic(const bool newton_raphson) override;
std::pair<pstring, pstring> create_solver_code() override;
private:
using mat_index_type = typename plib::pmatrix_cr_t<FT, SIZE>::index_type;
void generate_code(plib::putf8_fmt_writer &strm);
pstring static_compile_name();
const std::size_t m_dim;
plib::parray<FT, SIZE> RHS;
plib::parray<FT, SIZE> new_V;
mat_type mat;
plib::dynproc<void, double * , double * , double * > m_proc;
};
// ----------------------------------------------------------------------------------------
// matrix_solver - GCR
// ----------------------------------------------------------------------------------------
template <typename FT, int SIZE>
void matrix_solver_GCR_t<FT, SIZE>::generate_code(plib::putf8_fmt_writer &strm)
{

48
src/lib/netlist/solver/nld_ms_gmres.h
View File

@ -35,36 +35,14 @@ namespace devices
* maximize the efficiency of the incomplete LUT.
* This is already preconditioning.
*/
matrix_solver_GMRES_t(netlist_state_t &anetlist, const pstring &name, const solver_parameters_t *params, const std::size_t size)
// matrix_solver_direct_t<FT, SIZE>(anetlist, name, matrix_solver_t::PREFER_BAND_MATRIX, params, size)
: matrix_solver_direct_t<FT, SIZE>(anetlist, name, params, size)
matrix_solver_GMRES_t(netlist_state_t &anetlist, const pstring &name,
analog_net_t::list_t &nets,
const solver_parameters_t *params,
const std::size_t size)
: matrix_solver_direct_t<FT, SIZE>(anetlist, name, nets, params, size)
, m_ops(size, 0)
, m_gmres(size)
{
}
void vsetup(analog_net_t::list_t &nets) override;
unsigned vsolve_non_dynamic(const bool newton_raphson) override;
private:
using mattype = typename plib::pmatrix_cr_t<FT, SIZE>::index_type;
//plib::mat_precondition_none<FT, SIZE> m_ops;
plib::mat_precondition_ILU<FT, SIZE> m_ops;
//plib::mat_precondition_diag<FT, SIZE> m_ops;
plib::gmres_t<FT, SIZE> m_gmres;
};
// ----------------------------------------------------------------------------------------
// matrix_solver - GMRES
// ----------------------------------------------------------------------------------------
template <typename FT, int SIZE>
void matrix_solver_GMRES_t<FT, SIZE>::vsetup(analog_net_t::list_t &nets)
{
matrix_solver_direct_t<FT, SIZE>::vsetup(nets);
const std::size_t iN = this->size();
std::vector<std::vector<unsigned>> fill(iN);
@ -102,6 +80,22 @@ namespace devices
}
}
unsigned vsolve_non_dynamic(const bool newton_raphson) override;
private:
using mattype = typename plib::pmatrix_cr_t<FT, SIZE>::index_type;
//plib::mat_precondition_none<FT, SIZE> m_ops;
plib::mat_precondition_ILU<FT, SIZE> m_ops;
//plib::mat_precondition_diag<FT, SIZE> m_ops;
plib::gmres_t<FT, SIZE> m_gmres;
};
// ----------------------------------------------------------------------------------------
// matrix_solver - GMRES
// ----------------------------------------------------------------------------------------
template <typename FT, int SIZE>
unsigned matrix_solver_GMRES_t<FT, SIZE>::vsolve_non_dynamic(const bool newton_raphson)
{

30
src/lib/netlist/solver/nld_ms_sm.h
View File

@ -57,9 +57,17 @@ namespace devices
static constexpr const std::size_t storage_N = 100;
matrix_solver_sm_t(netlist_state_t &anetlist, const pstring &name,
const solver_parameters_t *params, const std::size_t size);
const analog_net_t::list_t &nets,
const solver_parameters_t *params, const std::size_t size)
: matrix_solver_t(anetlist, name, nets, params)
, m_dim(size)
, m_cnt(0)
{
/* FIXME: Shouldn't be necessary */
for (std::size_t k = 0; k < this->size(); k++)
state().save(*this, RHS(k), this->name(), plib::pfmt("RHS.{1}")(k));
}
void vsetup(analog_net_t::list_t &nets) override;
void reset() override { matrix_solver_t::reset(); }
protected:
@ -112,16 +120,6 @@ namespace devices
// matrix_solver_direct
// ----------------------------------------------------------------------------------------
template <typename FT, int SIZE>
void matrix_solver_sm_t<FT, SIZE>::vsetup(analog_net_t::list_t &nets)
{
matrix_solver_t::setup_base(nets);
/* FIXME: Shouldn't be necessary */
for (std::size_t k = 0; k < size(); k++)
state().save(*this, RHS(k), this->name(), plib::pfmt("RHS.{1}")(k));
}
template <typename FT, int SIZE>
void matrix_solver_sm_t<FT, SIZE>::LE_invert()
{
@ -298,14 +296,6 @@ namespace devices
return this->solve_non_dynamic(newton_raphson);
}
template <typename FT, int SIZE>
matrix_solver_sm_t<FT, SIZE>::matrix_solver_sm_t(netlist_state_t &anetlist, const pstring &name,
const solver_parameters_t *params, const std::size_t size)
: matrix_solver_t(anetlist, name, params)
, m_dim(size)
, m_cnt(0)
{
}
} // namespace devices
} // namespace netlist

14
src/lib/netlist/solver/nld_ms_sor.h
View File

@ -29,8 +29,10 @@ public:
using float_type = FT;
matrix_solver_SOR_t(netlist_state_t &anetlist, const pstring &name, const solver_parameters_t *params, const std::size_t size)
: matrix_solver_direct_t<FT, SIZE>(anetlist, name, params, size)
matrix_solver_SOR_t(netlist_state_t &anetlist, const pstring &name,
analog_net_t::list_t &nets,
const solver_parameters_t *params, const std::size_t size)
: matrix_solver_direct_t<FT, SIZE>(anetlist, name, nets, params, size)
, m_lp_fact(*this, "m_lp_fact", 0)
, w(size, 0.0)
, one_m_w(size, 0.0)
@ -39,7 +41,6 @@ public:
{
}
void vsetup(analog_net_t::list_t &nets) override;
unsigned vsolve_non_dynamic(const bool newton_raphson) override;
private:
@ -54,13 +55,6 @@ private:
// matrix_solver - Gauss - Seidel
// ----------------------------------------------------------------------------------------
template <typename FT, int SIZE>
void matrix_solver_SOR_t<FT, SIZE>::vsetup(analog_net_t::list_t &nets)
{
matrix_solver_direct_t<FT, SIZE>::vsetup(nets);
}
template <typename FT, int SIZE>
unsigned matrix_solver_SOR_t<FT, SIZE>::vsolve_non_dynamic(const bool newton_raphson)
{

14
src/lib/netlist/solver/nld_ms_sor_mat.h
View File

@ -32,16 +32,16 @@ namespace devices
using float_type = FT;
matrix_solver_SOR_mat_t(netlist_state_t &anetlist, const pstring &name, const solver_parameters_t *params, std::size_t size)
: matrix_solver_direct_t<FT, SIZE>(anetlist, name, params, size)
matrix_solver_SOR_mat_t(netlist_state_t &anetlist, const pstring &name,
const analog_net_t::list_t &nets,
const solver_parameters_t *params, std::size_t size)
: matrix_solver_direct_t<FT, SIZE>(anetlist, name, nets, params, size)
, m_Vdelta(*this, "m_Vdelta", std::vector<float_type>(size))
, m_omega(*this, "m_omega", params->m_gs_sor)
, m_lp_fact(*this, "m_lp_fact", 0)
{
}
void vsetup(analog_net_t::list_t &nets) override;
unsigned vsolve_non_dynamic(const bool newton_raphson) override;
private:
@ -57,12 +57,6 @@ namespace devices
// matrix_solver - Gauss - Seidel
// ----------------------------------------------------------------------------------------
template <typename FT, int SIZE>
void matrix_solver_SOR_mat_t<FT, SIZE>::vsetup(analog_net_t::list_t &nets)
{
matrix_solver_direct_t<FT, SIZE>::vsetup(nets);
}
#if 0
//FIXME: move to solve_base
template <unsigned m_N, unsigned storage_N>

34
src/lib/netlist/solver/nld_ms_w.h
View File

@ -63,9 +63,18 @@ public:
// FIXME: dirty hack to make this compile
static constexpr const std::size_t storage_N = 100;
matrix_solver_w_t(netlist_state_t &anetlist, const pstring &name, const solver_parameters_t *params, const std::size_t size);
matrix_solver_w_t(netlist_state_t &anetlist, const pstring &name,
const analog_net_t::list_t &nets,
const solver_parameters_t *params, const std::size_t size)
: matrix_solver_t(anetlist, name, nets, params)
, m_cnt(0)
, m_dim(size)
{
// FIXME: This shouldn't be necessary, recalculate on each entry ...
for (std::size_t k = 0; k < this->size(); k++)
state().save(*this, RHS(k), this->name(), plib::pfmt("RHS.{1}")(k));
}
void vsetup(analog_net_t::list_t &nets) override;
void reset() override { matrix_solver_t::reset(); }
protected:
@ -125,18 +134,6 @@ private:
// matrix_solver_direct
// ----------------------------------------------------------------------------------------
template <typename FT, int SIZE>
void matrix_solver_w_t<FT, SIZE>::vsetup(analog_net_t::list_t &nets)
{
matrix_solver_t::setup_base(nets);
// FIXME: This shouldn't be necessary, recalculate on each entry ...
for (std::size_t k = 0; k < size(); k++)
state().save(*this, RHS(k), this->name(), plib::pfmt("RHS.{1}")(k));
}
template <typename FT, int SIZE>
void matrix_solver_w_t<FT, SIZE>::LE_invert()
{
@ -369,15 +366,6 @@ unsigned matrix_solver_w_t<FT, SIZE>::vsolve_non_dynamic(const bool newton_raphs
return this->solve_non_dynamic(newton_raphson);
}
template <typename FT, int SIZE>
matrix_solver_w_t<FT, SIZE>::matrix_solver_w_t(netlist_state_t &anetlist, const pstring &name,
const solver_parameters_t *params, const std::size_t size)
: matrix_solver_t(anetlist, name, params)
, m_cnt(0)
, m_dim(size)
{
}
} //namespace devices
} // namespace netlist

69
src/lib/netlist/solver/nld_solver.cpp
View File

@ -110,39 +110,43 @@ namespace devices
}
template <class C>
plib::unique_ptr<matrix_solver_t> create_it(netlist_state_t &nl, pstring name, solver_parameters_t &params, std::size_t size)
plib::unique_ptr<matrix_solver_t> create_it(netlist_state_t &nl, pstring name,
analog_net_t::list_t &nets,
solver_parameters_t &params, std::size_t size)
{
return plib::make_unique<C>(nl, name, &params, size);
return plib::make_unique<C>(nl, name, nets, &params, size);
}
template <typename FT, int SIZE>
plib::unique_ptr<matrix_solver_t> NETLIB_NAME(solver)::create_solver(std::size_t size, const pstring &solvername)
plib::unique_ptr<matrix_solver_t> NETLIB_NAME(solver)::create_solver(std::size_t size,
const pstring &solvername,
analog_net_t::list_t &nets)
{
switch (m_params.m_method())
{
case matrix_type_e::MAT_CR:
if (size > 0) // GCR always outperforms MAT solver
{
return create_it<matrix_solver_GCR_t<FT, SIZE>>(state(), solvername, m_params, size);
return create_it<matrix_solver_GCR_t<FT, SIZE>>(state(), solvername, nets, m_params, size);
}
else
{
return create_it<matrix_solver_direct_t<FT, SIZE>>(state(), solvername, m_params, size);
return create_it<matrix_solver_direct_t<FT, SIZE>>(state(), solvername, nets, m_params, size);
}
case matrix_type_e::SOR_MAT:
return create_it<matrix_solver_SOR_mat_t<FT, SIZE>>(state(), solvername, m_params, size);
return create_it<matrix_solver_SOR_mat_t<FT, SIZE>>(state(), solvername, nets, m_params, size);
case matrix_type_e::MAT:
return create_it<matrix_solver_direct_t<FT, SIZE>>(state(), solvername, m_params, size);
return create_it<matrix_solver_direct_t<FT, SIZE>>(state(), solvername, nets, m_params, size);
case matrix_type_e::SM:
/* Sherman-Morrison Formula */
return create_it<matrix_solver_sm_t<FT, SIZE>>(state(), solvername, m_params, size);
return create_it<matrix_solver_sm_t<FT, SIZE>>(state(), solvername, nets, m_params, size);
case matrix_type_e::W:
/* Woodbury Formula */
return create_it<matrix_solver_w_t<FT, SIZE>>(state(), solvername, m_params, size);
return create_it<matrix_solver_w_t<FT, SIZE>>(state(), solvername, nets, m_params, size);
case matrix_type_e::SOR:
return create_it<matrix_solver_SOR_t<FT, SIZE>>(state(), solvername, m_params, size);
return create_it<matrix_solver_SOR_t<FT, SIZE>>(state(), solvername, nets, m_params, size);
case matrix_type_e::GMRES:
return create_it<matrix_solver_GMRES_t<FT, SIZE>>(state(), solvername, m_params, size);
return create_it<matrix_solver_GMRES_t<FT, SIZE>>(state(), solvername, nets, m_params, size);
}
return plib::unique_ptr<matrix_solver_t>();
}
@ -227,35 +231,35 @@ namespace devices
switch (net_count)
{
case 1:
ms = plib::make_unique<matrix_solver_direct1_t<double>>(state(), sname, &m_params);
ms = plib::make_unique<matrix_solver_direct1_t<double>>(state(), sname, grp, &m_params);
break;
case 2:
ms = plib::make_unique<matrix_solver_direct2_t<double>>(state(), sname, &m_params);
ms = plib::make_unique<matrix_solver_direct2_t<double>>(state(), sname, grp, &m_params);
break;
#if 1
#if 0
case 3:
ms = create_solver<double, 3>(3, sname);
ms = create_solver<double, 3>(3, sname, grp);
break;
case 4:
ms = create_solver<double, 4>(4, sname);
ms = create_solver<double, 4>(4, sname, grp);
break;
case 5:
ms = create_solver<double, 5>(5, sname);
ms = create_solver<double, 5>(5, sname, grp);
break;
case 6:
ms = create_solver<double, 6>(6, sname);
ms = create_solver<double, 6>(6, sname, grp);
break;
case 7:
ms = create_solver<double, 7>(7, sname);
ms = create_solver<double, 7>(7, sname, grp);
break;
case 8:
ms = create_solver<double, 8>(8, sname);
ms = create_solver<double, 8>(8, sname, grp);
break;
case 9:
ms = create_solver<double, 9>(9, sname);
ms = create_solver<double, 9>(9, sname, grp);
break;
case 10:
ms = create_solver<double, 10>(10, sname);
ms = create_solver<double, 10>(10, sname, grp);
break;
#if 0
case 11:
@ -282,7 +286,7 @@ namespace devices
#endif
#if 1
case 87:
ms = create_solver<double,86>(86, sname);
ms = create_solver<double,86>(86, sname, grp);
break;
#endif
#endif
@ -290,42 +294,39 @@ namespace devices
log().info(MI_NO_SPECIFIC_SOLVER(net_count));
if (net_count <= 8)
{
ms = create_solver<double, -8>(net_count, sname);
ms = create_solver<double, -8>(net_count, sname, grp);
}
else if (net_count <= 16)
{
ms = create_solver<double, -16>(net_count, sname);
ms = create_solver<double, -16>(net_count, sname, grp);
}
else if (net_count <= 32)
{
ms = create_solver<double, -32>(net_count, sname);
ms = create_solver<double, -32>(net_count, sname, grp);
}
else if (net_count <= 64)
{
ms = create_solver<double, -64>(net_count, sname);
ms = create_solver<double, -64>(net_count, sname, grp);
}
else if (net_count <= 128)
{
ms = create_solver<double, -128>(net_count, sname);
ms = create_solver<double, -128>(net_count, sname, grp);
}
else if (net_count <= 256)
{
ms = create_solver<double, -256>(net_count, sname);
ms = create_solver<double, -256>(net_count, sname, grp);
}
else if (net_count <= 512)
{
ms = create_solver<double, -512>(net_count, sname);
ms = create_solver<double, -512>(net_count, sname, grp);
}
else
{
ms = create_solver<double, 0>(net_count, sname);
ms = create_solver<double, 0>(net_count, sname, grp);
}
break;
}
// FIXME ...
ms->setup(grp);
log().verbose("Solver {1}", ms->name());
log().verbose(" ==> {1} nets", grp.size());
log().verbose(" has {1} elements", ms->has_dynamic_devices() ? "dynamic" : "no dynamic");

3
src/lib/netlist/solver/nld_solver.h
View File

@ -58,7 +58,8 @@ namespace devices
solver_parameters_t m_params;
template <typename FT, int SIZE>
plib::unique_ptr<matrix_solver_t> create_solver(std::size_t size, const pstring &solvername);
plib::unique_ptr<matrix_solver_t> create_solver(std::size_t size,
const pstring &solvername, analog_net_t::list_t &nets);
};
} // namespace devices