blas1.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_BASE_BLAS1
#define _H_GRB_BASE_BLAS1

#include <graphblas/rc.hpp>
#include <graphblas/ops.hpp>
#include <graphblas/phase.hpp>
#include <graphblas/monoid.hpp>
#include <graphblas/backends.hpp>
#include <graphblas/semiring.hpp>
#include <graphblas/descriptors.hpp>
#include <graphblas/internalops.hpp>

#include <assert.h>


namespace grb {

    #define NO_MASK Vector< bool >( 0 )

    template<
        Descriptor descr = descriptors::no_operation,
        class OP, enum Backend backend,
        typename OutputType,
        typename InputType1, typename InputType2,
        typename Coords
    >
    RC eWiseApply(
        Vector< OutputType, backend, Coords > &z,
        const InputType1 alpha,
        const InputType2 beta,
        const OP &op = 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< OP >::value, void
        >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cout << "In eWiseApply ([T1]<-T2<-T3), operator, base\n";
#endif
#ifndef NDEBUG
        const bool should_not_call_eWiseApplyOpASS_base = false;
        assert( should_not_call_eWiseApplyOpASS_base );
#endif
        (void) z;
        (void) alpha;
        (void) beta;
        (void) op;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class OP, enum Backend backend,
        typename OutputType, typename MaskType,
        typename InputType1, typename InputType2,
        typename Coords
    >
    RC eWiseApply(
        Vector< OutputType, backend, Coords > &z,
        const Vector< MaskType, backend, Coords > &mask,
        const InputType1 alpha,
        const InputType2 beta,
        const OP &op = OP(),
        const Phase &phase = EXECUTE,
        const typename std::enable_if<
            !grb::is_object< OutputType >::value &&
            !grb::is_object< MaskType >::value &&
            !grb::is_object< InputType1 >::value &&
            !grb::is_object< InputType2 >::value &&
            grb::is_operator< OP >::value, void
        >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cout << "In masked eWiseApply ([T1]<-T2<-T3), operator, base\n";
#endif
#ifndef NDEBUG
        const bool should_not_call_eWiseApplyOpAMSS_base = false;
        assert( should_not_call_eWiseApplyOpAMSS_base );
#endif
        (void) z;
        (void) mask;
        (void) alpha;
        (void) beta;
        (void) op;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Monoid, enum Backend backend,
        typename OutputType,
        typename InputType1, typename InputType2,
        typename Coords
    >
    RC eWiseApply(
        Vector< OutputType, backend, Coords > &z,
        const InputType1 alpha,
        const InputType2 beta,
        const Monoid &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
    ) {
#ifdef _DEBUG
        std::cout << "In eWiseApply ([T1]<-T2<-T3), monoid, base\n";
#endif
#ifndef NDEBUG
        const bool should_not_call_eWiseApplyMonASS_base = false;
        assert( should_not_call_eWiseApplyMonASS_base );
#endif
        (void) z;
        (void) alpha;
        (void) beta;
        (void) monoid;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Monoid, enum Backend backend,
        typename OutputType, typename MaskType,
        typename InputType1, typename InputType2,
        typename Coords
    >
    RC eWiseApply(
        Vector< OutputType, backend, Coords > &z,
        const Vector< MaskType, backend, Coords > &mask,
        const InputType1 alpha,
        const InputType2 beta,
        const Monoid &monoid = Monoid(),
        const Phase &phase = EXECUTE,
        const typename std::enable_if<
            !grb::is_object< OutputType >::value &&
            !grb::is_object< MaskType >::value &&
            !grb::is_object< InputType1 >::value &&
            !grb::is_object< InputType2 >::value &&
            grb::is_monoid< Monoid >::value, void
        >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cout << "In masked eWiseApply ([T1]<-T2<-T3), monoid, base\n";
#endif
#ifndef NDEBUG
        const bool should_not_call_eWiseApplyMonAMSS_base = false;
        assert( should_not_call_eWiseApplyMonAMSS_base );
#endif
        (void) z;
        (void) mask;
        (void) alpha;
        (void) beta;
        (void) monoid;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class OP, enum Backend backend,
        typename OutputType, typename InputType1, typename InputType2,
        typename Coords
    >
    RC eWiseApply(
        Vector< OutputType, backend, Coords > &z,
        const InputType1 alpha,
        const Vector< InputType2, backend, Coords > &y,
        const OP &op = 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< OP >::value, void
        >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cout << "In eWiseApply ([T1]<-T2<-[T3]), operator, base\n";
#endif
#ifndef NDEBUG
        const bool should_not_call_eWiseApplyOpASA_base = false;
        assert( should_not_call_eWiseApplyOpASA_base );
#endif
        (void) z;
        (void) alpha;
        (void) y;
        (void) op;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class OP, enum Backend backend,
        typename OutputType, typename MaskType,
        typename InputType1, typename InputType2,
        typename Coords
    >
    RC eWiseApply(
        Vector< OutputType, backend, Coords > &z,
        const Vector< MaskType, backend, Coords > &mask,
        const InputType1 alpha,
        const Vector< InputType2, backend, Coords > &y,
        const OP &op = OP(),
        const Phase &phase = EXECUTE,
        const typename std::enable_if<
            !grb::is_object< OutputType >::value &&
            !grb::is_object< MaskType >::value &&
            !grb::is_object< InputType1 >::value &&
            !grb::is_object< InputType2 >::value &&
            grb::is_operator< OP >::value, void
        >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cout << "In masked eWiseApply ([T1]<-T2<-[T3], operator, base)\n";
#endif
#ifndef NDEBUG
        const bool should_not_call_eWiseApplyOpAMSA_base = false;
        assert( should_not_call_eWiseApplyOpAMSA_base );
#endif
        (void) z;
        (void) mask;
        (void) alpha;
        (void) y;
        (void) op;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Monoid, enum Backend backend,
        typename OutputType, typename InputType1, typename InputType2,
        typename Coords
    >
    RC eWiseApply(
        Vector< OutputType, backend, Coords > &z,
        const InputType1 alpha,
        const Vector< InputType2, backend, Coords > &y,
        const Monoid &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
    ) {
#ifdef _DEBUG
        std::cout << "In unmasked eWiseApply ([T1]<-T2<-[T3], monoid, base)\n";
#endif
#ifndef NDEBUG
        const bool should_not_call_eWiseApplyMonoidASA_base = false;
        assert( should_not_call_eWiseApplyMonoidASA_base );
#endif
        (void) z;
        (void) alpha;
        (void) y;
        (void) monoid;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Monoid, enum Backend backend,
        typename OutputType, typename MaskType,
        typename InputType1, typename InputType2,
        typename Coords
    >
    RC eWiseApply(
        Vector< OutputType, backend, Coords > &z,
        const Vector< MaskType, backend, Coords > &mask,
        const InputType1 alpha,
        const Vector< InputType2, backend, Coords > &y,
        const Monoid &monoid = Monoid(),
        const Phase &phase = EXECUTE,
        const typename std::enable_if< !grb::is_object< OutputType >::value &&
            !grb::is_object< MaskType >::value &&
            !grb::is_object< InputType1 >::value &&
            !grb::is_object< InputType2 >::value &&
            grb::is_monoid< Monoid >::value,
        void >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cout << "In masked eWiseApply ([T1]<-T2<-[T3], using monoid)\n";
#endif
#ifndef NDEBUG
        const bool should_not_call_eWiseApplyMonoidAMSA_base = false;
        assert( should_not_call_eWiseApplyMonoidAMSA_base );
#endif
        (void) z;
        (void) mask;
        (void) alpha;
        (void) y;
        (void) monoid;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class OP, enum Backend backend,
        typename OutputType, typename InputType1, typename InputType2,
        typename Coords
    >
    RC eWiseApply(
        Vector< OutputType, backend, Coords > &z,
        const Vector< InputType1, backend, Coords > &x,
        const InputType2 beta,
        const OP &op = 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< OP >::value, void
        >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cout << "In eWiseApply ([T1]<-[T2]<-T3), operator, base\n";
#endif
#ifndef NDEBUG
        const bool should_not_call_eWiseApplyOpAAS_base = false;
        assert( should_not_call_eWiseApplyOpAAS_base );
#endif
        (void) z;
        (void) x;
        (void) beta;
        (void) op;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class OP, enum Backend backend,
        typename OutputType, typename MaskType,
        typename InputType1, typename InputType2,
        typename Coords
    >
    RC eWiseApply(
        Vector< OutputType, backend, Coords > &z,
        const Vector< MaskType, backend, Coords > &mask,
        const Vector< InputType1, backend, Coords > &x,
        const InputType2 beta,
        const OP &op = OP(),
        const Phase &phase = EXECUTE,
        const typename std::enable_if< !grb::is_object< OutputType >::value &&
            !grb::is_object< MaskType >::value &&
            !grb::is_object< InputType1 >::value &&
            !grb::is_object< InputType2 >::value &&
            grb::is_operator< OP >::value, void
        >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cout << "In masked eWiseApply ([T1]<-[T2]<-T3, operator, base)\n";
#endif
#ifndef NDEBUG
        const bool should_not_call_eWiseApplyOpAMAS_base = false;
        assert( should_not_call_eWiseApplyOpAMAS_base );
#endif
        (void) z;
        (void) mask;
        (void) x;
        (void) beta;
        (void) op;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Monoid, enum Backend backend,
        typename OutputType, typename InputType1, typename InputType2,
        typename Coords
    >
    RC eWiseApply(
        Vector< OutputType, backend, Coords > &z,
        const Vector< InputType1, backend, Coords > &x,
        const InputType2 beta,
        const Monoid &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
    ) {
#ifdef _DEBUG
        std::cout << "In unmasked eWiseApply ([T1]<-[T2]<-T3, monoid, base)\n";
#endif
#ifndef NDEBUG
        const bool should_not_call_eWiseApplyMonoidAAS_base = false;
        assert( should_not_call_eWiseApplyMonoidAAS_base );
#endif
        (void) z;
        (void) x;
        (void) beta;
        (void) monoid;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Monoid, enum Backend backend,
        typename OutputType, typename MaskType,
        typename InputType1, typename InputType2,
        typename Coords
    >
    RC eWiseApply(
        Vector< OutputType, backend, Coords > &z,
        const Vector< MaskType, backend, Coords > &mask,
        const Vector< InputType1, backend, Coords > &x,
        const InputType2 beta,
        const Monoid &monoid = Monoid(),
        const Phase &phase = EXECUTE,
        const typename std::enable_if< !grb::is_object< OutputType >::value &&
            !grb::is_object< MaskType >::value &&
            !grb::is_object< InputType1 >::value &&
            !grb::is_object< InputType2 >::value &&
            grb::is_monoid< Monoid >::value, void
        >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cout << "In masked eWiseApply ([T1]<-[T2]<-T3, monoid, base)\n";
#endif
#ifndef NDEBUG
        const bool should_not_call_eWiseApplyMonoidAMAS_base = false;
        assert( should_not_call_eWiseApplyMonoidAMAS_base );
#endif
        (void) z;
        (void) mask;
        (void) x;
        (void) beta;
        (void) monoid;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class OP, enum Backend backend,
        typename OutputType, typename InputType1, typename InputType2,
        typename Coords
    >
    RC eWiseApply(
        Vector< OutputType, backend, Coords > &z,
        const Vector< InputType1, backend, Coords > &x,
        const Vector< InputType2, backend, Coords > &y,
        const OP &op = 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< OP >::value, void
        >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cout << "In eWiseApply ([T1]<-[T2]<-[T3]), operator variant\n";
#endif
#ifndef NDEBUG
        const bool should_not_call_eWiseApplyOpAAA_base = false;
        assert( should_not_call_eWiseApplyOpAAA_base );
#endif
        (void) z;
        (void) x;
        (void) y;
        (void) op;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class OP, enum Backend backend,
        typename OutputType, typename MaskType,
        typename InputType1, typename InputType2,
        typename Coords
    >
    RC eWiseApply(
        Vector< OutputType, backend, Coords > &z,
        const Vector< MaskType, backend, Coords > &mask,
        const Vector< InputType1, backend, Coords > &x,
        const Vector< InputType2, backend, Coords > &y,
        const OP &op = OP(),
        const Phase &phase = EXECUTE,
        const typename std::enable_if<
            !grb::is_object< OutputType >::value &&
            !grb::is_object< MaskType >::value &&
            !grb::is_object< InputType1 >::value &&
            !grb::is_object< InputType2 >::value &&
            grb::is_operator< OP >::value, void
        >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cout << "In masked eWiseApply ([T1]<-[T2]<-[T3], operator, base)\n";
#endif
#ifndef NDEBUG
        const bool should_not_call_eWiseApplyOpAMAA_base = false;
        assert( should_not_call_eWiseApplyOpAMAA_base );
#endif
        (void) z;
        (void) mask;
        (void) x;
        (void) y;
        (void) op;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Monoid, enum Backend backend,
        typename OutputType, typename InputType1, typename InputType2,
        typename Coords
    >
    RC eWiseApply(
        Vector< OutputType, backend, Coords > &z,
        const Vector< InputType1, backend, Coords > &x,
        const Vector< InputType2, backend, Coords > &y,
        const Monoid &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
    ) {
#ifdef _DEBUG
        std::cout << "In unmasked eWiseApply ([T1]<-[T2]<-[T3], monoid, base)\n";
#endif
#ifndef NDEBUG
        const bool should_not_call_eWiseApplyOpAMAA_base = false;
        assert( should_not_call_eWiseApplyOpAMAA_base );
#endif
        (void) z;
        (void) x;
        (void) y;
        (void) monoid;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Monoid, enum Backend backend,
        typename OutputType, typename MaskType,
        typename InputType1, typename InputType2,
        typename Coords
    >
    RC eWiseApply(
        Vector< OutputType, backend, Coords > &z,
        const Vector< MaskType, backend, Coords > &mask,
        const Vector< InputType1, backend, Coords > &x,
        const Vector< InputType2, backend, Coords > &y,
        const Monoid &monoid = Monoid(),
        const Phase &phase = EXECUTE,
        const typename std::enable_if<
            !grb::is_object< OutputType >::value &&
            !grb::is_object< MaskType >::value &&
            !grb::is_object< InputType1 >::value &&
            !grb::is_object< InputType2 >::value &&
            grb::is_monoid< Monoid >::value, void
        >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cout << "In masked eWiseApply ([T1]<-[T2]<-[T3], monoid, base)\n";
#endif
#ifndef NDEBUG
        const bool should_not_call_eWiseApplyMonoidAMAA_base = false;
        assert( should_not_call_eWiseApplyMonoidAMAA_base );
#endif
        (void) z;
        (void) mask;
        (void) x;
        (void) y;
        (void) monoid;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Ring, enum Backend backend,
        typename OutputType, typename InputType1, typename InputType2,
        typename Coords
    >
    RC eWiseAdd(
        Vector< OutputType, backend, Coords > &z,
        const Vector< InputType1, backend, Coords > &x,
        const Vector< InputType2, backend, Coords > &y,
        const Ring &ring = Ring(),
        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_semiring< Ring >::value, void
        >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cout << "in eWiseAdd ([T1] <- [T2] + [T3]), unmasked, base";
#endif
#ifndef NDEBUG
        const bool should_not_call_eWiseAddAAA_base = false;
        assert( should_not_call_eWiseAddAAA_base );
#endif
        (void) z;
        (void) x;
        (void) y;
        (void) ring;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Ring, enum Backend backend,
        typename InputType1, typename InputType2, typename OutputType,
        typename Coords
    >
    RC eWiseAdd(
        Vector< OutputType, backend, Coords > &z,
        const InputType1 alpha,
        const Vector< InputType2, backend, Coords > &y,
        const Ring &ring = Ring(),
        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_semiring< Ring >::value, void
        >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cout << "in eWiseAdd ([T1] <- T2 + [T3]), unmasked, base";
#endif
#ifndef NDEBUG
        const bool should_not_call_eWiseAddASA_base = false;
        assert( should_not_call_eWiseAddASA_base );
#endif
        (void) z;
        (void) alpha;
        (void) y;
        (void) ring;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Ring, enum Backend backend,
        typename InputType1, typename InputType2, typename OutputType,
        typename Coords
    >
    RC eWiseAdd(
        Vector< OutputType, backend, Coords > &z,
        const Vector< InputType1, backend, Coords > &x,
        const InputType2 beta,
        const Ring &ring = Ring(),
        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_semiring< Ring >::value, void
        >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cout << "in eWiseAdd ([T1] <- [T2] + T3), unmasked, base";
#endif
#ifndef NDEBUG
        const bool should_not_call_eWiseAddAAS_base = false;
        assert( should_not_call_eWiseAddAAS_base );
#endif
        (void) z;
        (void) x;
        (void) beta;
        (void) ring;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Ring, enum Backend backend,
        typename InputType1, typename InputType2, typename OutputType,
        typename Coords
    >
    RC eWiseAdd(
        Vector< OutputType, backend, Coords > &z,
        const InputType1 alpha,
        const InputType2 beta,
        const Ring &ring = Ring(),
        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_semiring< Ring >::value, void
        >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cout << "in eWiseAdd ([T1] <- T2 + T3), unmasked, base";
#endif
#ifndef NDEBUG
        const bool should_not_call_eWiseAddASS_base = false;
        assert( should_not_call_eWiseAddASS_base );
#endif
        (void) z;
        (void) alpha;
        (void) beta;
        (void) ring;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Ring, enum Backend backend,
        typename OutputType, typename MaskType,
        typename InputType1, typename InputType2,
        typename Coords
    >
    RC eWiseAdd(
        Vector< OutputType, backend, Coords > &z,
        const Vector< MaskType, backend, Coords > &mask,
        const Vector< InputType1, backend, Coords > &x,
        const Vector< InputType2, backend, Coords > &y,
        const Ring &ring = Ring(),
        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_semiring< Ring >::value, void
        >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cout << "in eWiseAdd ([T1] <- [T2] + [T3]), masked, base";
#endif
#ifndef NDEBUG
        const bool should_not_call_eWiseAddAMAA_base = false;
        assert( should_not_call_eWiseAddAMAA_base );
#endif
        (void) z;
        (void) mask;
        (void) x;
        (void) y;
        (void) ring;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Ring, enum Backend backend,
        typename InputType1, typename InputType2,
        typename OutputType, typename MaskType,
        typename Coords
    >
    RC eWiseAdd(
        Vector< OutputType, backend, Coords > &z,
        const Vector< MaskType, backend, Coords > &mask,
        const InputType1 alpha,
        const Vector< InputType2, backend, Coords > &y,
        const Ring &ring = Ring(),
        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_semiring< Ring >::value, void
        >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cout << "in eWiseAdd ([T1] <- T2 + [T3]), masked, base";
#endif
#ifndef NDEBUG
        const bool should_not_call_eWiseAddAMSA_base = false;
        assert( should_not_call_eWiseAddAMSA_base );
#endif
        (void) z;
        (void) mask;
        (void) alpha;
        (void) y;
        (void) ring;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Ring, enum Backend backend,
        typename InputType1, typename InputType2,
        typename OutputType, typename MaskType,
        typename Coords
    >
    RC eWiseAdd(
        Vector< OutputType, backend, Coords > &z,
        const Vector< MaskType, backend, Coords > &mask,
        const Vector< InputType1, backend, Coords > &x,
        const InputType2 beta,
        const Ring &ring = Ring(),
        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_semiring< Ring >::value, void
        >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cout << "in eWiseAdd ([T1] <- [T2] + T3), masked, base";
#endif
#ifndef NDEBUG
        const bool should_not_call_eWiseAddAMAS_base = false;
        assert( should_not_call_eWiseAddAMAS_base );
#endif
        (void) z;
        (void) mask;
        (void) x;
        (void) beta;
        (void) ring;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Ring, enum Backend backend,
        typename InputType1, typename InputType2,
        typename OutputType, typename MaskType,
        typename Coords
    >
    RC eWiseAdd(
        Vector< OutputType, backend, Coords > &z,
        const Vector< MaskType, backend, Coords > &mask,
        const InputType1 alpha,
        const InputType2 beta,
        const Ring &ring = Ring(),
        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_semiring< Ring >::value, void
        >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cout << "in eWiseAdd ([T1] <- T2 + T3), masked, base";
#endif
#ifndef NDEBUG
        const bool should_not_call_eWiseAddAMSS_base = false;
        assert( should_not_call_eWiseAddAMSS_base );
#endif
        (void) z;
        (void) mask;
        (void) alpha;
        (void) beta;
        (void) ring;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Ring, enum Backend backend,
        typename InputType1, typename InputType2, typename OutputType,
        typename Coords
    >
    RC eWiseMul(
        Vector< OutputType, backend, Coords > &z,
        const Vector< InputType1, backend, Coords > &x,
        const Vector< InputType2, backend, Coords > &y,
        const Ring &ring = Ring(),
        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_semiring< Ring >::value, void
        >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cout << "in eWiseMul ([T1] <- [T2] * [T3]), unmasked, base";
#endif
#ifndef NDEBUG
        const bool should_not_call_eWiseMulAAA_base = false;
        assert( should_not_call_eWiseMulAAA_base );
#endif
        (void) z;
        (void) x;
        (void) y;
        (void) ring;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Ring, enum Backend backend,
        typename InputType1, typename InputType2, typename OutputType,
        typename Coords
    >
    RC eWiseMul(
        Vector< OutputType, backend, Coords > &z,
        const InputType1 alpha,
        const Vector< InputType2, backend, Coords > &y,
        const Ring &ring = Ring(),
        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_semiring< Ring >::value, void
        >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cout << "in eWiseMul ([T1] <- T2 * [T3]), unmasked, base";
#endif
#ifndef NDEBUG
        const bool should_not_call_eWiseMulASA_base = false;
        assert( should_not_call_eWiseMulASA_base );
#endif
        (void) z;
        (void) alpha;
        (void) y;
        (void) ring;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Ring, enum Backend backend,
        typename InputType1, typename InputType2, typename OutputType,
        typename Coords
    >
    RC eWiseMul(
        Vector< OutputType, backend, Coords > &z,
        const Vector< InputType1, backend, Coords > &x,
        const InputType2 beta,
        const Ring &ring = Ring(),
        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_semiring< Ring >::value, void
        >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cout << "in eWiseMul ([T1] <- [T2] * T3), unmasked, base";
#endif
#ifndef NDEBUG
        const bool should_not_call_eWiseMulAAS_base = false;
        assert( should_not_call_eWiseMulAAS_base );
#endif
        (void) z;
        (void) x;
        (void) beta;
        (void) ring;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Ring, enum Backend backend,
        typename InputType1, typename InputType2, typename OutputType,
        typename Coords
    >
    RC eWiseMul(
        Vector< OutputType, backend, Coords > &z,
        const InputType1 alpha,
        const InputType2 beta,
        const Ring &ring = Ring(),
        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_semiring< Ring >::value, void
        >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cout << "in eWiseMul ([T1] <- T2 * T3), unmasked, base";
#endif
#ifndef NDEBUG
        const bool should_not_call_eWiseMulASS_base = false;
        assert( should_not_call_eWiseMulASS_base );
#endif
        (void) z;
        (void) alpha;
        (void) beta;
        (void) ring;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Ring, enum Backend backend,
        typename InputType1, typename InputType2,
        typename OutputType, typename MaskType,
        typename Coords
    >
    RC eWiseMul(
        Vector< OutputType, backend, Coords > &z,
        const Vector< MaskType, backend, Coords > &mask,
        const Vector< InputType1, backend, Coords > &x,
        const Vector< InputType2, backend, Coords > &y,
        const Ring &ring = Ring(),
        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_semiring< Ring >::value, void
        >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cout << "in eWiseMul ([T1] <- [T2] * [T3]), masked, base";
#endif
#ifndef NDEBUG
        const bool should_not_call_eWiseMulAMAA_base = false;
        assert( should_not_call_eWiseMulAMAA_base );
#endif
        (void) z;
        (void) mask;
        (void) x;
        (void) y;
        (void) ring;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Ring, enum Backend backend,
        typename InputType1, typename InputType2,
        typename OutputType, typename MaskType,
        typename Coords
    >
    RC eWiseMul(
        Vector< OutputType, backend, Coords > &z,
        const Vector< MaskType, backend, Coords > &mask,
        const InputType1 alpha,
        const Vector< InputType2, backend, Coords > &y,
        const Ring &ring = Ring(),
        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_semiring< Ring >::value, void
        >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cout << "in eWiseMul ([T1] <- T2 * [T3]), masked, base";
#endif
#ifndef NDEBUG
        const bool should_not_call_eWiseMulAMSA_base = false;
        assert( should_not_call_eWiseMulAMSA_base );
#endif
        (void) z;
        (void) mask;
        (void) alpha;
        (void) y;
        (void) ring;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Ring, enum Backend backend,
        typename InputType1, typename InputType2,
        typename OutputType, typename MaskType,
        typename Coords
    >
    RC eWiseMul(
        Vector< OutputType, backend, Coords > &z,
        const Vector< MaskType, backend, Coords > &mask,
        const Vector< InputType1, backend, Coords > &x,
        const InputType2 beta,
        const Ring &ring = Ring(),
        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_semiring< Ring >::value, void
        >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cout << "in eWiseMul ([T1] <- [T2] * T3), masked, base";
#endif
#ifndef NDEBUG
        const bool should_not_call_eWiseMulAMAS_base = false;
        assert( should_not_call_eWiseMulAMAS_base );
#endif
        (void) z;
        (void) mask;
        (void) x;
        (void) beta;
        (void) ring;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Ring, enum Backend backend,
        typename InputType1, typename InputType2,
        typename OutputType, typename MaskType,
        typename Coords
    >
    RC eWiseMul(
        Vector< OutputType, backend, Coords > &z,
        const Vector< MaskType, backend, Coords > &mask,
        const InputType1 alpha,
        const InputType2 beta,
        const Ring &ring = Ring(),
        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_semiring< Ring >::value, void
        >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cout << "in eWiseMul ([T1] <- T2 * T3), masked, base";
#endif
#ifndef NDEBUG
        const bool should_not_call_eWiseMulAMSS_base = false;
        assert( should_not_call_eWiseMulAMSS_base );
#endif
        (void) z;
        (void) mask;
        (void) alpha;
        (void) beta;
        (void) ring;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        typename Func,
        typename DataType,
        Backend backend,
        typename Coords,
        typename... Args
    >
    RC eWiseLambda(
        const Func f,
        const Vector< DataType, backend, Coords > & x, Args...
    ) {
#ifndef NDEBUG
        const bool should_not_call_base_vector_ewiselambda = false;
        assert( should_not_call_base_vector_ewiselambda );
#endif
        (void) f;
        (void) x;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Monoid,
        typename InputType, typename IOType, typename MaskType,
        Backend backend, typename Coords
    >
    RC foldl(
        IOType &x,
        const Vector< InputType, backend, Coords > &y,
        const Vector< MaskType, backend, Coords > &mask,
        const Monoid &monoid = Monoid(),
        const typename std::enable_if< !grb::is_object< IOType >::value &&
            !grb::is_object< InputType >::value &&
            !grb::is_object< MaskType >::value &&
            grb::is_monoid< Monoid >::value, void
        >::type * const = nullptr
    ) {
#ifndef NDEBUG
        const bool should_not_call_base_scalar_foldl = false;
        assert( should_not_call_base_scalar_foldl );
#endif
        (void) y;
        (void) x;
        (void) mask;
        (void) monoid;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Monoid,
        typename IOType, typename InputType,
        Backend backend,
        typename Coords
    >
    RC foldl(
        IOType &x,
        const Vector< InputType, backend, Coords > &y,
        const Monoid &monoid = Monoid(),
        const typename std::enable_if<
            !grb::is_object< IOType >::value &&
            grb::is_monoid< Monoid >::value,
        void >::type * const = nullptr
    ) {
#ifndef NDEBUG
        const bool should_not_call_base_scalar_foldl_nomask = false;
        assert( should_not_call_base_scalar_foldl_nomask );
#endif
        (void) y;
        (void) x;
        (void) monoid;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class OP,
        typename IOType, typename InputType, typename MaskType,
        Backend backend, typename Coords
    >
    RC foldl(
        IOType &x,
        const Vector< InputType, backend, Coords > &y,
        const Vector< MaskType, backend, Coords > &mask,
        const OP &op = OP(),
        const typename std::enable_if<
            !grb::is_object< IOType >::value &&
            !grb::is_object< MaskType >::value &&
            grb::is_operator< OP >::value,
        void >::type * const = nullptr
    ) {
#ifndef NDEBUG
        const bool should_not_call_base_scalar_foldl_op = false;
        assert( should_not_call_base_scalar_foldl_op );
#endif
        (void) x;
        (void) y;
        (void) mask;
        (void) op;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Monoid,
        typename InputType, typename IOType, typename MaskType,
        Backend backend, typename Coords
    >
    RC foldr(
        const Vector< InputType, backend, Coords > &x,
        const Vector< MaskType, backend, Coords > &mask,
        IOType &y,
        const Monoid &monoid = Monoid(),
        const typename std::enable_if< !grb::is_object< IOType >::value &&
            !grb::is_object< InputType >::value &&
            !grb::is_object< MaskType >::value &&
            grb::is_monoid< Monoid >::value, void
        >::type * const = nullptr
    ) {
#ifndef NDEBUG
        const bool should_not_call_base_scalar_foldr = false;
        assert( should_not_call_base_scalar_foldr );
#endif
        (void) y;
        (void) x;
        (void) mask;
        (void) monoid;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Monoid,
        typename IOType, typename InputType,
        Backend backend, typename Coords
    >
    RC foldr(
        const Vector< InputType, backend, Coords > &y,
        IOType &x,
        const Monoid &monoid = Monoid(),
        const typename std::enable_if<
            !grb::is_object< IOType >::value &&
            grb::is_monoid< Monoid >::value,
        void >::type * const = nullptr
    ) {
#ifndef NDEBUG
        const bool should_not_call_base_scalar_foldr_nomask = false;
        assert( should_not_call_base_scalar_foldr_nomask );
#endif
        (void) y;
        (void) x;
        (void) monoid;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class AddMonoid, class AnyOp,
        typename OutputType, typename InputType1, typename InputType2,
        enum Backend backend, typename Coords
    >
    RC dot(
        OutputType &z,
        const Vector< InputType1, backend, Coords > &x,
        const Vector< InputType2, backend, Coords > &y,
        const AddMonoid &addMonoid = AddMonoid(),
        const AnyOp &anyOp = AnyOp(),
        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< AddMonoid >::value &&
            grb::is_operator< AnyOp >::value,
        void >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cout << "Should not call base grb::dot (monoid-operator version)\n";
#endif
#ifndef NDEBUG
        const bool should_not_call_base_dot_monOp = false;
        assert( should_not_call_base_dot_monOp );
#endif
        (void) z;
        (void) x;
        (void) y;
        (void) addMonoid;
        (void) anyOp;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class Ring,
        typename IOType, typename InputType1, typename InputType2,
        Backend backend, typename Coords
    >
    RC dot(
        IOType &z,
        const Vector< InputType1, backend, Coords > &x,
        const Vector< InputType2, backend, Coords > &y,
        const Ring &ring = Ring(),
        const Phase &phase = EXECUTE,
        const typename std::enable_if<
            !grb::is_object< InputType1 >::value &&
            !grb::is_object< InputType2 >::value &&
            !grb::is_object< IOType >::value &&
            grb::is_semiring< Ring >::value,
        void >::type * const = nullptr
    ) {
#ifdef _DEBUG
        std::cout << "Should not call base grb::dot (semiring version)\n";
#endif
#ifndef NDEBUG
        const bool should_not_call_base_dot_semiring = false;
        assert( should_not_call_base_dot_semiring );
#endif
        (void) z;
        (void) x;
        (void) y;
        (void) ring;
        (void) phase;
        return UNSUPPORTED;
    }

} // end namespace grb

#endif // end _H_GRB_BASE_BLAS1