Use non linear newton solver for sparse method (BlueBrain/nmodl#804)

* Use non linear newton solver for sparse method

It is possible to give non linear system to sparse solver.
The sparse method was mistaken using linear solver, now use deriv implicit.

Fix BlueBrain/nmodl#801 

NMODL Repo SHA: BlueBrain/nmodl@2833671

Author: Nicolas Cornu

src/nmodl/visitors/sympy_solver_visitor.cpp

@@ -555,9 +555,8 @@ void SympySolverVisitor::visit_derivative_block(ast::DerivativeBlock& node) {
             }
         }
 
-        if (solve_method == codegen::naming::SPARSE_METHOD) {
-            solve_linear_system(pre_solve_statements);
-        } else if (solve_method == codegen::naming::DERIVIMPLICIT_METHOD) {
+        if (solve_method == codegen::naming::SPARSE_METHOD ||
+            solve_method == codegen::naming::DERIVIMPLICIT_METHOD) {
             solve_non_linear_system(pre_solve_statements);
         } else {
             logger->error("SympySolverVisitor :: Solve method {} not supported", solve_method);

src/nmodl/visitors/sympy_solver_visitor.hpp

@@ -42,15 +42,7 @@ namespace visitor {
  * For `DERIVATIVE` block, solver method `euler`:
  *  - replace each ODE with forwards Euler timestep
  *
- * For `DERIVATIVE` block, solver method `sparse`:
- *  - construct backwards Euler timestep linear system
- *  - for small systems: solves resulting linear algebraic equation by
- *    Gaussian elimination, replaces differential equations
- *    with explicit solution of backwards Euler equations
- *  - for large systems, returns matrix and vector of linear system
- *    to be solved by e.g. LU factorization
- *
- * For `DERIVATIVE` block, solver method `derivimplicit`:
+ * For `DERIVATIVE` block, solver method `sparse` and `derivimplicit`:
  *  - construct backwards Euler timestep non-linear system
  *  - return function F and its Jacobian J to be solved by newton solver
  *
@@ -86,10 +78,10 @@ class SympySolverVisitor: public AstVisitor {
                                       const std::vector<std::string>& solutions,
                                       bool linear);
 
-    /// solve linear system (for "sparse" and "LINEAR")
+    /// solve linear system (for "LINEAR")
     void solve_linear_system(const std::vector<std::string>& pre_solve_statements = {});
 
-    /// solve non-linear system (for "derivimplicit" and "NONLINEAR")
+    /// solve non-linear system (for "derivimplicit", "sparse" and "NONLINEAR")
     void solve_non_linear_system(const std::vector<std::string>& pre_solve_statements = {});
 
     /// return NMODL string version of node, excluding any units