Fix linux build: add linux armadillo

native/armadillo_linux/include/armadillo_bits/BaseCube_bones.hpp

+// 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 BaseCube
+//! @{
+
+
+
+template<typename elem_type, typename derived>
+struct BaseCube_eval_Cube
+  {
+  arma_inline const derived& eval() const;
+  };
+
+
+template<typename elem_type, typename derived>
+struct BaseCube_eval_expr
+  {
+  arma_inline Cube<elem_type> eval() const;   //!< force the immediate evaluation of a delayed expression
+  };
+
+
+template<typename elem_type, typename derived, bool condition>
+struct BaseCube_eval {};
+
+template<typename elem_type, typename derived>
+struct BaseCube_eval<elem_type, derived, true>  { typedef BaseCube_eval_Cube<elem_type, derived>  result; };
+
+template<typename elem_type, typename derived>
+struct BaseCube_eval<elem_type, derived, false> { typedef BaseCube_eval_expr<elem_type, derived> result; };
+
+
+
+//! Analog of the Base class, intended for cubes
+template<typename elem_type, typename derived>
+struct BaseCube
+  : public BaseCube_eval<elem_type, derived, is_Cube<derived>::value>::result
+  {
+  arma_inline const derived& get_ref() const;
+  
+  arma_cold inline void print(                           const std::string extra_text = "") const;
+  arma_cold inline void print(std::ostream& user_stream, const std::string extra_text = "") const;
+  
+  arma_cold inline void raw_print(                           const std::string extra_text = "") const;
+  arma_cold inline void raw_print(std::ostream& user_stream, const std::string extra_text = "") const;
+  
+  inline arma_warn_unused elem_type min() const;
+  inline arma_warn_unused elem_type max() const;
+  
+  inline arma_warn_unused uword index_min() const;
+  inline arma_warn_unused uword index_max() const;
+  };
+
+
+
+//! @}

native/armadillo_linux/include/armadillo_bits/BaseCube_meat.hpp

+// 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 BaseCube
+//! @{
+
+
+
+template<typename elem_type, typename derived>
+arma_inline
+const derived&
+BaseCube<elem_type,derived>::get_ref() const
+  {
+  return static_cast<const derived&>(*this);
+  }
+
+
+
+template<typename elem_type, typename derived>
+arma_cold
+inline
+void
+BaseCube<elem_type,derived>::print(const std::string extra_text) const
+  {
+  const unwrap_cube<derived> tmp( (*this).get_ref() );
+  
+  tmp.M.impl_print(extra_text);
+  }
+
+
+
+template<typename elem_type, typename derived>
+arma_cold
+inline
+void
+BaseCube<elem_type,derived>::print(std::ostream& user_stream, const std::string extra_text) const
+  {
+  const unwrap_cube<derived> tmp( (*this).get_ref() );
+  
+  tmp.M.impl_print(user_stream, extra_text);
+  }
+  
+
+
+template<typename elem_type, typename derived>
+arma_cold
+inline
+void
+BaseCube<elem_type,derived>::raw_print(const std::string extra_text) const
+  {
+  const unwrap_cube<derived> tmp( (*this).get_ref() );
+  
+  tmp.M.impl_raw_print(extra_text);
+  }
+
+
+
+template<typename elem_type, typename derived>
+arma_cold
+inline
+void
+BaseCube<elem_type,derived>::raw_print(std::ostream& user_stream, const std::string extra_text) const
+  {
+  const unwrap_cube<derived> tmp( (*this).get_ref() );
+  
+  tmp.M.impl_raw_print(user_stream, extra_text);
+  }
+
+
+
+template<typename elem_type, typename derived>
+inline
+arma_warn_unused
+elem_type
+BaseCube<elem_type,derived>::min() const
+  {
+  return op_min::min( (*this).get_ref() );
+  }
+
+
+
+template<typename elem_type, typename derived>
+inline
+arma_warn_unused
+elem_type
+BaseCube<elem_type,derived>::max() const
+  {
+  return op_max::max( (*this).get_ref() );
+  }
+
+
+
+template<typename elem_type, typename derived>
+inline
+arma_warn_unused
+uword
+BaseCube<elem_type,derived>::index_min() const
+  {
+  const ProxyCube<derived> P( (*this).get_ref() );
+  
+  uword index = 0;
+  
+  if(P.get_n_elem() == 0)
+    {
+    arma_debug_check(true, "index_min(): object has no elements");
+    }
+  else
+    {
+    op_min::min_with_index(P, index);
+    }
+  
+  return index;
+  }
+
+
+
+template<typename elem_type, typename derived>
+inline
+arma_warn_unused
+uword
+BaseCube<elem_type,derived>::index_max() const
+  {
+  const ProxyCube<derived> P( (*this).get_ref() );
+  
+  uword index = 0;
+  
+  if(P.get_n_elem() == 0)
+    {
+    arma_debug_check(true, "index_max(): object has no elements");
+    }
+  else
+    {
+    op_max::max_with_index(P, index);
+    }
+  
+  return index;
+  }
+
+
+
+//
+// extra functions defined in BaseCube_eval_Cube
+
+template<typename elem_type, typename derived>
+arma_inline
+const derived&
+BaseCube_eval_Cube<elem_type, derived>::eval() const
+  {
+  arma_extra_debug_sigprint();
+  
+  return static_cast<const derived&>(*this);
+  }
+
+
+
+//
+// extra functions defined in BaseCube_eval_expr
+
+template<typename elem_type, typename derived>
+arma_inline
+Cube<elem_type>
+BaseCube_eval_expr<elem_type, derived>::eval() const
+  {
+  arma_extra_debug_sigprint();
+  
+  return Cube<elem_type>( static_cast<const derived&>(*this) );
+  }
+
+
+
+//! @}

native/armadillo_linux/include/armadillo_bits/Base_bones.hpp

+// 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 Base
+//! @{
+
+
+
+template<typename derived>
+struct Base_inv_yes
+  {
+  arma_inline const Op<derived,op_inv> i() const;   //!< matrix inverse
+  
+  arma_deprecated inline const Op<derived,op_inv> i(const bool ) const;   //!< kept only for compatibility with old user code
+  arma_deprecated inline const Op<derived,op_inv> i(const char*) const;   //!< kept only for compatibility with old user code
+  };
+
+
+template<typename derived>
+struct Base_inv_no
+  {
+  };
+
+
+template<typename derived, bool condition>
+struct Base_inv {};
+
+template<typename derived>
+struct Base_inv<derived, true>  { typedef Base_inv_yes<derived> result; };
+
+template<typename derived>
+struct Base_inv<derived, false> { typedef Base_inv_no<derived>  result; };
+
+
+
+template<typename elem_type, typename derived>
+struct Base_eval_Mat
+  {
+  arma_inline const derived& eval() const;
+  };
+
+
+template<typename elem_type, typename derived>
+struct Base_eval_expr
+  {
+  arma_inline Mat<elem_type> eval() const;   //!< force the immediate evaluation of a delayed expression
+  };
+
+
+template<typename elem_type, typename derived, bool condition>
+struct Base_eval {};
+
+template<typename elem_type, typename derived>
+struct Base_eval<elem_type, derived, true>  { typedef Base_eval_Mat<elem_type, derived>  result; };
+
+template<typename elem_type, typename derived>
+struct Base_eval<elem_type, derived, false> { typedef Base_eval_expr<elem_type, derived> result; };
+
+
+
+template<typename derived>
+struct Base_trans_cx
+  {
+  arma_inline const Op<derived,op_htrans>  t() const;
+  arma_inline const Op<derived,op_htrans> ht() const;
+  arma_inline const Op<derived,op_strans> st() const;  // simple transpose: no complex conjugates
+  };
+
+
+template<typename derived>
+struct Base_trans_default
+  {
+  arma_inline const Op<derived,op_htrans>  t() const;
+  arma_inline const Op<derived,op_htrans> ht() const;
+  arma_inline const Op<derived,op_htrans> st() const;  // return op_htrans instead of op_strans, as it's handled better by matrix multiplication code
+  };
+
+
+template<typename derived, bool condition>
+struct Base_trans {};
+
+template<typename derived>
+struct Base_trans<derived, true>  { typedef Base_trans_cx<derived>      result; };
+
+template<typename derived>
+struct Base_trans<derived, false> { typedef Base_trans_default<derived> result; };
+
+
+
+//! Class for static polymorphism, modelled after the "Curiously Recurring Template Pattern" (CRTP).
+//! Used for type-safe downcasting in functions that restrict their input(s) to be classes that are
+//! derived from Base (e.g. Mat, Op, Glue, diagview, subview).
+//! A Base object can be converted to a Mat object by the unwrap class.
+
+template<typename elem_type, typename derived>
+struct Base
+  : public Base_inv<derived, is_supported_blas_type<elem_type>::value>::result
+  , public Base_eval<elem_type, derived, is_Mat<derived>::value>::result
+  , public Base_trans<derived, is_cx<elem_type>::value>::result
+  {
+  arma_inline const derived& get_ref() const;
+  
+  arma_cold inline void print(                           const std::string extra_text = "") const;
+  arma_cold inline void print(std::ostream& user_stream, const std::string extra_text = "") const;
+  
+  arma_cold inline void raw_print(                           const std::string extra_text = "") const;
+  arma_cold inline void raw_print(std::ostream& user_stream, const std::string extra_text = "") const;
+  
+  inline arma_warn_unused elem_type min() const;
+  inline arma_warn_unused elem_type max() const;
+  
+  inline elem_type min(uword& index_of_min_val) const;
+  inline elem_type max(uword& index_of_max_val) const;
+  
+  inline elem_type min(uword& row_of_min_val, uword& col_of_min_val) const;
+  inline elem_type max(uword& row_of_max_val, uword& col_of_max_val) const;
+  
+  inline arma_warn_unused uword index_min() const;
+  inline arma_warn_unused uword index_max() const;
+  };
+
+
+
+//! @}

native/armadillo_linux/include/armadillo_bits/Base_meat.hpp

+// 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 Base
+//! @{
+
+
+
+template<typename elem_type, typename derived>
+arma_inline
+const derived&
+Base<elem_type,derived>::get_ref() const
+  {
+  return static_cast<const derived&>(*this);
+  }
+
+
+
+template<typename elem_type, typename derived>
+arma_cold
+inline
+void
+Base<elem_type,derived>::print(const std::string extra_text) const
+  {
+  if(is_op_strans<derived>::value || is_op_htrans<derived>::value)
+    {
+    const Proxy<derived> P( (*this).get_ref() );
+    
+    const quasi_unwrap< typename Proxy<derived>::stored_type > tmp(P.Q);
+    
+    tmp.M.impl_print(extra_text);
+    }
+  else
+    {
+    const quasi_unwrap<derived> tmp( (*this).get_ref() );
+    
+    tmp.M.impl_print(extra_text);
+    }
+  }
+
+
+
+template<typename elem_type, typename derived>
+arma_cold
+inline
+void
+Base<elem_type,derived>::print(std::ostream& user_stream, const std::string extra_text) const
+  {
+  if(is_op_strans<derived>::value || is_op_htrans<derived>::value)
+    {
+    const Proxy<derived> P( (*this).get_ref() );
+    
+    const quasi_unwrap< typename Proxy<derived>::stored_type > tmp(P.Q);
+    
+    tmp.M.impl_print(user_stream, extra_text);
+    }
+  else
+    {
+    const quasi_unwrap<derived> tmp( (*this).get_ref() );
+    
+    tmp.M.impl_print(user_stream, extra_text);
+    }
+  }
+  
+
+
+template<typename elem_type, typename derived>
+arma_cold
+inline
+void
+Base<elem_type,derived>::raw_print(const std::string extra_text) const
+  {
+  if(is_op_strans<derived>::value || is_op_htrans<derived>::value)
+    {
+    const Proxy<derived> P( (*this).get_ref() );
+    
+    const quasi_unwrap< typename Proxy<derived>::stored_type > tmp(P.Q);
+    
+    tmp.M.impl_raw_print(extra_text);
+    }
+  else
+    {
+    const quasi_unwrap<derived> tmp( (*this).get_ref() );
+    
+    tmp.M.impl_raw_print(extra_text);
+    }
+  }
+
+
+
+template<typename elem_type, typename derived>
+arma_cold
+inline
+void
+Base<elem_type,derived>::raw_print(std::ostream& user_stream, const std::string extra_text) const
+  {
+  if(is_op_strans<derived>::value || is_op_htrans<derived>::value)
+    {
+    const Proxy<derived> P( (*this).get_ref() );
+    
+    const quasi_unwrap< typename Proxy<derived>::stored_type > tmp(P.Q);
+    
+    tmp.M.impl_raw_print(user_stream, extra_text);
+    }
+  else
+    {
+    const quasi_unwrap<derived> tmp( (*this).get_ref() );
+    
+    tmp.M.impl_raw_print(user_stream, extra_text);
+    }
+  }
+
+
+
+template<typename elem_type, typename derived>
+inline
+arma_warn_unused
+elem_type
+Base<elem_type,derived>::min() const
+  {
+  return op_min::min( (*this).get_ref() );
+  }
+
+
+
+template<typename elem_type, typename derived>
+inline
+arma_warn_unused
+elem_type
+Base<elem_type,derived>::max() const
+  {
+  return op_max::max( (*this).get_ref() );
+  }
+
+
+
+template<typename elem_type, typename derived>
+inline
+elem_type
+Base<elem_type,derived>::min(uword& index_of_min_val) const
+  {
+  const Proxy<derived> P( (*this).get_ref() );
+  
+  return op_min::min_with_index(P, index_of_min_val);
+  }
+
+
+
+template<typename elem_type, typename derived>
+inline
+elem_type
+Base<elem_type,derived>::max(uword& index_of_max_val) const
+  {
+  const Proxy<derived> P( (*this).get_ref() );
+  
+  return op_max::max_with_index(P, index_of_max_val);
+  }
+
+
+
+template<typename elem_type, typename derived>
+inline
+elem_type
+Base<elem_type,derived>::min(uword& row_of_min_val, uword& col_of_min_val) const
+  {
+  const Proxy<derived> P( (*this).get_ref() );
+  
+  uword index = 0;
+  
+  const elem_type val = op_min::min_with_index(P, index);
+  
+  const uword local_n_rows = P.get_n_rows();
+  
+  row_of_min_val = index % local_n_rows;