/var/lib/jenkins/jobs/Skylark/workspace/sketch/dense_transform_Elemental_local.hpp

Go to the documentation of this file.

#ifndef SKYLARK_DENSE_TRANSFORM_ELEMENTAL_LOCAL_HPP
#define SKYLARK_DENSE_TRANSFORM_ELEMENTAL_LOCAL_HPP

#include "../base/base.hpp"

#include "transforms.hpp"
#include "dense_transform_data.hpp"
#include "../utility/comm.hpp"
#include "../utility/get_communicator.hpp"

#include "sketch_params.hpp"

namespace skylark { namespace sketch {

template <typename ValueType,
          template <typename> class InputType,
          template <typename> class ValueDistribution>
struct dense_transform_t <
    InputType<ValueType>,
    elem::Matrix<ValueType>,
    ValueDistribution> :
        public dense_transform_data_t<ValueDistribution> {

    typedef ValueType value_type;
    typedef InputType<value_type> matrix_type;
    typedef elem::Matrix<value_type> output_matrix_type;
    typedef ValueDistribution<value_type> value_distribution_type;
    typedef dense_transform_data_t<ValueDistribution> data_type;

    dense_transform_t (int N, int S, double scale, base::context_t& context)
        : data_type (N, S, scale, context) {

    }

    dense_transform_t (const dense_transform_t<matrix_type,
                                         output_matrix_type,
                                         ValueDistribution>& other)
        : data_type(other) {}

    dense_transform_t(const data_type& other_data)
        : data_type(other_data) {}


    template <typename Dimension>
    void apply (const matrix_type& A,
                output_matrix_type& sketch_of_A,
                Dimension dimension) const {
        try {
            apply_impl_local(A, sketch_of_A, dimension);
        } catch (std::logic_error e) {
            SKYLARK_THROW_EXCEPTION (
                base::elemental_exception()
                    << base::error_msg(e.what()) );
        }
    }

    int get_N() const { return this->_N; } 
    int get_S() const { return this->_S; } 
    const sketch_transform_data_t* get_data() const { return this; }

private:

    // TODO: Block-by-block mode
    void apply_impl_local (const matrix_type& A,
                          output_matrix_type& sketch_of_A,
                          skylark::sketch::rowwise_tag tag) const {

        output_matrix_type R;
        data_type::realize_matrix_view(R);

        base::Gemm (elem::NORMAL,
                    elem::TRANSPOSE,
                    value_type(1),
                    A,
                    R,
                    value_type(0),
                    sketch_of_A);
    }


    // TODO: Block-by-block mode
    void apply_impl_local (const matrix_type& A,
                          output_matrix_type& sketch_of_A,
                          skylark::sketch::columnwise_tag tag) const {

        output_matrix_type R;
        data_type::realize_matrix_view(R);

        base::Gemm (elem::NORMAL,
                    elem::NORMAL,
                    value_type(1),
                    R,
                    A,
                    value_type(0),
                    sketch_of_A);
    }
};

} } 
#endif // SKYLARK_DENSE_TRANSFORM_ELEMENTAL_LOCAL_HPP