diff --git a/dynare++/integ/cc/product.hh b/dynare++/integ/cc/product.hh
index 3ded7b2ac2f1615ae64d29781c82581b75a45f15..812c469cc04d78b4d000ea18641d5ee3738e75f5 100644
--- a/dynare++/integ/cc/product.hh
+++ b/dynare++/integ/cc/product.hh
@@ -93,10 +93,10 @@ class ProductQuadrature : public QuadratureImpl<prodpit>
   const OneDQuadrature &uquad;
 public:
   ProductQuadrature(int d, const OneDQuadrature &uq);
-  virtual ~ProductQuadrature()
-  = default;
+  ~ProductQuadrature()
+  override = default;
   int
-  numEvals(int l) const
+  numEvals(int l) const override
   {
     int res = 1;
     for (int i = 0; i < dimen(); i++)
@@ -105,7 +105,7 @@ public:
   }
   void designLevelForEvals(int max_eval, int &lev, int &evals) const;
 protected:
-  prodpit begin(int ti, int tn, int level) const;
+  prodpit begin(int ti, int tn, int level) const override;
 };
 
 #endif
diff --git a/dynare++/integ/cc/quadrature.hh b/dynare++/integ/cc/quadrature.hh
index 02cf1bc4ef9e923f5e8b92c1558c918a8ca370e2..302a96a186c852c90c427a7e375e5c4f5fca9b47 100644
--- a/dynare++/integ/cc/quadrature.hh
+++ b/dynare++/integ/cc/quadrature.hh
@@ -120,7 +120,7 @@ public:
      smarter. */
 
   void
-  operator()()
+  operator()() override
   {
     _Tpit beg = quad.begin(ti, tn, level);
     _Tpit end = quad.begin(ti+1, tn, level);
@@ -162,7 +162,7 @@ public:
 
   /* Just fill a thread group with workes and run it. */
   void
-  integrate(VectorFunctionSet &fs, int level, Vector &out) const
+  integrate(VectorFunctionSet &fs, int level, Vector &out) const override
   {
     // todo: out.length()==func.outdim()
     // todo: dim == func.indim()
@@ -177,7 +177,7 @@ public:
   }
   void
   integrate(const VectorFunction &func,
-            int level, int tn, Vector &out) const
+            int level, int tn, Vector &out) const override
   {
     VectorFunctionSet fs(func, tn);
     integrate(fs, level, out);
@@ -246,25 +246,25 @@ public:
   {
     calcOffsets();
   }
-  virtual ~OneDPrecalcQuadrature()
-  = default;
+  ~OneDPrecalcQuadrature()
+  override = default;
   int
-  numLevels() const
+  numLevels() const override
   {
     return num_levels;
   }
   int
-  numPoints(int level) const
+  numPoints(int level) const override
   {
     return num_points[level-1];
   }
   double
-  point(int level, int i) const
+  point(int level, int i) const override
   {
     return points[offsets[level-1]+i];
   }
   double
-  weight(int level, int i) const
+  weight(int level, int i) const override
   {
     return weights[offsets[level-1]+i];
   }
diff --git a/dynare++/integ/cc/quasi_mcarlo.hh b/dynare++/integ/cc/quasi_mcarlo.hh
index 189cb16d5216d8702ecb54c37b44c04552a11e3e..92102c1445c964bfb833e6eff63984c5cccf19f2 100644
--- a/dynare++/integ/cc/quasi_mcarlo.hh
+++ b/dynare++/integ/cc/quasi_mcarlo.hh
@@ -206,16 +206,16 @@ public:
     : QuadratureImpl<qmcpit>(d), QMCSpecification(d, l, p)
   {
   }
-  virtual ~QMCarloCubeQuadrature()
-  = default;
+  ~QMCarloCubeQuadrature()
+  override = default;
   int
-  numEvals(int l) const
+  numEvals(int l) const override
   {
     return l;
   }
 protected:
   qmcpit
-  begin(int ti, int tn, int lev) const
+  begin(int ti, int tn, int lev) const override
   {
     return qmcpit(*this, ti*level()/tn + 1);
   }
@@ -280,16 +280,16 @@ public:
     : QuadratureImpl<qmcnpit>(d), QMCSpecification(d, l, p)
   {
   }
-  virtual ~QMCarloNormalQuadrature()
-  = default;
+  ~QMCarloNormalQuadrature()
+  override = default;
   int
-  numEvals(int l) const
+  numEvals(int l) const override
   {
     return l;
   }
 protected:
   qmcnpit
-  begin(int ti, int tn, int lev) const
+  begin(int ti, int tn, int lev) const override
   {
     return qmcnpit(*this, ti*level()/tn + 1);
   }
@@ -299,14 +299,14 @@ protected:
 class WarnockPerScheme : public PermutationScheme
 {
 public:
-  int permute(int i, int base, int c) const;
+  int permute(int i, int base, int c) const override;
 };
 
 /* Declares reverse permutation scheme. */
 class ReversePerScheme : public PermutationScheme
 {
 public:
-  int permute(int i, int base, int c) const;
+  int permute(int i, int base, int c) const override;
 };
 
 /* Declares no permutation (identity) scheme. */
@@ -314,7 +314,7 @@ class IdentityPerScheme : public PermutationScheme
 {
 public:
   int
-  permute(int i, int base, int c) const
+  permute(int i, int base, int c) const override
   {
     return c;
   }
diff --git a/dynare++/integ/cc/smolyak.hh b/dynare++/integ/cc/smolyak.hh
index bef067b2ef0095afd686392e28268bf50ba21e51..c0ac0b763163a06ae331a5e859f2b8f61cf1cd87 100644
--- a/dynare++/integ/cc/smolyak.hh
+++ b/dynare++/integ/cc/smolyak.hh
@@ -108,12 +108,12 @@ class SmolyakQuadrature : public QuadratureImpl<smolpit>
   PascalTriangle psc;
 public:
   SmolyakQuadrature(int d, int l, const OneDQuadrature &uq);
-  virtual ~SmolyakQuadrature()
-  = default;
-  virtual int numEvals(int level) const;
+  ~SmolyakQuadrature()
+  override = default;
+  int numEvals(int level) const override;
   void designLevelForEvals(int max_eval, int &lev, int &evals) const;
 protected:
-  smolpit begin(int ti, int tn, int level) const;
+  smolpit begin(int ti, int tn, int level) const override;
   unsigned int
   numSummands() const
   {
diff --git a/dynare++/integ/cc/vector_function.hh b/dynare++/integ/cc/vector_function.hh
index 74d1da377a62c766410aa8a0971a85799be7c4c0..8f9dab8129ca8dc2dd620cd450c8295a2f23bd23 100644
--- a/dynare++/integ/cc/vector_function.hh
+++ b/dynare++/integ/cc/vector_function.hh
@@ -153,17 +153,17 @@ public:
   GaussConverterFunction(VectorFunction &f, const GeneralMatrix &vcov);
   GaussConverterFunction(VectorFunction *f, const GeneralMatrix &vcov);
   GaussConverterFunction(const GaussConverterFunction &f);
-  virtual ~GaussConverterFunction()
+  ~GaussConverterFunction() override
   {
     if (delete_flag)
       delete func;
   }
-  virtual VectorFunction *
-  clone() const
+  VectorFunction *
+  clone() const override
   {
     return new GaussConverterFunction(*this);
   }
-  virtual void eval(const Vector &point, const ParameterSignal &sig, Vector &out);
+  void eval(const Vector &point, const ParameterSignal &sig, Vector &out) override;
 private:
   double calcMultiplier() const;
   void calcCholeskyFactor(const GeneralMatrix &vcov);
diff --git a/dynare++/integ/testing/tests.cc b/dynare++/integ/testing/tests.cc
index 85e0876331749f16799354de8f74436034d59baf..fb88c51463849c1683f8eee6251cce00f4a16d31 100644
--- a/dynare++/integ/testing/tests.cc
+++ b/dynare++/integ/testing/tests.cc
@@ -37,11 +37,11 @@ public:
      
   = default;
   VectorFunction *
-  clone() const
+  clone() const override
   {
     return new MomentFunction(*this);
   }
-  void eval(const Vector &point, const ParameterSignal &sig, Vector &out);
+  void eval(const Vector &point, const ParameterSignal &sig, Vector &out) override;
 };
 
 void
@@ -72,11 +72,11 @@ public:
      
   = default;
   VectorFunction *
-  clone() const
+  clone() const override
   {
     return new TensorPower(*this);
   }
-  void eval(const Vector &point, const ParameterSignal &sig, Vector &out);
+  void eval(const Vector &point, const ParameterSignal &sig, Vector &out) override;
 };
 
 void
@@ -108,11 +108,11 @@ public:
   {
   }
   VectorFunction *
-  clone() const
+  clone() const override
   {
     return new Function1(*this);
   }
-  virtual void eval(const Vector &point, const ParameterSignal &sig, Vector &out);
+  void eval(const Vector &point, const ParameterSignal &sig, Vector &out) override;
 };
 
 void
@@ -144,11 +144,11 @@ public:
      
   = default;
   VectorFunction *
-  clone() const
+  clone() const override
   {
     return new Function1Trans(*this);
   }
-  virtual void eval(const Vector &point, const ParameterSignal &sig, Vector &out);
+  void eval(const Vector &point, const ParameterSignal &sig, Vector &out) override;
 };
 
 void
@@ -438,7 +438,7 @@ public:
   }
 
   bool
-  run() const
+  run() const override
   {
     GeneralMatrix m(2, 2);
     m.zeros(); m.get(0, 0) = 1; m.get(1, 1) = 1;
@@ -455,7 +455,7 @@ public:
   }
 
   bool
-  run() const
+  run() const override
   {
     GeneralMatrix m(3, 3);
     m.zeros();
@@ -474,7 +474,7 @@ public:
   }
 
   bool
-  run() const
+  run() const override
   {
     GeneralMatrix m(2, 2);
     m.zeros(); m.get(0, 0) = 1; m.get(1, 1) = 1;
@@ -491,7 +491,7 @@ public:
   }
 
   bool
-  run() const
+  run() const override
   {
     GeneralMatrix m(3, 3);
     m.zeros();
@@ -510,7 +510,7 @@ public:
   }
 
   bool
-  run() const
+  run() const override
   {
     GeneralMatrix m(2, 2);
     m.zeros(); m.get(0, 0) = 1; m.get(1, 1) = 1;
@@ -527,7 +527,7 @@ public:
   }
 
   bool
-  run() const
+  run() const override
   {
     GeneralMatrix m(3, 3);
     m.zeros();
@@ -547,7 +547,7 @@ public:
   }
 
   bool
-  run() const
+  run() const override
   {
     Function1Trans f1(6);
     Vector res(1); res[0] = 1.0;
@@ -564,7 +564,7 @@ public:
   }
 
   bool
-  run() const
+  run() const override
   {
     Function1 f1(6);
     return qmc_cube(f1, 1.0, 1.e-4, 1000000);
diff --git a/dynare++/kord/approximation.hh b/dynare++/kord/approximation.hh
index 320a5b9e2e029450b60c31a9aa7e67cb83f28cca..5614301828b0fb6f7f3935316a0d949c6b35aa79 100644
--- a/dynare++/kord/approximation.hh
+++ b/dynare++/kord/approximation.hh
@@ -73,7 +73,7 @@ public:
   typedef StackContainer<FGSTensor>::_Ctype _Ctype;
   typedef StackContainer<FGSTensor>::itype itype;
   ZAuxContainer(const _Ctype *gss, int ngss, int ng, int ny, int nu);
-  itype getType(int i, const Symmetry &s) const;
+  itype getType(int i, const Symmetry &s) const override;
 };
 
 /* This class provides an interface to approximation algorithms. The
diff --git a/dynare++/kord/decision_rule.hh b/dynare++/kord/decision_rule.hh
index bc4f996af17ecc80d05ec9c8b01495e6737010de..77f573722cf75647d0fc9333fe3415800adec53f 100644
--- a/dynare++/kord/decision_rule.hh
+++ b/dynare++/kord/decision_rule.hh
@@ -126,31 +126,31 @@ public:
     centralize(dr);
   }
   const Vector &
-  getSteady() const
+  getSteady() const override
   {
     return ysteady;
   }
   TwoDMatrix *simulate(emethod em, int np, const Vector &ystart,
-                       ShockRealization &sr) const;
+                       ShockRealization &sr) const override;
   void evaluate(emethod em, Vector &out, const ConstVector &ys,
-                const ConstVector &u) const;
-  DecisionRule *centralizedClone(const Vector &fixpoint) const;
-  void writeMat(mat_t *fd, const char *prefix) const;
+                const ConstVector &u) const override;
+  DecisionRule *centralizedClone(const Vector &fixpoint) const override;
+  void writeMat(mat_t *fd, const char *prefix) const override;
 
   int
-  nexog() const
+  nexog() const override
   {
     return nu;
   }
   const PartitionY &
-  getYPart() const
+  getYPart() const override
   {
     return ypart;
   }
 protected:
   void fillTensors(const _Tg &g, double sigma);
   void centralize(const DecisionRuleImpl &dr);
-  void eval(emethod em, Vector &out, const ConstVector &v) const;
+  void eval(emethod em, Vector &out, const ConstVector &v) const override;
 };
 
 /* Here we have to fill the tensor polynomial. This involves two
@@ -495,8 +495,8 @@ public:
   typedef typename DecisionRule::emethod emethod;
   DRFixPoint(const _Tg &g, const PartitionY &yp,
              const Vector &ys, double sigma);
-  virtual
-  ~DRFixPoint();
+  
+  ~DRFixPoint() override;
 
   bool calcFixPoint(emethod em, Vector &out);
 
@@ -925,7 +925,7 @@ public:
     : res(sim_res), dr(dec_rule), em(emet), np(num_per), st(start), sr(shock_r)
   {
   }
-  void operator()();
+  void operator()() override;
 };
 
 /* This worker simulates a given impulse |imp| to a given shock
@@ -951,7 +951,7 @@ public:
       idata(id), ishock(ishck), imp(impulse)
   {
   }
-  void operator()();
+  void operator()() override;
 };
 
 /* This class does the real time simulation job for
@@ -977,7 +977,7 @@ public:
     : res(sim_res), dr(dec_rule), em(emet), np(num_per), ystart(start), sr(shock_r)
   {
   }
-  void operator()();
+  void operator()() override;
 };
 
 /* This class generates draws from Gaussian distribution with zero mean
@@ -999,11 +999,11 @@ public:
     : mtwister(sr.mtwister), factor(sr.factor)
   {
   }
-  virtual ~RandomShockRealization()
-  = default;
-  void get(int n, Vector &out);
+  ~RandomShockRealization()
+  override = default;
+  void get(int n, Vector &out) override;
   int
-  numShocks() const
+  numShocks() const override
   {
     return factor.nrows();
   }
@@ -1032,9 +1032,9 @@ public:
   {
   }
   ExplicitShockRealization(ShockRealization &sr, int num_per);
-  void get(int n, Vector &out);
+  void get(int n, Vector &out) override;
   int
-  numShocks() const
+  numShocks() const override
   {
     return shocks.nrows();
   }
@@ -1069,9 +1069,9 @@ public:
     KORD_RAISE_IF(sh.nrows() != v.nrows() || v.nrows() != v.ncols(),
                   "Wrong dimension of input matrix in GenShockRealization constructor");
   }
-  void get(int n, Vector &out);
+  void get(int n, Vector &out) override;
   int
-  numShocks() const
+  numShocks() const override
   {
     return RandomShockRealization::numShocks();
   }
diff --git a/dynare++/kord/global_check.hh b/dynare++/kord/global_check.hh
index 7234bcff3e5e3132d36d9636f75434b7ed2deb06..4c88d6a9d2ee6a639a8abcf0e2f71c7442996f8b 100644
--- a/dynare++/kord/global_check.hh
+++ b/dynare++/kord/global_check.hh
@@ -74,14 +74,14 @@ protected:
 public:
   ResidFunction(const Approximation &app);
   ResidFunction(const ResidFunction &rf);
-  virtual
-  ~ResidFunction();
-  virtual VectorFunction *
-  clone() const
+  
+  ~ResidFunction() override;
+  VectorFunction *
+  clone() const override
   {
     return new ResidFunction(*this);
   }
-  virtual void eval(const Vector &point, const ParameterSignal &sig, Vector &out);
+  void eval(const Vector &point, const ParameterSignal &sig, Vector &out) override;
   void setYU(const Vector &ys, const Vector &xx);
 };
 
@@ -97,10 +97,10 @@ public:
   GResidFunction(const GResidFunction &rf)
      
   = default;
-  virtual ~GResidFunction()
-  = default;
-  virtual VectorFunction *
-  clone() const
+  ~GResidFunction()
+  override = default;
+  VectorFunction *
+  clone() const override
   {
     return new GResidFunction(*this);
   }
diff --git a/dynare++/kord/journal.hh b/dynare++/kord/journal.hh
index c3d40fcdaf3e0620dd1482cf59ae863d8e21b050..6e99054fba77b7baa8e297c467f60551cff72192 100644
--- a/dynare++/kord/journal.hh
+++ b/dynare++/kord/journal.hh
@@ -49,7 +49,7 @@ public:
   {
     printHeader();
   }
-  ~Journal()
+  ~Journal() override
   {
     flush();
   }
@@ -139,7 +139,7 @@ public:
   {
     prefix_end[0] = '\0'; journal.incrementDepth();
   }
-  ~JournalRecordPair();
+  ~JournalRecordPair() override;
 private:
   void writePrefixForEnd(const SystemResourcesFlash &f);
 };
diff --git a/dynare++/kord/korder.hh b/dynare++/kord/korder.hh
index 73d0fa8e3e8ebfa38f354171a0dc1191107ac824..526277e253712e911429fb9fa381ce1461e57166 100644
--- a/dynare++/kord/korder.hh
+++ b/dynare++/kord/korder.hh
@@ -162,7 +162,7 @@ public:
   {
   }
   PLUMatrix(const PLUMatrix &plu);
-  virtual ~PLUMatrix()
+  ~PLUMatrix() override
   {
     delete [] ipiv;
   }
diff --git a/dynare++/kord/korder_stoch.hh b/dynare++/kord/korder_stoch.hh
index c6a6b1b44c8a412f2b73745aa90c57279f85efd0..d072d4454459e70b69fe4597b6fb7e66098ebb5f 100644
--- a/dynare++/kord/korder_stoch.hh
+++ b/dynare++/kord/korder_stoch.hh
@@ -254,7 +254,7 @@ public:
     : GContainer<_Ttype>(gs, ngs, nu)
   {
   }
-  itype getType(int i, const Symmetry &s) const;
+  itype getType(int i, const Symmetry &s) const override;
 };
 
 /* This routine corresponds to this stack:
@@ -298,7 +298,7 @@ public:
     : ZContainer<_Ttype>(gss, ngss, g, ng, ny, nu)
   {
   }
-  itype getType(int i, const Symmetry &s) const;
+  itype getType(int i, const Symmetry &s) const override;
 };
 
 /* This |getType| method corresponds to this stack:
diff --git a/dynare++/kord/mersenne_twister.hh b/dynare++/kord/mersenne_twister.hh
index a76b586696026c2fe426267d5c729e47c13d37ba..b442786e118411462b82e354e241a4932402c8d5 100644
--- a/dynare++/kord/mersenne_twister.hh
+++ b/dynare++/kord/mersenne_twister.hh
@@ -29,7 +29,7 @@ public:
   uint32 lrand();
   double drand();
   double
-  uniform()
+  uniform() override
   {
     return drand();
   }
diff --git a/dynare++/kord/random.hh b/dynare++/kord/random.hh
index ad2c062d636a10f4e3de86a58bf53859a163949e..7e7e44d980c2387326f61fcee543768f13837624 100644
--- a/dynare++/kord/random.hh
+++ b/dynare++/kord/random.hh
@@ -21,7 +21,7 @@ public:
 class SystemRandomGenerator : public RandomGenerator
 {
 public:
-  double uniform();
+  double uniform() override;
   void initSeed(int seed);
 };
 
diff --git a/dynare++/kord/tests.cc b/dynare++/kord/tests.cc
index 86827ae68f0a5e53f26bc95a732ab04bc15e3691..68239d655c69f4b76ae2cacd42021da850a804c1 100644
--- a/dynare++/kord/tests.cc
+++ b/dynare++/kord/tests.cc
@@ -343,7 +343,7 @@ public:
   }
 
   bool
-  run() const
+  run() const override
   {
     TwoDMatrix gy(8, 4, gy_data);
     TwoDMatrix gu(8, 3, gu_data);
@@ -366,7 +366,7 @@ public:
   }
 
   bool
-  run() const
+  run() const override
   {
     TwoDMatrix gy(30, 20, gy_data2);
     TwoDMatrix gu(30, 10, gu_data2);
@@ -390,7 +390,7 @@ public:
   }
 
   bool
-  run() const
+  run() const override
   {
     TwoDMatrix gy(30, 20, gy_data2);
     TwoDMatrix gu(30, 10, gu_data2);
diff --git a/dynare++/parser/cc/atom_assignings.hh b/dynare++/parser/cc/atom_assignings.hh
index 14e4b62d249560780d91d023f14f889dc5d61871..e3e660f5cd0eb43da710084cbabc5020be2e27fa 100644
--- a/dynare++/parser/cc/atom_assignings.hh
+++ b/dynare++/parser/cc/atom_assignings.hh
@@ -97,14 +97,14 @@ namespace ogp
         std::vector<double>(a.expr.nformulas()), aa(a)
     {
     }
-    virtual ~AtomAsgnEvaluator()
-    = default;
+    ~AtomAsgnEvaluator()
+    override = default;
     /** This sets all initial values to NaNs, all constants and
      * all values set by user by call set_value. This is called by
      * FormulaEvaluator::eval() method, which is called by eval()
      * method passing this argument as AtomValues. So the
      * ogp::EvalTree will be always this->etree. */
-    void setValues(EvalTree &et) const;
+    void setValues(EvalTree &et) const override;
     /** User setting of the values. For example in initval,
      * parameters are known and should be set to their values. In
      * constrast endogenous variables are set initially to NaNs by
@@ -114,7 +114,7 @@ namespace ogp
      * also checks whether the i-th expression is an atom. If so,
      * it sets the value of the atom in ogp::EvalTree
      * this->etree. */
-    void load(int i, double res);
+    void load(int i, double res) override;
     /** After the user values have been set, the assignments can
      * be evaluated. For this purpose we have eval() method. The
      * result is that this object as std::vector<double> will
diff --git a/dynare++/parser/cc/atom_substitutions.hh b/dynare++/parser/cc/atom_substitutions.hh
index 36f523bb05baa4453eef7b3c379ca28598f38a4c..ee8c831e9020ed8eff052c45a239d615aa7ec2bc 100644
--- a/dynare++/parser/cc/atom_substitutions.hh
+++ b/dynare++/parser/cc/atom_substitutions.hh
@@ -131,8 +131,8 @@ namespace ogp
     SAtoms(const SAtoms &sa)
        
     = default;
-    virtual ~SAtoms()
-    = default;
+    ~SAtoms()
+    override = default;
     /** This substitutes all lags and leads for all exogenous and
      * all lags and leads greater than 1 for all endogenous
      * variables. This is useful for perfect foresight problems
diff --git a/dynare++/parser/cc/dynamic_atoms.hh b/dynare++/parser/cc/dynamic_atoms.hh
index 27800522d11491758f4afd55fae7407fdd2463fb..829d3f3d26d2398495317541518990e71413c7c3 100644
--- a/dynare++/parser/cc/dynamic_atoms.hh
+++ b/dynare++/parser/cc/dynamic_atoms.hh
@@ -100,7 +100,7 @@ namespace ogp
     void import_constants(const Constants &c, OperationTree &otree, Tintintmap &tmap);
     /** Implements AtomValues interface. This sets the values to
      * the evaluation tree EvalTree. */
-    void setValues(EvalTree &et) const;
+    void setValues(EvalTree &et) const override;
     /** This adds a constant with the given tree index. The
      * constant must be checked previously and asserted that it
      * does not exist. */
@@ -169,8 +169,8 @@ namespace ogp
     /** Construct empty DynamicAtoms. */
     DynamicAtoms();
     DynamicAtoms(const DynamicAtoms &da);
-    virtual ~DynamicAtoms()
-    = default;
+    ~DynamicAtoms()
+    override = default;
     /** Check the nulary term identified by its string
      * representation. The nulary term can be either a constant or
      * a variable. If constant, -1 is returned so that it could be
@@ -178,19 +178,19 @@ namespace ogp
      * appeared or not. If variable, then -1 is returned only if
      * the variable has not been assigned an index, otherwise the
      * assigned index is returned. */
-    int check(const char *name) const;
+    int check(const char *name) const override;
     /** Assign the nulary term identified by its string
      * representation. This method should be called when check()
      * returns -1. */
-    void assign(const char *name, int t);
+    void assign(const char *name, int t) override;
     /** Return a number of all variables. */
     int
-    nvar() const
+    nvar() const override
     {
       return nv;
     }
     /** Return the vector of variable indices. */
-    vector<int> variables() const;
+    vector<int> variables() const override;
     /** Return max lead and min lag for a variable given by the
      * index. If a variable cannot be found, the method retursn
      * the smallest integer as maxlead and the largest integer as
@@ -254,7 +254,7 @@ namespace ogp
      * storage. */
     void unassign_variable(const char *varname, int ll, int t);
     /** Debug print. */
-    void print() const;
+    void print() const override;
   protected:
     /** Do the check for the variable. A subclass may need to
      * reimplement this so that it could raise an error if the
diff --git a/dynare++/parser/cc/fine_atoms.hh b/dynare++/parser/cc/fine_atoms.hh
index e24e584bb1857a9f2bf2bcb8e01fcaef8ad5f598..dfd213d33ad704e7483eba73b1733e6e0d2c02cf 100644
--- a/dynare++/parser/cc/fine_atoms.hh
+++ b/dynare++/parser/cc/fine_atoms.hh
@@ -33,12 +33,12 @@ namespace ogp
     {
     }
     VarOrdering *
-    clone(const vector<const char *> &vnames, const DynamicAtoms &a) const
+    clone(const vector<const char *> &vnames, const DynamicAtoms &a) const override
     {
       return new EndoVarOrdering1(*this, vnames, a);
     }
     void
-    do_ordering()
+    do_ordering() override
     {
       do_pbspbfbf();
     }
@@ -61,12 +61,12 @@ namespace ogp
     {
     }
     VarOrdering *
-    clone(const vector<const char *> &vnames, const DynamicAtoms &a) const
+    clone(const vector<const char *> &vnames, const DynamicAtoms &a) const override
     {
       return new EndoVarOrdering2(*this, vnames, a);
     }
     void
-    do_ordering()
+    do_ordering() override
     {
       do_bfspbfpb();
     }
@@ -88,12 +88,12 @@ namespace ogp
     {
     }
     VarOrdering *
-    clone(const vector<const char *> &vnames, const DynamicAtoms &a) const
+    clone(const vector<const char *> &vnames, const DynamicAtoms &a) const override
     {
       return new ExoVarOrdering(*this, vnames, a);
     }
     void
-    do_ordering()
+    do_ordering() override
     {
       do_increasing_time();
     }
@@ -234,7 +234,7 @@ namespace ogp
     }
     FineAtoms(const FineAtoms &fa);
     /** Deletes endo_order and exo_order. */
-    virtual ~FineAtoms()
+    ~FineAtoms() override
     {
       if (endo_order)
         delete endo_order;
@@ -248,7 +248,7 @@ namespace ogp
      * variable is declared by inserting it to
      * DynamicAtoms::varnames. This is a responsibility of a
      * subclass. */
-    int check_variable(const char *name) const;
+    int check_variable(const char *name) const override;
     /** This calculates min lag and max lead of endogenous variables. */
     void
     endovarspan(int &mlead, int &mlag) const
@@ -310,7 +310,7 @@ namespace ogp
     /** Return the atoms with respect to which we are going to
      * differentiate. This must be called after
      * parsing_finished. */
-    vector<int> variables() const;
+    vector<int> variables() const override;
     /** Return the number of static. */
     int nstat() const;
     /** Return the number of predetermined. */
@@ -412,7 +412,7 @@ namespace ogp
      * action. */
     virtual void register_uniq_param(const char *name);
     /** Debug print. */
-    void print() const;
+    void print() const override;
   private:
     /** This performs the common part of parsing_finished(), which
      * is a construction of internal orderings. */
diff --git a/dynare++/parser/cc/static_atoms.hh b/dynare++/parser/cc/static_atoms.hh
index 83135abf7dfbe16d613e4ebb68dc409a642e6f0e..77b6970e4106d0d1bfc656b3d01bc149e10d4d7b 100644
--- a/dynare++/parser/cc/static_atoms.hh
+++ b/dynare++/parser/cc/static_atoms.hh
@@ -42,8 +42,8 @@ namespace ogp
       import_atoms(da, otree, tmap);
     }
     /* Destructor. */
-    virtual ~StaticAtoms()
-    = default;
+    ~StaticAtoms()
+    override = default;
     /** This imports atoms from dynamic atoms inserting the new
      * tree indices to the given tree (including constants). The
      * mapping from old atoms to new atoms is traced in tmap. */
@@ -53,17 +53,17 @@ namespace ogp
      * constant is registered in Constants, it returns -1
      * otherwise. If the name is not constant, it returns result
      * from check_variable, which is implemented by a subclass. */
-    int check(const char *name) const;
+    int check(const char *name) const override;
     /** This assigns a given tree index to the variable name. The
      * name should have been checked before the call. */
-    void assign(const char *name, int t);
+    void assign(const char *name, int t) override;
     int
-    nvar() const
+    nvar() const override
     {
       return varnames.num();
     }
     /** This returns a vector of all variables. */
-    vector<int> variables() const;
+    vector<int> variables() const override;
     /** This returns a tree index of the given variable. */
     int index(const char *name) const;
     /** This returns a name from the given tree index. NULL is
@@ -76,7 +76,7 @@ namespace ogp
       return varorder[i];
     }
     /** Debug print. */
-    void print() const;
+    void print() const override;
     /** This registers a variable. A subclass can reimplement
      * this, for example, to ensure uniqueness of the
      * name. However, this method should be always called in
diff --git a/dynare++/parser/cc/static_fine_atoms.hh b/dynare++/parser/cc/static_fine_atoms.hh
index 026b405f6eef974331fb87df88190b77fc9ccaf1..24ddb4859bcfb11c3355f964f771f512611ff118 100644
--- a/dynare++/parser/cc/static_fine_atoms.hh
+++ b/dynare++/parser/cc/static_fine_atoms.hh
@@ -84,8 +84,8 @@ namespace ogp
     {
       StaticFineAtoms::import_atoms(fa, otree, tmap, dummy);
     }
-    virtual ~StaticFineAtoms()
-    = default;
+    ~StaticFineAtoms()
+    override = default;
     /** This adds atoms from dynamic atoms inserting new tree
      * indices to the given tree and tracing the mapping from old
      * atoms to new atoms in tmap. The ordering of the static
@@ -102,7 +102,7 @@ namespace ogp
      * variable is declared by inserting it to
      * StaticAtoms::varnames, which is done with registering
      * methods. This a responsibility of a subclass. */
-    int check_variable(const char *name) const;
+    int check_variable(const char *name) const override;
     /** Return an (external) ordering of parameters. */
     const vector<const char *> &
     get_params() const
@@ -128,7 +128,7 @@ namespace ogp
     /** Return the atoms with respect to which we are going to
      * differentiate. */
     vector<int>
-    variables() const
+    variables() const override
     {
       return der_atoms;
     }
@@ -190,7 +190,7 @@ namespace ogp
      * action. */
     virtual void register_uniq_param(const char *name);
     /** Debug print. */
-    void print() const;
+    void print() const override;
   private:
     /** Add endogenous variable name, which is already in the name
      * storage. */
diff --git a/dynare++/parser/cc/tree.hh b/dynare++/parser/cc/tree.hh
index ea2ccd84c7e51891c747fd6597a7f3286a302205..409a4ec37fd5bc0c20cd1924dfeae1ae916c7bc7 100644
--- a/dynare++/parser/cc/tree.hh
+++ b/dynare++/parser/cc/tree.hh
@@ -460,7 +460,7 @@ namespace ogp
     {
     }
     /** Format the operation with the default syntax. */
-    void format(const Operation &op, int t, FILE *fd);
+    void format(const Operation &op, int t, FILE *fd) override;
     /** This prints a string represenation of the given term, for
      * example 'tmp10' for term 10. In this implementation it
      * prints $10. */
diff --git a/dynare++/src/dynare3.hh b/dynare++/src/dynare3.hh
index 92b99e68aadb428c295a3feb82175acafe8e4885..6b5e4acd00d355c529b306c5e8c7e2e75bf461bd 100644
--- a/dynare++/src/dynare3.hh
+++ b/dynare++/src/dynare3.hh
@@ -24,12 +24,12 @@ class DynareNameList : public NameList
 public:
   DynareNameList(const Dynare &dynare);
   int
-  getNum() const
+  getNum() const override
   {
     return (int) names.size();
   }
   const char *
-  getName(int i) const
+  getName(int i) const override
   {
     return names[i];
   }
@@ -45,12 +45,12 @@ class DynareExogNameList : public NameList
 public:
   DynareExogNameList(const Dynare &dynare);
   int
-  getNum() const
+  getNum() const override
   {
     return (int) names.size();
   }
   const char *
-  getName(int i) const
+  getName(int i) const override
   {
     return names[i];
   }
@@ -63,12 +63,12 @@ public:
   DynareStateNameList(const Dynare &dynare, const DynareNameList &dnl,
                       const DynareExogNameList &denl);
   int
-  getNum() const
+  getNum() const override
   {
     return (int) names.size();
   }
   const char *
-  getName(int i) const
+  getName(int i) const override
   {
     return names[i];
   }
@@ -106,34 +106,34 @@ public:
   /** Makes a deep copy of the object. */
   Dynare(const Dynare &dyn);
   DynamicModel *
-  clone() const
+  clone() const override
   {
     return new Dynare(*this);
   }
-  virtual
-  ~Dynare();
+  
+  ~Dynare() override;
   int
-  nstat() const
+  nstat() const override
   {
     return model->getAtoms().nstat();
   }
   int
-  nboth() const
+  nboth() const override
   {
     return model->getAtoms().nboth();
   }
   int
-  npred() const
+  npred() const override
   {
     return model->getAtoms().npred();
   }
   int
-  nforw() const
+  nforw() const override
   {
     return model->getAtoms().nforw();
   }
   int
-  nexog() const
+  nexog() const override
   {
     return model->getAtoms().nexo();
   }
@@ -153,23 +153,23 @@ public:
     return model->getAtoms().ny();
   }
   int
-  order() const
+  order() const override
   {
     return model->getOrder();
   }
 
   const NameList &
-  getAllEndoNames() const
+  getAllEndoNames() const override
   {
     return *dnl;
   }
   const NameList &
-  getStateNames() const
+  getStateNames() const override
   {
     return *dsnl;
   }
   const NameList &
-  getExogNames() const
+  getExogNames() const override
   {
     return *denl;
   }
@@ -180,7 +180,7 @@ public:
     return model->getVcov();
   }
   const TwoDMatrix &
-  getVcov() const
+  getVcov() const override
   {
     return model->getVcov();
   }
@@ -201,17 +201,17 @@ public:
   }
 
   const TensorContainer<FSSparseTensor> &
-  getModelDerivatives() const
+  getModelDerivatives() const override
   {
     return md;
   }
   const Vector &
-  getSteady() const
+  getSteady() const override
   {
     return *ysteady;
   }
   Vector &
-  getSteady()
+  getSteady() override
   {
     return *ysteady;
   }
@@ -224,15 +224,15 @@ public:
   // here is true public interface
   void solveDeterministicSteady(Vector &steady);
   void
-  solveDeterministicSteady()
+  solveDeterministicSteady() override
   {
     solveDeterministicSteady(*ysteady);
   }
-  void evaluateSystem(Vector &out, const Vector &yy, const Vector &xx);
+  void evaluateSystem(Vector &out, const Vector &yy, const Vector &xx) override;
   void evaluateSystem(Vector &out, const Vector &yym, const Vector &yy,
-                      const Vector &yyp, const Vector &xx);
+                      const Vector &yyp, const Vector &xx) override;
   void calcDerivatives(const Vector &yy, const Vector &xx);
-  void calcDerivativesAtSteady();
+  void calcDerivativesAtSteady() override;
 
   void writeMat(mat_t *fd, const char *prefix) const;
   void writeDump(const std::string &basename) const;
@@ -245,7 +245,7 @@ class DynareEvalLoader : public ogp::FormulaEvalLoader, public Vector
 public:
   DynareEvalLoader(const ogp::FineAtoms &a, Vector &out);
   void
-  load(int i, double res)
+  load(int i, double res) override
   {
     operator[](i) = res;
   }
@@ -259,7 +259,7 @@ protected:
 public:
   DynareDerEvalLoader(const ogp::FineAtoms &a, TensorContainer<FSSparseTensor> &mod_ders,
                       int order);
-  void load(int i, int iord, const int *vars, double res);
+  void load(int i, int iord, const int *vars, double res) override;
 };
 
 class DynareJacobian : public ogu::Jacobian, public ogp::FormulaDerEvalLoader
@@ -268,10 +268,10 @@ protected:
   Dynare &d;
 public:
   DynareJacobian(Dynare &dyn);
-  virtual ~DynareJacobian()
-  = default;
-  void load(int i, int iord, const int *vars, double res);
-  void eval(const Vector &in);
+  ~DynareJacobian()
+  override = default;
+  void load(int i, int iord, const int *vars, double res) override;
+  void eval(const Vector &in) override;
 };
 
 class DynareVectorFunction : public ogu::VectorFunction
@@ -283,19 +283,19 @@ public:
     : d(dyn)
   {
   }
-  virtual ~DynareVectorFunction()
-  = default;
+  ~DynareVectorFunction()
+  override = default;
   int
-  inDim() const
+  inDim() const override
   {
     return d.ny();
   }
   int
-  outDim() const
+  outDim() const override
   {
     return d.ny();
   }
-  void eval(const ConstVector &in, Vector &out);
+  void eval(const ConstVector &in, Vector &out) override;
 };
 
 #endif
diff --git a/dynare++/src/dynare_atoms.hh b/dynare++/src/dynare_atoms.hh
index 212bd99ae20d1335f5e7034c398ce96d8ff2360c..2025901878af8cae9c076c9c5d91697cb2d91ff5 100644
--- a/dynare++/src/dynare_atoms.hh
+++ b/dynare++/src/dynare_atoms.hh
@@ -36,17 +36,17 @@ namespace ogdyn
     DynareStaticAtoms(const DynareStaticAtoms &a)
        
     = default;
-    virtual ~DynareStaticAtoms()
-    = default;
+    ~DynareStaticAtoms()
+    override = default;
     /** This registers a unique varname identifier. It throws an
      * exception if the variable name is duplicate. It checks the
      * uniqueness and then it calls StaticAtoms::register_name. */
-    void register_name(const char *name);
+    void register_name(const char *name) override;
   protected:
     /** This returns a tree index of the given variable, and if
      * the variable has not been registered, it throws an
      * exception. */
-    int check_variable(const char *name) const;
+    int check_variable(const char *name) const override;
   };
 
   class DynareDynamicAtoms : public ogp::SAtoms, public ogp::NularyStringConvertor
@@ -63,24 +63,24 @@ namespace ogdyn
     {
     }
     DynareDynamicAtoms(const DynareDynamicAtoms &dda);
-    virtual ~DynareDynamicAtoms()
-    = default;
+    ~DynareDynamicAtoms()
+    override = default;
     /** This parses a variable of the forms: varname(+3),
      * varname(3), varname, varname(-3), varname(0), varname(+0),
      * varname(-0). */
-    virtual void parse_variable(const char *in, std::string &out, int &ll) const;
+    void parse_variable(const char *in, std::string &out, int &ll) const override;
     /** Registers unique name of endogenous variable. */
-    void register_uniq_endo(const char *name);
+    void register_uniq_endo(const char *name) override;
     /** Registers unique name of exogenous variable. */
-    void register_uniq_exo(const char *name);
+    void register_uniq_exo(const char *name) override;
     /** Registers unique name of parameter. */
-    void register_uniq_param(const char *name);
+    void register_uniq_param(const char *name) override;
     /** Return true if the name is a given type. */
     bool is_type(const char *name, atype tp) const;
     /** Debug print. */
-    void print() const;
+    void print() const override;
     /** Implement NularyStringConvertor::convert. */
-    std::string convert(int t) const;
+    std::string convert(int t) const override;
   };
 
   /** This class represents the atom values for dynare, where
@@ -116,7 +116,7 @@ namespace ogdyn
       : atoms(a), paramvals(pvals), yym(ym), yy(y), yyp(yp), xx(x)
     {
     }
-    void setValues(ogp::EvalTree &et) const;
+    void setValues(ogp::EvalTree &et) const override;
   };
 
   /** This class represents the atom values at the steady state. It
@@ -144,7 +144,7 @@ namespace ogdyn
       xx.zeros();
     }
     void
-    setValues(ogp::EvalTree &et) const
+    setValues(ogp::EvalTree &et) const override
     {
       av.setValues(et);
     }
@@ -177,7 +177,7 @@ namespace ogdyn
     {
     }
     /** Set the values to the tree defined over the static atoms. */
-    void setValues(ogp::EvalTree &et) const;
+    void setValues(ogp::EvalTree &et) const override;
   };
 
   /** This class takes a vector of endogenous variables and a
@@ -196,7 +196,7 @@ namespace ogdyn
     DynareSteadySubstitutions(const ogp::FineAtoms &a, const ogp::OperationTree &tree,
                               const Tsubstmap &subst,
                               const Vector &pvals, Vector &yy);
-    void load(int i, double res);
+    void load(int i, double res) override;
   protected:
     Vector &y;
     vector<const char *> left_hand_sides;
@@ -219,7 +219,7 @@ namespace ogdyn
                                     const ogp::OperationTree &tree,
                                     const Tsubstmap &subst,
                                     const Vector &pvals, Vector &yy);
-    void load(int i, double res);
+    void load(int i, double res) override;
   protected:
     Vector &y;
     vector<const char *> left_hand_sides;
diff --git a/dynare++/src/dynare_model.hh b/dynare++/src/dynare_model.hh
index 3d01ebce0b521e1cbfe346765a86c380b0a19a12..8efbd4c4f3b9c5c57de13343585d8a48afb9222d 100644
--- a/dynare++/src/dynare_model.hh
+++ b/dynare++/src/dynare_model.hh
@@ -257,10 +257,10 @@ namespace ogdyn
      * in the model file. */
     DynareParser(const char *str, int len, int ord);
     DynareParser(const DynareParser &p);
-    virtual
-    ~DynareParser();
+    
+    ~DynareParser() override;
     DynareModel *
-    clone() const
+    clone() const override
     {
       return new DynareParser(*this);
     }
@@ -364,9 +364,9 @@ namespace ogdyn
        
     = default;
     ~DynareSPModel()
-    = default;
-    virtual DynareModel *
-    clone() const
+    override = default;
+    DynareModel *
+    clone() const override
     {
       return new DynareSPModel(*this);
     }
@@ -384,7 +384,7 @@ namespace ogdyn
     NLSelector(const DynareModel &m) : model(m)
     {
     }
-    bool operator()(int t) const;
+    bool operator()(int t) const override;
   };
 
   /** This class writes a mathematical code evaluating the system of
@@ -426,27 +426,27 @@ namespace ogdyn
     char *id;
   public:
     MatlabSSWriter(const DynareModel &dm, const char *idd);
-    virtual ~MatlabSSWriter()
+    ~MatlabSSWriter() override
     {
       delete [] id;
     }
   protected:
     // from ModelSSWriter
-    void write_der0_preamble(FILE *fd) const;
-    void write_der1_preamble(FILE *fd) const;
+    void write_der0_preamble(FILE *fd) const override;
+    void write_der1_preamble(FILE *fd) const override;
     /** This writes atom assignments. We have four kinds of atoms
      * set here: endogenous vars coming from one parameter,
      * parameter values given by the second parameter, constants,
      * and the OperationTree::num_constants hardwired constants in
      * ogp::OperationTree. */
-    void write_atom_assignment(FILE *fd) const;
-    void write_der0_assignment(FILE *fd) const;
-    void write_der1_assignment(FILE *fd) const;
+    void write_atom_assignment(FILE *fd) const override;
+    void write_der0_assignment(FILE *fd) const override;
+    void write_der1_assignment(FILE *fd) const override;
     /** This prints t10 for t=10. */
-    void format_term(int t, FILE *fd) const;
+    void format_term(int t, FILE *fd) const override;
     /** This prints a10 for t=10. The atoms a10 are supposed to be
      * set by write_atom_assignments(). */
-    void format_nulary(int t, FILE *fd) const;
+    void format_nulary(int t, FILE *fd) const override;
   private:
     void write_common1_preamble(FILE *fd) const;
     void write_common2_preamble(FILE *fd) const;
@@ -465,7 +465,7 @@ namespace ogdyn
         model(m)
     {
     }
-    void format_nulary(int t, FILE *fd) const;
+    void format_nulary(int t, FILE *fd) const override;
   };
 };
 
diff --git a/dynare++/src/nlsolve.hh b/dynare++/src/nlsolve.hh
index aa8727105030a3a81d92692a91ed475ed5d4ce66..9b976f6f8444964cf5c1ed49080cf8f819d345cd 100644
--- a/dynare++/src/nlsolve.hh
+++ b/dynare++/src/nlsolve.hh
@@ -64,8 +64,8 @@ namespace ogu
       : TwoDMatrix(n, n)
     {
     }
-    virtual ~Jacobian()
-    = default;
+    ~Jacobian()
+    override = default;
     virtual void eval(const Vector &in) = 0;
   };
 
@@ -88,8 +88,8 @@ namespace ogu
     {
       xnewton.zeros(); xcauchy.zeros(); x.zeros();
     }
-    virtual ~NLSolver()
-    = default;
+    ~NLSolver()
+    override = default;
     /** Returns true if the problem has converged. xx as input is the
      * starting value, as output it is a solution. */
     bool solve(Vector &xx, int &iter);
@@ -97,7 +97,7 @@ namespace ogu
      * func(xx)^T*func(xx), where
      * xx=x+lambda*xcauchy+(1-lambda)*xnewton. It is non-const only
      * because it calls func, x, xnewton, xcauchy is not changed. */
-    double eval(double lambda);
+    double eval(double lambda) override;
   };
 
 };
diff --git a/dynare++/src/planner_builder.hh b/dynare++/src/planner_builder.hh
index b38e2eb2dac2e7b6c8a16772b215e6d0c7e22f40..85ea5946a3357fadfa3a7823bee3d7f6a22784fa 100644
--- a/dynare++/src/planner_builder.hh
+++ b/dynare++/src/planner_builder.hh
@@ -315,7 +315,7 @@ namespace ogdyn
      * builder.diff_f_save have been put the the
      * ogp::FormulaCustomEvaluator. This is documented in the code
      * of the constructor. */
-    void load(int i, double res);
+    void load(int i, double res) override;
   };
 };
 
diff --git a/dynare++/sylv/cc/BlockDiagonal.hh b/dynare++/sylv/cc/BlockDiagonal.hh
index d1acc1ae65263e892d8d1d594e60c17ca5ab8d70..c658e8eb6a75b244e9b9c7b44e8b5ddf8b38c814 100644
--- a/dynare++/sylv/cc/BlockDiagonal.hh
+++ b/dynare++/sylv/cc/BlockDiagonal.hh
@@ -22,7 +22,7 @@ public:
     GeneralMatrix::operator=(t); return *this;
   }
   const BlockDiagonal &operator=(const BlockDiagonal &b);
-  ~BlockDiagonal()
+  ~BlockDiagonal() override
   {
     delete [] row_len; delete [] col_len;
   }
@@ -32,15 +32,15 @@ public:
   int getLargestBlock() const;
   void printInfo() const;
 
-  void multKron(KronVector &x) const;
-  void multKronTrans(KronVector &x) const;
+  void multKron(KronVector &x) const override;
+  void multKronTrans(KronVector &x) const override;
 
-  const_col_iter col_begin(const DiagonalBlock &b) const;
-  col_iter col_begin(const DiagonalBlock &b);
-  const_row_iter row_end(const DiagonalBlock &b) const;
-  row_iter row_end(const DiagonalBlock &b);
+  const_col_iter col_begin(const DiagonalBlock &b) const override;
+  col_iter col_begin(const DiagonalBlock &b) override;
+  const_row_iter row_end(const DiagonalBlock &b) const override;
+  row_iter row_end(const DiagonalBlock &b) override;
   QuasiTriangular *
-  clone() const
+  clone() const override
   {
     return new BlockDiagonal(*this);
   }
diff --git a/dynare++/sylv/cc/IterativeSylvester.hh b/dynare++/sylv/cc/IterativeSylvester.hh
index 3163f8fbb42d123d2424d18c12317eb1803c25fb..3f86716f9b86ec04756b656bfea378c6431aa06b 100644
--- a/dynare++/sylv/cc/IterativeSylvester.hh
+++ b/dynare++/sylv/cc/IterativeSylvester.hh
@@ -25,7 +25,7 @@ public:
     : SylvesterSolver(kdecomp, fdecomp)
   {
   }
-  void solve(SylvParams &pars, KronVector &x) const;
+  void solve(SylvParams &pars, KronVector &x) const override;
 private:
   double performFirstStep(KronVector &x) const;
   static double performStep(const QuasiTriangular &k, const QuasiTriangular &f,
diff --git a/dynare++/sylv/cc/QuasiTriangular.hh b/dynare++/sylv/cc/QuasiTriangular.hh
index b66ead9df84c1e0f76795906cde2cc9e32dcc844..e6ef3ff5e4b52fdc8e345efbc836fc6c2b9e4e94 100644
--- a/dynare++/sylv/cc/QuasiTriangular.hh
+++ b/dynare++/sylv/cc/QuasiTriangular.hh
@@ -332,7 +332,7 @@ public:
   {
   };
   _Self &
-  operator++()
+  operator++() override
   {
     _Tparent::ptr++; row++; return *this;
   }
@@ -367,7 +367,7 @@ public:
   {
   };
   _Self &
-  operator++()
+  operator++() override
   {
     _Tparent::ptr += _Tparent::d_size; col++; return *this;
   }
@@ -413,8 +413,8 @@ public:
   QuasiTriangular(const SchurDecomp &decomp);
   QuasiTriangular(const SchurDecompZero &decomp);
   QuasiTriangular(const QuasiTriangular &t);
-  virtual
-  ~QuasiTriangular();
+  
+  ~QuasiTriangular() override;
   const Diagonal &
   getDiagonal() const
   {
diff --git a/dynare++/sylv/cc/QuasiTriangularZero.hh b/dynare++/sylv/cc/QuasiTriangularZero.hh
index 049f6a802b2eb923ae0a368038ef7ee9581621fb..632a336a974eae40b449dc87a283793d3bb8fd46 100644
--- a/dynare++/sylv/cc/QuasiTriangularZero.hh
+++ b/dynare++/sylv/cc/QuasiTriangularZero.hh
@@ -20,38 +20,38 @@ public:
   QuasiTriangularZero(int p, const QuasiTriangularZero &t);
   QuasiTriangularZero(const QuasiTriangular &t);
   QuasiTriangularZero(const SchurDecompZero &decomp);
-  ~QuasiTriangularZero();
-  void solvePre(Vector &x, double &eig_min);
-  void solvePreTrans(Vector &x, double &eig_min);
-  void multVec(Vector &x, const ConstVector &b) const;
-  void multVecTrans(Vector &x, const ConstVector &b) const;
-  void multaVec(Vector &x, const ConstVector &b) const;
-  void multaVecTrans(Vector &x, const ConstVector &b) const;
-  void multKron(KronVector &x) const;
-  void multKronTrans(KronVector &x) const;
-  void multLeftOther(GeneralMatrix &a) const;
+  ~QuasiTriangularZero() override;
+  void solvePre(Vector &x, double &eig_min) override;
+  void solvePreTrans(Vector &x, double &eig_min) override;
+  void multVec(Vector &x, const ConstVector &b) const override;
+  void multVecTrans(Vector &x, const ConstVector &b) const override;
+  void multaVec(Vector &x, const ConstVector &b) const override;
+  void multaVecTrans(Vector &x, const ConstVector &b) const override;
+  void multKron(KronVector &x) const override;
+  void multKronTrans(KronVector &x) const override;
+  void multLeftOther(GeneralMatrix &a) const override;
   /* clone */
-  virtual QuasiTriangular *
-  clone() const
+  QuasiTriangular *
+  clone() const override
   {
     return new QuasiTriangularZero(*this);
   }
-  virtual QuasiTriangular *
-  clone(int p, const QuasiTriangular &t) const
+  QuasiTriangular *
+  clone(int p, const QuasiTriangular &t) const override
   {
     return new QuasiTriangularZero(p, (const QuasiTriangularZero &) t);
   }
-  virtual QuasiTriangular *
-  clone(double r) const
+  QuasiTriangular *
+  clone(double r) const override
   {
     return new QuasiTriangularZero(r, *this);
   }
-  virtual QuasiTriangular *
-  clone(double r, double rr, const QuasiTriangular &tt) const
+  QuasiTriangular *
+  clone(double r, double rr, const QuasiTriangular &tt) const override
   {
     return new QuasiTriangularZero(r, *this, rr, (const QuasiTriangularZero &) tt);
   }
-  void print() const;
+  void print() const override;
 };
 
 #endif /* QUASI_TRIANGULAR_ZERO_H */
diff --git a/dynare++/sylv/cc/SchurDecomp.hh b/dynare++/sylv/cc/SchurDecomp.hh
index 8dd53525b75351917bfbf2010b091f47b48682b9..15c652b7e738745980af0712c7a87efe3ca90c8e 100644
--- a/dynare++/sylv/cc/SchurDecomp.hh
+++ b/dynare++/sylv/cc/SchurDecomp.hh
@@ -54,7 +54,7 @@ public:
   {
     return ru;
   }
-  int getDim() const;
+  int getDim() const override;
   int
   getZeroCols() const
   {
diff --git a/dynare++/sylv/cc/SylvException.hh b/dynare++/sylv/cc/SylvException.hh
index 2bc1757ce2f602d6bd69abc863a4495afc8fef3e..43c5b00e509c3b3258a55d4872a3e619bf5cbb36 100644
--- a/dynare++/sylv/cc/SylvException.hh
+++ b/dynare++/sylv/cc/SylvException.hh
@@ -26,7 +26,7 @@ class SylvExceptionMessage : public SylvException
   char message[500];
 public:
   SylvExceptionMessage(const char *f, int l, const char *mes);
-  virtual int printMessage(char *str, int maxlen) const;
+  int printMessage(char *str, int maxlen) const override;
 };
 
 // define macros:
diff --git a/dynare++/sylv/cc/TriangularSylvester.hh b/dynare++/sylv/cc/TriangularSylvester.hh
index b158bbbb3be01aeb66c49c0cc8c3df9643dc8ff6..077f60e7ed423baae89df99bf3cb3c955ab0f912 100644
--- a/dynare++/sylv/cc/TriangularSylvester.hh
+++ b/dynare++/sylv/cc/TriangularSylvester.hh
@@ -19,10 +19,10 @@ public:
   TriangularSylvester(const QuasiTriangular &k, const QuasiTriangular &f);
   TriangularSylvester(const SchurDecompZero &kdecomp, const SchurDecomp &fdecomp);
   TriangularSylvester(const SchurDecompZero &kdecomp, const SimilarityDecomp &fdecomp);
-  virtual
-  ~TriangularSylvester();
+  
+  ~TriangularSylvester() override;
   void print() const;
-  void solve(SylvParams &pars, KronVector &d) const;
+  void solve(SylvParams &pars, KronVector &d) const override;
 
   void solvi(double r, KronVector &d, double &eig_min) const;
   void solvii(double alpha, double beta1, double beta2,
diff --git a/dynare++/sylv/testing/tests.cc b/dynare++/sylv/testing/tests.cc
index ba90ac175ae4c1b07b9cafc05b1255832d8215b7..3b8e4d9bbdb6481f8e7ca2dd789b55606e47efc4 100644
--- a/dynare++/sylv/testing/tests.cc
+++ b/dynare++/sylv/testing/tests.cc
@@ -537,7 +537,7 @@ public:
   PureTriangTest() : TestRunnable("pure triangular solve (5)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class PureTriangTransTest : public TestRunnable
@@ -546,7 +546,7 @@ public:
   PureTriangTransTest() : TestRunnable("pure triangular solve trans (5)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class PureTrLargeTest : public TestRunnable
@@ -555,7 +555,7 @@ public:
   PureTrLargeTest() : TestRunnable("pure triangular large solve (300)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class PureTrLargeTransTest : public TestRunnable
@@ -564,7 +564,7 @@ public:
   PureTrLargeTransTest() : TestRunnable("pure triangular large solve trans (300)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class QuasiTriangTest : public TestRunnable
@@ -573,7 +573,7 @@ public:
   QuasiTriangTest() : TestRunnable("quasi triangular solve (7)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class QuasiTriangTransTest : public TestRunnable
@@ -582,7 +582,7 @@ public:
   QuasiTriangTransTest() : TestRunnable("quasi triangular solve trans (7)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class QuasiTrLargeTest : public TestRunnable
@@ -591,7 +591,7 @@ public:
   QuasiTrLargeTest() : TestRunnable("quasi triangular solve large (250)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class QuasiTrLargeTransTest : public TestRunnable
@@ -600,7 +600,7 @@ public:
   QuasiTrLargeTransTest() : TestRunnable("quasi triangular solve large trans (250)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class QuasiZeroSmallTest : public TestRunnable
@@ -609,7 +609,7 @@ public:
   QuasiZeroSmallTest() : TestRunnable("quasi tr. zero small test (2x1)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class MultKronSmallTest : public TestRunnable
@@ -618,7 +618,7 @@ public:
   MultKronSmallTest() : TestRunnable("kronecker small mult (2=2x1)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class MultKronTest : public TestRunnable
@@ -627,7 +627,7 @@ public:
   MultKronTest() : TestRunnable("kronecker mult (245=7x7x5)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class MultKronSmallTransTest : public TestRunnable
@@ -636,7 +636,7 @@ public:
   MultKronSmallTransTest() : TestRunnable("kronecker small trans mult (2=2x1)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class MultKronTransTest : public TestRunnable
@@ -645,7 +645,7 @@ public:
   MultKronTransTest() : TestRunnable("kronecker trans mult (245=7x7x5)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class LevelKronTest : public TestRunnable
@@ -654,7 +654,7 @@ public:
   LevelKronTest() : TestRunnable("kronecker level mult (1715=7x[7]x7x5)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class LevelKronTransTest : public TestRunnable
@@ -663,7 +663,7 @@ public:
   LevelKronTransTest() : TestRunnable("kronecker level trans mult (1715=7x[7]x7x5)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class LevelZeroKronTest : public TestRunnable
@@ -672,7 +672,7 @@ public:
   LevelZeroKronTest() : TestRunnable("kronecker level mult (1715=7x7x7x[5])")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class LevelZeroKronTransTest : public TestRunnable
@@ -681,7 +681,7 @@ public:
   LevelZeroKronTransTest() : TestRunnable("kronecker level trans mult (1715=7x7x7x[5])")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class KronPowerTest : public TestRunnable
@@ -690,7 +690,7 @@ public:
   KronPowerTest() : TestRunnable("kronecker power mult (1715=7x7x7x5)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class SmallLinEvalTest : public TestRunnable
@@ -699,7 +699,7 @@ public:
   SmallLinEvalTest() : TestRunnable("lin eval (24=2 x 2x2x3)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class LinEvalTest : public TestRunnable
@@ -708,7 +708,7 @@ public:
   LinEvalTest() : TestRunnable("lin eval (490=2 x 7x7x5)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class SmallQuaEvalTest : public TestRunnable
@@ -717,7 +717,7 @@ public:
   SmallQuaEvalTest() : TestRunnable("qua eval (24=2 x 2x2x3)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class QuaEvalTest : public TestRunnable
@@ -726,7 +726,7 @@ public:
   QuaEvalTest() : TestRunnable("qua eval (490=2 x 7x7x5)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class TriSylvSmallRealTest : public TestRunnable
@@ -735,7 +735,7 @@ public:
   TriSylvSmallRealTest() : TestRunnable("triangular sylvester small real solve (12=2x2x3)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class TriSylvSmallComplexTest : public TestRunnable
@@ -744,7 +744,7 @@ public:
   TriSylvSmallComplexTest() : TestRunnable("triangular sylvester small complx solve (12=2x2x3)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class TriSylvTest : public TestRunnable
@@ -753,7 +753,7 @@ public:
   TriSylvTest() : TestRunnable("triangular sylvester solve (245=7x7x5)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class TriSylvBigTest : public TestRunnable
@@ -762,7 +762,7 @@ public:
   TriSylvBigTest() : TestRunnable("triangular sylvester big solve (48000=40x40x30)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class TriSylvLargeTest : public TestRunnable
@@ -771,7 +771,7 @@ public:
   TriSylvLargeTest() : TestRunnable("triangular sylvester large solve (1920000=40x40x40x30)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class IterSylvTest : public TestRunnable
@@ -780,7 +780,7 @@ public:
   IterSylvTest() : TestRunnable("iterative sylvester solve (245=7x7x5)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class IterSylvLargeTest : public TestRunnable
@@ -789,7 +789,7 @@ public:
   IterSylvLargeTest() : TestRunnable("iterative sylvester large solve (1920000=40x40x40x30)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class GenSylvSmallTest : public TestRunnable
@@ -798,7 +798,7 @@ public:
   GenSylvSmallTest() : TestRunnable("general sylvester small solve (18=3x3x2)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class GenSylvTest : public TestRunnable
@@ -807,7 +807,7 @@ public:
   GenSylvTest() : TestRunnable("general sylvester solve (12000=20x20x30)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class GenSylvSingTest : public TestRunnable
@@ -816,7 +816,7 @@ public:
   GenSylvSingTest() : TestRunnable("general sylvester solve for sing. C (2500000=50x50x50x20)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class GenSylvLargeTest : public TestRunnable
@@ -825,7 +825,7 @@ public:
   GenSylvLargeTest() : TestRunnable("general sylvester solve (2500000=50x50x50x20)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class EigBubFrankTest : public TestRunnable
@@ -834,7 +834,7 @@ public:
   EigBubFrankTest() : TestRunnable("eig. bubble frank test (12x12)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class EigBubSplitTest : public TestRunnable
@@ -844,7 +844,7 @@ public:
   EigBubSplitTest() : TestRunnable("eig. bubble complex split test (3x3)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class EigBubSameTest : public TestRunnable
@@ -854,7 +854,7 @@ public:
   EigBubSameTest() : TestRunnable("eig. bubble same test (5x5)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class BlockDiagSmallTest : public TestRunnable
@@ -863,7 +863,7 @@ public:
   BlockDiagSmallTest() : TestRunnable("block diagonalization small test (7x7)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class BlockDiagFrankTest : public TestRunnable
@@ -872,7 +872,7 @@ public:
   BlockDiagFrankTest() : TestRunnable("block diagonalization of frank (12x12)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class BlockDiagIllCondTest : public TestRunnable
@@ -881,7 +881,7 @@ public:
   BlockDiagIllCondTest() : TestRunnable("block diagonalization of ill conditioned (15x15)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 class BlockDiagBigTest : public TestRunnable
@@ -890,7 +890,7 @@ public:
   BlockDiagBigTest() : TestRunnable("block diagonalization big test (50x50)")
   {
   }
-  bool run() const;
+  bool run() const override;
 };
 
 /**********************************************************/
diff --git a/dynare++/tl/cc/fine_container.hh b/dynare++/tl/cc/fine_container.hh
index fb5c01752c38e174b8e925ee89e5d02613f34e71..4bccbc9b391ac096bef07479e89cbd4daa82ebab 100644
--- a/dynare++/tl/cc/fine_container.hh
+++ b/dynare++/tl/cc/fine_container.hh
@@ -125,14 +125,14 @@ public:
 
   /* Here we deallocate the refined containers, and deallocate the array of
      refined containers. */
-  virtual ~FineContainer()
+  ~FineContainer() override
   {
     for (int i = 0; i < _Stype::numConts(); i++)
       delete ref_conts[i];
     delete [] ref_conts;
   }
   itype
-  getType(int i, const Symmetry &s) const
+  getType(int i, const Symmetry &s) const override
   {
     return stack_cont.getType(getOldIndex(i), s);
   }
diff --git a/dynare++/tl/cc/fs_tensor.hh b/dynare++/tl/cc/fs_tensor.hh
index f0635eecca9a3e22652c8470ce780b4b3f9de479..34e07e2327cc401eb229b07958b5e0900fc66880 100644
--- a/dynare++/tl/cc/fs_tensor.hh
+++ b/dynare++/tl/cc/fs_tensor.hh
@@ -67,16 +67,16 @@ public:
   {
   }
 
-  void increment(IntSequence &v) const;
-  void decrement(IntSequence &v) const;
-  UTensor&unfold() const;
+  void increment(IntSequence &v) const override;
+  void decrement(IntSequence &v) const override;
+  UTensor&unfold() const override;
   Symmetry
   getSym() const
   {
     return Symmetry(dimen());
   }
 
-  int getOffset(const IntSequence &v) const;
+  int getOffset(const IntSequence &v) const override;
   void addSubTensor(const FGSTensor &t);
   int
   nvar() const
@@ -111,16 +111,16 @@ public:
   {
   }
 
-  void increment(IntSequence &v) const;
-  void decrement(IntSequence &v) const;
-  FTensor&fold() const;
+  void increment(IntSequence &v) const override;
+  void decrement(IntSequence &v) const override;
+  FTensor&fold() const override;
   Symmetry
   getSym() const
   {
     return Symmetry(dimen());
   }
 
-  int getOffset(const IntSequence &v) const;
+  int getOffset(const IntSequence &v) const override;
   void addSubTensor(const UGSTensor &t);
   int
   nvar() const
diff --git a/dynare++/tl/cc/gs_tensor.hh b/dynare++/tl/cc/gs_tensor.hh
index 8fe53cb8ccb7cc6adadc10331016b1db5d189865..d266bf58bb608313c80bd5c1d9e85dac8fbcab0d 100644
--- a/dynare++/tl/cc/gs_tensor.hh
+++ b/dynare++/tl/cc/gs_tensor.hh
@@ -169,16 +169,16 @@ public:
   {
   }
 
-  virtual ~FGSTensor()
-  = default;
+  ~FGSTensor()
+  override = default;
 
-  void increment(IntSequence &v) const;
+  void increment(IntSequence &v) const override;
   void
-  decrement(IntSequence &v) const
+  decrement(IntSequence &v) const override
   {
     tdims.decrement(v);
   }
-  UTensor&unfold() const;
+  UTensor&unfold() const override;
   const TensorDimens &
   getDims() const
   {
@@ -193,7 +193,7 @@ public:
   void contractAndAdd(int i, FGSTensor &out,
                       const FRSingleTensor &col) const;
   int
-  getOffset(const IntSequence &v) const
+  getOffset(const IntSequence &v) const override
   {
     return tdims.calcFoldOffset(v);
   }
@@ -237,12 +237,12 @@ public:
     : UTensor(0, t.nrows(), t), tdims(t.nvar(), t.dimen())
   {
   }
-  virtual ~UGSTensor()
-  = default;
+  ~UGSTensor()
+  override = default;
 
-  void increment(IntSequence &v) const;
-  void decrement(IntSequence &v) const;
-  FTensor&fold() const;
+  void increment(IntSequence &v) const override;
+  void decrement(IntSequence &v) const override;
+  FTensor&fold() const override;
   const TensorDimens &
   getDims() const
   {
@@ -256,7 +256,7 @@ public:
 
   void contractAndAdd(int i, UGSTensor &out,
                       const URSingleTensor &col) const;
-  int getOffset(const IntSequence &v) const;
+  int getOffset(const IntSequence &v) const override;
 private:
   void unfoldData();
 public:
diff --git a/dynare++/tl/cc/kron_prod.hh b/dynare++/tl/cc/kron_prod.hh
index a787e5d012f01a175d011a8218b33fba9aa689d7..e3a9834b2250eebb2a50b70fb82e821d9d0580da 100644
--- a/dynare++/tl/cc/kron_prod.hh
+++ b/dynare++/tl/cc/kron_prod.hh
@@ -224,7 +224,7 @@ public:
     : KronProd(dim), matlist(new const TwoDMatrix *[dim])
   {
   }
-  virtual ~KronProdAll()
+  ~KronProdAll() override
   {
     delete [] matlist;
   }
@@ -236,7 +236,7 @@ public:
     return *(matlist[i]);
   }
 
-  void mult(const ConstTwoDMatrix &in, TwoDMatrix &out) const;
+  void mult(const ConstTwoDMatrix &in, TwoDMatrix &out) const override;
   Vector *multRows(const IntSequence &irows) const;
 private:
   bool isUnit() const;
@@ -301,7 +301,7 @@ public:
       mat(kpa.getMat(kpa.dimen()-1))
   {
   }
-  void mult(const ConstTwoDMatrix &in, TwoDMatrix &out) const;
+  void mult(const ConstTwoDMatrix &in, TwoDMatrix &out) const override;
 };
 
 /* This class represents $A\otimes I$. We have only one reference to
@@ -320,7 +320,7 @@ public:
   }
   KronProdAI(const KronProdIAI &kpiai);
 
-  void mult(const ConstTwoDMatrix &in, TwoDMatrix &out) const;
+  void mult(const ConstTwoDMatrix &in, TwoDMatrix &out) const override;
 };
 
 /* This class represents $I\otimes A\otimes I$. We have only one reference to
@@ -337,7 +337,7 @@ public:
       mat(kpa.getMat(i))
   {
   }
-  void mult(const ConstTwoDMatrix &in, TwoDMatrix &out) const;
+  void mult(const ConstTwoDMatrix &in, TwoDMatrix &out) const override;
 };
 
 #endif
diff --git a/dynare++/tl/cc/ps_tensor.hh b/dynare++/tl/cc/ps_tensor.hh
index eb6ec9063830ad9ddbffc173d5552c51ec65915f..8827ce8f5b5f19a1fa36baa2e7c44e8b5b3605cf 100644
--- a/dynare++/tl/cc/ps_tensor.hh
+++ b/dynare++/tl/cc/ps_tensor.hh
@@ -204,11 +204,11 @@ public:
      
   = default;
 
-  void increment(IntSequence &v) const;
-  void decrement(IntSequence &v) const;
-  FTensor&fold() const;
+  void increment(IntSequence &v) const override;
+  void decrement(IntSequence &v) const override;
+  FTensor&fold() const override;
 
-  int getOffset(const IntSequence &v) const;
+  int getOffset(const IntSequence &v) const override;
   void addTo(FGSTensor &out) const;
   void addTo(UGSTensor &out) const;
 
@@ -368,11 +368,11 @@ public:
      
   = default;
 
-  void increment(IntSequence &v) const;
-  void decrement(IntSequence &v) const;
-  UTensor&unfold() const;
+  void increment(IntSequence &v) const override;
+  void decrement(IntSequence &v) const override;
+  UTensor&unfold() const override;
 
-  int getOffset(const IntSequence &v) const;
+  int getOffset(const IntSequence &v) const override;
   void addTo(FGSTensor &out) const;
 };
 
diff --git a/dynare++/tl/cc/pyramid_prod2.hh b/dynare++/tl/cc/pyramid_prod2.hh
index a948fcb8a0c08ef435b632d99f84f2185e53b52b..d8b9e33a0490e9e383f880f0c4dbb8fbc8fde8ff 100644
--- a/dynare++/tl/cc/pyramid_prod2.hh
+++ b/dynare++/tl/cc/pyramid_prod2.hh
@@ -135,17 +135,17 @@ public:
   IrregTensor(const IrregTensorHeader &h);
   void addTo(FRSingleTensor &out) const;
   void
-  increment(IntSequence &v) const
+  increment(IntSequence &v) const override
   {
     header.increment(v);
   }
   void
-  decrement(IntSequence &v) const
+  decrement(IntSequence &v) const override
   {
     TL_RAISE("Not implemented error in IrregTensor::decrement");
   }
   int
-  getOffset(const IntSequence &v) const
+  getOffset(const IntSequence &v) const override
   {
     TL_RAISE("Not implemented error in IrregTensor::getOffset"); return 0;
   }
diff --git a/dynare++/tl/cc/rfs_tensor.hh b/dynare++/tl/cc/rfs_tensor.hh
index c70bbd0de603f4f64fde28c6853f694c94091216..c935ed6f95b5eed3288556a12acfb1b2e6a0ede4 100644
--- a/dynare++/tl/cc/rfs_tensor.hh
+++ b/dynare++/tl/cc/rfs_tensor.hh
@@ -57,14 +57,14 @@ public:
   = default;
   URTensor(const FRTensor &ft);
 
-  virtual ~URTensor()
-  = default;
+  ~URTensor()
+  override = default;
 
-  void increment(IntSequence &v) const;
-  void decrement(IntSequence &v) const;
-  FTensor&fold() const;
+  void increment(IntSequence &v) const override;
+  void decrement(IntSequence &v) const override;
+  FTensor&fold() const override;
 
-  int getOffset(const IntSequence &v) const;
+  int getOffset(const IntSequence &v) const override;
   int
   nvar() const
   {
@@ -93,12 +93,12 @@ public:
   = default;
   FRTensor(const URTensor &ut);
 
-  virtual ~FRTensor()
-  = default;
+  ~FRTensor()
+  override = default;
 
-  void increment(IntSequence &v) const;
-  void decrement(IntSequence &v) const;
-  UTensor&unfold() const;
+  void increment(IntSequence &v) const override;
+  void decrement(IntSequence &v) const override;
+  UTensor&unfold() const override;
 
   int
   nvar() const
@@ -106,7 +106,7 @@ public:
     return nv;
   }
   int
-  getOffset(const IntSequence &v) const
+  getOffset(const IntSequence &v) const override
   {
     return FTensor::getOffset(v, nv);
   }
@@ -136,9 +136,9 @@ public:
   URSingleTensor(const URSingleTensor &ut)
      
   = default;
-  virtual ~URSingleTensor()
-  = default;
-  FTensor&fold() const;
+  ~URSingleTensor()
+  override = default;
+  FTensor&fold() const override;
 };
 
 /* This class represents one column row-oriented tensor. The only way
@@ -158,8 +158,8 @@ public:
   FRSingleTensor(const FRSingleTensor &ft)
      
   = default;
-  virtual ~FRSingleTensor()
-  = default;
+  ~FRSingleTensor()
+  override = default;
 };
 
 #endif
diff --git a/dynare++/tl/cc/sparse_tensor.hh b/dynare++/tl/cc/sparse_tensor.hh
index 0017106fd53bb88537d26da926245507622d052c..b8f1fa2f212901809e95be100b2c30c3002c69a2 100644
--- a/dynare++/tl/cc/sparse_tensor.hh
+++ b/dynare++/tl/cc/sparse_tensor.hh
@@ -138,7 +138,7 @@ public:
   void insert(const IntSequence &s, int r, double c);
   void multColumnAndAdd(const Tensor &t, Vector &v) const;
   const Symmetry &
-  getSym() const
+  getSym() const override
   {
     return sym;
   }
@@ -169,7 +169,7 @@ public:
   = default;
   void insert(const IntSequence &s, int r, double c);
   const Symmetry &
-  getSym() const
+  getSym() const override
   {
     return tdims.getSym();
   }
diff --git a/dynare++/tl/cc/stack_container.hh b/dynare++/tl/cc/stack_container.hh
index 638b276c231aa7869d2676f22422fad2fbac2326..52cb862420e3f9d604c841f10e490feefe63bb9e 100644
--- a/dynare++/tl/cc/stack_container.hh
+++ b/dynare++/tl/cc/stack_container.hh
@@ -148,48 +148,48 @@ public:
       conts(new const _Ctype *[nc])
   {
   }
-  virtual ~StackContainer()
+  ~StackContainer() override
   {
     delete [] conts;
   }
   const IntSequence &
-  getStackSizes() const
+  getStackSizes() const override
   {
     return stack_sizes;
   }
   IntSequence &
-  getStackSizes()
+  getStackSizes() override
   {
     return stack_sizes;
   }
   const IntSequence &
-  getStackOffsets() const
+  getStackOffsets() const override
   {
     return stack_offsets;
   }
   IntSequence &
-  getStackOffsets()
+  getStackOffsets() override
   {
     return stack_offsets;
   }
   int
-  numConts() const
+  numConts() const override
   {
     return num_conts;
   }
   const _Ctype *
-  getCont(int i) const
+  getCont(int i) const override
   {
     return conts[i];
   }
-  virtual itype getType(int i, const Symmetry &s) const = 0;
+  itype getType(int i, const Symmetry &s) const override = 0;
   int
-  numStacks() const
+  numStacks() const override
   {
     return stack_sizes.size();
   }
   bool
-  isZero(int i, const Symmetry &s) const
+  isZero(int i, const Symmetry &s) const override
   {
     TL_RAISE_IF(i < 0 || i >= numStacks(),
                 "Wrong index to stack in StackContainer::isZero.");
@@ -198,7 +198,7 @@ public:
   }
 
   const _Ttype *
-  getMatrix(int i, const Symmetry &s) const
+  getMatrix(int i, const Symmetry &s) const override
   {
     TL_RAISE_IF(isZero(i, s) || getType(i, s) == _Stype::unit,
                 "Matrix is not returned in StackContainer::getMatrix");
@@ -206,7 +206,7 @@ public:
   }
 
   int
-  getLengthOfMatrixStacks(const Symmetry &s) const
+  getLengthOfMatrixStacks(const Symmetry &s) const override
   {
     int res = 0;
     int i = 0;
@@ -216,7 +216,7 @@ public:
   }
 
   int
-  getUnitPos(const Symmetry &s) const
+  getUnitPos(const Symmetry &s) const override
   {
     if (s.dimen() != 1)
       return -1;
@@ -228,7 +228,7 @@ public:
 
   Vector *
   createPackedColumn(const Symmetry &s,
-                     const IntSequence &coor, int &iu) const
+                     const IntSequence &coor, int &iu) const override
   {
     TL_RAISE_IF(s.dimen() != coor.size(),
                 "Incompatible coordinates for symmetry in StackContainer::createPackedColumn");
@@ -360,7 +360,7 @@ public:
      file, how $z$ looks, and code is clear. */
 
   itype
-  getType(int i, const Symmetry &s) const
+  getType(int i, const Symmetry &s) const override
   {
     if (i == 0)
       return _Stype::matrix;
@@ -443,7 +443,7 @@ public:
      information. */
 
   itype
-  getType(int i, const Symmetry &s) const
+  getType(int i, const Symmetry &s) const override
   {
     if (i == 0)
       if (s[2] > 0 || s == Symmetry(0, 0, 0, 1))
@@ -656,7 +656,7 @@ public:
                      const Symmetry &s,
                      const FGSContainer &dcontainer,
                      FGSTensor &outten);
-  void operator()();
+  void operator()() override;
 };
 
 class WorkerFoldMAASparse1 : public THREAD
@@ -670,7 +670,7 @@ public:
   WorkerFoldMAASparse1(const FoldedStackContainer &container,
                        const FSSparseTensor &ten,
                        FGSTensor &outten, const IntSequence &c);
-  void operator()();
+  void operator()() override;
 };
 
 class WorkerFoldMAASparse2 : public THREAD
@@ -683,7 +683,7 @@ public:
   WorkerFoldMAASparse2(const FoldedStackContainer &container,
                        const FSSparseTensor &ten,
                        FGSTensor &outten, const IntSequence &c);
-  void operator()();
+  void operator()() override;
 };
 
 class WorkerFoldMAASparse4 : public THREAD
@@ -696,7 +696,7 @@ public:
   WorkerFoldMAASparse4(const FoldedStackContainer &container,
                        const FSSparseTensor &ten,
                        FGSTensor &outten, const IntSequence &c);
-  void operator()();
+  void operator()() override;
 };
 
 class WorkerUnfoldMAADense : public THREAD
@@ -710,7 +710,7 @@ public:
                        const Symmetry &s,
                        const UGSContainer &dcontainer,
                        UGSTensor &outten);
-  void operator()();
+  void operator()() override;
 };
 
 class WorkerUnfoldMAASparse1 : public THREAD
@@ -724,7 +724,7 @@ public:
   WorkerUnfoldMAASparse1(const UnfoldedStackContainer &container,
                          const FSSparseTensor &ten,
                          UGSTensor &outten, const IntSequence &c);
-  void operator()();
+  void operator()() override;
 };
 
 class WorkerUnfoldMAASparse2 : public THREAD
@@ -737,7 +737,7 @@ public:
   WorkerUnfoldMAASparse2(const UnfoldedStackContainer &container,
                          const FSSparseTensor &ten,
                          UGSTensor &outten, const IntSequence &c);
-  void operator()();
+  void operator()() override;
 };
 
 #endif
diff --git a/dynare++/tl/cc/tensor.hh b/dynare++/tl/cc/tensor.hh
index 4f0c497e6a13f134e195dc3290854f5ed84d186e..2a30f569f734ee2333ee9e65f7de4e390ed415b6 100644
--- a/dynare++/tl/cc/tensor.hh
+++ b/dynare++/tl/cc/tensor.hh
@@ -197,8 +197,8 @@ public:
       dim(t.dim)
   {
   }
-  virtual ~Tensor()
-  = default;
+  ~Tensor()
+  override = default;
   virtual void increment(IntSequence &v) const = 0;
   virtual void decrement(IntSequence &v) const = 0;
   virtual int getOffset(const IntSequence &v) const = 0;
@@ -252,8 +252,8 @@ public:
     : Tensor(first_row, num, t)
   {
   }
-  virtual ~UTensor()
-  = default;
+  ~UTensor()
+  override = default;
   virtual FTensor&fold() const = 0;
 
   static void increment(IntSequence &v, int nv);
@@ -287,8 +287,8 @@ public:
     : Tensor(first_row, num, t)
   {
   }
-  virtual ~FTensor()
-  = default;
+  ~FTensor()
+  override = default;
   virtual UTensor&unfold() const = 0;
 
   static void decrement(IntSequence &v, int nv);
diff --git a/dynare++/tl/cc/twod_matrix.hh b/dynare++/tl/cc/twod_matrix.hh
index 76c663123f9737a43b3ac2d64e4af36b5f53101f..2f2435c9db83363373955652299f12b7524fabad 100644
--- a/dynare++/tl/cc/twod_matrix.hh
+++ b/dynare++/tl/cc/twod_matrix.hh
@@ -42,8 +42,8 @@ public:
     : ConstGeneralMatrix(m, first_row, first_col, rows, cols)
   {
   }
-  virtual ~ConstTwoDMatrix()
-  = default;
+  ~ConstTwoDMatrix()
+  override = default;
 
   int
   nrows() const
@@ -115,8 +115,8 @@ public:
     : GeneralMatrix(a, b)
   {
   }
-  virtual ~TwoDMatrix()
-  = default;
+  ~TwoDMatrix()
+  override = default;
 
   int
   nrows() const
diff --git a/dynare++/tl/testing/tests.cc b/dynare++/tl/testing/tests.cc
index 940787c8e88bb012023db5f6ded080a11a6068b5..558ca40904f38987087cef198b72c22726197c9b 100644
--- a/dynare++/tl/testing/tests.cc
+++ b/dynare++/tl/testing/tests.cc
@@ -600,7 +600,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     Symmetry s(2, 3);
     IntSequence nvs(2); nvs[0] = 4; nvs[1] = 2;
@@ -616,7 +616,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     Symmetry s(2, 3);
     IntSequence nvs(2); nvs[0] = 4; nvs[1] = 2;
@@ -632,7 +632,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     Symmetry s(2, 3, 2);
     IntSequence nvs(3); nvs[0] = 5; nvs[1] = 2; nvs[2] = 2;
@@ -648,7 +648,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     Symmetry s(2, 3, 2);
     IntSequence nvs(3); nvs[0] = 5; nvs[1] = 2; nvs[2] = 2;
@@ -664,7 +664,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     Symmetry s(1, 1, 3);
     IntSequence nvs(3); nvs[0] = 3; nvs[1] = 3; nvs[2] = 2;
@@ -680,7 +680,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     Symmetry s(2, 3, 2);
     IntSequence nvs(3); nvs[0] = 4; nvs[1] = 2; nvs[2] = 4;
@@ -696,7 +696,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     Symmetry s(1, 1, 3);
     IntSequence nvs(3); nvs[0] = 3; nvs[1] = 3; nvs[2] = 2;
@@ -712,7 +712,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     Symmetry s(2, 3, 2);
     IntSequence nvs(3); nvs[0] = 4; nvs[1] = 2; nvs[2] = 4;
@@ -728,7 +728,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     Symmetry s(2, 3);
     IntSequence nvs(2); nvs[0] = 4; nvs[1] = 2;
@@ -744,7 +744,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     Symmetry s(2, 3);
     IntSequence nvs(2); nvs[0] = 4; nvs[1] = 2;
@@ -760,7 +760,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     Symmetry s(2, 3, 2);
     IntSequence nvs(3); nvs[0] = 5; nvs[1] = 2; nvs[2] = 2;
@@ -776,7 +776,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     Symmetry s(2, 3, 2);
     IntSequence nvs(3); nvs[0] = 5; nvs[1] = 2; nvs[2] = 2;
@@ -792,7 +792,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     return fs_fold_unfold(5, 4, 3);
   }
@@ -806,7 +806,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     Symmetry s(1, 2, 2);
     IntSequence nvs(3); nvs[0] = 3; nvs[1] = 3; nvs[2] = 2;
@@ -822,7 +822,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     return fs_fold_unfold(5, 9, 4);
   }
@@ -836,7 +836,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     Symmetry s(2, 1, 2);
     IntSequence nvs(3); nvs[0] = 6; nvs[1] = 2; nvs[2] = 6;
@@ -852,7 +852,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     return r_fold_unfold(5, 3, 3);
   }
@@ -866,7 +866,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     return r_fold_unfold(5, 6, 5);
   }
@@ -880,7 +880,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     IntSequence bnvs(2); bnvs[0] = 3; bnvs[1] = 2;
     return dense_prod(Symmetry(1, 2), bnvs, 2, 3, 2);
@@ -895,7 +895,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     IntSequence bnvs(2); bnvs[0] = 10; bnvs[1] = 7;
     return dense_prod(Symmetry(2, 3), bnvs, 3, 15, 10);
@@ -910,7 +910,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     IntSequence bnvs(2); bnvs[0] = 13; bnvs[1] = 11;
     return dense_prod(Symmetry(3, 2), bnvs, 3, 20, 20);
@@ -925,7 +925,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     return folded_monomial(10, 4, 5, 3, 4);
   }
@@ -939,7 +939,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     return folded_monomial(20, 12, 10, 5, 4);
   }
@@ -953,7 +953,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     return unfolded_monomial(10, 4, 5, 3, 4);
   }
@@ -967,7 +967,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     return unfolded_monomial(20, 12, 10, 5, 4);
   }
@@ -981,7 +981,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     return folded_contraction(5, 4, 3);
   }
@@ -995,7 +995,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     return folded_contraction(20, 12, 5);
   }
@@ -1009,7 +1009,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     return unfolded_contraction(5, 4, 3);
   }
@@ -1023,7 +1023,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     return unfolded_contraction(20, 12, 5);
   }
@@ -1037,7 +1037,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     return poly_eval(4, 5, 4);
   }
@@ -1051,7 +1051,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     return poly_eval(244, 97, 2);
   }
@@ -1066,7 +1066,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     return fold_zcont(3, 2, 2, 1, 2, 2, 3);
   }
@@ -1081,7 +1081,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     return fold_zcont(13, 5, 7, 4, 6, 7, 4);
   }
@@ -1096,7 +1096,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     return unfold_zcont(3, 2, 2, 1, 2, 2, 3);
   }
@@ -1111,7 +1111,7 @@ public:
   {
   }
   bool
-  run() const
+  run() const override
   {
     return unfold_zcont(13, 5, 7, 4, 6, 7, 4);
   }