dlib C++ Library - matrix_expressions.h

    // Copyright (C) 2006  Davis E. King (davis@dlib.net)
    // License: Boost Software License   See LICENSE.txt for the full license.
    #ifndef DLIB_MATRIx_EXPRESSIONS_H_
    #define DLIB_MATRIx_EXPRESSIONS_H_

    #include "matrix_fwd.h"

    #ifdef _MSC_VER
    // This #pragma directive is also located in the algs.h file but for whatever
    // reason visual studio 9 just ignores it when it is only there.

    // this is to disable the "'this' : used in base member initializer list"
    // warning you get from some of the GUI objects since all the objects
    // require that their parent class be passed into their constructor.
    // In this case though it is totally safe so it is ok to disable this warning.
    #pragma warning(disable : 4355)
    #endif

    namespace dlib
    {

    // ----------------------------------------------------------------------------------------
    // ----------------------------------------------------------------------------------------
    //            Helper templates for making operators used by expression objects
    // ----------------------------------------------------------------------------------------
    // ----------------------------------------------------------------------------------------

        template <typename T>
        class matrix_range_exp;

        template <typename T>
        struct matrix_traits<matrix_range_exp<T> >
        {
            typedef T type;
            typedef const T const_ret_type;
            typedef default_memory_manager mem_manager_type;
            typedef row_major_layout layout_type;
            const static long NR = 1;
            const static long NC = 0;
            const static long cost = 1;
        };

        template <typename T>
        class matrix_range_exp : public matrix_exp<matrix_range_exp<T> >
        {
        public:
            typedef typename matrix_traits<matrix_range_exp>::type type;
            typedef typename matrix_traits<matrix_range_exp>::const_ret_type const_ret_type;
            typedef typename matrix_traits<matrix_range_exp>::mem_manager_type mem_manager_type;
            const static long NR = matrix_traits<matrix_range_exp>::NR;
            const static long NC = matrix_traits<matrix_range_exp>::NC;
            const static long cost = matrix_traits<matrix_range_exp>::cost;
            typedef typename matrix_traits<matrix_range_exp>::layout_type layout_type;

            matrix_range_exp (
                T start_,
                T end_
            )
            {
                start = start_;
                if (start_ <= end_)
                    inc = 1;
                else
                    inc = -1;
                nc_ = std::abs(end_ - start_) + 1;
            }
            matrix_range_exp (
                T start_,
                T inc_,
                T end_
            )
            {
                start = start_;
                nc_ = std::abs(end_ - start_)/inc_ + 1;
                if (start_ <= end_)
                    inc = inc_;
                else
                    inc = -inc_;
            }

            matrix_range_exp (
                T start_,
                T end_,
                long num,
                bool
            )
            {
                start = start_;
                nc_ = num;
                if (num > 1)
                {
                    inc = (end_-start_)/(num-1);
                }
                else
                {
                    inc = 0;
                    start = end_;
                }

            }

            const_ret_type operator() (
                long,
                long c
            ) const { return start + c*inc;  }

            const_ret_type operator() (
                long c
            ) const { return start + c*inc;  }

            template <typename U>
            bool aliases (
                const matrix_exp<U>&
            ) const { return false; }

            template <typename U>
            bool destructively_aliases (
                const matrix_exp<U>&
            ) const { return false; }

            long nr (
            ) const { return NR; }

            long nc (
            ) const { return nc_; }

            long nc_;
            T start;
            T inc;
        };

    // ----------------------------------------------------------------------------------------

        template <typename T>
        class matrix_log_range_exp;

        template <typename T>
        struct matrix_traits<matrix_log_range_exp<T> >
        {
            typedef T type;
            typedef const T const_ret_type;
            typedef default_memory_manager mem_manager_type;
            typedef row_major_layout layout_type;
            const static long NR = 1;
            const static long NC = 0;
            const static long cost = 1;
        };

        template <typename T>
        class matrix_log_range_exp : public matrix_exp<matrix_log_range_exp<T> >
        {
        public:
            typedef typename matrix_traits<matrix_log_range_exp>::type type;
            typedef typename matrix_traits<matrix_log_range_exp>::const_ret_type const_ret_type;
            typedef typename matrix_traits<matrix_log_range_exp>::mem_manager_type mem_manager_type;
            const static long NR = matrix_traits<matrix_log_range_exp>::NR;
            const static long NC = matrix_traits<matrix_log_range_exp>::NC;
            const static long cost = matrix_traits<matrix_log_range_exp>::cost;
            typedef typename matrix_traits<matrix_log_range_exp>::layout_type layout_type;

            matrix_log_range_exp (
                T start_,
                T end_,
                long num
            )
            {
                start = start_;
                nc_ = num;
                if (num > 1)
                {
                    inc = (end_-start_)/(num-1);
                }
                else
                {
                    inc = 0;
                    start = end_;
                }

            }

            const_ret_type operator() (
                long,
                long c
            ) const { return std::pow((T)10,start + c*inc);  }

            const_ret_type operator() (
                long c
            ) const { return std::pow((T)10,start + c*inc);  }

            template <typename U>
            bool aliases (
                const matrix_exp<U>&
            ) const { return false; }

            template <typename U>
            bool destructively_aliases (
                const matrix_exp<U>&
            ) const { return false; }

            long nr (
            ) const { return NR; }

            long nc (
            ) const { return nc_; }

            long nc_;
            T start;
            T inc;
        };

    // ----------------------------------------------------------------------------------------

        template <long start, long inc_, long end>
        class matrix_range_static_exp;

        template <long start, long inc_, long end>
        struct matrix_traits<matrix_range_static_exp<start,inc_,end> >
        {
            typedef long type;
            typedef const long const_ret_type;
            typedef default_memory_manager mem_manager_type;
            const static long NR = 1;
            const static long NC = tabs<(end - start)>::value/inc_ + 1;
            const static long cost = 1;
            typedef row_major_layout layout_type;
        };

        template <long start, long inc_, long end_>
        class matrix_range_static_exp : public matrix_exp<matrix_range_static_exp<start,inc_,end_> >
        {
        public:
            typedef typename matrix_traits<matrix_range_static_exp>::type type;
            typedef typename matrix_traits<matrix_range_static_exp>::const_ret_type const_ret_type;
            typedef typename matrix_traits<matrix_range_static_exp>::mem_manager_type mem_manager_type;
            const static long NR = matrix_traits<matrix_range_static_exp>::NR;
            const static long NC = matrix_traits<matrix_range_static_exp>::NC;
            const static long cost = matrix_traits<matrix_range_static_exp>::cost;
            typedef typename matrix_traits<matrix_range_static_exp>::layout_type layout_type;

            const static long inc = (start <= end_)?inc_:-inc_;

            matrix_range_static_exp (
            ) {}

            const_ret_type operator() (
                long ,
                long c
            ) const { return start + c*inc;  }

            const_ret_type operator() (
                long c
            ) const { return start + c*inc;  }

            template <typename U>
            bool aliases (
                const matrix_exp<U>&
            ) const { return false; }

            template <typename U>
            bool destructively_aliases (
                const matrix_exp<U>&
            ) const { return false; }

            long nr (
            ) const { return NR; }

            long nc (
            ) const { return NC; }

        };

    // ----------------------------------------------------------------------------------------

    }

    #endif // DLIB_MATRIx_EXPRESSIONS_H_