blas2.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_BLAS2_BASE
#define _H_GRB_BLAS2_BASE

#include <assert.h>

#include <graphblas/backends.hpp>
#include <graphblas/blas1.hpp>
#include <graphblas/descriptors.hpp>
#include <graphblas/rc.hpp>
#include <graphblas/semiring.hpp>

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


namespace grb {

    template<
        Descriptor descr = descriptors::no_operation,
        class Semiring,
        typename IOType, typename InputType1, typename InputType2,
        typename InputType3, typename InputType4,
        typename Coords, typename RIT, typename CIT, typename NIT,
        Backend backend
    >
    RC mxv(
        Vector< IOType, backend, Coords > &u,
        const Vector< InputType3, backend, Coords > &u_mask,
        const Matrix< InputType2, backend, RIT, CIT, NIT > &A,
        const Vector< InputType1, backend, Coords > &v,
        const Vector< InputType4, backend, Coords > &v_mask,
        const Semiring &semiring = Semiring(),
        const Phase &phase = EXECUTE,
        const typename std::enable_if<
            grb::is_semiring< Semiring >::value &&
            !grb::is_object< IOType >::value &&
            !grb::is_object< InputType1 >::value &&
            !grb::is_object< InputType2 >::value &&
            !grb::is_object< InputType3 >::value &&
            !grb::is_object< InputType4 >::value,
        void >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cerr << "Selected backend does not implement mxv "
            << "(doubly-masked, semiring)\n";
#endif
#ifndef NDEBUG
        const bool selected_backed_does_not_support_doubly_masked_mxv_sr = false;
        assert( selected_backed_does_not_support_doubly_masked_mxv_sr );
#endif
        (void) u;
        (void) u_mask;
        (void) A;
        (void) v;
        (void) v_mask;
        (void) semiring;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Semiring,
        typename IOType, typename InputType1, typename InputType2,
        typename InputType3, typename InputType4,
        typename Coords, typename RIT, typename CIT, typename NIT,
        enum Backend backend
    >
    RC vxm(
        Vector< IOType, backend, Coords > &u,
        const Vector< InputType3, backend, Coords > &u_mask,
        const Vector< InputType1, backend, Coords > &v,
        const Vector< InputType4, backend, Coords > &v_mask,
        const Matrix< InputType2, backend, RIT, CIT, NIT > &A,
        const Semiring &semiring = Semiring(),
        const Phase &phase = EXECUTE,
        typename std::enable_if<
            grb::is_semiring< Semiring >::value &&
            !grb::is_object< InputType1 >::value &&
            !grb::is_object< InputType2 >::value &&
            !grb::is_object< InputType3 >::value &&
            !grb::is_object< InputType4 >::value &&
            !grb::is_object< IOType >::value,
        void >::type * = nullptr
    ) {
#ifdef _DEBUG
        std::cerr << "Selected backend does not implement doubly-masked grb::vxm\n";
#endif
#ifndef NDEBUG
        const bool selected_backend_does_not_support_doubly_masked_vxm_sr = false;
        assert( selected_backend_does_not_support_doubly_masked_vxm_sr );
#endif
        (void) u;
        (void) u_mask;
        (void) v;
        (void) v_mask;
        (void) A;
        (void) semiring;
        return UNSUPPORTED;
    }

    template<
        typename Func, typename DataType,
        typename RIT, typename CIT, typename NIT,
        Backend implementation = config::default_backend,
        typename... Args
    >
    RC eWiseLambda(
        const Func f,
        const Matrix< DataType, implementation, RIT, CIT, NIT > &A,
        Args...
    ) {
#ifdef _DEBUG
        std::cerr << "Selected backend does not implement grb::eWiseLambda (matrices)\n";
#endif
#ifndef NDEBUG
        const bool selected_backend_does_not_support_matrix_eWiseLamba = false;
        assert( selected_backend_does_not_support_matrix_eWiseLamba );
#endif
        (void) f;
        (void) A;
        return UNSUPPORTED;
    }

     // default (non-)implementations follow:

    template<
        Descriptor descr = descriptors::no_operation,
        class Ring,
        typename IOType, typename InputType1, typename InputType2,
        typename InputType3,
        typename RIT, typename CIT, typename NIT,
        typename Coords,
        enum Backend implementation = config::default_backend
    >
    RC mxv(
        Vector< IOType, implementation, Coords > &u,
        const Vector< InputType3, implementation, Coords > &mask,
        const Matrix< InputType2, implementation, RIT, CIT, NIT > &A,
        const Vector< InputType1, implementation, Coords > &v,
        const Ring &ring = Ring(),
        const Phase &phase = EXECUTE,
        typename std::enable_if<
            grb::is_semiring< Ring >::value,
        void >::type * = nullptr
    ) {
#ifdef _DEBUG
        std::cerr << "Selected backend does not implement grb::mxv (output-masked)\n";
#endif
#ifndef NDEBUG
        const bool backend_does_not_support_output_masked_mxv = false;
        assert( backend_does_not_support_output_masked_mxv );
#endif
        (void) u;
        (void) mask;
        (void) A;
        (void) v;
        (void) ring;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Ring,
        typename IOType, typename InputType1, typename InputType2,
        typename Coords, typename RIT, typename CIT, typename NIT,
        Backend implementation = config::default_backend
    >
    RC mxv(
        Vector< IOType, implementation, Coords > &u,
        const Matrix< InputType2, implementation, RIT, CIT, NIT > &A,
        const Vector< InputType1, implementation, Coords > &v,
        const Ring &ring,
        typename std::enable_if<
            grb::is_semiring< Ring >::value, void
        >::type * = nullptr
    ) {
#ifdef _DEBUG
        std::cerr << "Selected backend does not implement grb::mxv\n";
#endif
#ifndef NDEBUG
        const bool backend_does_not_support_mxv = false;
        assert( backend_does_not_support_mxv );
#endif
        (void) u;
        (void) A;
        (void) v;
        (void) ring;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Ring,
        typename IOType, typename InputType1, typename InputType2,
        typename InputType3,
        typename Coords, typename RIT, typename CIT, typename NIT,
        enum Backend implementation = config::default_backend
    >
    RC vxm(
        Vector< IOType, implementation, Coords > &u,
        const Vector< InputType3, implementation, Coords > &mask,
        const Vector< InputType1, implementation, Coords > &v,
        const Matrix< InputType2, implementation, RIT, CIT, NIT > &A,
        const Ring &ring = Ring(),
        const Phase &phase = EXECUTE,
        typename std::enable_if<
            grb::is_semiring< Ring >::value, void
        >::type * = nullptr
    ) {
#ifdef _DEBUG
        std::cerr << "Selected backend does not implement grb::vxm (output-masked)\n";
#endif
#ifndef NDEBUG
        const bool selected_backend_does_not_support_output_masked_vxm = false;
        assert( selected_backend_does_not_support_output_masked_vxm );
#endif
        (void) u;
        (void) mask;
        (void) v;
        (void) A;
        (void) ring;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Ring,
        typename IOType, typename InputType1, typename InputType2,
        typename Coords, typename RIT, typename CIT, typename NIT,
        enum Backend implementation = config::default_backend
    >
    RC vxm(
        Vector< IOType, implementation, Coords > &u,
        const Vector< InputType1, implementation, Coords > &v,
        const Matrix< InputType2, implementation, RIT, CIT, NIT > &A,
        const Ring &ring = Ring(),
        const Phase &phase = EXECUTE,
        typename std::enable_if<
            grb::is_semiring< Ring >::value, void
        >::type * = nullptr
    ) {
#ifdef _DEBUG
        std::cerr << "Selected backend does not implement grb::vxm\n";
#endif
#ifndef NDEBUG
        const bool selected_backend_does_not_support_vxm = false;
        assert( selected_backend_does_not_support_vxm );
#endif
        (void) u;
        (void) v;
        (void) A;
        (void) ring;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class AdditiveMonoid, class MultiplicativeOperator,
        typename IOType, typename InputType1, typename InputType2,
        typename InputType3, typename InputType4,
        typename Coords, typename RIT, typename CIT, typename NIT,
        Backend backend
    >
    RC vxm(
        Vector< IOType, backend, Coords > &u,
        const Vector< InputType3, backend, Coords > &mask,
        const Vector< InputType1, backend, Coords > &v,
        const Vector< InputType4, backend, Coords > &v_mask,
        const Matrix< InputType2, backend, RIT, CIT, NIT > &A,
        const AdditiveMonoid &add = AdditiveMonoid(),
        const MultiplicativeOperator &mul = MultiplicativeOperator(),
        const Phase &phase = EXECUTE,
        const typename std::enable_if<
            grb::is_monoid< AdditiveMonoid >::value &&
            grb::is_operator< MultiplicativeOperator >::value &&
            !grb::is_object< IOType >::value &&
            !grb::is_object< InputType1 >::value &&
            !grb::is_object< InputType2 >::value &&
            !grb::is_object< InputType3 >::value &&
            !grb::is_object< InputType4 >::value &&
            !std::is_same< InputType2, void >::value,
        void >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cerr << "Selected backend does not implement vxm (doubly-masked)\n";
#endif
#ifndef NDEBUG
        const bool selected_backed_does_not_support_doubly_masked_vxm = false;
        assert( selected_backed_does_not_support_doubly_masked_vxm );
#endif
        (void) u;
        (void) mask;
        (void) v;
        (void) v_mask;
        (void) A;
        (void) add;
        (void) mul;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class AdditiveMonoid, class MultiplicativeOperator,
        typename IOType, typename InputType1, typename InputType2,
        typename InputType3, typename InputType4,
        typename Coords, typename RIT, typename CIT, typename NIT,
        Backend backend
    >
    RC mxv(
        Vector< IOType, backend, Coords > &u,
        const Vector< InputType3, backend, Coords > &mask,
        const Matrix< InputType2, backend, RIT, CIT, NIT > &A,
        const Vector< InputType1, backend, Coords > &v,
        const Vector< InputType4, backend, Coords > &v_mask,
        const AdditiveMonoid &add = AdditiveMonoid(),
        const MultiplicativeOperator &mul = MultiplicativeOperator(),
        const Phase &phase = EXECUTE,
        const typename std::enable_if<
            grb::is_monoid< AdditiveMonoid >::value &&
            grb::is_operator< MultiplicativeOperator >::value &&
            !grb::is_object< IOType >::value &&
            !grb::is_object< InputType1 >::value &&
            !grb::is_object< InputType2 >::value &&
            !grb::is_object< InputType3 >::value &&
            !grb::is_object< InputType4 >::value &&
            !std::is_same< InputType2,
        void >::value, void >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cerr << "Selected backend does not implement mxv (doubly-masked)\n";
#endif
#ifndef NDEBUG
        const bool selected_backed_does_not_support_doubly_masked_mxv = false;
        assert( selected_backed_does_not_support_doubly_masked_mxv );
#endif
        (void) u;
        (void) mask;
        (void) A;
        (void) v;
        (void) v_mask;
        (void) add;
        (void) mul;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class AdditiveMonoid, class MultiplicativeOperator,
        typename IOType, typename InputType1, typename InputType2,
        typename InputType3,
        typename Coords, typename RIT, typename CIT, typename NIT,
        Backend backend
    >
    RC mxv(
        Vector< IOType, backend, Coords > &u,
        const Vector< InputType3, backend, Coords > &mask,
        const Matrix< InputType2, backend, RIT, NIT, CIT > &A,
        const Vector< InputType1, backend, Coords > &v,
        const AdditiveMonoid & add = AdditiveMonoid(),
        const MultiplicativeOperator & mul = MultiplicativeOperator(),
        const Phase &phase = EXECUTE,
        const typename std::enable_if<
            grb::is_monoid< AdditiveMonoid >::value &&
            grb::is_operator< MultiplicativeOperator >::value &&
            !grb::is_object< IOType >::value &&
            !grb::is_object< InputType1 >::value &&
            !grb::is_object< InputType2 >::value &&
            !grb::is_object< InputType3 >::value &&
            !std::is_same< InputType2, void >::value,
        void >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cerr << "Selected backend does not implement "
            << "singly-masked monoid-op mxv\n";
#endif
#ifndef NDEBUG
        const bool selected_backed_does_not_support_masked_monop_mxv = false;
        assert( selected_backed_does_not_support_masked_monop_mxv );
#endif
        (void) u;
        (void) mask;
        (void) A;
        (void) v;
        (void) add;
        (void) mul;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class AdditiveMonoid, class MultiplicativeOperator,
        typename IOType, typename InputType1, typename InputType2,
        typename Coords, typename RIT, typename CIT, typename NIT,
        Backend backend
    >
    RC vxm(
        Vector< IOType, backend, Coords > &u,
        const Vector< InputType1, backend, Coords > &v,
        const Matrix< InputType2, backend, RIT, CIT, NIT > &A,
        const AdditiveMonoid &add = AdditiveMonoid(),
        const MultiplicativeOperator &mul = MultiplicativeOperator(),
        const Phase &phase = EXECUTE,
        const typename std::enable_if<
            grb::is_monoid< AdditiveMonoid >::value &&
            grb::is_operator< MultiplicativeOperator >::value &&
            !grb::is_object< IOType >::value &&
            !grb::is_object< InputType1 >::value &&
            !grb::is_object< InputType2 >::value &&
            !std::is_same< InputType2, void >::value,
        void >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cerr << "Selected backend does not implement vxm "
            << "(unmasked, monoid-op version )\n";
#endif
#ifndef NDEBUG
        const bool selected_backed_does_not_support_monop_vxm = false;
        assert( selected_backed_does_not_support_monop_vxm );
#endif
        (void) u;
        (void) v;
        (void) A;
        (void) add;
        (void) mul;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class AdditiveMonoid, class MultiplicativeOperator,
        typename IOType, typename InputType1, typename InputType2,
        typename InputType3,
        typename Coords, typename RIT, typename CIT, typename NIT,
        Backend implementation
    >
    RC vxm(
        Vector< IOType, implementation, Coords > &u,
        const Vector< InputType3, implementation, Coords > &mask,
        const Vector< InputType1, implementation, Coords > &v,
        const Matrix< InputType2, implementation, RIT, CIT, NIT > &A,
        const AdditiveMonoid &add = AdditiveMonoid(),
        const MultiplicativeOperator &mul = MultiplicativeOperator(),
        const Phase &phase = EXECUTE,
        typename std::enable_if<
            grb::is_monoid< AdditiveMonoid >::value &&
            grb::is_operator< MultiplicativeOperator >::value &&
            !grb::is_object< IOType >::value &&
            !grb::is_object< InputType1 >::value &&
            !grb::is_object< InputType2 >::value &&
            !std::is_same< InputType2, void >::value,
        void >::type * = nullptr
    ) {
#ifdef _DEBUG
        std::cerr << "Selected backend does not implement grb::vxm (output-masked)\n";
#endif
#ifndef NDEBUG
        const bool selected_backed_does_not_support_masked_monop_vxm = false;
        assert( selected_backed_does_not_support_masked_monop_vxm );
#endif
        (void) u;
        (void) mask;
        (void) v;
        (void) A;
        (void) add;
        (void) mul;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class AdditiveMonoid, class MultiplicativeOperator,
        typename IOType, typename InputType1, typename InputType2,
        typename Coords, typename RIT, typename CIT, typename NIT,
        Backend backend
    >
    RC mxv(
        Vector< IOType, backend, Coords > &u,
        const Matrix< InputType2, backend, RIT, CIT, NIT > &A,
        const Vector< InputType1, backend, Coords > &v,
        const AdditiveMonoid &add = AdditiveMonoid(),
        const MultiplicativeOperator &mul = MultiplicativeOperator(),
        const Phase &phase = EXECUTE,
        const typename std::enable_if<
            grb::is_monoid< AdditiveMonoid >::value &&
            grb::is_operator< MultiplicativeOperator >::value &&
            !grb::is_object< IOType >::value &&
            !grb::is_object< InputType1 >::value &&
            !grb::is_object< InputType2 >::value &&
            !std::is_same< InputType2, void >::value,
        void >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cerr << "Selected backend does not implement grb::mxv (unmasked)\n";
#endif
#ifndef NDEBUG
        const bool selected_backed_does_not_support_monop_mxv = false;
        assert( selected_backed_does_not_support_monop_mxv );
#endif
        (void) u;
        (void) A;
        (void) v;
        (void) add;
        (void) mul;
        return UNSUPPORTED;
    }

} // namespace grb

#endif // end _H_GRB_BLAS2_BASE