diff --git a/include/armadillo_bits/access.hpp b/include/armadillo_bits/access.hpp
index 7031eea7..7d35cfa0 100644
--- a/include/armadillo_bits/access.hpp
+++ b/include/armadillo_bits/access.hpp
@@ -23,19 +23,19 @@
 struct access
   {
   //! internal function to allow modification of data declared as read-only (use with caution)
-  template<typename T1>   constexpr static T1&  rw (const T1& x)        { return const_cast<T1& >(x); }
-  template<typename T1>   constexpr static T1*& rwp(const T1* const& x) { return const_cast<T1*&>(x); }
+  template<typename T1>   static constexpr T1&  rw (const T1& x)        { return const_cast<T1& >(x); }
+  template<typename T1>   static constexpr T1*& rwp(const T1* const& x) { return const_cast<T1*&>(x); }
   
   //! internal function to obtain the real part of either a plain number or a complex number
-  template<typename eT>   constexpr static const eT& tmp_real(const eT&              X) { return X;        }
-  template<typename  T>   constexpr static const   T tmp_real(const std::complex<T>& X) { return X.real(); }
+  template<typename eT>   static constexpr const eT& tmp_real(const eT&              X) { return X;        }
+  template<typename  T>   static constexpr const   T tmp_real(const std::complex<T>& X) { return X.real(); }
   
   //! internal function to obtain the imag part of either a plain number or a complex number
-  template<typename eT>   constexpr static const eT tmp_imag(const eT                ) { return eT(0);    }
-  template<typename  T>   constexpr static const  T tmp_imag(const std::complex<T>& X) { return X.imag(); }
+  template<typename eT>   static constexpr const eT tmp_imag(const eT                ) { return eT(0);    }
+  template<typename  T>   static constexpr const  T tmp_imag(const std::complex<T>& X) { return X.imag(); }
   
   //! internal function to work around braindead compilers
-  template<typename eT>   constexpr static const typename enable_if2<is_cx<eT>::no,  const eT&>::result alt_conj(const eT& X) { return X;            }
+  template<typename eT>   static constexpr const typename enable_if2<is_cx<eT>::no,  const eT&>::result alt_conj(const eT& X) { return X;            }
   template<typename eT> arma_inline static const typename enable_if2<is_cx<eT>::yes, const eT >::result alt_conj(const eT& X) { return std::conj(X); }
   };
 
diff --git a/include/armadillo_bits/arma_rel_comparators.hpp b/include/armadillo_bits/arma_rel_comparators.hpp
index 977617b2..334723ed 100644
--- a/include/armadillo_bits/arma_rel_comparators.hpp
+++ b/include/armadillo_bits/arma_rel_comparators.hpp
@@ -24,7 +24,7 @@
 template<typename eT>
 struct arma_lt_comparator
   {
-  arma_inline bool operator() (const eT a, const eT b) const { return (a < b); }
+  constexpr bool operator() (const eT a, const eT b) const { return (a < b); }
   };
 
 
@@ -32,7 +32,7 @@ struct arma_lt_comparator
 template<typename eT>
 struct arma_gt_comparator
   {
-  arma_inline bool operator() (const eT a, const eT b) const { return (a > b); }
+  constexpr bool operator() (const eT a, const eT b) const { return (a > b); }
   };
 
 
@@ -40,7 +40,7 @@ struct arma_gt_comparator
 template<typename eT>
 struct arma_leq_comparator
   {
-  arma_inline bool operator() (const eT a, const eT b) const { return (a <= b); }
+  constexpr bool operator() (const eT a, const eT b) const { return (a <= b); }
   };
   
 
@@ -48,7 +48,7 @@ struct arma_leq_comparator
 template<typename eT>
 struct arma_geq_comparator
   {
-  arma_inline bool operator() (const eT a, const eT b) const { return (a >= b); }
+  constexpr bool operator() (const eT a, const eT b) const { return (a >= b); }
   };
 
 
diff --git a/include/armadillo_bits/fft_engine_fftw3.hpp b/include/armadillo_bits/fft_engine_fftw3.hpp
index 14c8c3b5..a61120db 100644
--- a/include/armadillo_bits/fft_engine_fftw3.hpp
+++ b/include/armadillo_bits/fft_engine_fftw3.hpp
@@ -33,12 +33,12 @@ struct fft_engine_fftw3_aux
 template<typename cx_type, bool inverse>
 struct fft_engine_fftw3
   {
-  constexpr static int fftw3_sign_forward  = -1;
-  constexpr static int fftw3_sign_backward = +1;
+  static constexpr int fftw3_sign_forward  = -1;
+  static constexpr int fftw3_sign_backward = +1;
   
-  constexpr static unsigned int fftw3_flag_destroy  = (1u << 0);
-  constexpr static unsigned int fftw3_flag_preserve = (1u << 4);
-  constexpr static unsigned int fftw3_flag_estimate = (1u << 6);
+  static constexpr unsigned int fftw3_flag_destroy  = (1u << 0);
+  static constexpr unsigned int fftw3_flag_preserve = (1u << 4);
+  static constexpr unsigned int fftw3_flag_estimate = (1u << 6);
   
   const uword N;
   
diff --git a/include/armadillo_bits/upgrade_val.hpp b/include/armadillo_bits/upgrade_val.hpp
index f317db2e..8ca48676 100644
--- a/include/armadillo_bits/upgrade_val.hpp
+++ b/include/armadillo_bits/upgrade_val.hpp
@@ -30,8 +30,8 @@ struct upgrade_val
   typedef typename promote_type<T1,T2>::result T1_result;
   typedef typename promote_type<T1,T2>::result T2_result;
   
-  constexpr
   static
+  constexpr
   typename promote_type<T1,T2>::result
   apply(const T1 x)
     {
@@ -39,8 +39,8 @@ struct upgrade_val
     return out_type(x);
     }
   
-  constexpr
   static
+  constexpr
   typename promote_type<T1,T2>::result
   apply(const T2 x)
     {
@@ -58,7 +58,7 @@ struct upgrade_val<T,T>
   typedef T T1_result;
   typedef T T2_result;
   
-  constexpr static const T& apply(const T& x) { return x; }
+  static constexpr const T& apply(const T& x) { return x; }
   };
 
 
@@ -71,8 +71,8 @@ struct upgrade_val< std::complex<T>, T2 >
   typedef std::complex<T> T1_result;
   typedef T               T2_result;
   
-  constexpr static const std::complex<T>& apply(const std::complex<T>& x) { return x;    }
-  constexpr static       T                apply(const T2 x)               { return T(x); }
+  static constexpr const std::complex<T>& apply(const std::complex<T>& x) { return x;    }
+  static constexpr       T                apply(const T2 x)               { return T(x); }
   };
 
 
@@ -83,8 +83,8 @@ struct upgrade_val< T1, std::complex<T> >
   typedef T               T1_result;
   typedef std::complex<T> T2_result;
   
-  constexpr static       T                apply(const T1 x)               { return T(x); }
-  constexpr static const std::complex<T>& apply(const std::complex<T>& x) { return x;    }
+  static constexpr       T                apply(const T1 x)               { return T(x); }
+  static constexpr const std::complex<T>& apply(const std::complex<T>& x) { return x;    }
   };
 
 
@@ -95,8 +95,8 @@ struct upgrade_val< std::complex<float>, double >
   typedef std::complex<double> T1_result;
   typedef double               T2_result;
   
-  constexpr static const std::complex<double> apply(const std::complex<float>& x) { return std::complex<double>(x); }
-  constexpr static       double               apply(const double x)               { return x; }
+  static constexpr const std::complex<double> apply(const std::complex<float>& x) { return std::complex<double>(x); }
+  static constexpr       double               apply(const double x)               { return x; }
   };
 
 
@@ -106,8 +106,8 @@ struct upgrade_val< double, std::complex<float> >
   typedef double              T1_result;
   typedef std::complex<float> T2_result;
   
-  constexpr static       double               apply(const double x)               { return x; }
-  constexpr static const std::complex<double> apply(const std::complex<float>& x) { return std::complex<double>(x); }
+  static constexpr       double               apply(const double x)               { return x; }
+  static constexpr const std::complex<double> apply(const std::complex<float>& x) { return std::complex<double>(x); }
   };
 
 
@@ -118,8 +118,8 @@ struct upgrade_val< std::complex<float>, std::complex<double> >
   typedef std::complex<double> T1_result;
   typedef std::complex<double> T2_result;
   
-  constexpr static const std::complex<double>  apply(const std::complex<float>&  x) { return std::complex<double>(x); }
-  constexpr static const std::complex<double>& apply(const std::complex<double>& x) { return x; }
+  static constexpr const std::complex<double>  apply(const std::complex<float>&  x) { return std::complex<double>(x); }
+  static constexpr const std::complex<double>& apply(const std::complex<double>& x) { return x; }
   };
 
 
@@ -129,8 +129,8 @@ struct upgrade_val< std::complex<double>, std::complex<float> >
   typedef std::complex<double> T1_result;
   typedef std::complex<double> T2_result;
   
-  constexpr static const std::complex<double>& apply(const std::complex<double>& x) { return x; }
-  constexpr static const std::complex<double>  apply(const std::complex<float>&  x) { return std::complex<double>(x); }
+  static constexpr const std::complex<double>& apply(const std::complex<double>& x) { return x; }
+  static constexpr const std::complex<double>  apply(const std::complex<float>&  x) { return std::complex<double>(x); }
   };
 
 
@@ -140,8 +140,8 @@ struct upgrade_val< std::complex<double>, float >
   typedef std::complex<double> T1_result;
   typedef double               T2_result;
   
-  constexpr static const std::complex<double>& apply(const std::complex<double>& x) { return x; }
-  constexpr static       double                apply(const float x)                 { return double(x); }
+  static constexpr const std::complex<double>& apply(const std::complex<double>& x) { return x; }
+  static constexpr       double                apply(const float x)                 { return double(x); }
   };
 
 
@@ -151,8 +151,8 @@ struct upgrade_val< float, std::complex<double> >
   typedef double               T1_result;
   typedef std::complex<double> T2_result;
   
-  constexpr static       double                apply(const float x)                 { return double(x); }
-  constexpr static const std::complex<double>& apply(const std::complex<double>& x) { return x; }
+  static constexpr       double                apply(const float x)                 { return double(x); }
+  static constexpr const std::complex<double>& apply(const std::complex<double>& x) { return x; }
   };
 
 
@@ -164,8 +164,8 @@ struct upgrade_val< std::complex<fp16>, std::complex<double> >
   typedef std::complex<double> T1_result;
   typedef std::complex<double> T2_result;
   
-  constexpr static const std::complex<double>  apply(const std::complex<fp16>&   x) { return std::complex<double>(x); }
-  constexpr static const std::complex<double>& apply(const std::complex<double>& x) { return x; }
+  static constexpr const std::complex<double>  apply(const std::complex<fp16>&   x) { return std::complex<double>(x); }
+  static constexpr const std::complex<double>& apply(const std::complex<double>& x) { return x; }
   };
 
 
@@ -175,8 +175,8 @@ struct upgrade_val< std::complex<double>, std::complex<fp16> >
   typedef std::complex<double> T1_result;
   typedef std::complex<double> T2_result;
   
-  constexpr static const std::complex<double>& apply(const std::complex<double>& x) { return x; }
-  constexpr static const std::complex<double>  apply(const std::complex<fp16>&   x) { return std::complex<double>(x); }
+  static constexpr const std::complex<double>& apply(const std::complex<double>& x) { return x; }
+  static constexpr const std::complex<double>  apply(const std::complex<fp16>&   x) { return std::complex<double>(x); }
   };
 
 
@@ -186,8 +186,8 @@ struct upgrade_val< std::complex<fp16>, std::complex<float> >
   typedef std::complex<float> T1_result;
   typedef std::complex<float> T2_result;
   
-  constexpr static const std::complex<float>  apply(const std::complex<fp16>&  x) { return std::complex<float>(x); }
-  constexpr static const std::complex<float>& apply(const std::complex<float>& x) { return x; }
+  static constexpr const std::complex<float>  apply(const std::complex<fp16>&  x) { return std::complex<float>(x); }
+  static constexpr const std::complex<float>& apply(const std::complex<float>& x) { return x; }
   };
 
 
@@ -197,8 +197,8 @@ struct upgrade_val< std::complex<float>, std::complex<fp16> >
   typedef std::complex<float> T1_result;
   typedef std::complex<float> T2_result;
   
-  constexpr static const std::complex<float>& apply(const std::complex<float>& x) { return x; }
-  constexpr static const std::complex<float>  apply(const std::complex<fp16>&  x) { return std::complex<float>(x); }
+  static constexpr const std::complex<float>& apply(const std::complex<float>& x) { return x; }
+  static constexpr const std::complex<float>  apply(const std::complex<fp16>&  x) { return std::complex<float>(x); }
   };
 
 
@@ -208,8 +208,8 @@ struct upgrade_val< std::complex<double>, fp16 >
   typedef std::complex<double> T1_result;
   typedef double               T2_result;
   
-  constexpr static const std::complex<double>& apply(const std::complex<double>& x) { return x; }
-  constexpr static       double                apply(const fp16 x)                  { return double(x); }
+  static constexpr const std::complex<double>& apply(const std::complex<double>& x) { return x; }
+  static constexpr       double                apply(const fp16 x)                  { return double(x); }
   };
 
 
@@ -219,8 +219,8 @@ struct upgrade_val< fp16, std::complex<double> >
   typedef double               T1_result;
   typedef std::complex<double> T2_result;
   
-  constexpr static       double                apply(const fp16 x)                  { return double(x); }
-  constexpr static const std::complex<double>& apply(const std::complex<double>& x) { return x; }
+  static constexpr       double                apply(const fp16 x)                  { return double(x); }
+  static constexpr const std::complex<double>& apply(const std::complex<double>& x) { return x; }
   };
 
 
@@ -230,8 +230,8 @@ struct upgrade_val< std::complex<float>, fp16 >
   typedef std::complex<float> T1_result;
   typedef float               T2_result;
   
-  constexpr static const std::complex<float>& apply(const std::complex<float>& x) { return x; }
-  constexpr static       float                apply(const fp16 x)                 { return float(x); }
+  static constexpr const std::complex<float>& apply(const std::complex<float>& x) { return x; }
+  static constexpr       float                apply(const fp16 x)                 { return float(x); }
   };
 
 
@@ -241,8 +241,8 @@ struct upgrade_val< fp16, std::complex<float> >
   typedef float               T1_result;
   typedef std::complex<float> T2_result;
   
-  constexpr static       float                apply(const fp16 x)                 { return float(x); }
-  constexpr static const std::complex<float>& apply(const std::complex<float>& x) { return x; }
+  static constexpr       float                apply(const fp16 x)                 { return float(x); }
+  static constexpr const std::complex<float>& apply(const std::complex<float>& x) { return x; }
   };
 
 #endif