// Copyright (C) 2008 Davis E. King (davis@dlib.net)
// License: Boost Software License See LICENSE.txt for the full license.
#ifndef DLIB_MATRIx_ASSIGn_FWD_
#define DLIB_MATRIx_ASSIGn_FWD_
// GCC 4.8 gives false alarms about some variables being uninitialized. Disable these
// false warnings.
#if defined(__GNUC__) && ((__GNUC__ >= 4 && __GNUC_MINOR__ >= 8) || (__GNUC__ > 4))
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#endif
#include "../enable_if.h"
#include "matrix_data_layout.h"
#include "../algs.h"
namespace dlib
{
/*
The point of the matrix_assign() functions is to contain all the various
optimizations that help the matrix assign a matrix_exp to an actual matrix
object quickly.
*/
// ----------------------------------------------------------------------------------------
namespace ma
{
// This template here controls how big a compile time sized matrix needs
// to be for it to get passed into the optimized versions of the
// matrix_assign() function. So small matrices are evaluated with a simple
// loop like the ones in this file and bigger matrices may get sent to BLAS
// routines or some other kind of optimized thing.
template < typename EXP, typename enable = void >
struct is_small_matrix { static const bool value = false; };
template < typename EXP >
struct is_small_matrix<EXP, typename enable_if_c<EXP::NR>=1 && EXP::NC>=1 &&
EXP::NR<=17 && EXP::NC<=17 && (EXP::cost <= 70)>::type> { static const bool value = true; };
// I wouldn't use this mul object to do the multiply but visual studio 7.1 wouldn't
// compile otherwise.
template <long a, long b>
struct mul { const static long value = a*b; };
template < typename EXP, typename enable = void >
struct is_very_small_matrix { static const bool value = false; };
template < typename EXP >
struct is_very_small_matrix<EXP, typename enable_if_c<EXP::NR>=1 && EXP::NC>=1 &&
(mul<EXP::NR,EXP::NC>::value <= 16) && (EXP::cost <= 70)>::type> { static const bool value = true; };
template < typename EXP, typename enable = void >
struct has_column_major_layout { static const bool value = false; };
template < typename EXP >
struct has_column_major_layout<EXP, typename enable_if<is_same_type<typename EXP::layout_type, column_major_layout> >::type >
{ static const bool value = true; };
}
// ----------------------------------------------------------------------------------------
template <
typename EXP
>
class matrix_exp;
// ----------------------------------------------------------------------------------------
template <typename EXP1, typename EXP2>
inline typename disable_if<ma::has_column_major_layout<EXP1> >::type
matrix_assign_default (
EXP1& dest,
const EXP2& src
)
/*!
requires
- src.destructively_aliases(dest) == false
- dest.nr() == src.nr()
- dest.nc() == src.nc()
ensures
- #dest == src
!*/
{
for (long r = 0; r < src.nr(); ++r)
{
for (long c = 0; c < src.nc(); ++c)
{
dest(r,c) = src(r,c);
}
}
}
// ----------------------------------------------------------------------------------------
template <typename EXP1, typename EXP2>
inline typename enable_if<ma::has_column_major_layout<EXP1> >::type
matrix_assign_default (
EXP1& dest,
const EXP2& src
)
/*!
requires
- src.destructively_aliases(dest) == false
- dest.nr() == src.nr()
- dest.nc() == src.nc()
ensures
- #dest == src
!*/
{
for (long c = 0; c < src.nc(); ++c)
{
for (long r = 0; r < src.nr(); ++r)
{
dest(r,c) = src(r,c);
}
}
}
// ----------------------------------------------------------------------------------------
template <typename EXP1, typename EXP2>
inline typename disable_if<ma::has_column_major_layout<EXP1> >::type
matrix_assign_default (
EXP1& dest,
const EXP2& src,
typename EXP2::type alpha,
bool add_to
)
/*!
requires
- src.destructively_aliases(dest) == false
- dest.nr() == src.nr()
- dest.nc() == src.nc()
ensures
- if (add_to == false) then
- #dest == alpha*src
- else
- #dest == dest + alpha*src
!*/
{
if (add_to)
{
if (alpha == static_cast<typename EXP2::type>(1))
{
for (long r = 0; r < src.nr(); ++r)
{
for (long c = 0; c < src.nc(); ++c)
{
dest(r,c) += src(r,c);
}
}
}
else if (alpha == static_cast<typename EXP2::type>(-1))
{
for (long r = 0; r < src.nr(); ++r)
{
for (long c = 0; c < src.nc(); ++c)
{
dest(r,c) -= src(r,c);
}
}
}
else
{
for (long r = 0; r < src.nr(); ++r)
{
for (long c = 0; c < src.nc(); ++c)
{
dest(r,c) += alpha*src(r,c);
}
}
}
}
else
{
if (alpha == static_cast<typename EXP2::type>(1))
{
for (long r = 0; r < src.nr(); ++r)
{
for (long c = 0; c < src.nc(); ++c)
{
dest(r,c) = src(r,c);
}
}
}
else
{
for (long r = 0; r < src.nr(); ++r)
{
for (long c = 0; c < src.nc(); ++c)
{
dest(r,c) = alpha*src(r,c);
}
}
}
}
}
// ----------------------------------------------------------------------------------------
template <typename EXP1, typename EXP2>
inline typename enable_if<ma::has_column_major_layout<EXP1> >::type
matrix_assign_default (
EXP1& dest,
const EXP2& src,
typename EXP2::type alpha,
bool add_to
)
/*!
requires
- src.destructively_aliases(dest) == false
- dest.nr() == src.nr()
- dest.nc() == src.nc()
ensures
- if (add_to == false) then
- #dest == alpha*src
- else
- #dest == dest + alpha*src
!*/
{
if (add_to)
{
if (alpha == static_cast<typename EXP2::type>(1))
{
for (long c = 0; c < src.nc(); ++c)
{
for (long r = 0; r < src.nr(); ++r)
{
dest(r,c) += src(r,c);
}
}
}
else if (alpha == static_cast<typename EXP2::type>(-1))
{
for (long c = 0; c < src.nc(); ++c)
{
for (long r = 0; r < src.nr(); ++r)
{
dest(r,c) -= src(r,c);
}
}
}
else
{
for (long c = 0; c < src.nc(); ++c)
{
for (long r = 0; r < src.nr(); ++r)
{
dest(r,c) += alpha*src(r,c);
}
}
}
}
else
{
if (alpha == static_cast<typename EXP2::type>(1))
{
for (long c = 0; c < src.nc(); ++c)
{
for (long r = 0; r < src.nr(); ++r)
{
dest(r,c) = src(r,c);
}
}
}
else
{
for (long c = 0; c < src.nc(); ++c)
{
for (long r = 0; r < src.nr(); ++r)
{
dest(r,c) = alpha*src(r,c);
}
}
}
}
}
// ----------------------------------------------------------------------------------------
template <
typename matrix_dest_type,
typename src_exp
>
void matrix_assign_big (
matrix_dest_type& dest,
const matrix_exp<src_exp>& src
)
{
matrix_assign_default(dest,src);
}
// ----------------------------------------------------------------------------------------
template <
typename matrix_dest_type,
typename src_exp
>
inline typename disable_if<ma::is_small_matrix<src_exp> >::type matrix_assign (
matrix_dest_type& dest,
const matrix_exp<src_exp>& src
)
/*!
requires
- src.destructively_aliases(dest) == false
- dest.nr() == src.nr()
- dest.nc() == src.nc()
ensures
- #dest == src
!*/
{
// Call src.ref() here so that the derived type of the matrix_exp shows
// up so we can overload matrix_assign_big() based on various matrix expression
// types.
matrix_assign_big(dest,src.ref());
}
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
// this code is here to perform an unrolled version of the matrix_assign() function
template < typename DEST, typename SRC, long NR, long NC,
long R = 0, long C = 0, bool base_case = (R==NR) >
struct matrix_unroll_helper
{
inline static void go ( DEST& dest, const SRC& src)
{
dest(R,C) = src(R,C);
matrix_unroll_helper<DEST,SRC,NR,NC, R + (C+1)/NC, (C+1)%NC>::go(dest,src);
}
};
template < typename DEST, typename SRC, long NR, long NC, long R, long C >
struct matrix_unroll_helper<DEST,SRC,NR,NC,R,C,true>
{ inline static void go ( DEST& , const SRC& ) {} };
template <typename DEST, typename SRC>
inline void matrix_assign_unrolled (
DEST& dest,
const SRC& src
)
/*!
requires
- src.destructively_aliases(dest) == false
- dest.nr() == src.nr()
- dest.nc() == src.nc()
ensures
- #dest == src
!*/
{
COMPILE_TIME_ASSERT(SRC::NR*SRC::NC != 0);
matrix_unroll_helper<DEST,SRC, SRC::NR, SRC::NC>::go(dest,src);
}
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
template <
typename matrix_dest_type,
typename src_exp
>
inline typename enable_if_c<ma::is_small_matrix<src_exp>::value && ma::is_very_small_matrix<src_exp>::value==false >::type matrix_assign (
matrix_dest_type& dest,
const matrix_exp<src_exp>& src
)
/*!
requires
- src.destructively_aliases(dest) == false
- dest.nr() == src.nr()
- dest.nc() == src.nc()
ensures
- #dest == src
!*/
{
matrix_assign_default(dest,src.ref());
}
// ----------------------------------------------------------------------------------------
template <
typename matrix_dest_type,
typename src_exp
>
inline typename enable_if_c<ma::is_small_matrix<src_exp>::value && ma::is_very_small_matrix<src_exp>::value==true >::type matrix_assign (
matrix_dest_type& dest,
const matrix_exp<src_exp>& src
)
/*!
requires
- src.destructively_aliases(dest) == false
- dest.nr() == src.nr()
- dest.nc() == src.nc()
ensures
- #dest == src
!*/
{
matrix_assign_unrolled(dest,src.ref());
}
// ----------------------------------------------------------------------------------------
}
#if defined(__GNUC__) && ((__GNUC__ >= 4 && __GNUC_MINOR__ >= 8) || (__GNUC__ > 4))
#pragma GCC diagnostic pop
#endif
#endif // DLIB_MATRIx_ASSIGn_FWD_