blas3.hpp

Go to the documentation of this file.

/*
 *   Copyright 2021 Huawei Technologies Co., Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef _H_GRB_BLAS3_BASE
#define _H_GRB_BLAS3_BASE

#include <graphblas/backends.hpp>
#include <graphblas/phase.hpp>

#include "matrix.hpp"
#include "vector.hpp"


namespace grb {

    template<
        Descriptor descr = descriptors::no_operation,
        typename OutputType, typename InputType1, typename InputType2,
        typename CIT1, typename RIT1, typename NIT1,
        typename CIT2, typename RIT2, typename NIT2,
        typename CIT3, typename RIT3, typename NIT3,
        class Semiring,
        Backend backend
    >
    RC mxm(
        Matrix< OutputType, backend, CIT1, RIT1, NIT1 > &C,
        const Matrix< InputType1, backend, CIT2, RIT2, NIT2 > &A,
        const Matrix< InputType2, backend, CIT3, RIT3, NIT3 > &B,
        const Semiring &ring = Semiring(),
        const Phase &phase = EXECUTE
    ) {
#ifdef _DEBUG
        std::cerr << "Selected backend does not implement grb::mxm "
            << "(semiring version)\n";
#endif
#ifndef NDEBUG
        const bool selected_backend_does_not_support_mxm = false;
        assert( selected_backend_does_not_support_mxm );
#endif
        (void) C;
        (void) A;
        (void) B;
        (void) ring;
        (void) phase;
        // this is the generic stub implementation
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        typename OutputType, typename InputType1, typename InputType2,
        typename InputType3, typename RIT, typename CIT, typename NIT,
        Backend backend, typename Coords
    >
    RC zip(
        Matrix< OutputType, backend, RIT, CIT, NIT > &A,
        const Vector< InputType1, backend, Coords > &x,
        const Vector< InputType2, backend, Coords > &y,
        const Vector< InputType3, backend, Coords > &z,
        const Phase &phase = EXECUTE
    ) {
        (void) x;
        (void) y;
        (void) z;
        (void) phase;
#ifdef _DEBUG
        std::cerr << "Selected backend does not implement grb::zip (vectors into "
            << "matrices, non-void)\n";
#endif
#ifndef NDEBUG
        const bool selected_backend_does_not_support_zip_from_vectors_to_matrix
            = false;
        assert( selected_backend_does_not_support_zip_from_vectors_to_matrix );
#endif
        const RC ret = grb::clear( A );
        return ret == SUCCESS ? UNSUPPORTED : ret;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        typename InputType1, typename InputType2, typename InputType3,
        typename RIT, typename CIT, typename NIT,
        Backend backend, typename Coords
    >
    RC zip(
        Matrix< void, backend, RIT, CIT, NIT > &A,
        const Vector< InputType1, backend, Coords > &x,
        const Vector< InputType2, backend, Coords > &y,
        const Phase &phase = EXECUTE
    ) {
        (void) x;
        (void) y;
        (void) phase;
#ifdef _DEBUG
        std::cerr << "Selected backend does not implement grb::zip (vectors into "
            << "matrices, void)\n";
#endif
#ifndef NDEBUG
        const bool selected_backend_does_not_support_zip_from_vectors_to_void_matrix
            = false;
        assert( selected_backend_does_not_support_zip_from_vectors_to_void_matrix );
#endif
        const RC ret = grb::clear( A );
        return ret == SUCCESS ? UNSUPPORTED : ret;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Monoid,
        typename OutputType, typename InputType1, typename InputType2,
        typename RIT1, typename CIT1, typename NIT1,
        typename RIT2, typename CIT2, typename NIT2,
        typename RIT3, typename CIT3, typename NIT3,
        Backend backend
    >
    RC eWiseApply(
        Matrix< OutputType, backend, RIT1, CIT1, NIT1 > &C,
        const Matrix< InputType1, backend, RIT2, CIT2, NIT2 > &A,
        const Matrix< InputType2, backend, RIT3, CIT3, NIT3 > &B,
        const Monoid &monoid,
        const Phase phase = EXECUTE,
        const typename std::enable_if<
            !grb::is_object< OutputType >::value &&
            !grb::is_object< InputType1 >::value &&
            !grb::is_object< InputType2 >::value &&
            grb::is_monoid< Monoid >::value,
        void >::type * const = nullptr
    ) {
        (void) C;
        (void) A;
        (void) B;
        (void) phase;
#ifdef _DEBUG
        std::cerr << "Selected backend does not implement grb::eWiseApply\n";
#endif
#ifndef NDEBUG
        const bool selected_backend_does_not_support_ewiseapply = false;
        assert( selected_backend_does_not_support_ewiseapply );
#endif
        const RC ret = grb::clear( A );
        return ret == SUCCESS ? UNSUPPORTED : ret;
    }

    template<
        Descriptor descr = grb::descriptors::no_operation,
        class Operator,
        typename OutputType, typename InputType1, typename InputType2,
        typename RIT1, typename CIT1, typename NIT1,
        typename RIT2, typename CIT2, typename NIT2,
        typename RIT3, typename CIT3, typename NIT3,
        Backend backend
    >
    RC eWiseApply(
        Matrix< OutputType, backend, RIT1, CIT1, NIT1 > &C,
        const Matrix< InputType1, backend, RIT2, CIT2, NIT2 > &A,
        const Matrix< InputType2, backend, RIT3, CIT3, NIT3 > &B,
        const Operator &op,
        const Phase phase = EXECUTE,
        const typename std::enable_if<
            !grb::is_object< OutputType >::value &&
            !grb::is_object< InputType1 >::value &&
            !grb::is_object< InputType2 >::value &&
            grb::is_operator< Operator >::value,
        void >::type * const = nullptr
    ) {
        (void) C;
        (void) A;
        (void) B;
        (void) phase;
#ifdef _DEBUG
        std::cerr << "Selected backend does not implement grb::eWiseApply\n";
#endif
#ifndef NDEBUG
        const bool selected_backend_does_not_support_ewiseapply = false;
        assert( selected_backend_does_not_support_ewiseapply );
#endif
        const RC ret = grb::clear( A );
        return ret == SUCCESS ? UNSUPPORTED : ret;
    }

} // namespace grb

#endif // end _H_GRB_BLAS3_BASE