Skip to content

D
dlib
Commit f825990c authored by Davis King's avatar Davis King
Browse files
Options

Changed the matrix operations so that they result in shorter type names 

when compiled.  This avoids problems in compilers like visual studio.

--HG--
extra : convert_revision : svn%3Afdd8eb12-d10e-0410-9acb-85c331704f74/trunk%402301
parent 2801ca62
Show whitespace changes
Inline Side-by-side
Showing with 158 additions and 89 deletions
dlib/matrix/matrix_math_functions.h
View file @ f825990c
...@@ -16,19 +16,20 @@ namespace dlib ...@@ -16,19 +16,20 @@ namespace dlib
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
#define DLIB_MATRIX_SIMPLE_STD_FUNCTION(name) template <typename EXP> \ #define DLIB_MATRIX_SIMPLE_STD_FUNCTION(name) struct op_##name { \
struct op_##name : has_nondestructive_aliasing, preserves_dimensions<EXP> \ template <typename EXP> \
struct op : has_nondestructive_aliasing, preserves_dimensions<EXP> \
{ \ { \
typedef typename EXP::type type; \ typedef typename EXP::type type; \
template <typename M> \ template <typename M> \
static type apply ( const M& m, long r, long c) \ static type apply ( const M& m, long r, long c) \
{ return static_cast<type>(std::name(m(r,c))); } \ { return static_cast<type>(std::name(m(r,c))); } \
}; \ };}; \
template < typename EXP > \ template < typename EXP > \
const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_##name<EXP> > > name ( \ const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_##name> > name ( \
const matrix_exp<EXP>& m) \ const matrix_exp<EXP>& m) \
{ \ { \
typedef matrix_unary_exp<matrix_exp<EXP>,op_##name<EXP> > exp; \ typedef matrix_unary_exp<matrix_exp<EXP>,op_##name> exp; \
return matrix_exp<exp>(exp(m)); \ return matrix_exp<exp>(exp(m)); \
} }
...@@ -57,8 +58,10 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -57,8 +58,10 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
struct op_sigmoid
{
template <typename EXP> template <typename EXP>
struct op_sigmoid : has_nondestructive_aliasing, preserves_dimensions<EXP> struct op : has_nondestructive_aliasing, preserves_dimensions<EXP>
{ {
typedef typename EXP::type type; typedef typename EXP::type type;
template <typename M> template <typename M>
...@@ -69,22 +72,25 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -69,22 +72,25 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
return static_cast<type>(1.0/(1.0 + temp)); return static_cast<type>(1.0/(1.0 + temp));
} }
}; };
};
template < template <
typename EXP typename EXP
> >
const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_sigmoid<EXP> > > sigmoid ( const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_sigmoid> > sigmoid (
const matrix_exp<EXP>& m const matrix_exp<EXP>& m
) )
{ {
typedef matrix_unary_exp<matrix_exp<EXP>,op_sigmoid<EXP> > exp; typedef matrix_unary_exp<matrix_exp<EXP>,op_sigmoid> exp;
return matrix_exp<exp>(exp(m)); return matrix_exp<exp>(exp(m));
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
struct op_round_zeros
{
template <typename EXP> template <typename EXP>
struct op_round_zeros : has_nondestructive_aliasing, preserves_dimensions<EXP> struct op : has_nondestructive_aliasing, preserves_dimensions<EXP>
{ {
typedef typename EXP::type type; typedef typename EXP::type type;
template <typename M, typename T> template <typename M, typename T>
...@@ -97,11 +103,12 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -97,11 +103,12 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
return 0; return 0;
} }
}; };
};
template < template <
typename EXP typename EXP
> >
const matrix_exp<matrix_scalar_binary_exp<matrix_exp<EXP>,typename EXP::type,op_round_zeros<EXP> > > round_zeros ( const matrix_exp<matrix_scalar_binary_exp<matrix_exp<EXP>,typename EXP::type,op_round_zeros> > round_zeros (
const matrix_exp<EXP>& m const matrix_exp<EXP>& m
) )
{ {
...@@ -111,14 +118,14 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -111,14 +118,14 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
is_same_type<typename EXP::type,double>::value == true || is_same_type<typename EXP::type,double>::value == true ||
is_same_type<typename EXP::type,long double>::value == true is_same_type<typename EXP::type,long double>::value == true
)); ));
typedef matrix_scalar_binary_exp<matrix_exp<EXP>,typename EXP::type, op_round_zeros<EXP> > exp; typedef matrix_scalar_binary_exp<matrix_exp<EXP>,typename EXP::type, op_round_zeros> exp;
return matrix_exp<exp>(exp(m,10*std::numeric_limits<typename EXP::type>::epsilon())); return matrix_exp<exp>(exp(m,10*std::numeric_limits<typename EXP::type>::epsilon()));
} }
template < template <
typename EXP typename EXP
> >
const matrix_exp<matrix_scalar_binary_exp<matrix_exp<EXP>,typename EXP::type,op_round_zeros<EXP> > > round_zeros ( const matrix_exp<matrix_scalar_binary_exp<matrix_exp<EXP>,typename EXP::type,op_round_zeros> > round_zeros (
const matrix_exp<EXP>& m, const matrix_exp<EXP>& m,
typename EXP::type eps typename EXP::type eps
) )
...@@ -129,70 +136,79 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -129,70 +136,79 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
is_same_type<typename EXP::type,double>::value == true || is_same_type<typename EXP::type,double>::value == true ||
is_same_type<typename EXP::type,long double>::value == true is_same_type<typename EXP::type,long double>::value == true
)); ));
typedef matrix_scalar_binary_exp<matrix_exp<EXP>,typename EXP::type, op_round_zeros<EXP> > exp; typedef matrix_scalar_binary_exp<matrix_exp<EXP>,typename EXP::type, op_round_zeros> exp;
return matrix_exp<exp>(exp(m,eps)); return matrix_exp<exp>(exp(m,eps));
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
struct op_cubed
{
template <typename EXP> template <typename EXP>
struct op_cubed : has_nondestructive_aliasing, preserves_dimensions<EXP> struct op : has_nondestructive_aliasing, preserves_dimensions<EXP>
{ {
typedef typename EXP::type type; typedef typename EXP::type type;
template <typename M> template <typename M>
static type apply ( const M& m, long r, long c) static type apply ( const M& m, long r, long c)
{ return m(r,c)*m(r,c)*m(r,c); } { return m(r,c)*m(r,c)*m(r,c); }
}; };
};
template < template <
typename EXP typename EXP
> >
const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_cubed<EXP> > > cubed ( const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_cubed> > cubed (
const matrix_exp<EXP>& m const matrix_exp<EXP>& m
) )
{ {
typedef matrix_unary_exp<matrix_exp<EXP>,op_cubed<EXP> > exp; typedef matrix_unary_exp<matrix_exp<EXP>,op_cubed> exp;
return matrix_exp<exp>(exp(m)); return matrix_exp<exp>(exp(m));
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
struct op_squared
{
template <typename EXP> template <typename EXP>
struct op_squared : has_nondestructive_aliasing, preserves_dimensions<EXP> struct op : has_nondestructive_aliasing, preserves_dimensions<EXP>
{ {
typedef typename EXP::type type; typedef typename EXP::type type;
template <typename M> template <typename M>
static type apply ( const M& m, long r, long c) static type apply ( const M& m, long r, long c)
{ return m(r,c)*m(r,c); } { return m(r,c)*m(r,c); }
}; };
};
template < template <
typename EXP typename EXP
> >
const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_squared<EXP> > > squared ( const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_squared> > squared (
const matrix_exp<EXP>& m const matrix_exp<EXP>& m
) )
{ {
typedef matrix_unary_exp<matrix_exp<EXP>,op_squared<EXP> > exp; typedef matrix_unary_exp<matrix_exp<EXP>,op_squared> exp;
return matrix_exp<exp>(exp(m)); return matrix_exp<exp>(exp(m));
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
struct op_pow
{
template <typename EXP> template <typename EXP>
struct op_pow : has_nondestructive_aliasing, preserves_dimensions<EXP> struct op : has_nondestructive_aliasing, preserves_dimensions<EXP>
{ {
typedef typename EXP::type type; typedef typename EXP::type type;
template <typename M, typename S> template <typename M, typename S>
static type apply ( const M& m, const S& s, long r, long c) static type apply ( const M& m, const S& s, long r, long c)
{ return static_cast<type>(std::pow(m(r,c),s)); } { return static_cast<type>(std::pow(m(r,c),s)); }
}; };
};
template < template <
typename EXP, typename EXP,
typename S typename S
> >
const matrix_exp<matrix_scalar_binary_exp<matrix_exp<EXP>,typename EXP::type,op_pow<EXP> > > pow ( const matrix_exp<matrix_scalar_binary_exp<matrix_exp<EXP>,typename EXP::type,op_pow> > pow (
const matrix_exp<EXP>& m, const matrix_exp<EXP>& m,
const S& s const S& s
) )
...@@ -203,14 +219,16 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -203,14 +219,16 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
is_same_type<typename EXP::type,double>::value == true || is_same_type<typename EXP::type,double>::value == true ||
is_same_type<typename EXP::type,long double>::value == true is_same_type<typename EXP::type,long double>::value == true
)); ));
typedef matrix_scalar_binary_exp<matrix_exp<EXP>,typename EXP::type,op_pow<EXP> > exp; typedef matrix_scalar_binary_exp<matrix_exp<EXP>,typename EXP::type,op_pow> exp;
return matrix_exp<exp>(exp(m,s)); return matrix_exp<exp>(exp(m,s));
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
struct op_reciprocal
{
template <typename EXP> template <typename EXP>
struct op_reciprocal : has_nondestructive_aliasing, preserves_dimensions<EXP> struct op : has_nondestructive_aliasing, preserves_dimensions<EXP>
{ {
typedef typename EXP::type type; typedef typename EXP::type type;
template <typename M> template <typename M>
...@@ -223,11 +241,12 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -223,11 +241,12 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
return 0; return 0;
} }
}; };
};
template < template <
typename EXP typename EXP
> >
const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_reciprocal<EXP> > > reciprocal ( const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_reciprocal> > reciprocal (
const matrix_exp<EXP>& m const matrix_exp<EXP>& m
) )
{ {
...@@ -237,14 +256,16 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -237,14 +256,16 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
is_same_type<typename EXP::type,double>::value == true || is_same_type<typename EXP::type,double>::value == true ||
is_same_type<typename EXP::type,long double>::value == true is_same_type<typename EXP::type,long double>::value == true
)); ));
typedef matrix_unary_exp<matrix_exp<EXP>,op_reciprocal<EXP> > exp; typedef matrix_unary_exp<matrix_exp<EXP>,op_reciprocal> exp;
return matrix_exp<exp>(exp(m)); return matrix_exp<exp>(exp(m));
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
struct op_normalize
{
template <typename EXP> template <typename EXP>
struct op_normalize : has_nondestructive_aliasing, preserves_dimensions<EXP> struct op : has_nondestructive_aliasing, preserves_dimensions<EXP>
{ {
typedef typename EXP::type type; typedef typename EXP::type type;
template <typename M> template <typename M>
...@@ -253,11 +274,12 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -253,11 +274,12 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
return m(r,c)*s; return m(r,c)*s;
} }
}; };
};
template < template <
typename EXP typename EXP
> >
const matrix_exp<matrix_scalar_binary_exp<matrix_exp<EXP>,typename EXP::type,op_normalize<EXP> > > normalize ( const matrix_exp<matrix_scalar_binary_exp<matrix_exp<EXP>,typename EXP::type,op_normalize> > normalize (
const matrix_exp<EXP>& m const matrix_exp<EXP>& m
) )
{ {
...@@ -267,7 +289,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -267,7 +289,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
is_same_type<typename EXP::type,double>::value == true || is_same_type<typename EXP::type,double>::value == true ||
is_same_type<typename EXP::type,long double>::value == true is_same_type<typename EXP::type,long double>::value == true
)); ));
typedef matrix_scalar_binary_exp<matrix_exp<EXP>,typename EXP::type, op_normalize<EXP> > exp; typedef matrix_scalar_binary_exp<matrix_exp<EXP>,typename EXP::type, op_normalize> exp;
typename EXP::type temp = std::sqrt(sum(squared(m))); typename EXP::type temp = std::sqrt(sum(squared(m)));
if (temp != 0.0) if (temp != 0.0)
...@@ -278,8 +300,10 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -278,8 +300,10 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
struct op_round
{
template <typename EXP> template <typename EXP>
struct op_round : has_nondestructive_aliasing, preserves_dimensions<EXP> struct op : has_nondestructive_aliasing, preserves_dimensions<EXP>
{ {
typedef typename EXP::type type; typedef typename EXP::type type;
template <typename M> template <typename M>
...@@ -288,11 +312,12 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -288,11 +312,12 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
return static_cast<type>(std::floor(m(r,c)+0.5)); return static_cast<type>(std::floor(m(r,c)+0.5));
} }
}; };
};
template < template <
typename EXP typename EXP
> >
const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_round<EXP> > > round ( const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_round> > round (
const matrix_exp<EXP>& m const matrix_exp<EXP>& m
) )
{ {
...@@ -302,14 +327,16 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -302,14 +327,16 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
is_same_type<typename EXP::type,double>::value == true || is_same_type<typename EXP::type,double>::value == true ||
is_same_type<typename EXP::type,long double>::value == true is_same_type<typename EXP::type,long double>::value == true
)); ));
typedef matrix_unary_exp<matrix_exp<EXP>,op_round<EXP> > exp; typedef matrix_unary_exp<matrix_exp<EXP>,op_round> exp;
return matrix_exp<exp>(exp(m)); return matrix_exp<exp>(exp(m));
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
struct op_complex_matrix
{
template <typename EXP1, typename EXP2> template <typename EXP1, typename EXP2>
struct op_complex_matrix : has_nondestructive_aliasing, preserves_dimensions<EXP1,EXP2> struct op : has_nondestructive_aliasing, preserves_dimensions<EXP1,EXP2>
{ {
typedef std::complex<typename EXP1::type> type; typedef std::complex<typename EXP1::type> type;
...@@ -317,12 +344,13 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -317,12 +344,13 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
static type apply ( const M1& m1, const M2& m2 , long r, long c) static type apply ( const M1& m1, const M2& m2 , long r, long c)
{ return type(m1(r,c),m2(r,c)); } { return type(m1(r,c),m2(r,c)); }
}; };
};
template < template <
typename EXP1, typename EXP1,
typename EXP2 typename EXP2
> >
const matrix_exp<matrix_binary_exp<matrix_exp<EXP1>,matrix_exp<EXP2>,op_complex_matrix<EXP1,EXP2> > > complex_matrix ( const matrix_exp<matrix_binary_exp<matrix_exp<EXP1>,matrix_exp<EXP2>,op_complex_matrix> > complex_matrix (
const matrix_exp<EXP1>& real_part, const matrix_exp<EXP1>& real_part,
const matrix_exp<EXP2>& imag_part const matrix_exp<EXP2>& imag_part
) )
...@@ -340,73 +368,82 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -340,73 +368,82 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
<< "\n\timag_part.nr(): " << imag_part.nr() << "\n\timag_part.nr(): " << imag_part.nr()
<< "\n\timag_part.nc(): " << imag_part.nc() << "\n\timag_part.nc(): " << imag_part.nc()
); );
typedef matrix_binary_exp<matrix_exp<EXP1>,matrix_exp<EXP2>,op_complex_matrix<EXP1,EXP2> > exp; typedef matrix_binary_exp<matrix_exp<EXP1>,matrix_exp<EXP2>,op_complex_matrix> exp;
return matrix_exp<exp>(exp(real_part,imag_part)); return matrix_exp<exp>(exp(real_part,imag_part));
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
struct op_norm
{
template <typename EXP> template <typename EXP>
struct op_norm : has_nondestructive_aliasing, preserves_dimensions<EXP> struct op : has_nondestructive_aliasing, preserves_dimensions<EXP>
{ {
typedef typename EXP::type::value_type type; typedef typename EXP::type::value_type type;
template <typename M> template <typename M>
static type apply ( const M& m, long r, long c) static type apply ( const M& m, long r, long c)
{ return std::norm(m(r,c)); } { return std::norm(m(r,c)); }
}; };
};
template < template <
typename EXP typename EXP
> >
const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_norm<EXP> > > norm ( const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_norm> > norm (
const matrix_exp<EXP>& m const matrix_exp<EXP>& m
) )
{ {
typedef matrix_unary_exp<matrix_exp<EXP>,op_norm<EXP> > exp; typedef matrix_unary_exp<matrix_exp<EXP>,op_norm> exp;
return matrix_exp<exp>(exp(m)); return matrix_exp<exp>(exp(m));
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
struct op_real
{
template <typename EXP> template <typename EXP>
struct op_real : has_nondestructive_aliasing, preserves_dimensions<EXP> struct op : has_nondestructive_aliasing, preserves_dimensions<EXP>
{ {
typedef typename EXP::type::value_type type; typedef typename EXP::type::value_type type;
template <typename M> template <typename M>
static type apply ( const M& m, long r, long c) static type apply ( const M& m, long r, long c)
{ return std::real(m(r,c)); } { return std::real(m(r,c)); }
}; };
};
template < template <
typename EXP typename EXP
> >
const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_real<EXP> > > real ( const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_real> > real (
const matrix_exp<EXP>& m const matrix_exp<EXP>& m
) )
{ {
typedef matrix_unary_exp<matrix_exp<EXP>,op_real<EXP> > exp; typedef matrix_unary_exp<matrix_exp<EXP>,op_real> exp;
return matrix_exp<exp>(exp(m)); return matrix_exp<exp>(exp(m));
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
struct op_imag
{
template <typename EXP> template <typename EXP>
struct op_imag : has_nondestructive_aliasing, preserves_dimensions<EXP> struct op : has_nondestructive_aliasing, preserves_dimensions<EXP>
{ {
typedef typename EXP::type::value_type type; typedef typename EXP::type::value_type type;
template <typename M> template <typename M>
static type apply ( const M& m, long r, long c) static type apply ( const M& m, long r, long c)
{ return std::imag(m(r,c)); } { return std::imag(m(r,c)); }
}; };
};
template < template <
typename EXP typename EXP
> >
const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_imag<EXP> > > imag ( const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_imag> > imag (
const matrix_exp<EXP>& m const matrix_exp<EXP>& m
) )
{ {
typedef matrix_unary_exp<matrix_exp<EXP>,op_imag<EXP> > exp; typedef matrix_unary_exp<matrix_exp<EXP>,op_imag> exp;
return matrix_exp<exp>(exp(m)); return matrix_exp<exp>(exp(m));
} }
......
dlib/matrix/matrix_utilities.h
View file @ f825990c
...@@ -895,7 +895,7 @@ namespace dlib ...@@ -895,7 +895,7 @@ namespace dlib
template < template <
typename M, typename M,
typename OP typename OP_
> >
class matrix_unary_exp class matrix_unary_exp
{ {
...@@ -904,6 +904,8 @@ namespace dlib ...@@ -904,6 +904,8 @@ namespace dlib
- must be a matrix_exp or matrix_ref object (or - must be a matrix_exp or matrix_ref object (or
an object with a compatible interface). an object with a compatible interface).
!*/ !*/
typedef typename OP_::template op<M> OP;
public: public:
typedef typename OP::type type; typedef typename OP::type type;
typedef matrix_unary_exp ref_type; typedef matrix_unary_exp ref_type;
...@@ -1179,7 +1181,7 @@ namespace dlib ...@@ -1179,7 +1181,7 @@ namespace dlib
template < template <
typename M, typename M,
typename S, typename S,
typename OP typename OP_
> >
class matrix_scalar_binary_exp class matrix_scalar_binary_exp
{ {
...@@ -1188,6 +1190,8 @@ namespace dlib ...@@ -1188,6 +1190,8 @@ namespace dlib
- must be a matrix_exp or matrix_ref object (or - must be a matrix_exp or matrix_ref object (or
an object with a compatible interface). an object with a compatible interface).
!*/ !*/
typedef typename OP_::template op<M> OP;
public: public:
typedef typename OP::type type; typedef typename OP::type type;
typedef matrix_scalar_binary_exp ref_type; typedef matrix_scalar_binary_exp ref_type;
...@@ -1240,7 +1244,7 @@ namespace dlib ...@@ -1240,7 +1244,7 @@ namespace dlib
template < template <
typename M1, typename M1,
typename M2, typename M2,
typename OP typename OP_
> >
class matrix_binary_exp class matrix_binary_exp
{ {
...@@ -1249,6 +1253,8 @@ namespace dlib ...@@ -1249,6 +1253,8 @@ namespace dlib
- must be a matrix_exp or matrix_ref object (or - must be a matrix_exp or matrix_ref object (or
an object with a compatible interface). an object with a compatible interface).
!*/ !*/
typedef typename OP_::template op<M1,M2> OP;
public: public:
typedef typename OP::type type; typedef typename OP::type type;
typedef matrix_binary_exp ref_type; typedef matrix_binary_exp ref_type;
...@@ -1743,8 +1749,10 @@ namespace dlib ...@@ -1743,8 +1749,10 @@ namespace dlib
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
struct op_trans
{
template <typename EXP> template <typename EXP>
struct op_trans : has_destructive_aliasing struct op : has_destructive_aliasing
{ {
const static long NR = EXP::NC; const static long NR = EXP::NC;
const static long NC = EXP::NR; const static long NC = EXP::NR;
...@@ -1759,22 +1767,26 @@ namespace dlib ...@@ -1759,22 +1767,26 @@ namespace dlib
template <typename M> template <typename M>
static long nc (const M& m) { return m.nr(); } static long nc (const M& m) { return m.nr(); }
}; };
};
template < template <
typename EXP typename EXP
> >
const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_trans<EXP> > > trans ( const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_trans> > trans (
const matrix_exp<EXP>& m const matrix_exp<EXP>& m
) )
{ {
typedef matrix_unary_exp<matrix_exp<EXP>,op_trans<EXP> > exp; typedef matrix_unary_exp<matrix_exp<EXP>,op_trans> exp;
return matrix_exp<exp>(exp(m)); return matrix_exp<exp>(exp(m));
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename EXP, long R, long C> template <long R, long C>
struct op_removerc : has_destructive_aliasing struct op_removerc
{
template <typename EXP>
struct op : has_destructive_aliasing
{ {
const static long NR = EXP::NR - 1; const static long NR = EXP::NR - 1;
const static long NC = EXP::NC - 1; const static long NC = EXP::NC - 1;
...@@ -1804,13 +1816,14 @@ namespace dlib ...@@ -1804,13 +1816,14 @@ namespace dlib
template <typename M> template <typename M>
static long nc (const M& m) { return m.nc() - 1; } static long nc (const M& m) { return m.nc() - 1; }
}; };
};
template < template <
long R, long R,
long C, long C,
typename EXP typename EXP
> >
const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_removerc<EXP,R,C> > > removerc ( const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_removerc<R,C> > > removerc (
const matrix_exp<EXP>& m const matrix_exp<EXP>& m
) )
{ {
...@@ -1826,14 +1839,16 @@ namespace dlib ...@@ -1826,14 +1839,16 @@ namespace dlib
<< "\n\tR: " << R << "\n\tR: " << R
<< "\n\tC: " << C << "\n\tC: " << C
); );
typedef matrix_unary_exp<matrix_exp<EXP>,op_removerc<EXP,R,C> > exp; typedef matrix_unary_exp<matrix_exp<EXP>,op_removerc<R,C> > exp;
return matrix_exp<exp>(exp(m)); return matrix_exp<exp>(exp(m));
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
struct op_diag
{
template <typename EXP> template <typename EXP>
struct op_diag : has_destructive_aliasing struct op : has_destructive_aliasing
{ {
const static long NR = EXP::NC; const static long NR = EXP::NC;
const static long NC = 1; const static long NC = 1;
...@@ -1848,11 +1863,12 @@ namespace dlib ...@@ -1848,11 +1863,12 @@ namespace dlib
template <typename M> template <typename M>
static long nc (const M& m) { return 1; } static long nc (const M& m) { return 1; }
}; };
};
template < template <
typename EXP typename EXP
> >
const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_diag<EXP> > > diag ( const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_diag> > diag (
const matrix_exp<EXP>& m const matrix_exp<EXP>& m
) )
{ {
...@@ -1864,30 +1880,34 @@ namespace dlib ...@@ -1864,30 +1880,34 @@ namespace dlib
<< "\n\tm.nr(): " << m.nr() << "\n\tm.nr(): " << m.nr()
<< "\n\tm.nc(): " << m.nc() << "\n\tm.nc(): " << m.nc()
); );
typedef matrix_unary_exp<matrix_exp<EXP>,op_diag<EXP> > exp; typedef matrix_unary_exp<matrix_exp<EXP>,op_diag> exp;
return matrix_exp<exp>(exp(m)); return matrix_exp<exp>(exp(m));
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename EXP, typename target_type> template <typename target_type>
struct op_cast : has_nondestructive_aliasing, preserves_dimensions<EXP> struct op_cast
{
template <typename EXP>
struct op : has_nondestructive_aliasing, preserves_dimensions<EXP>
{ {
typedef target_type type; typedef target_type type;
template <typename M> template <typename M>
static type apply ( const M& m, long r, long c) static type apply ( const M& m, long r, long c)
{ return static_cast<target_type>(m(r,c)); } { return static_cast<target_type>(m(r,c)); }
}; };
};
template < template <
typename target_type, typename target_type,
typename EXP typename EXP
> >
const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_cast<EXP,target_type> > > matrix_cast ( const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_cast<target_type> > > matrix_cast (
const matrix_exp<EXP>& m const matrix_exp<EXP>& m
) )
{ {
typedef matrix_unary_exp<matrix_exp<EXP>,op_cast<EXP,target_type> > exp; typedef matrix_unary_exp<matrix_exp<EXP>,op_cast<target_type> > exp;
return matrix_exp<exp>(exp(m)); return matrix_exp<exp>(exp(m));
} }
...@@ -2740,21 +2760,25 @@ namespace dlib ...@@ -2740,21 +2760,25 @@ namespace dlib
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <long R, long C, typename EXP> template <long R, long C>
struct op_rotate : has_destructive_aliasing, preserves_dimensions<EXP> struct op_rotate
{
template <typename EXP>
struct op : has_destructive_aliasing, preserves_dimensions<EXP>
{ {
typedef typename EXP::type type; typedef typename EXP::type type;
template <typename M> template <typename M>
static type apply ( const M& m, long r, long c) static type apply ( const M& m, long r, long c)
{ return m((r+R)%m.nr(),(c+C)%m.nc()); } { return m((r+R)%m.nr(),(c+C)%m.nc()); }
}; };
};
template < template <
long R, long R,
long C, long C,
typename EXP typename EXP
> >
const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_rotate<R,C,EXP> > > rotate ( const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_rotate<R,C> > > rotate (
const matrix_exp<EXP>& m const matrix_exp<EXP>& m
) )
{ {
...@@ -2770,14 +2794,16 @@ namespace dlib ...@@ -2770,14 +2794,16 @@ namespace dlib
<< "\n\tR: " << R << "\n\tR: " << R
<< "\n\tC: " << C << "\n\tC: " << C
); );
typedef matrix_unary_exp<matrix_exp<EXP>,op_rotate<R,C,EXP> > exp; typedef matrix_unary_exp<matrix_exp<EXP>,op_rotate<R,C> > exp;
return matrix_exp<exp>(exp(m)); return matrix_exp<exp>(exp(m));
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename EXP1, typename EXP2, typename EXP3 = void, typename EXP4 = void> struct op_pointwise_multiply
struct op_pointwise_multiply : public has_nondestructive_aliasing, public preserves_dimensions<EXP1,EXP2,EXP3,EXP4> {
template <typename EXP1, typename EXP2>
struct op : public has_nondestructive_aliasing, public preserves_dimensions<EXP1,EXP2>
{ {
typedef typename EXP1::type type; typedef typename EXP1::type type;
...@@ -2785,12 +2811,13 @@ namespace dlib ...@@ -2785,12 +2811,13 @@ namespace dlib
static type apply ( const M1& m1, const M2& m2 , long r, long c) static type apply ( const M1& m1, const M2& m2 , long r, long c)
{ return m1(r,c)*m2(r,c); } { return m1(r,c)*m2(r,c); }
}; };
};
template < template <
typename EXP1, typename EXP1,
typename EXP2 typename EXP2
> >
inline const matrix_exp<matrix_binary_exp<matrix_exp<EXP1>,matrix_exp<EXP2>,op_pointwise_multiply<EXP1,EXP2> > > pointwise_multiply ( inline const matrix_exp<matrix_binary_exp<EXP1,EXP2,op_pointwise_multiply> > pointwise_multiply (
const matrix_exp<EXP1>& a, const matrix_exp<EXP1>& a,
const matrix_exp<EXP2>& b const matrix_exp<EXP2>& b
) )
...@@ -2807,8 +2834,8 @@ namespace dlib ...@@ -2807,8 +2834,8 @@ namespace dlib
<< "\n\tb.nr(): " << b.nr() << "\n\tb.nr(): " << b.nr()
<< "\n\tb.nc(): " << b.nc() << "\n\tb.nc(): " << b.nc()
); );
typedef matrix_binary_exp<matrix_exp<EXP1>,matrix_exp<EXP2>,op_pointwise_multiply<EXP1,EXP2> > exp; typedef matrix_binary_exp<EXP1,EXP2,op_pointwise_multiply> exp;
return matrix_exp<exp>(exp(a,b)); return matrix_exp<exp>(exp(a.ref(),b.ref()));
} }
template < template <
...@@ -2816,9 +2843,7 @@ namespace dlib ...@@ -2816,9 +2843,7 @@ namespace dlib
typename EXP2, typename EXP2,
typename EXP3 typename EXP3
> >
inline const matrix_exp< inline const matrix_exp<matrix_binary_exp<matrix_binary_exp<EXP1,EXP2,op_pointwise_multiply>,EXP3,op_pointwise_multiply> >
matrix_binary_exp< matrix_binary_exp<matrix_exp<EXP1>,matrix_exp<EXP2>,op_pointwise_multiply<EXP1,EXP2> > ,
matrix_exp<EXP3>, op_pointwise_multiply<EXP1,EXP2,EXP3> > >
pointwise_multiply ( pointwise_multiply (
const matrix_exp<EXP1>& a, const matrix_exp<EXP1>& a,
const matrix_exp<EXP2>& b, const matrix_exp<EXP2>& b,
...@@ -2843,10 +2868,10 @@ namespace dlib ...@@ -2843,10 +2868,10 @@ namespace dlib
<< "\n\tc.nr(): " << c.nr() << "\n\tc.nr(): " << c.nr()
<< "\n\tc.nc(): " << c.nc() << "\n\tc.nc(): " << c.nc()
); );
typedef matrix_binary_exp<matrix_exp<EXP1>,matrix_exp<EXP2>,op_pointwise_multiply<EXP1,EXP2> > exp; typedef matrix_binary_exp<EXP1,EXP2,op_pointwise_multiply> exp;
typedef matrix_binary_exp< exp , matrix_exp<EXP3>, op_pointwise_multiply<EXP1,EXP2,EXP3> > exp2; typedef matrix_binary_exp<exp , EXP3, op_pointwise_multiply> exp2;
return matrix_exp<exp2>(exp2(exp(a,b),c)); return matrix_exp<exp2>(exp2(exp(a.ref(),b.ref()),c.ref()));
} }
template < template <
...@@ -2856,9 +2881,9 @@ namespace dlib ...@@ -2856,9 +2881,9 @@ namespace dlib
typename EXP4 typename EXP4
> >
inline const matrix_exp< inline const matrix_exp<
matrix_binary_exp< matrix_binary_exp<matrix_exp<EXP1>,matrix_exp<EXP2>,op_pointwise_multiply<EXP1,EXP2> > , matrix_binary_exp<matrix_binary_exp<EXP1,EXP2,op_pointwise_multiply> ,
matrix_binary_exp<matrix_exp<EXP3>,matrix_exp<EXP4>,op_pointwise_multiply<EXP3,EXP4> >, matrix_binary_exp<EXP3,EXP4,op_pointwise_multiply>,
op_pointwise_multiply<EXP1,EXP2,EXP3,EXP4> > > op_pointwise_multiply> >
pointwise_multiply ( pointwise_multiply (
const matrix_exp<EXP1>& a, const matrix_exp<EXP1>& a,
const matrix_exp<EXP2>& b, const matrix_exp<EXP2>& b,
...@@ -2890,11 +2915,11 @@ namespace dlib ...@@ -2890,11 +2915,11 @@ namespace dlib
<< "\n\td.nr(): " << d.nr() << "\n\td.nr(): " << d.nr()
<< "\n\td.nc(): " << d.nc() << "\n\td.nc(): " << d.nc()
); );
typedef matrix_binary_exp<matrix_exp<EXP1>,matrix_exp<EXP2>,op_pointwise_multiply<EXP1,EXP2> > exp1; typedef matrix_binary_exp<EXP1,EXP2,op_pointwise_multiply> exp1;
typedef matrix_binary_exp<matrix_exp<EXP3>,matrix_exp<EXP4>,op_pointwise_multiply<EXP3,EXP4> > exp2; typedef matrix_binary_exp<EXP3,EXP4,op_pointwise_multiply> exp2;
typedef matrix_binary_exp< exp1 , exp2, op_pointwise_multiply<EXP1,EXP2,EXP3,EXP4> > exp3; typedef matrix_binary_exp< exp1 , exp2, op_pointwise_multiply> exp3;
return matrix_exp<exp3>(exp3(exp1(a,b),exp2(c,d))); return matrix_exp<exp3>(exp3(exp1(a.ref(),b.ref()),exp2(c.ref(),d.ref())));
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
...@@ -3072,8 +3097,11 @@ namespace dlib ...@@ -3072,8 +3097,11 @@ namespace dlib
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <long lower, long upper, typename EXP> template <long lower, long upper>
struct op_clamp : has_nondestructive_aliasing, preserves_dimensions<EXP> struct op_clamp
{
template <typename EXP>
struct op : has_nondestructive_aliasing, preserves_dimensions<EXP>
{ {
typedef typename EXP::type type; typedef typename EXP::type type;
...@@ -3089,17 +3117,18 @@ namespace dlib ...@@ -3089,17 +3117,18 @@ namespace dlib
return temp; return temp;
} }
}; };
};
template < template <
long l, long l,
long u, long u,
typename EXP typename EXP
> >
const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_clamp<l,u,EXP> > > clamp ( const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_clamp<l,u> > > clamp (
const matrix_exp<EXP>& m const matrix_exp<EXP>& m
) )
{ {
typedef matrix_unary_exp<matrix_exp<EXP>,op_clamp<l,u,EXP> > exp; typedef matrix_unary_exp<matrix_exp<EXP>,op_clamp<l,u> > exp;
return matrix_exp<exp>(exp(m)); return matrix_exp<exp>(exp(m));
} }
...@@ -3134,8 +3163,10 @@ namespace dlib ...@@ -3134,8 +3163,10 @@ namespace dlib
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
struct op_scale_columns
{
template <typename EXP1, typename EXP2> template <typename EXP1, typename EXP2>
struct op_scale_columns : has_nondestructive_aliasing struct op : has_nondestructive_aliasing
{ {
typedef typename EXP1::type type; typedef typename EXP1::type type;
typedef typename EXP1::mem_manager_type mem_manager_type; typedef typename EXP1::mem_manager_type mem_manager_type;
...@@ -3151,12 +3182,13 @@ namespace dlib ...@@ -3151,12 +3182,13 @@ namespace dlib
template <typename M1, typename M2> template <typename M1, typename M2>
static long nc (const M1& m1, const M2& ) { return m1.nc(); } static long nc (const M1& m1, const M2& ) { return m1.nc(); }
}; };
};
template < template <
typename EXP1, typename EXP1,
typename EXP2 typename EXP2
> >
const matrix_exp<matrix_binary_exp<matrix_exp<EXP1>,matrix_exp<EXP2>,op_scale_columns<EXP1,EXP2> > > scale_columns ( const matrix_exp<matrix_binary_exp<matrix_exp<EXP1>,matrix_exp<EXP2>,op_scale_columns> > scale_columns (
const matrix_exp<EXP1>& m, const matrix_exp<EXP1>& m,
const matrix_exp<EXP2>& v const matrix_exp<EXP2>& v
) )
...@@ -3173,7 +3205,7 @@ namespace dlib ...@@ -3173,7 +3205,7 @@ namespace dlib
<< "\n\tv.nr(): " << v.nr() << "\n\tv.nr(): " << v.nr()
<< "\n\tv.nc(): " << v.nc() << "\n\tv.nc(): " << v.nc()
); );
typedef matrix_binary_exp<matrix_exp<EXP1>,matrix_exp<EXP2>,op_scale_columns<EXP1,EXP2> > exp; typedef matrix_binary_exp<matrix_exp<EXP1>,matrix_exp<EXP2>,op_scale_columns> exp;
return matrix_exp<exp>(exp(m,v)); return matrix_exp<exp>(exp(m,v));
} }
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment