void SequentialSolver::solve_local(vec& res,
const system_type& sys,
const vec& rhs,
bool correct) const {
if( d_iterateOnBilaterals.getValue() || !m_localSystem.H.nonZeros() )
return solve_impl( res, sys, rhs, correct );
const size_t localsize = m_localSystem.size();
vec localrhs(localsize), localres(localsize);
// reordering rhs
m_localSub.toLocal( localrhs, rhs );
// reordering res, for warm_start...
m_localSub.toLocal( localres, res );
// performing the solve on the reorganized system
solve_impl( localres, m_localSystem, localrhs, correct );
// reordering res
m_localSub.fromLocal( res, localres );
}
void solve(GF2E& d, const mat_GF2E& A, vec_GF2E& x, const vec_GF2E& b)
{
solve_impl(d, x, A, b, false);
}
void solve(GF2E& d, vec_GF2E& x, const mat_GF2E& A, const vec_GF2E& b)
{
solve_impl(d, x, A, b, true);
}
void solve(zz_pE& d, const mat_zz_pE& A, vec_zz_pE& x, const vec_zz_pE& b)
{
solve_impl(d, x, A, b, false);
}
void solve(zz_pE& d, vec_zz_pE& x, const mat_zz_pE& A, const vec_zz_pE& b)
{
solve_impl(d, x, A, b, true);
}
void solve(ZZ_p& d, const mat_ZZ_p& A, vec_ZZ_p& x, const vec_ZZ_p& b)
{
solve_impl(d, x, A, b, false);
}
void solve(ZZ_p& d, vec_ZZ_p& x, const mat_ZZ_p& A, const vec_ZZ_p& b)
{
solve_impl(d, x, A, b, true);
}
Sudoku SudokuSolver::solve(const Sudoku& sudoku) const {
return solve_impl(sudoku, false);
}
Sudoku SudokuSolver::random_solution(const Sudoku& sudoku) const {
return solve_impl(sudoku, true);
}
void BaseSequentialSolver::correct(vec& res,
const system_type& sys,
const vec& rhs,
real /*damping*/ ) const {
solve_impl(res, sys, rhs, true );
}
void BaseSequentialSolver::solve(vec& res,
const system_type& sys,
const vec& rhs) const {
solve_impl(res, sys, rhs, false );
}