Class AsDiagonalOp

extensions/include/cuMat/src/UnaryOps.h:362–407

*/
template<typename _Child>
class AsDiagonalOp : public CwiseOp<AsDiagonalOp<_Child> >
{
public:
    typedef CwiseOp<AsDiagonalOp<_Child> > Base;
    typedef AsDiagonalOp<_Child> Type;
    CUMAT_PUBLIC_API
    using VectorType = typename internal::traits<Type>::VectorType;
    enum
    {
        Size = internal::traits<Type>::Size,
        IsRowVector = internal::traits<_Child>::RowsAtCompileTime == 1,
    };

protected:
    typedef typename MatrixReadWrapper<_Child, AccessFlags::ReadCwise>::type child_wrapped_t;
    const child_wrapped_t child_;
    const Index size_;

public:
    explicit AsDiagonalOp(const MatrixBase<_Child>& child)
        : child_(child.derived())
        , size_(child.rows()==1 ? child.cols() : child.rows())
    {
        CUMAT_STATIC_ASSERT(internal::traits<_Child>::RowsAtCompileTime == 1 || internal::traits<_Child>::ColsAtCompileTime == 1,
            "The child expression must be a compile-time row or column vector");
    }

    __host__ __device__ CUMAT_STRONG_INLINE Index rows() const { return size_; }
    __host__ __device__ CUMAT_STRONG_INLINE Index cols() const { return size_; }
    __host__ __device__ CUMAT_STRONG_INLINE Index batches() const { return child_.batches(); }

    __device__ CUMAT_STRONG_INLINE Scalar coeff(Index row, Index col, Index batch, Index index) const
    {
        using Functor = typename internal::AsDiagonalFunctor<VectorType>;
        if (row == col)
        {
            if (IsRowVector)
                return Functor::asDiagonal(child_.derived().coeff(0, col, batch, -1));
            else
                return Functor::asDiagonal(child_.derived().coeff(row, 0, batch, -1));
        } else
        {
            return typename Functor::MatrixType(0);
        }
    }
};


namespace internal {