From fb9994ce6f8044dd08bef7e6b64d6e4fea514fa9 Mon Sep 17 00:00:00 2001
From: conrad <conrad@localhost.localdomain>
Date: Sat, 15 Jun 2024 00:14:48 +1000
Subject: [PATCH] rename mtSpReductionOp to mtSpReduceOp

---
 include/armadillo                                |  4 ++--
 include/armadillo_bits/Mat_bones.hpp             | 14 +++++++-------
 include/armadillo_bits/Mat_meat.hpp              | 14 +++++++-------
 include/armadillo_bits/SpMat_bones.hpp           | 14 +++++++-------
 include/armadillo_bits/SpMat_meat.hpp            | 14 +++++++-------
 include/armadillo_bits/SpProxy.hpp               | 10 +++++-----
 include/armadillo_bits/arma_forward.hpp          |  2 +-
 include/armadillo_bits/fn_diagvec.hpp            |  4 ++--
 include/armadillo_bits/fn_max.hpp                |  8 ++++----
 include/armadillo_bits/fn_mean.hpp               |  8 ++++----
 include/armadillo_bits/fn_min.hpp                |  8 ++++----
 include/armadillo_bits/fn_stddev.hpp             |  8 ++++----
 include/armadillo_bits/fn_sum.hpp                |  8 ++++----
 include/armadillo_bits/fn_var.hpp                |  8 ++++----
 include/armadillo_bits/fn_vecnorm.hpp            | 16 ++++++++--------
 ...uctionOp_bones.hpp => mtSpReduceOp_bones.hpp} | 10 +++++-----
 ...eductionOp_meat.hpp => mtSpReduceOp_meat.hpp} |  8 ++++----
 include/armadillo_bits/op_sp_diagvec_bones.hpp   |  2 +-
 include/armadillo_bits/op_sp_diagvec_meat.hpp    |  2 +-
 include/armadillo_bits/op_sp_max_bones.hpp       |  2 +-
 include/armadillo_bits/op_sp_max_meat.hpp        |  2 +-
 include/armadillo_bits/op_sp_mean_bones.hpp      |  2 +-
 include/armadillo_bits/op_sp_mean_meat.hpp       |  2 +-
 include/armadillo_bits/op_sp_min_bones.hpp       |  2 +-
 include/armadillo_bits/op_sp_min_meat.hpp        |  2 +-
 include/armadillo_bits/op_sp_stddev_bones.hpp    |  2 +-
 include/armadillo_bits/op_sp_stddev_meat.hpp     |  2 +-
 include/armadillo_bits/op_sp_sum_bones.hpp       |  2 +-
 include/armadillo_bits/op_sp_sum_meat.hpp        |  2 +-
 include/armadillo_bits/op_sp_var_bones.hpp       |  2 +-
 include/armadillo_bits/op_sp_var_meat.hpp        |  2 +-
 include/armadillo_bits/op_sp_vecnorm_bones.hpp   |  4 ++--
 include/armadillo_bits/op_sp_vecnorm_meat.hpp    |  4 ++--
 include/armadillo_bits/traits.hpp                |  6 +++---
 include/armadillo_bits/unwrap_spmat.hpp          |  4 ++--
 35 files changed, 102 insertions(+), 102 deletions(-)
 rename include/armadillo_bits/{mtSpReductionOp_bones.hpp => mtSpReduceOp_bones.hpp} (83%)
 rename include/armadillo_bits/{mtSpReductionOp_meat.hpp => mtSpReduceOp_meat.hpp} (80%)

diff --git a/include/armadillo b/include/armadillo
index 6be4e325..6bf138bf 100644
--- a/include/armadillo
+++ b/include/armadillo
@@ -221,7 +221,7 @@ namespace arma
   #include "armadillo_bits/OpCube_bones.hpp"
   #include "armadillo_bits/SpOp_bones.hpp"
   #include "armadillo_bits/SpToDOp_bones.hpp"
-  #include "armadillo_bits/mtSpReductionOp_bones.hpp"
+  #include "armadillo_bits/mtSpReduceOp_bones.hpp"
   
   #include "armadillo_bits/eOp_bones.hpp"
   #include "armadillo_bits/eOpCube_bones.hpp"
@@ -628,7 +628,7 @@ namespace arma
   #include "armadillo_bits/mtOp_meat.hpp"
   #include "armadillo_bits/mtOpCube_meat.hpp"
   #include "armadillo_bits/mtSpOp_meat.hpp"
-  #include "armadillo_bits/mtSpReductionOp_meat.hpp"
+  #include "armadillo_bits/mtSpReduceOp_meat.hpp"
   
   #include "armadillo_bits/Glue_meat.hpp"
   #include "armadillo_bits/GlueCube_meat.hpp"
diff --git a/include/armadillo_bits/Mat_bones.hpp b/include/armadillo_bits/Mat_bones.hpp
index 95a58856..48012e8a 100644
--- a/include/armadillo_bits/Mat_bones.hpp
+++ b/include/armadillo_bits/Mat_bones.hpp
@@ -368,13 +368,13 @@ class Mat : public Base< eT, Mat<eT> >
   template<typename T1, typename op_type> inline Mat& operator%=(const SpToDOp<T1, op_type>& X);
   template<typename T1, typename op_type> inline Mat& operator/=(const SpToDOp<T1, op_type>& X);
   
-  template<typename T1, typename op_type> inline explicit    Mat(const mtSpReductionOp<eT, T1, op_type>& X);
-  template<typename T1, typename op_type> inline Mat& operator= (const mtSpReductionOp<eT, T1, op_type>& X);
-  template<typename T1, typename op_type> inline Mat& operator+=(const mtSpReductionOp<eT, T1, op_type>& X);
-  template<typename T1, typename op_type> inline Mat& operator-=(const mtSpReductionOp<eT, T1, op_type>& X);
-  template<typename T1, typename op_type> inline Mat& operator*=(const mtSpReductionOp<eT, T1, op_type>& X);
-  template<typename T1, typename op_type> inline Mat& operator%=(const mtSpReductionOp<eT, T1, op_type>& X);
-  template<typename T1, typename op_type> inline Mat& operator/=(const mtSpReductionOp<eT, T1, op_type>& X);
+  template<typename T1, typename op_type> inline explicit    Mat(const mtSpReduceOp<eT, T1, op_type>& X);
+  template<typename T1, typename op_type> inline Mat& operator= (const mtSpReduceOp<eT, T1, op_type>& X);
+  template<typename T1, typename op_type> inline Mat& operator+=(const mtSpReduceOp<eT, T1, op_type>& X);
+  template<typename T1, typename op_type> inline Mat& operator-=(const mtSpReduceOp<eT, T1, op_type>& X);
+  template<typename T1, typename op_type> inline Mat& operator*=(const mtSpReduceOp<eT, T1, op_type>& X);
+  template<typename T1, typename op_type> inline Mat& operator%=(const mtSpReduceOp<eT, T1, op_type>& X);
+  template<typename T1, typename op_type> inline Mat& operator/=(const mtSpReduceOp<eT, T1, op_type>& X);
   
   template<typename T1, typename T2, typename glue_type> inline             Mat(const Glue<T1, T2, glue_type>& X);
   template<typename T1, typename T2, typename glue_type> inline Mat& operator= (const Glue<T1, T2, glue_type>& X);
diff --git a/include/armadillo_bits/Mat_meat.hpp b/include/armadillo_bits/Mat_meat.hpp
index af00497d..54ed5094 100644
--- a/include/armadillo_bits/Mat_meat.hpp
+++ b/include/armadillo_bits/Mat_meat.hpp
@@ -5658,7 +5658,7 @@ Mat<eT>::operator/=(const SpToDOp<T1, op_type>& X)
 template<typename eT>
 template<typename T1, typename op_type>
 inline
-Mat<eT>::Mat(const mtSpReductionOp<eT, T1, op_type>& X)
+Mat<eT>::Mat(const mtSpReduceOp<eT, T1, op_type>& X)
   : n_rows(0)
   , n_cols(0)
   , n_elem(0)
@@ -5678,7 +5678,7 @@ template<typename eT>
 template<typename T1, typename op_type>
 inline
 Mat<eT>&
-Mat<eT>::operator=(const mtSpReductionOp<eT, T1, op_type>& X)
+Mat<eT>::operator=(const mtSpReduceOp<eT, T1, op_type>& X)
   {
   arma_debug_sigprint();
 
@@ -5693,7 +5693,7 @@ template<typename eT>
 template<typename T1, typename op_type>
 inline
 Mat<eT>&
-Mat<eT>::operator+=(const mtSpReductionOp<eT, T1, op_type>& X)
+Mat<eT>::operator+=(const mtSpReduceOp<eT, T1, op_type>& X)
   {
   arma_debug_sigprint();
   
@@ -5708,7 +5708,7 @@ template<typename eT>
 template<typename T1, typename op_type>
 inline
 Mat<eT>&
-Mat<eT>::operator-=(const mtSpReductionOp<eT, T1, op_type>& X)
+Mat<eT>::operator-=(const mtSpReduceOp<eT, T1, op_type>& X)
   {
   arma_debug_sigprint();
   
@@ -5723,7 +5723,7 @@ template<typename eT>
 template<typename T1, typename op_type>
 inline
 Mat<eT>&
-Mat<eT>::operator*=(const mtSpReductionOp<eT, T1, op_type>& X)
+Mat<eT>::operator*=(const mtSpReduceOp<eT, T1, op_type>& X)
   {
   arma_debug_sigprint();
   
@@ -5738,7 +5738,7 @@ template<typename eT>
 template<typename T1, typename op_type>
 inline
 Mat<eT>&
-Mat<eT>::operator%=(const mtSpReductionOp<eT, T1, op_type>& X)
+Mat<eT>::operator%=(const mtSpReduceOp<eT, T1, op_type>& X)
   {
   arma_debug_sigprint();
   
@@ -5753,7 +5753,7 @@ template<typename eT>
 template<typename T1, typename op_type>
 inline
 Mat<eT>&
-Mat<eT>::operator/=(const mtSpReductionOp<eT, T1, op_type>& X)
+Mat<eT>::operator/=(const mtSpReduceOp<eT, T1, op_type>& X)
   {
   arma_debug_sigprint();
   
diff --git a/include/armadillo_bits/SpMat_bones.hpp b/include/armadillo_bits/SpMat_bones.hpp
index 2d64a3bb..34b7d81b 100644
--- a/include/armadillo_bits/SpMat_bones.hpp
+++ b/include/armadillo_bits/SpMat_bones.hpp
@@ -200,13 +200,13 @@ class SpMat : public SpBase< eT, SpMat<eT> >
   template<typename T1, typename T2, typename spglue_type> inline SpMat& operator%=(const mtSpGlue<eT, T1, T2, spglue_type>& X);
   template<typename T1, typename T2, typename spglue_type> inline SpMat& operator/=(const mtSpGlue<eT, T1, T2, spglue_type>& X);
   
-  template<typename T1, typename op_type> inline             SpMat(const mtSpReductionOp<eT, T1, op_type>& X);
-  template<typename T1, typename op_type> inline SpMat& operator= (const mtSpReductionOp<eT, T1, op_type>& X);
-  template<typename T1, typename op_type> inline SpMat& operator+=(const mtSpReductionOp<eT, T1, op_type>& X);
-  template<typename T1, typename op_type> inline SpMat& operator-=(const mtSpReductionOp<eT, T1, op_type>& X);
-  template<typename T1, typename op_type> inline SpMat& operator*=(const mtSpReductionOp<eT, T1, op_type>& X);
-  template<typename T1, typename op_type> inline SpMat& operator%=(const mtSpReductionOp<eT, T1, op_type>& X);
-  template<typename T1, typename op_type> inline SpMat& operator/=(const mtSpReductionOp<eT, T1, op_type>& X);
+  template<typename T1, typename op_type> inline             SpMat(const mtSpReduceOp<eT, T1, op_type>& X);
+  template<typename T1, typename op_type> inline SpMat& operator= (const mtSpReduceOp<eT, T1, op_type>& X);
+  template<typename T1, typename op_type> inline SpMat& operator+=(const mtSpReduceOp<eT, T1, op_type>& X);
+  template<typename T1, typename op_type> inline SpMat& operator-=(const mtSpReduceOp<eT, T1, op_type>& X);
+  template<typename T1, typename op_type> inline SpMat& operator*=(const mtSpReduceOp<eT, T1, op_type>& X);
+  template<typename T1, typename op_type> inline SpMat& operator%=(const mtSpReduceOp<eT, T1, op_type>& X);
+  template<typename T1, typename op_type> inline SpMat& operator/=(const mtSpReduceOp<eT, T1, op_type>& X);
   
   
   arma_inline       SpSubview_row<eT> row(const uword row_num);
diff --git a/include/armadillo_bits/SpMat_meat.hpp b/include/armadillo_bits/SpMat_meat.hpp
index b869ea89..89ce5d17 100644
--- a/include/armadillo_bits/SpMat_meat.hpp
+++ b/include/armadillo_bits/SpMat_meat.hpp
@@ -2191,7 +2191,7 @@ SpMat<eT>::operator/=(const mtSpGlue<eT, T1, T2, spglue_type>& X)
 template<typename eT>
 template<typename T1, typename op_type>
 inline
-SpMat<eT>::SpMat(const mtSpReductionOp<eT, T1, op_type>& X)
+SpMat<eT>::SpMat(const mtSpReduceOp<eT, T1, op_type>& X)
   : n_rows(0)
   , n_cols(0)
   , n_elem(0)
@@ -2214,7 +2214,7 @@ template<typename eT>
 template<typename T1, typename op_type>
 inline
 SpMat<eT>&
-SpMat<eT>::operator=(const mtSpReductionOp<eT, T1, op_type>& X)
+SpMat<eT>::operator=(const mtSpReduceOp<eT, T1, op_type>& X)
   {
   arma_debug_sigprint();
   
@@ -2229,7 +2229,7 @@ template<typename eT>
 template<typename T1, typename op_type>
 inline
 SpMat<eT>&
-SpMat<eT>::operator+=(const mtSpReductionOp<eT, T1, op_type>& X)
+SpMat<eT>::operator+=(const mtSpReduceOp<eT, T1, op_type>& X)
   {
   arma_debug_sigprint();
   
@@ -2244,7 +2244,7 @@ template<typename eT>
 template<typename T1, typename op_type>
 inline
 SpMat<eT>&
-SpMat<eT>::operator-=(const mtSpReductionOp<eT, T1, op_type>& X)
+SpMat<eT>::operator-=(const mtSpReduceOp<eT, T1, op_type>& X)
   {
   arma_debug_sigprint();
   
@@ -2259,7 +2259,7 @@ template<typename eT>
 template<typename T1, typename op_type>
 inline
 SpMat<eT>&
-SpMat<eT>::operator*=(const mtSpReductionOp<eT, T1, op_type>& X)
+SpMat<eT>::operator*=(const mtSpReduceOp<eT, T1, op_type>& X)
   {
   arma_debug_sigprint();
   
@@ -2274,7 +2274,7 @@ template<typename eT>
 template<typename T1, typename op_type>
 inline
 SpMat<eT>&
-SpMat<eT>::operator%=(const mtSpReductionOp<eT, T1, op_type>& X)
+SpMat<eT>::operator%=(const mtSpReduceOp<eT, T1, op_type>& X)
   {
   arma_debug_sigprint();
   
@@ -2289,7 +2289,7 @@ template<typename eT>
 template<typename T1, typename op_type>
 inline
 SpMat<eT>&
-SpMat<eT>::operator/=(const mtSpReductionOp<eT, T1, op_type>& X)
+SpMat<eT>::operator/=(const mtSpReduceOp<eT, T1, op_type>& X)
   {
   arma_debug_sigprint();
   
diff --git a/include/armadillo_bits/SpProxy.hpp b/include/armadillo_bits/SpProxy.hpp
index df2a3cd8..3accff62 100644
--- a/include/armadillo_bits/SpProxy.hpp
+++ b/include/armadillo_bits/SpProxy.hpp
@@ -686,7 +686,7 @@ struct SpProxy< mtSpGlue<out_eT, T1, T2, spglue_type> >
 
 
 template<typename out_eT, typename T1, typename op_type>
-struct SpProxy< mtSpReductionOp<out_eT, T1, op_type> >
+struct SpProxy< mtSpReduceOp<out_eT, T1, op_type> >
   {
   typedef          out_eT                          elem_type;
   typedef typename get_pod_type<elem_type>::result pod_type;
@@ -698,13 +698,13 @@ struct SpProxy< mtSpReductionOp<out_eT, T1, op_type> >
   static constexpr bool use_iterator   = false;
   static constexpr bool Q_is_generated = true;
   
-  static constexpr bool is_row  = mtSpReductionOp<out_eT, T1, op_type>::is_row;
-  static constexpr bool is_col  = mtSpReductionOp<out_eT, T1, op_type>::is_col;
-  static constexpr bool is_xvec = mtSpReductionOp<out_eT, T1, op_type>::is_xvec;
+  static constexpr bool is_row  = mtSpReduceOp<out_eT, T1, op_type>::is_row;
+  static constexpr bool is_col  = mtSpReduceOp<out_eT, T1, op_type>::is_col;
+  static constexpr bool is_xvec = mtSpReduceOp<out_eT, T1, op_type>::is_xvec;
   
   arma_aligned const SpMat<out_eT> Q;
   
-  inline explicit SpProxy(const mtSpReductionOp<out_eT, T1, op_type>& A)
+  inline explicit SpProxy(const mtSpReduceOp<out_eT, T1, op_type>& A)
     : Q(A)
     {
     arma_debug_sigprint();
diff --git a/include/armadillo_bits/arma_forward.hpp b/include/armadillo_bits/arma_forward.hpp
index 7b02bb9d..06f4d1c7 100644
--- a/include/armadillo_bits/arma_forward.hpp
+++ b/include/armadillo_bits/arma_forward.hpp
@@ -326,7 +326,7 @@ struct state_type
 
 template<                 typename T1, typename spop_type> class   SpOp;
 template<typename out_eT, typename T1, typename spop_type> class mtSpOp;
-template<typename out_eT, typename T1, typename   op_type> class mtSpReductionOp;
+template<typename out_eT, typename T1, typename   op_type> class mtSpReduceOp;
 
 template<                 typename T1, typename T2, typename spglue_type> class   SpGlue;
 template<typename out_eT, typename T1, typename T2, typename spglue_type> class mtSpGlue;
diff --git a/include/armadillo_bits/fn_diagvec.hpp b/include/armadillo_bits/fn_diagvec.hpp
index 8fc2b6dc..3665a09d 100644
--- a/include/armadillo_bits/fn_diagvec.hpp
+++ b/include/armadillo_bits/fn_diagvec.hpp
@@ -51,12 +51,12 @@ diagvec(const Base<typename T1::elem_type,T1>& X, const sword diag_id)
 template<typename T1>
 arma_warn_unused
 arma_inline
-const mtSpReductionOp<typename T1::elem_type, T1, op_sp_diagvec>
+const mtSpReduceOp<typename T1::elem_type, T1, op_sp_diagvec>
 diagvec(const SpBase<typename T1::elem_type,T1>& X, const sword diag_id = 0)
   {
   arma_debug_sigprint();
   
-  return mtSpReductionOp<typename T1::elem_type, T1, op_sp_diagvec>(X.get_ref(), ((diag_id < 0) ? -diag_id : diag_id), ((diag_id < 0) ? 1 : 0) );
+  return mtSpReduceOp<typename T1::elem_type, T1, op_sp_diagvec>(X.get_ref(), ((diag_id < 0) ? -diag_id : diag_id), ((diag_id < 0) ? 1 : 0) );
   }
 
 
diff --git a/include/armadillo_bits/fn_max.hpp b/include/armadillo_bits/fn_max.hpp
index a0d5a5ea..39337b22 100644
--- a/include/armadillo_bits/fn_max.hpp
+++ b/include/armadillo_bits/fn_max.hpp
@@ -152,13 +152,13 @@ typename
 enable_if2
   <
   is_arma_sparse_type<T1>::value && resolves_to_sparse_vector<T1>::no,
-  const mtSpReductionOp<typename T1::elem_type, T1, op_sp_max>
+  const mtSpReduceOp<typename T1::elem_type, T1, op_sp_max>
   >::result
 max(const T1& X)
   {
   arma_debug_sigprint();
   
-  return mtSpReductionOp<typename T1::elem_type, T1, op_sp_max>(X, 0, 0);
+  return mtSpReduceOp<typename T1::elem_type, T1, op_sp_max>(X, 0, 0);
   }
 
 
@@ -170,13 +170,13 @@ typename
 enable_if2
   <
   is_arma_sparse_type<T1>::value,
-  const mtSpReductionOp<typename T1::elem_type, T1, op_sp_max>
+  const mtSpReduceOp<typename T1::elem_type, T1, op_sp_max>
   >::result
 max(const T1& X, const uword dim)
   {
   arma_debug_sigprint();
   
-  return mtSpReductionOp<typename T1::elem_type, T1, op_sp_max>(X, dim, 0);
+  return mtSpReduceOp<typename T1::elem_type, T1, op_sp_max>(X, dim, 0);
   }
 
 
diff --git a/include/armadillo_bits/fn_mean.hpp b/include/armadillo_bits/fn_mean.hpp
index 509c4826..23416280 100644
--- a/include/armadillo_bits/fn_mean.hpp
+++ b/include/armadillo_bits/fn_mean.hpp
@@ -113,13 +113,13 @@ typename
 enable_if2
   <
   is_arma_sparse_type<T1>::value && resolves_to_sparse_vector<T1>::no,
-  const mtSpReductionOp<typename T1::elem_type, T1, op_sp_mean>
+  const mtSpReduceOp<typename T1::elem_type, T1, op_sp_mean>
   >::result
 mean(const T1& x)
   {
   arma_debug_sigprint();
   
-  return mtSpReductionOp<typename T1::elem_type, T1, op_sp_mean>(x, 0, 0);
+  return mtSpReduceOp<typename T1::elem_type, T1, op_sp_mean>(x, 0, 0);
   }
 
 
@@ -131,13 +131,13 @@ typename
 enable_if2
   <
   is_arma_sparse_type<T1>::value,
-  const mtSpReductionOp<typename T1::elem_type, T1, op_sp_mean>
+  const mtSpReduceOp<typename T1::elem_type, T1, op_sp_mean>
   >::result
 mean(const T1& x, const uword dim)
   {
   arma_debug_sigprint();
   
-  return mtSpReductionOp<typename T1::elem_type, T1, op_sp_mean>(x, dim, 0);
+  return mtSpReduceOp<typename T1::elem_type, T1, op_sp_mean>(x, dim, 0);
   }
 
 
diff --git a/include/armadillo_bits/fn_min.hpp b/include/armadillo_bits/fn_min.hpp
index 0835d6f6..f5f230e2 100644
--- a/include/armadillo_bits/fn_min.hpp
+++ b/include/armadillo_bits/fn_min.hpp
@@ -152,13 +152,13 @@ typename
 enable_if2
   <
   is_arma_sparse_type<T1>::value && resolves_to_sparse_vector<T1>::no,
-  const mtSpReductionOp<typename T1::elem_type, T1, op_sp_min>
+  const mtSpReduceOp<typename T1::elem_type, T1, op_sp_min>
   >::result
 min(const T1& X)
   {
   arma_debug_sigprint();
   
-  return mtSpReductionOp<typename T1::elem_type, T1, op_sp_min>(X, 0, 0);
+  return mtSpReduceOp<typename T1::elem_type, T1, op_sp_min>(X, 0, 0);
   }
 
 
@@ -170,13 +170,13 @@ typename
 enable_if2
   <
   is_arma_sparse_type<T1>::value,
-  const mtSpReductionOp<typename T1::elem_type, T1, op_sp_min>
+  const mtSpReduceOp<typename T1::elem_type, T1, op_sp_min>
   >::result
 min(const T1& X, const uword dim)
   {
   arma_debug_sigprint();
   
-  return mtSpReductionOp<typename T1::elem_type, T1, op_sp_min>(X, dim, 0);
+  return mtSpReduceOp<typename T1::elem_type, T1, op_sp_min>(X, dim, 0);
   }
 
 
diff --git a/include/armadillo_bits/fn_stddev.hpp b/include/armadillo_bits/fn_stddev.hpp
index 1f106631..cb8e2785 100644
--- a/include/armadillo_bits/fn_stddev.hpp
+++ b/include/armadillo_bits/fn_stddev.hpp
@@ -111,13 +111,13 @@ typename
 enable_if2
   <
   is_arma_sparse_type<T1>::value && resolves_to_sparse_vector<T1>::no, 
-  const mtSpReductionOp<typename T1::pod_type, T1, op_sp_stddev>
+  const mtSpReduceOp<typename T1::pod_type, T1, op_sp_stddev>
   >::result
 stddev(const T1& X, const uword norm_type = 0)
   {
   arma_debug_sigprint();
   
-  return mtSpReductionOp<typename T1::pod_type, T1, op_sp_stddev>(X, norm_type, 0);
+  return mtSpReduceOp<typename T1::pod_type, T1, op_sp_stddev>(X, norm_type, 0);
   }
 
 
@@ -129,13 +129,13 @@ typename
 enable_if2
   <
   is_arma_sparse_type<T1>::value,
-  const mtSpReductionOp<typename T1::pod_type, T1, op_sp_stddev>
+  const mtSpReduceOp<typename T1::pod_type, T1, op_sp_stddev>
   >::result
 stddev(const T1& X, const uword norm_type, const uword dim)
   {
   arma_debug_sigprint();
   
-  return mtSpReductionOp<typename T1::pod_type, T1, op_sp_stddev>(X, norm_type, dim);
+  return mtSpReduceOp<typename T1::pod_type, T1, op_sp_stddev>(X, norm_type, dim);
   }
 
 
diff --git a/include/armadillo_bits/fn_sum.hpp b/include/armadillo_bits/fn_sum.hpp
index 02f673ff..c27b1c4a 100644
--- a/include/armadillo_bits/fn_sum.hpp
+++ b/include/armadillo_bits/fn_sum.hpp
@@ -115,13 +115,13 @@ typename
 enable_if2
   <
   is_arma_sparse_type<T1>::value && resolves_to_sparse_vector<T1>::no,
-  const mtSpReductionOp<typename T1::elem_type, T1, op_sp_sum>
+  const mtSpReduceOp<typename T1::elem_type, T1, op_sp_sum>
   >::result
 sum(const T1& x)
   {
   arma_debug_sigprint();
   
-  return mtSpReductionOp<typename T1::elem_type, T1, op_sp_sum>(x, 0, 0);
+  return mtSpReduceOp<typename T1::elem_type, T1, op_sp_sum>(x, 0, 0);
   }
 
 
@@ -133,13 +133,13 @@ typename
 enable_if2
   <
   is_arma_sparse_type<T1>::value,
-  const mtSpReductionOp<typename T1::elem_type, T1, op_sp_sum>
+  const mtSpReduceOp<typename T1::elem_type, T1, op_sp_sum>
   >::result
 sum(const T1& x, const uword dim)
   {
   arma_debug_sigprint();
   
-  return mtSpReductionOp<typename T1::elem_type, T1, op_sp_sum>(x, dim, 0);
+  return mtSpReduceOp<typename T1::elem_type, T1, op_sp_sum>(x, dim, 0);
   }
 
 
diff --git a/include/armadillo_bits/fn_var.hpp b/include/armadillo_bits/fn_var.hpp
index f998884f..1902e30a 100644
--- a/include/armadillo_bits/fn_var.hpp
+++ b/include/armadillo_bits/fn_var.hpp
@@ -111,13 +111,13 @@ typename
 enable_if2
   <
   is_arma_sparse_type<T1>::value && resolves_to_sparse_vector<T1>::no, 
-  const mtSpReductionOp<typename T1::pod_type, T1, op_sp_var>
+  const mtSpReduceOp<typename T1::pod_type, T1, op_sp_var>
   >::result
 var(const T1& X, const uword norm_type = 0)
   {
   arma_debug_sigprint();
   
-  return mtSpReductionOp<typename T1::pod_type, T1, op_sp_var>(X, norm_type, 0);
+  return mtSpReduceOp<typename T1::pod_type, T1, op_sp_var>(X, norm_type, 0);
   }
 
 
@@ -129,13 +129,13 @@ typename
 enable_if2
   <
   is_arma_sparse_type<T1>::value,
-  const mtSpReductionOp<typename T1::pod_type, T1, op_sp_var>
+  const mtSpReduceOp<typename T1::pod_type, T1, op_sp_var>
   >::result
 var(const T1& X, const uword norm_type, const uword dim)
   {
   arma_debug_sigprint();
   
-  return mtSpReductionOp<typename T1::pod_type, T1, op_sp_var>(X, norm_type, dim);
+  return mtSpReduceOp<typename T1::pod_type, T1, op_sp_var>(X, norm_type, dim);
   }
 
 
diff --git a/include/armadillo_bits/fn_vecnorm.hpp b/include/armadillo_bits/fn_vecnorm.hpp
index 61f80e5e..4cfc2d99 100644
--- a/include/armadillo_bits/fn_vecnorm.hpp
+++ b/include/armadillo_bits/fn_vecnorm.hpp
@@ -249,7 +249,7 @@ typename
 enable_if2
   <
   is_arma_sparse_type<T1>::value && resolves_to_sparse_vector<T1>::no,
-  const mtSpReductionOp<typename T1::pod_type, T1, op_sp_vecnorm>
+  const mtSpReduceOp<typename T1::pod_type, T1, op_sp_vecnorm>
   >::result
 vecnorm
   (
@@ -265,7 +265,7 @@ vecnorm
   
   const uword dim = 0;
   
-  return mtSpReductionOp<typename T1::pod_type, T1, op_sp_vecnorm>(X, k, dim);
+  return mtSpReduceOp<typename T1::pod_type, T1, op_sp_vecnorm>(X, k, dim);
   }
 
 
@@ -273,7 +273,7 @@ vecnorm
 template<typename T1>
 arma_warn_unused
 inline
-const mtSpReductionOp<typename T1::pod_type, T1, op_sp_vecnorm>
+const mtSpReduceOp<typename T1::pod_type, T1, op_sp_vecnorm>
 vecnorm
   (
   const SpBase<typename T1::elem_type,T1>& X,
@@ -285,7 +285,7 @@ vecnorm
   arma_debug_sigprint();
   arma_ignore(junk);
   
-  return mtSpReductionOp<typename T1::pod_type, T1, op_sp_vecnorm>(X.get_ref(), k, dim);
+  return mtSpReduceOp<typename T1::pod_type, T1, op_sp_vecnorm>(X.get_ref(), k, dim);
   }
 
 
@@ -327,7 +327,7 @@ typename
 enable_if2
   <
   is_arma_sparse_type<T1>::value && resolves_to_sparse_vector<T1>::no,
-  const mtSpReductionOp<typename T1::pod_type, T1, op_sp_vecnorm_ext>
+  const mtSpReduceOp<typename T1::pod_type, T1, op_sp_vecnorm_ext>
   >::result
 vecnorm
   (
@@ -350,7 +350,7 @@ vecnorm
   
   const uword dim = 0;
   
-  return mtSpReductionOp<typename T1::pod_type, T1, op_sp_vecnorm_ext>(X, method_id, dim);
+  return mtSpReduceOp<typename T1::pod_type, T1, op_sp_vecnorm_ext>(X, method_id, dim);
   }
 
 
@@ -358,7 +358,7 @@ vecnorm
 template<typename T1>
 arma_warn_unused
 inline
-const mtSpReductionOp<typename T1::pod_type, T1, op_sp_vecnorm_ext>
+const mtSpReduceOp<typename T1::pod_type, T1, op_sp_vecnorm_ext>
 vecnorm
   (
   const SpBase<typename T1::elem_type,T1>& X,
@@ -377,7 +377,7 @@ vecnorm
   if( (sig == 'i') || (sig == 'I') || (sig == '+') )  { method_id = 1; }
   if( (sig == '-')                                 )  { method_id = 2; }
   
-  return mtSpReductionOp<typename T1::pod_type, T1, op_sp_vecnorm_ext>(X.get_ref(), method_id, dim);
+  return mtSpReduceOp<typename T1::pod_type, T1, op_sp_vecnorm_ext>(X.get_ref(), method_id, dim);
   }
 
 
diff --git a/include/armadillo_bits/mtSpReductionOp_bones.hpp b/include/armadillo_bits/mtSpReduceOp_bones.hpp
similarity index 83%
rename from include/armadillo_bits/mtSpReductionOp_bones.hpp
rename to include/armadillo_bits/mtSpReduceOp_bones.hpp
index 6465fdd4..8fba56ed 100644
--- a/include/armadillo_bits/mtSpReductionOp_bones.hpp
+++ b/include/armadillo_bits/mtSpReduceOp_bones.hpp
@@ -16,13 +16,13 @@
 // ------------------------------------------------------------------------
 
 
-//! \addtogroup mtSpReductionOp
+//! \addtogroup mtSpReduceOp
 //! @{
 
 
 
 template<typename out_eT, typename T1, typename op_type>
-class mtSpReductionOp : public SpBase< out_eT, mtSpReductionOp<out_eT, T1, op_type> >
+class mtSpReduceOp : public SpBase< out_eT, mtSpReduceOp<out_eT, T1, op_type> >
   {
   public:
   
@@ -35,9 +35,9 @@ class mtSpReductionOp : public SpBase< out_eT, mtSpReductionOp<out_eT, T1, op_ty
   static constexpr bool is_col  = op_type::template traits<T1>::is_col;
   static constexpr bool is_xvec = op_type::template traits<T1>::is_xvec;
   
-  inline explicit mtSpReductionOp(const T1& in_m);
-  inline          mtSpReductionOp(const T1& in_m, const uword in_aux_uword_a, const uword in_aux_uword_b);
-  inline         ~mtSpReductionOp();
+  inline explicit mtSpReduceOp(const T1& in_m);
+  inline          mtSpReduceOp(const T1& in_m, const uword in_aux_uword_a, const uword in_aux_uword_b);
+  inline         ~mtSpReduceOp();
   
   arma_aligned const T1&   m;            //!< the operand; must be derived from SpBase
   arma_aligned       uword aux_uword_a;  //!< auxiliary data, uword format
diff --git a/include/armadillo_bits/mtSpReductionOp_meat.hpp b/include/armadillo_bits/mtSpReduceOp_meat.hpp
similarity index 80%
rename from include/armadillo_bits/mtSpReductionOp_meat.hpp
rename to include/armadillo_bits/mtSpReduceOp_meat.hpp
index c7f1ea28..e7a63c75 100644
--- a/include/armadillo_bits/mtSpReductionOp_meat.hpp
+++ b/include/armadillo_bits/mtSpReduceOp_meat.hpp
@@ -16,14 +16,14 @@
 // ------------------------------------------------------------------------
 
 
-//! \addtogroup mtSpReductionOp
+//! \addtogroup mtSpReduceOp
 //! @{
 
 
 
 template<typename out_eT, typename T1, typename op_type>
 inline
-mtSpReductionOp<out_eT, T1, op_type>::mtSpReductionOp(const T1& in_m)
+mtSpReduceOp<out_eT, T1, op_type>::mtSpReduceOp(const T1& in_m)
   : m(in_m)
   {
   arma_debug_sigprint();
@@ -33,7 +33,7 @@ mtSpReductionOp<out_eT, T1, op_type>::mtSpReductionOp(const T1& in_m)
 
 template<typename out_eT, typename T1, typename op_type>
 inline
-mtSpReductionOp<out_eT, T1, op_type>::mtSpReductionOp(const T1& in_m, const uword in_aux_uword_a, const uword in_aux_uword_b)
+mtSpReduceOp<out_eT, T1, op_type>::mtSpReduceOp(const T1& in_m, const uword in_aux_uword_a, const uword in_aux_uword_b)
   : m(in_m)
   , aux_uword_a(in_aux_uword_a)
   , aux_uword_b(in_aux_uword_b)
@@ -45,7 +45,7 @@ mtSpReductionOp<out_eT, T1, op_type>::mtSpReductionOp(const T1& in_m, const uwor
 
 template<typename out_eT, typename T1, typename op_type>
 inline
-mtSpReductionOp<out_eT, T1, op_type>::~mtSpReductionOp()
+mtSpReduceOp<out_eT, T1, op_type>::~mtSpReduceOp()
   {
   arma_debug_sigprint();
   }
diff --git a/include/armadillo_bits/op_sp_diagvec_bones.hpp b/include/armadillo_bits/op_sp_diagvec_bones.hpp
index 7c9e8776..de011c1a 100644
--- a/include/armadillo_bits/op_sp_diagvec_bones.hpp
+++ b/include/armadillo_bits/op_sp_diagvec_bones.hpp
@@ -34,7 +34,7 @@ class op_sp_diagvec
     };
   
   template<typename T1>
-  inline static void apply(Mat<typename T1::elem_type>& out, const mtSpReductionOp<typename T1::elem_type, T1, op_sp_diagvec>& in);
+  inline static void apply(Mat<typename T1::elem_type>& out, const mtSpReduceOp<typename T1::elem_type, T1, op_sp_diagvec>& in);
   };
 
 
diff --git a/include/armadillo_bits/op_sp_diagvec_meat.hpp b/include/armadillo_bits/op_sp_diagvec_meat.hpp
index a869c117..a332f852 100644
--- a/include/armadillo_bits/op_sp_diagvec_meat.hpp
+++ b/include/armadillo_bits/op_sp_diagvec_meat.hpp
@@ -24,7 +24,7 @@
 template<typename T1>
 inline
 void
-op_sp_diagvec::apply(Mat<typename T1::elem_type>& out, const mtSpReductionOp<typename T1::elem_type, T1,op_sp_diagvec>& in)
+op_sp_diagvec::apply(Mat<typename T1::elem_type>& out, const mtSpReduceOp<typename T1::elem_type, T1,op_sp_diagvec>& in)
   {
   arma_debug_sigprint();
   
diff --git a/include/armadillo_bits/op_sp_max_bones.hpp b/include/armadillo_bits/op_sp_max_bones.hpp
index 884f9208..92b7c3a4 100644
--- a/include/armadillo_bits/op_sp_max_bones.hpp
+++ b/include/armadillo_bits/op_sp_max_bones.hpp
@@ -32,7 +32,7 @@ class op_sp_max
     };
   
   template<typename T1>
-  inline static void apply(Mat<typename T1::elem_type>& out, const mtSpReductionOp<typename T1::elem_type, T1, op_sp_max>& in);
+  inline static void apply(Mat<typename T1::elem_type>& out, const mtSpReduceOp<typename T1::elem_type, T1, op_sp_max>& in);
   
   //
   
diff --git a/include/armadillo_bits/op_sp_max_meat.hpp b/include/armadillo_bits/op_sp_max_meat.hpp
index b748f0bc..b86bf280 100644
--- a/include/armadillo_bits/op_sp_max_meat.hpp
+++ b/include/armadillo_bits/op_sp_max_meat.hpp
@@ -24,7 +24,7 @@
 template<typename T1>
 inline
 void
-op_sp_max::apply(Mat<typename T1::elem_type>& out, const mtSpReductionOp<typename T1::elem_type, T1, op_sp_max>& in)
+op_sp_max::apply(Mat<typename T1::elem_type>& out, const mtSpReduceOp<typename T1::elem_type, T1, op_sp_max>& in)
   {
   arma_debug_sigprint();
   
diff --git a/include/armadillo_bits/op_sp_mean_bones.hpp b/include/armadillo_bits/op_sp_mean_bones.hpp
index 2f908ccd..8147eed1 100644
--- a/include/armadillo_bits/op_sp_mean_bones.hpp
+++ b/include/armadillo_bits/op_sp_mean_bones.hpp
@@ -35,7 +35,7 @@ class op_sp_mean
   
   // Apply mean into an output sparse matrix (or vector).
   template<typename T1>
-  inline static void apply(Mat<typename T1::elem_type>& out, const mtSpReductionOp<typename T1::elem_type, T1, op_sp_mean>& in);
+  inline static void apply(Mat<typename T1::elem_type>& out, const mtSpReduceOp<typename T1::elem_type, T1, op_sp_mean>& in);
   
   template<typename T1>
   inline static void apply_fast(Mat<typename T1::elem_type>& out, const SpProxy<T1>& p, const uword dim);
diff --git a/include/armadillo_bits/op_sp_mean_meat.hpp b/include/armadillo_bits/op_sp_mean_meat.hpp
index 34b57e6d..eb4b5acc 100644
--- a/include/armadillo_bits/op_sp_mean_meat.hpp
+++ b/include/armadillo_bits/op_sp_mean_meat.hpp
@@ -24,7 +24,7 @@
 template<typename T1>
 inline
 void
-op_sp_mean::apply(Mat<typename T1::elem_type>& out, const mtSpReductionOp<typename T1::elem_type, T1, op_sp_mean>& in)
+op_sp_mean::apply(Mat<typename T1::elem_type>& out, const mtSpReduceOp<typename T1::elem_type, T1, op_sp_mean>& in)
   {
   arma_debug_sigprint();
   
diff --git a/include/armadillo_bits/op_sp_min_bones.hpp b/include/armadillo_bits/op_sp_min_bones.hpp
index 119a26e4..eea90371 100644
--- a/include/armadillo_bits/op_sp_min_bones.hpp
+++ b/include/armadillo_bits/op_sp_min_bones.hpp
@@ -32,7 +32,7 @@ class op_sp_min
     };
   
   template<typename T1>
-  inline static void apply(Mat<typename T1::elem_type>& out, const mtSpReductionOp<typename T1::elem_type, T1, op_sp_min>& in);
+  inline static void apply(Mat<typename T1::elem_type>& out, const mtSpReduceOp<typename T1::elem_type, T1, op_sp_min>& in);
   
   //
   
diff --git a/include/armadillo_bits/op_sp_min_meat.hpp b/include/armadillo_bits/op_sp_min_meat.hpp
index ce0e8d9b..cb7c80d4 100644
--- a/include/armadillo_bits/op_sp_min_meat.hpp
+++ b/include/armadillo_bits/op_sp_min_meat.hpp
@@ -24,7 +24,7 @@
 template<typename T1>
 inline
 void
-op_sp_min::apply(Mat<typename T1::elem_type>& out, const mtSpReductionOp<typename T1::elem_type, T1, op_sp_min>& in)
+op_sp_min::apply(Mat<typename T1::elem_type>& out, const mtSpReduceOp<typename T1::elem_type, T1, op_sp_min>& in)
   {
   arma_debug_sigprint();
   
diff --git a/include/armadillo_bits/op_sp_stddev_bones.hpp b/include/armadillo_bits/op_sp_stddev_bones.hpp
index 43e522e8..85616e13 100644
--- a/include/armadillo_bits/op_sp_stddev_bones.hpp
+++ b/include/armadillo_bits/op_sp_stddev_bones.hpp
@@ -34,7 +34,7 @@ class op_sp_stddev
     };
   
   template<typename T1>
-  inline static void apply(Mat<typename T1::pod_type>& out, const mtSpReductionOp<typename T1::pod_type, T1, op_sp_stddev>& in);
+  inline static void apply(Mat<typename T1::pod_type>& out, const mtSpReduceOp<typename T1::pod_type, T1, op_sp_stddev>& in);
   
   template<typename T1>
   inline static void apply_slow(Mat<typename T1::pod_type>& out, const SpProxy<T1>& p, const uword norm_type, const uword dim);
diff --git a/include/armadillo_bits/op_sp_stddev_meat.hpp b/include/armadillo_bits/op_sp_stddev_meat.hpp
index 584f93d9..56521a1e 100644
--- a/include/armadillo_bits/op_sp_stddev_meat.hpp
+++ b/include/armadillo_bits/op_sp_stddev_meat.hpp
@@ -24,7 +24,7 @@
 template<typename T1>
 inline
 void
-op_sp_stddev::apply(Mat<typename T1::pod_type>& out, const mtSpReductionOp<typename T1::pod_type, T1, op_sp_stddev>& in)
+op_sp_stddev::apply(Mat<typename T1::pod_type>& out, const mtSpReduceOp<typename T1::pod_type, T1, op_sp_stddev>& in)
   {
   arma_debug_sigprint();
   
diff --git a/include/armadillo_bits/op_sp_sum_bones.hpp b/include/armadillo_bits/op_sp_sum_bones.hpp
index bea50745..9831804f 100644
--- a/include/armadillo_bits/op_sp_sum_bones.hpp
+++ b/include/armadillo_bits/op_sp_sum_bones.hpp
@@ -33,7 +33,7 @@ class op_sp_sum
     };
   
   template<typename T1>
-  inline static void apply(Mat<typename T1::elem_type>& out, const mtSpReductionOp<typename T1::elem_type, T1, op_sp_sum>& in);
+  inline static void apply(Mat<typename T1::elem_type>& out, const mtSpReduceOp<typename T1::elem_type, T1, op_sp_sum>& in);
   };
 
 
diff --git a/include/armadillo_bits/op_sp_sum_meat.hpp b/include/armadillo_bits/op_sp_sum_meat.hpp
index 73f34940..8e9a22da 100644
--- a/include/armadillo_bits/op_sp_sum_meat.hpp
+++ b/include/armadillo_bits/op_sp_sum_meat.hpp
@@ -24,7 +24,7 @@
 template<typename T1>
 inline
 void
-op_sp_sum::apply(Mat<typename T1::elem_type>& out, const mtSpReductionOp<typename T1::elem_type, T1, op_sp_sum>& in)
+op_sp_sum::apply(Mat<typename T1::elem_type>& out, const mtSpReduceOp<typename T1::elem_type, T1, op_sp_sum>& in)
   {
   arma_debug_sigprint();
   
diff --git a/include/armadillo_bits/op_sp_var_bones.hpp b/include/armadillo_bits/op_sp_var_bones.hpp
index 3344180b..bdac6e33 100644
--- a/include/armadillo_bits/op_sp_var_bones.hpp
+++ b/include/armadillo_bits/op_sp_var_bones.hpp
@@ -35,7 +35,7 @@ class op_sp_var
     };
   
   template<typename T1>
-  inline static void apply(Mat<typename T1::pod_type>& out, const mtSpReductionOp<typename T1::pod_type, T1, op_sp_var>& in);
+  inline static void apply(Mat<typename T1::pod_type>& out, const mtSpReduceOp<typename T1::pod_type, T1, op_sp_var>& in);
   
   template<typename T1>
   inline static void apply_slow(Mat<typename T1::pod_type>& out, const SpProxy<T1>& p, const uword norm_type, const uword dim);
diff --git a/include/armadillo_bits/op_sp_var_meat.hpp b/include/armadillo_bits/op_sp_var_meat.hpp
index a3fef170..8c5cdff8 100644
--- a/include/armadillo_bits/op_sp_var_meat.hpp
+++ b/include/armadillo_bits/op_sp_var_meat.hpp
@@ -24,7 +24,7 @@
 template<typename T1>
 inline
 void
-op_sp_var::apply(Mat<typename T1::pod_type>& out, const mtSpReductionOp<typename T1::pod_type, T1, op_sp_var>& in)
+op_sp_var::apply(Mat<typename T1::pod_type>& out, const mtSpReduceOp<typename T1::pod_type, T1, op_sp_var>& in)
   {
   arma_debug_sigprint();
   
diff --git a/include/armadillo_bits/op_sp_vecnorm_bones.hpp b/include/armadillo_bits/op_sp_vecnorm_bones.hpp
index 8d70ad0d..79190743 100644
--- a/include/armadillo_bits/op_sp_vecnorm_bones.hpp
+++ b/include/armadillo_bits/op_sp_vecnorm_bones.hpp
@@ -33,7 +33,7 @@ class op_sp_vecnorm
     };
   
   template<typename T1>
-  inline static void apply(Mat<typename T1::pod_type>& out, const mtSpReductionOp<typename T1::pod_type, T1, op_sp_vecnorm>& expr);
+  inline static void apply(Mat<typename T1::pod_type>& out, const mtSpReduceOp<typename T1::pod_type, T1, op_sp_vecnorm>& expr);
   
   template<typename eT>
   inline static void apply_direct(Mat< typename get_pod_type<eT>::result >& out, const SpMat<eT>& X, const uword k);
@@ -56,7 +56,7 @@ class op_sp_vecnorm_ext
     };
   
   template<typename T1>
-  inline static void apply(Mat<typename T1::pod_type>& out, const mtSpReductionOp<typename T1::pod_type, T1, op_sp_vecnorm_ext>& expr);
+  inline static void apply(Mat<typename T1::pod_type>& out, const mtSpReduceOp<typename T1::pod_type, T1, op_sp_vecnorm_ext>& expr);
   
   template<typename eT>
   inline static void apply_direct(Mat< typename get_pod_type<eT>::result >& out, const SpMat<eT>& X, const uword method_id);
diff --git a/include/armadillo_bits/op_sp_vecnorm_meat.hpp b/include/armadillo_bits/op_sp_vecnorm_meat.hpp
index 3e5ae46b..e5cfab2b 100644
--- a/include/armadillo_bits/op_sp_vecnorm_meat.hpp
+++ b/include/armadillo_bits/op_sp_vecnorm_meat.hpp
@@ -24,7 +24,7 @@
 template<typename T1>
 inline
 void
-op_sp_vecnorm::apply(Mat<typename T1::pod_type>& out, const mtSpReductionOp<typename T1::pod_type, T1, op_sp_vecnorm>& expr)
+op_sp_vecnorm::apply(Mat<typename T1::pod_type>& out, const mtSpReduceOp<typename T1::pod_type, T1, op_sp_vecnorm>& expr)
   {
   arma_debug_sigprint();
   
@@ -110,7 +110,7 @@ op_sp_vecnorm::apply_direct(Mat< typename get_pod_type<eT>::result >& out, const
 template<typename T1>
 inline
 void
-op_sp_vecnorm_ext::apply(Mat<typename T1::pod_type>& out, const mtSpReductionOp<typename T1::pod_type, T1, op_sp_vecnorm_ext>& expr)
+op_sp_vecnorm_ext::apply(Mat<typename T1::pod_type>& out, const mtSpReduceOp<typename T1::pod_type, T1, op_sp_vecnorm_ext>& expr)
   {
   arma_debug_sigprint();
   
diff --git a/include/armadillo_bits/traits.hpp b/include/armadillo_bits/traits.hpp
index 3274b6d5..5318ef9f 100644
--- a/include/armadillo_bits/traits.hpp
+++ b/include/armadillo_bits/traits.hpp
@@ -718,11 +718,11 @@ struct is_mtSpGlue< mtSpGlue<eT, T1, T2, spglue_type> >
 
 
 template<typename T>
-struct is_mtSpReductionOp
+struct is_mtSpReduceOp
   { static constexpr bool value = false; };
  
 template<typename eT, typename T1, typename op_type>
-struct is_mtSpReductionOp< mtSpReductionOp<eT, T1, op_type> >
+struct is_mtSpReduceOp< mtSpReduceOp<eT, T1, op_type> >
   { static constexpr bool value = true; };
 
 
@@ -741,7 +741,7 @@ struct is_arma_sparse_type
   || is_SpGlue<T1>::value
   || is_mtSpOp<T1>::value
   || is_mtSpGlue<T1>::value
-  || is_mtSpReductionOp<T1>::value
+  || is_mtSpReduceOp<T1>::value
   ;
   };
 
diff --git a/include/armadillo_bits/unwrap_spmat.hpp b/include/armadillo_bits/unwrap_spmat.hpp
index fba6b89e..460b9621 100644
--- a/include/armadillo_bits/unwrap_spmat.hpp
+++ b/include/armadillo_bits/unwrap_spmat.hpp
@@ -194,12 +194,12 @@ struct unwrap_spmat< mtSpGlue<out_eT, T1, T2, spglue_type> >
 
 
 template<typename out_eT, typename T1, typename op_type>
-struct unwrap_spmat< mtSpReductionOp<out_eT, T1, op_type> >
+struct unwrap_spmat< mtSpReduceOp<out_eT, T1, op_type> >
   {
   typedef SpMat<out_eT> stored_type;
   
   inline
-  unwrap_spmat(const mtSpReductionOp<out_eT, T1, op_type>& A)
+  unwrap_spmat(const mtSpReduceOp<out_eT, T1, op_type>& A)
     : M(A)
     {
     arma_debug_sigprint();