Skip to content

GitLab

"tests/git@developer.sourcefind.cn:OpenDAS/dgl.git" did not exist on "463650a772e0c86f11a0184483acbb877404d3b6"
Commit dd08cc4f authored by Davis King's avatar Davis King
Browse files

Refactored a bunch of the matrix code into a cleaner form. I also added a 

cost member to all the matrix expressions so that the complexity of an
expression can be measured and temporaries introduced when appropriate.

--HG--
extra : convert_revision : svn%3Afdd8eb12-d10e-0410-9acb-85c331704f74/trunk%402732
parent 14121d95
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 1782 additions and 1278 deletions
dlib/is_kind.h
View file @ dd08cc4f
...@@ -45,7 +45,7 @@ namespace dlib ...@@ -45,7 +45,7 @@ namespace dlib
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
template <typename T> template <typename T, typename helper = void>
struct is_matrix : public default_is_kind_value struct is_matrix : public default_is_kind_value
{ {
/*! /*!
...@@ -54,6 +54,9 @@ namespace dlib ...@@ -54,6 +54,9 @@ namespace dlib
- else - else
- is_matrix<T>::value == false - is_matrix<T>::value == false
!*/ !*/
// Don't set the helper to anything. Just let it be void.
ASSERT_ARE_SAME_TYPE(helper,void);
}; };
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
......
dlib/matrix/matrix.h
View file @ dd08cc4f
This diff is collapsed.
dlib/matrix/matrix_abstract.h
View file @ dd08cc4f
...@@ -167,6 +167,7 @@ namespace dlib ...@@ -167,6 +167,7 @@ namespace dlib
const static long NR = EXP::NR; const static long NR = EXP::NR;
const static long NC = EXP::NC; const static long NC = EXP::NC;
typedef matrix<type,NR,NC, mem_manager_type> matrix_type; typedef matrix<type,NR,NC, mem_manager_type> matrix_type;
const static long cost = EXP::cost;
matrix_exp ( matrix_exp (
const EXP& exp const EXP& exp
......
dlib/matrix/matrix_assign.h
View file @ dd08cc4f
...@@ -50,6 +50,9 @@ namespace dlib ...@@ -50,6 +50,9 @@ namespace dlib
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
// TODO
#if 0
template < template <
typename matrix_dest_type, typename matrix_dest_type,
typename EXP1, typename EXP1,
...@@ -117,6 +120,7 @@ namespace dlib ...@@ -117,6 +120,7 @@ namespace dlib
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
#endif
} }
......
dlib/matrix/matrix_expressions.h 0 → 100644
View file @ dd08cc4f
This diff is collapsed.
dlib/matrix/matrix_math_functions.h
View file @ dd08cc4f
...@@ -17,45 +17,45 @@ namespace dlib ...@@ -17,45 +17,45 @@ namespace dlib
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
#define DLIB_MATRIX_SIMPLE_STD_FUNCTION(name) struct op_##name { \ #define DLIB_MATRIX_SIMPLE_STD_FUNCTION(name,extra_cost) struct op_##name { \
template <typename EXP> \ template <typename EXP> \
struct op : has_nondestructive_aliasing, preserves_dimensions<EXP> \ struct op : has_nondestructive_aliasing, preserves_dimensions<EXP> \
{ \ { \
const static long cost = EXP::cost+(extra_cost); \
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> > name ( \ const matrix_unary_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; \ return matrix_unary_exp<EXP,op_##name>(m.ref()); \
return matrix_exp<exp>(exp(m)); \
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
DLIB_MATRIX_SIMPLE_STD_FUNCTION(abs) DLIB_MATRIX_SIMPLE_STD_FUNCTION(abs,3)
DLIB_MATRIX_SIMPLE_STD_FUNCTION(sqrt) DLIB_MATRIX_SIMPLE_STD_FUNCTION(sqrt,7)
DLIB_MATRIX_SIMPLE_STD_FUNCTION(log) DLIB_MATRIX_SIMPLE_STD_FUNCTION(log,7)
DLIB_MATRIX_SIMPLE_STD_FUNCTION(log10) DLIB_MATRIX_SIMPLE_STD_FUNCTION(log10,7)
DLIB_MATRIX_SIMPLE_STD_FUNCTION(exp) DLIB_MATRIX_SIMPLE_STD_FUNCTION(exp,7)
DLIB_MATRIX_SIMPLE_STD_FUNCTION(conj) DLIB_MATRIX_SIMPLE_STD_FUNCTION(conj,1)
DLIB_MATRIX_SIMPLE_STD_FUNCTION(ceil) DLIB_MATRIX_SIMPLE_STD_FUNCTION(ceil,2)
DLIB_MATRIX_SIMPLE_STD_FUNCTION(floor) DLIB_MATRIX_SIMPLE_STD_FUNCTION(floor,20)
DLIB_MATRIX_SIMPLE_STD_FUNCTION(sin) DLIB_MATRIX_SIMPLE_STD_FUNCTION(sin,7)
DLIB_MATRIX_SIMPLE_STD_FUNCTION(cos) DLIB_MATRIX_SIMPLE_STD_FUNCTION(cos,7)
DLIB_MATRIX_SIMPLE_STD_FUNCTION(tan) DLIB_MATRIX_SIMPLE_STD_FUNCTION(tan,7)
DLIB_MATRIX_SIMPLE_STD_FUNCTION(sinh) DLIB_MATRIX_SIMPLE_STD_FUNCTION(sinh,7)
DLIB_MATRIX_SIMPLE_STD_FUNCTION(cosh) DLIB_MATRIX_SIMPLE_STD_FUNCTION(cosh,7)
DLIB_MATRIX_SIMPLE_STD_FUNCTION(tanh) DLIB_MATRIX_SIMPLE_STD_FUNCTION(tanh,7)
DLIB_MATRIX_SIMPLE_STD_FUNCTION(asin) DLIB_MATRIX_SIMPLE_STD_FUNCTION(asin,7)
DLIB_MATRIX_SIMPLE_STD_FUNCTION(acos) DLIB_MATRIX_SIMPLE_STD_FUNCTION(acos,7)
DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan,7)
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
...@@ -64,6 +64,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -64,6 +64,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
template <typename EXP> template <typename EXP>
struct op : has_nondestructive_aliasing, preserves_dimensions<EXP> struct op : has_nondestructive_aliasing, preserves_dimensions<EXP>
{ {
const static long cost = EXP::cost+7;
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)
...@@ -76,12 +77,11 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -76,12 +77,11 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
template < template <
typename EXP typename EXP
> >
const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_sigmoid> > sigmoid ( const matrix_unary_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; return matrix_unary_exp<EXP,op_sigmoid>(m.ref());
return matrix_exp<exp>(exp(m));
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
...@@ -91,6 +91,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -91,6 +91,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
template <typename EXP> template <typename EXP>
struct op : has_nondestructive_aliasing, preserves_dimensions<EXP> struct op : has_nondestructive_aliasing, preserves_dimensions<EXP>
{ {
const static long cost = EXP::cost+1;
typedef typename EXP::type type; typedef typename EXP::type type;
template <typename M, typename T> template <typename M, typename T>
static type apply ( const M& m, const T& eps, long r, long c) static type apply ( const M& m, const T& eps, long r, long c)
...@@ -107,28 +108,27 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -107,28 +108,27 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
template < template <
typename EXP typename EXP
> >
const matrix_exp<matrix_scalar_binary_exp<matrix_exp<EXP>,typename EXP::type,op_round_zeros> > round_zeros ( const matrix_scalar_binary_exp<EXP,typename EXP::type,op_round_zeros> round_zeros (
const matrix_exp<EXP>& m const matrix_exp<EXP>& m
) )
{ {
// you can only round matrices that contain built in scalar types like double, long, float, etc... // you can only round matrices that contain built in scalar types like double, long, float, etc...
COMPILE_TIME_ASSERT(is_built_in_scalar_type<typename EXP::type>::value); COMPILE_TIME_ASSERT(is_built_in_scalar_type<typename EXP::type>::value);
typedef matrix_scalar_binary_exp<matrix_exp<EXP>,typename EXP::type, op_round_zeros> exp; typedef matrix_scalar_binary_exp<EXP,typename EXP::type, op_round_zeros> exp;
return matrix_exp<exp>(exp(m,10*std::numeric_limits<typename EXP::type>::epsilon())); return exp(m.ref(),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> > round_zeros ( const matrix_scalar_binary_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
) )
{ {
// you can only round matrices that contain built in scalar types like double, long, float, etc... // you can only round matrices that contain built in scalar types like double, long, float, etc...
COMPILE_TIME_ASSERT(is_built_in_scalar_type<typename EXP::type>::value); COMPILE_TIME_ASSERT(is_built_in_scalar_type<typename EXP::type>::value);
typedef matrix_scalar_binary_exp<matrix_exp<EXP>,typename EXP::type, op_round_zeros> exp; return matrix_scalar_binary_exp<EXP,typename EXP::type, op_round_zeros>(m.ref(),eps);
return matrix_exp<exp>(exp(m,eps));
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
...@@ -138,6 +138,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -138,6 +138,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
template <typename EXP> template <typename EXP>
struct op : has_nondestructive_aliasing, preserves_dimensions<EXP> struct op : has_nondestructive_aliasing, preserves_dimensions<EXP>
{ {
const static long cost = EXP::cost+2;
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)
...@@ -151,12 +152,11 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -151,12 +152,11 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
template < template <
typename EXP typename EXP
> >
const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_cubed> > cubed ( const matrix_unary_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; return matrix_unary_exp<EXP,op_cubed>(m.ref());
return matrix_exp<exp>(exp(m));
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
...@@ -166,6 +166,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -166,6 +166,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
template <typename EXP> template <typename EXP>
struct op : has_nondestructive_aliasing, preserves_dimensions<EXP> struct op : has_nondestructive_aliasing, preserves_dimensions<EXP>
{ {
const static long cost = EXP::cost+1;
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)
...@@ -179,12 +180,11 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -179,12 +180,11 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
template < template <
typename EXP typename EXP
> >
const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_squared> > squared ( const matrix_unary_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; return matrix_unary_exp<EXP,op_squared>(m.ref());
return matrix_exp<exp>(exp(m));
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
...@@ -194,6 +194,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -194,6 +194,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
template <typename EXP> template <typename EXP>
struct op : has_nondestructive_aliasing, preserves_dimensions<EXP> struct op : has_nondestructive_aliasing, preserves_dimensions<EXP>
{ {
const static long cost = EXP::cost+4;
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)
...@@ -205,7 +206,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -205,7 +206,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
typename EXP, typename EXP,
typename S typename S
> >
const matrix_exp<matrix_scalar_binary_exp<matrix_exp<EXP>,typename EXP::type,op_pow> > pow ( const matrix_scalar_binary_exp<EXP,typename EXP::type,op_pow> pow (
const matrix_exp<EXP>& m, const matrix_exp<EXP>& m,
const S& s const S& s
) )
...@@ -216,8 +217,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -216,8 +217,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_pow> exp; return matrix_scalar_binary_exp<EXP,typename EXP::type,op_pow>(m.ref(),s);
return matrix_exp<exp>(exp(m,s));
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
...@@ -227,6 +227,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -227,6 +227,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
template <typename EXP> template <typename EXP>
struct op : has_nondestructive_aliasing, preserves_dimensions<EXP> struct op : has_nondestructive_aliasing, preserves_dimensions<EXP>
{ {
const static long cost = EXP::cost+2;
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)
...@@ -243,7 +244,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -243,7 +244,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
template < template <
typename EXP typename EXP
> >
const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_reciprocal> > reciprocal ( const matrix_unary_exp<EXP,op_reciprocal> reciprocal (
const matrix_exp<EXP>& m const matrix_exp<EXP>& m
) )
{ {
...@@ -253,8 +254,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -253,8 +254,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_unary_exp<matrix_exp<EXP>,op_reciprocal> exp; return matrix_unary_exp<EXP,op_reciprocal>(m.ref());
return matrix_exp<exp>(exp(m));
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
...@@ -264,6 +264,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -264,6 +264,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
template <typename EXP> template <typename EXP>
struct op : has_nondestructive_aliasing, preserves_dimensions<EXP> struct op : has_nondestructive_aliasing, preserves_dimensions<EXP>
{ {
const static long cost = EXP::cost+1;
typedef typename EXP::type type; typedef typename EXP::type type;
template <typename M> template <typename M>
static type apply ( const M& m, const type& s, long r, long c) static type apply ( const M& m, const type& s, long r, long c)
...@@ -276,7 +277,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -276,7 +277,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
template < template <
typename EXP typename EXP
> >
const matrix_exp<matrix_scalar_binary_exp<matrix_exp<EXP>,typename EXP::type,op_normalize> > normalize ( const matrix_scalar_binary_exp<EXP,typename EXP::type,op_normalize> normalize (
const matrix_exp<EXP>& m const matrix_exp<EXP>& m
) )
{ {
...@@ -286,13 +287,13 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -286,13 +287,13 @@ 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; typedef matrix_scalar_binary_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)
temp = 1.0/temp; temp = 1.0/temp;
return matrix_exp<exp>(exp(m,temp)); return exp(m.ref(),temp);
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
...@@ -302,6 +303,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -302,6 +303,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
template <typename EXP, typename enabled = void> template <typename EXP, typename enabled = void>
struct op : has_nondestructive_aliasing, preserves_dimensions<EXP> struct op : has_nondestructive_aliasing, preserves_dimensions<EXP>
{ {
const static long cost = EXP::cost+3;
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)
...@@ -314,6 +316,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -314,6 +316,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
struct op<EXP,typename enable_if_c<std::numeric_limits<typename EXP::type>::is_integer>::type > struct op<EXP,typename enable_if_c<std::numeric_limits<typename EXP::type>::is_integer>::type >
: has_nondestructive_aliasing, preserves_dimensions<EXP> : has_nondestructive_aliasing, preserves_dimensions<EXP>
{ {
const static long cost = EXP::cost;
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)
...@@ -326,14 +329,14 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -326,14 +329,14 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
template < template <
typename EXP typename EXP
> >
const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_round> > round ( const matrix_unary_exp<EXP,op_round> round (
const matrix_exp<EXP>& m const matrix_exp<EXP>& m
) )
{ {
// you can only round matrices that contain built in scalar types like double, long, float, etc... // you can only round matrices that contain built in scalar types like double, long, float, etc...
COMPILE_TIME_ASSERT(is_built_in_scalar_type<typename EXP::type>::value); COMPILE_TIME_ASSERT(is_built_in_scalar_type<typename EXP::type>::value);
typedef matrix_unary_exp<matrix_exp<EXP>,op_round> exp; typedef matrix_unary_exp<EXP,op_round> exp;
return matrix_exp<exp>(exp(m)); return exp(m.ref());
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
...@@ -343,6 +346,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -343,6 +346,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
template <typename EXP1, typename EXP2> template <typename EXP1, typename EXP2>
struct op : has_nondestructive_aliasing, preserves_dimensions<EXP1,EXP2> struct op : has_nondestructive_aliasing, preserves_dimensions<EXP1,EXP2>
{ {
const static long cost = EXP1::cost+EXP2::cost+1;
typedef std::complex<typename EXP1::type> type; typedef std::complex<typename EXP1::type> type;
template <typename M1, typename M2> template <typename M1, typename M2>
...@@ -355,7 +359,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -355,7 +359,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
typename EXP1, typename EXP1,
typename EXP2 typename EXP2
> >
const matrix_exp<matrix_binary_exp<matrix_exp<EXP1>,matrix_exp<EXP2>,op_complex_matrix> > complex_matrix ( const matrix_binary_exp<EXP1,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
) )
...@@ -373,8 +377,8 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -373,8 +377,8 @@ 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> exp; typedef matrix_binary_exp<EXP1,EXP2,op_complex_matrix> exp;
return matrix_exp<exp>(exp(real_part,imag_part)); return exp(real_part.ref(),imag_part.ref());
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
...@@ -384,6 +388,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -384,6 +388,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
template <typename EXP> template <typename EXP>
struct op : has_nondestructive_aliasing, preserves_dimensions<EXP> struct op : has_nondestructive_aliasing, preserves_dimensions<EXP>
{ {
const static long cost = EXP::cost+2;
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)
...@@ -394,12 +399,12 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -394,12 +399,12 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
template < template <
typename EXP typename EXP
> >
const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_norm> > norm ( const matrix_unary_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; typedef matrix_unary_exp<EXP,op_norm> exp;
return matrix_exp<exp>(exp(m)); return exp(m.ref());
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
...@@ -409,6 +414,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -409,6 +414,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
template <typename EXP> template <typename EXP>
struct op : has_nondestructive_aliasing, preserves_dimensions<EXP> struct op : has_nondestructive_aliasing, preserves_dimensions<EXP>
{ {
const static long cost = EXP::cost;
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)
...@@ -419,12 +425,12 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -419,12 +425,12 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
template < template <
typename EXP typename EXP
> >
const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_real> > real ( const matrix_unary_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; typedef matrix_unary_exp<EXP,op_real> exp;
return matrix_exp<exp>(exp(m)); return exp(m.ref());
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
...@@ -434,6 +440,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -434,6 +440,7 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
template <typename EXP> template <typename EXP>
struct op : has_nondestructive_aliasing, preserves_dimensions<EXP> struct op : has_nondestructive_aliasing, preserves_dimensions<EXP>
{ {
const static long cost = EXP::cost;
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)
...@@ -444,12 +451,12 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan) ...@@ -444,12 +451,12 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan)
template < template <
typename EXP typename EXP
> >
const matrix_exp<matrix_unary_exp<matrix_exp<EXP>,op_imag> > imag ( const matrix_unary_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; typedef matrix_unary_exp<EXP,op_imag> exp;
return matrix_exp<exp>(exp(m)); return exp(m.ref());
} }
// ---------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------
......
dlib/matrix/matrix_utilities.h
View file @ dd08cc4f
This diff is collapsed.
dlib/test/matrix2.cpp
View file @ dd08cc4f
...@@ -300,7 +300,13 @@ namespace ...@@ -300,7 +300,13 @@ namespace
DLIB_CASSERT((round(m2*m1) == identity_matrix<double,4>()),""); DLIB_CASSERT((round(m2*m1) == identity_matrix<double,4>()),"");
DLIB_CASSERT((round(tmp(m2*m1)) == identity_matrix<double,4>()),""); DLIB_CASSERT((round(tmp(m2*m1)) == identity_matrix<double,4>()),"");
DLIB_CASSERT(round(m2*10000) == round(inv(m1)*10000),""); DLIB_CASSERT(round(m2*10000) == round(inv(m1)*10000),
round(m2*10000) - round(inv(m1)*10000)
<< "\n\n" << round(m2*10000)
<< "\n\n" << round(inv(m1)*10000)
<< "\n\n" << m2
<< "\n\n" << inv(m1)
);
DLIB_CASSERT(m1 == abs(-1*m1),""); DLIB_CASSERT(m1 == abs(-1*m1),"");
DLIB_CASSERT(abs(m2) == abs(-1*m2),""); DLIB_CASSERT(abs(m2) == abs(-1*m2),"");
......
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