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 CIT, typename RIT, typename NIT,
        class Semiring,
        Backend backend
    >
    RC mxm(
        Matrix< OutputType, backend, CIT, RIT, NIT > &C,
        const Matrix< InputType1, backend, CIT, RIT, NIT > &A,
        const Matrix< InputType2, backend, CIT, RIT, NIT > &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;
    }
 
} // namespace grb
 
#endif // end _H_GRB_BLAS3_BASE