initial implementation of .row_as_mat() and .col_as_mat()

include/armadillo

@@ -315,6 +315,8 @@ namespace arma
   #include "armadillo_bits/op_sp_minus_bones.hpp"
   #include "armadillo_bits/op_powmat_bones.hpp"
   #include "armadillo_bits/op_rank_bones.hpp"
+  #include "armadillo_bits/op_row_as_mat_bones.hpp"
+  #include "armadillo_bits/op_col_as_mat_bones.hpp"
   
   #include "armadillo_bits/glue_times_bones.hpp"
   #include "armadillo_bits/glue_mixed_bones.hpp"
@@ -751,6 +753,8 @@ namespace arma
   #include "armadillo_bits/op_sp_minus_meat.hpp"
   #include "armadillo_bits/op_powmat_meat.hpp"
   #include "armadillo_bits/op_rank_meat.hpp"
+  #include "armadillo_bits/op_row_as_mat_meat.hpp"
+  #include "armadillo_bits/op_col_as_mat_meat.hpp"
   
   #include "armadillo_bits/glue_times_meat.hpp"
   #include "armadillo_bits/glue_mixed_meat.hpp"

include/armadillo_bits/BaseCube_bones.hpp

@@ -74,6 +74,9 @@ struct BaseCube
   arma_warn_unused inline bool is_finite() const;
   arma_warn_unused inline bool has_inf()   const;
   arma_warn_unused inline bool has_nan()   const;
+  
+  arma_warn_unused inline const CubeToMatOp<derived, op_row_as_mat> row_as_mat(const uword in_row) const;
+  arma_warn_unused inline const CubeToMatOp<derived, op_col_as_mat> col_as_mat(const uword in_col) const;
   };
 
 

include/armadillo_bits/BaseCube_meat.hpp

@@ -397,6 +397,26 @@ BaseCube<elem_type,derived>::has_nan() const
 
 
 
+template<typename elem_type, typename derived>
+inline
+const CubeToMatOp<derived, op_row_as_mat>
+BaseCube<elem_type,derived>::row_as_mat(const uword in_row) const
+  {
+  return CubeToMatOp<derived, op_row_as_mat>( (*this).get_ref(), in_row );
+  }
+
+
+
+template<typename elem_type, typename derived>
+inline
+const CubeToMatOp<derived, op_col_as_mat>
+BaseCube<elem_type,derived>::col_as_mat(const uword in_col) const
+  {
+  return CubeToMatOp<derived, op_col_as_mat>( (*this).get_ref(), in_col );
+  }
+
+
+
 //
 // extra functions defined in BaseCube_eval_Cube
 

include/armadillo_bits/CubeToMatOp_bones.hpp

@@ -30,11 +30,11 @@ class CubeToMatOp : public Base< typename T1::elem_type, CubeToMatOp<T1, op_type
   typedef typename get_pod_type<elem_type>::result pod_type;
   
   inline explicit CubeToMatOp(const T1& in_m);
-  inline          CubeToMatOp(const T1& in_m, const elem_type in_aux);
+  inline          CubeToMatOp(const T1& in_m, const uword in_aux_uword);
   inline         ~CubeToMatOp();
   
-  arma_aligned const T1&       m;            //!< the operand; must be derived from BaseCube
-  arma_aligned       elem_type aux;          //!< auxiliary data, using the element type as used by T1
+  arma_aligned const T1&   m;            //!< the operand; must be derived from BaseCube
+  arma_aligned       uword aux_uword;    //!< auxiliary data, uword format
   
   static constexpr bool is_row  = op_type::template traits<T1>::is_row;
   static constexpr bool is_col  = op_type::template traits<T1>::is_col;

include/armadillo_bits/CubeToMatOp_meat.hpp

@@ -33,9 +33,9 @@ CubeToMatOp<T1, op_type>::CubeToMatOp(const T1& in_m)
 
 template<typename T1, typename op_type>
 inline
-CubeToMatOp<T1, op_type>::CubeToMatOp(const T1& in_m, const typename T1::elem_type in_aux)
+CubeToMatOp<T1, op_type>::CubeToMatOp(const T1& in_m, const uword in_aux_uword)
   : m(in_m)
-  , aux(in_aux)
+  , aux_uword(in_aux_uword)
   {
   arma_extra_debug_sigprint();
   }

include/armadillo_bits/arma_forward.hpp

@@ -91,6 +91,10 @@ class op_diagmat;
 class op_trimat;
 class op_vectorise_row;
 class op_vectorise_col;
+
+class op_row_as_mat;
+class op_col_as_mat;
+
 class glue_times;
 class glue_times_diag;
 

include/armadillo_bits/op_col_as_mat_bones.hpp

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: Apache-2.0
+// 
+// Copyright 2008-2016 Conrad Sanderson (http://conradsanderson.id.au)
+// Copyright 2008-2016 National ICT Australia (NICTA)
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// ------------------------------------------------------------------------
+
+
+//! \addtogroup op_col_as_mat
+//! @{
+
+
+class op_col_as_mat
+  : public traits_op_default
+  {
+  public:
+  
+  template<typename T1> inline static void apply(Mat<typename T1::elem_type>& out, const CubeToMatOp<T1, op_col_as_mat>& expr);
+  };
+
+
+
+//! @}

include/armadillo_bits/op_col_as_mat_meat.hpp

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: Apache-2.0
+// 
+// Copyright 2008-2016 Conrad Sanderson (http://conradsanderson.id.au)
+// Copyright 2008-2016 National ICT Australia (NICTA)
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// ------------------------------------------------------------------------
+
+
+//! \addtogroup op_col_as_mat
+//! @{
+
+
+
+template<typename T1>
+inline
+void
+op_col_as_mat::apply(Mat<typename T1::elem_type>& out, const CubeToMatOp<T1, op_col_as_mat>& expr)
+  {
+  arma_extra_debug_sigprint();
+  
+  typedef typename T1::elem_type eT;
+  
+  const unwrap_cube<T1> U(expr.m);
+  const Cube<eT>&   A = U.M;
+  
+  const uword in_col = expr.aux_uword;
+  
+  arma_debug_check_bounds( (in_col >= A.n_cols), "Cube::col_as_mat(): index out of bounds" );
+  
+  const uword A_n_rows   = A.n_rows;
+  const uword A_n_slices = A.n_slices;
+  
+  out.set_size(A_n_rows, A_n_slices);
+  
+  for(uword s=0; s < A_n_slices; ++s)
+    {
+    arrayops::copy(out.colptr(s), A.slice_colptr(s, in_col), A_n_rows);
+    }
+  }
+
+
+
+//! @}

include/armadillo_bits/op_row_as_mat_bones.hpp

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: Apache-2.0
+// 
+// Copyright 2008-2016 Conrad Sanderson (http://conradsanderson.id.au)
+// Copyright 2008-2016 National ICT Australia (NICTA)
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// ------------------------------------------------------------------------
+
+
+//! \addtogroup op_row_as_mat
+//! @{
+
+
+class op_row_as_mat
+  : public traits_op_default
+  {
+  public:
+  
+  template<typename T1> inline static void apply(Mat<typename T1::elem_type>& out, const CubeToMatOp<T1, op_row_as_mat>& expr);
+  };
+
+
+
+//! @}

include/armadillo_bits/op_row_as_mat_meat.hpp

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: Apache-2.0
+// 
+// Copyright 2008-2016 Conrad Sanderson (http://conradsanderson.id.au)
+// Copyright 2008-2016 National ICT Australia (NICTA)
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// ------------------------------------------------------------------------
+
+
+//! \addtogroup op_row_as_mat
+//! @{
+
+
+
+template<typename T1>
+inline
+void
+op_row_as_mat::apply(Mat<typename T1::elem_type>& out, const CubeToMatOp<T1, op_row_as_mat>& expr)
+  {
+  arma_extra_debug_sigprint();
+  
+  typedef typename T1::elem_type eT;
+  
+  const unwrap_cube<T1> U(expr.m);
+  const Cube<eT>&   A = U.M;
+  
+  const uword in_row = expr.aux_uword;
+  
+  arma_debug_check_bounds( (in_row >= A.n_rows), "Cube::row_as_mat(): index out of bounds" );
+  
+  const uword A_n_cols   = A.n_cols;
+  const uword A_n_rows   = A.n_rows;
+  const uword A_n_slices = A.n_slices;
+  
+  out.set_size(A_n_slices, A_n_cols);
+  
+  for(uword s=0; s < A_n_slices; ++s)
+    {
+    const eT*   A_mem = &(A.at(in_row, 0, s));
+          eT* out_mem = &(out.at(s,0));
+    
+    for(uword c=0; c < A_n_cols; ++c)
+      {
+      (*out_mem) = (*A_mem);
+      
+        A_mem += A_n_rows;
+      out_mem += A_n_slices;
+      }
+    }
+  }
+
+
+
+//! @}