Update to Bandicoot release 2.1.1 (#4)

Co-authored-by: coatless <[email protected]>

Author: github-actions[bot]

inst/include/bandicoot

@@ -216,6 +216,8 @@ namespace coot
   #include "bandicoot_bits/Cube_bones.hpp"
   #include "bandicoot_bits/subview_cube_bones.hpp"
 
+  #include "bandicoot_bits/diskio_bones.hpp"
+
   #include "bandicoot_bits/eOp_bones.hpp"
   #include "bandicoot_bits/eGlue_bones.hpp"
   #include "bandicoot_bits/eop_core_bones.hpp"
@@ -228,6 +230,8 @@ namespace coot
   #include "bandicoot_bits/mtOpCube_bones.hpp"
   #include "bandicoot_bits/eGlueCube_bones.hpp"
   #include "bandicoot_bits/mtGlueCube_bones.hpp"
+  #include "bandicoot_bits/OpCube_bones.hpp"
+  #include "bandicoot_bits/GlueCube_bones.hpp"
   #include "bandicoot_bits/CubeToMatOp_bones.hpp"
   #include "bandicoot_bits/coot_rng_bones.hpp"
 
@@ -642,6 +646,8 @@ namespace coot
   #include "bandicoot_bits/Cube_meat.hpp"
   #include "bandicoot_bits/subview_cube_meat.hpp"
 
+  #include "bandicoot_bits/diskio_meat.hpp"
+
   #include "bandicoot_bits/eOp_meat.hpp"
   #include "bandicoot_bits/eGlue_meat.hpp"
   #include "bandicoot_bits/eop_core_meat.hpp"
@@ -654,6 +660,8 @@ namespace coot
   #include "bandicoot_bits/mtOpCube_meat.hpp"
   #include "bandicoot_bits/eGlueCube_meat.hpp"
   #include "bandicoot_bits/mtGlueCube_meat.hpp"
+  #include "bandicoot_bits/OpCube_meat.hpp"
+  #include "bandicoot_bits/GlueCube_meat.hpp"
   #include "bandicoot_bits/CubeToMatOp_meat.hpp"
   #include "bandicoot_bits/coot_rng_meat.hpp"
 

inst/include/bandicoot_bits/BaseCube_bones.hpp

@@ -68,4 +68,8 @@ struct BaseCube
 
   coot_warn_unused inline const CubeToMatOp<derived, op_row_as_mat> row_as_mat(const uword in_row) const;
   coot_warn_unused inline const CubeToMatOp<derived, op_col_as_mat> col_as_mat(const uword in_col) const;
+
+  coot_warn_unused inline bool is_finite() const;
+  coot_warn_unused inline bool has_inf() const;
+  coot_warn_unused inline bool has_nan() const;
   };

inst/include/bandicoot_bits/BaseCube_meat.hpp

@@ -233,6 +233,69 @@ BaseCube<elem_type, derived>::col_as_mat(const uword in_col) const
 
 
 
+template<typename elem_type, typename derived>
+inline
+bool
+BaseCube<elem_type, derived>::is_finite() const
+  {
+  coot_extra_debug_sigprint();
+
+  // The is_finite kernels only work on contiguous memory.
+  if (is_non_integral<elem_type>::value)
+    {
+    Cube<elem_type> tmp((*this).get_ref());
+    return tmp.is_finite();
+    }
+  else
+    {
+    return true;
+    }
+  }
+
+
+
+template<typename elem_type, typename derived>
+inline
+bool
+BaseCube<elem_type, derived>::has_inf() const
+  {
+  coot_extra_debug_sigprint();
+
+  // The has_inf kernels only work on contiguous memory.
+  if (is_non_integral<elem_type>::value)
+    {
+    Cube<elem_type> tmp((*this).get_ref());
+    return tmp.has_inf();
+    }
+  else
+    {
+    return false;
+    }
+  }
+
+
+
+template<typename elem_type, typename derived>
+inline
+bool
+BaseCube<elem_type, derived>::has_nan() const
+  {
+  coot_extra_debug_sigprint();
+
+  // The has_nan kernels only work on contiguous memory.
+  if (is_non_integral<elem_type>::value)
+    {
+    Cube<elem_type> tmp((*this).get_ref());
+    return tmp.has_nan();
+    }
+  else
+    {
+    return false;
+    }
+  }
+
+
+
 //
 // extra functions defined in BaseCube_eval_Cube
 

inst/include/bandicoot_bits/Base_bones.hpp

@@ -121,4 +121,8 @@ struct Base
 
   coot_warn_unused inline uword index_min() const;
   coot_warn_unused inline uword index_max() const;
+
+  coot_warn_unused inline bool is_finite()  const;
+  coot_warn_unused inline bool has_inf()    const;
+  coot_warn_unused inline bool has_nan()    const;
   };

inst/include/bandicoot_bits/Base_meat.hpp

@@ -336,3 +336,66 @@ Base<elem_type,derived>::index_max() const
   {
   return mtop_index_max::apply_direct( (*this).get_ref() );
   }
+
+
+
+template<typename elem_type, typename derived>
+inline
+bool
+Base<elem_type, derived>::is_finite() const
+  {
+  coot_extra_debug_sigprint();
+
+  // The finite kernels only work on contiguous memory.
+  if (is_non_integral<elem_type>::value)
+    {
+    Mat<elem_type> tmp((*this).get_ref());
+    return tmp.is_finite();
+    }
+  else
+    {
+    return true;
+    }
+  }
+
+
+
+template<typename elem_type, typename derived>
+inline
+bool
+Base<elem_type, derived>::has_inf() const
+  {
+  coot_extra_debug_sigprint();
+
+  // The has_inf kernels only work on contiguous memory.
+  if (is_non_integral<elem_type>::value)
+    {
+    Mat<elem_type> tmp((*this).get_ref());
+    return tmp.has_inf();
+    }
+  else
+    {
+    return false;
+    }
+  }
+
+
+
+template<typename elem_type, typename derived>
+inline
+bool
+Base<elem_type, derived>::has_nan() const
+  {
+  coot_extra_debug_sigprint();
+
+  // The has_nan kernels only work on contiguous memory.
+  if (is_non_integral<elem_type>::value)
+    {
+    Mat<elem_type> tmp((*this).get_ref());
+    return tmp.has_nan();
+    }
+  else
+    {
+    return false;
+    }
+  }

inst/include/bandicoot_bits/Col_bones.hpp

@@ -51,8 +51,17 @@ class Col : public Mat<eT>
   inline                  Col(Col&& X);
   inline const Col& operator=(Col&& X);
 
-  // TODO: inline            Col(Mat<eT>&& m);
-  // TODO: inline Col& operator=(Mat<eT>&& m);
+  inline            Col(const char*        text);
+  inline Col& operator=(const char*        text);
+
+  inline            Col(const std::string& text);
+  inline Col& operator=(const std::string& text);
+
+  inline            Col(const std::vector<eT>& x);
+  inline Col& operator=(const std::vector<eT>& x);
+
+  inline            Col(const std::initializer_list<eT>& list);
+  inline Col& operator=(const std::initializer_list<eT>& list);
 
   template<typename T1> inline            Col(const Base<eT, T1>& X);
   template<typename T1> inline Col& operator=(const Base<eT, T1>& X);