ops_vectors.h

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2017, Individual contributors, see AUTHORS file     |
   | See: http://www.mrpt.org/Authors - All rights reserved.                |
   | Released under BSD License. See details in http://www.mrpt.org/License |
   +------------------------------------------------------------------------+ */
#ifndef mrpt_math_vector_ops_H
#define mrpt_math_vector_ops_H

#include <mrpt/utils/utils_defs.h>
#include <mrpt/utils/CStream.h>
#include <mrpt/math/CMatrixTemplateNumeric.h>
#include <iomanip>  // for setprecision(), etc.
#include <iterator>  // std::ostream_iterator

// Many of the functions originally in this file are now in ops_containers.h
#include <mrpt/math/ops_containers.h>

namespace mrpt
{
namespace utils
{
class CFileStream;
}

namespace math
{
// Frwd. decl.
template <typename T, std::size_t N>
class CArrayNumeric;

/** \addtogroup container_ops_grp
  *  @{ */

/** \name Generic std::vector element-wise operations
  * @{
  */

/** a*=b (element-wise multiplication) */
template <typename T1, typename T2>
inline std::vector<T1>& operator*=(std::vector<T1>& a, const std::vector<T2>& b)
{
        ASSERT_EQUAL_(a.size(), b.size())
        const size_t N = a.size();
        for (size_t i = 0; i < N; i++) a[i] *= b[i];
        return a;
}

/** a*=k (multiplication by a constant) */
template <typename T1>
inline std::vector<T1>& operator*=(std::vector<T1>& a, const T1 b)
{
        const size_t N = a.size();
        for (size_t i = 0; i < N; i++) a[i] *= b;
        return a;
}

/** a*b (element-wise multiplication) */
template <typename T1, typename T2>
inline std::vector<T1> operator*(
        const std::vector<T1>& a, const std::vector<T2>& b)
{
        ASSERT_EQUAL_(a.size(), b.size())
        const size_t N = a.size();
        std::vector<T1> ret(N);
        for (size_t i = 0; i < N; i++) ret[i] = a[i] * b[i];
        return ret;
}

/** a+=b (element-wise sum) */
template <typename T1, typename T2>
inline std::vector<T1>& operator+=(std::vector<T1>& a, const std::vector<T2>& b)
{
        ASSERT_EQUAL_(a.size(), b.size())
        const size_t N = a.size();
        for (size_t i = 0; i < N; i++) a[i] += b[i];
        return a;
}

/** a+=b (sum a constant) */
template <typename T1>
inline std::vector<T1>& operator+=(std::vector<T1>& a, const T1 b)
{
        const size_t N = a.size();
        for (size_t i = 0; i < N; i++) a[i] += b;
        return a;
}

/** a+b (element-wise sum) */
template <typename T1, typename T2>
inline std::vector<T1> operator+(
        const std::vector<T1>& a, const std::vector<T2>& b)
{
        ASSERT_EQUAL_(a.size(), b.size())
        const size_t N = a.size();
        std::vector<T1> ret(N);
        for (size_t i = 0; i < N; i++) ret[i] = a[i] + b[i];
        return ret;
}

template <typename T1, typename T2>
inline std::vector<T1> operator-(
        const std::vector<T1>& v1, const std::vector<T2>& v2)
{
        ASSERT_EQUAL_(v1.size(), v2.size())
        std::vector<T1> res(v1.size());
        for (size_t i = 0; i < v1.size(); i++) res[i] = v1[i] - v2[i];
        return res;
}

/** @} */

/** A template function for printing out the contents of a std::vector variable.
        */
template <class T>
std::ostream& operator<<(std::ostream& out, const std::vector<T>& d)
{
        const std::streamsize old_pre = out.precision();
        const std::ios_base::fmtflags old_flags = out.flags();
        out << "[" << std::fixed << std::setprecision(4);
        std::copy(d.begin(), d.end(), std::ostream_iterator<T>(out, " "));
        out << "]";
        out.flags(old_flags);
        out.precision(old_pre);
        return out;
}

/** A template function for printing out the contents of a std::vector variable.
        */
template <class T>
std::ostream& operator<<(std::ostream& out, std::vector<T>* d)
{
        const std::streamsize old_pre = out.precision();
        const std::ios_base::fmtflags old_flags = out.flags();
        out << "[" << std::fixed << std::setprecision(4);
        copy(d->begin(), d->end(), std::ostream_iterator<T>(out, " "));
        out << "]";
        out.flags(old_flags);
        out.precision(old_pre);
        return out;
}

/** Binary dump of a CArrayNumeric<T,N> to a stream. */
template <typename T, size_t N>
mrpt::utils::CStream& operator<<(
        mrpt::utils::CStream& ostrm, const CArrayNumeric<T, N>& a)
{
        ostrm << mrpt::utils::TTypeName<CArrayNumeric<T, N>>::get();
        if (N) ostrm.WriteBufferFixEndianness<T>(&a[0], N);
        return ostrm;
}

/** Binary read of a CArrayNumeric<T,N> from a stream. */
template <typename T, size_t N>
mrpt::utils::CStream& operator>>(
        mrpt::utils::CStream& istrm, CArrayNumeric<T, N>& a)
{
        static const std::string namExpect =
                mrpt::utils::TTypeName<CArrayNumeric<T, N>>::get();
        std::string nam;
        istrm >> nam;
        ASSERTMSG_(
                nam == namExpect, format(
                                                          "Error deserializing: expected '%s', got '%s'",
                                                          namExpect.c_str(), nam.c_str()))
        if (N) istrm.ReadBufferFixEndianness<T>(&a[0], N);
        return istrm;
}

/**  @} */  // end of grouping

}  // End of math namespace

}  // End of mrpt namespace

#endif