monoid.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_MONOID
#define _H_GRB_MONOID

#ifdef _DEBUG
#include <cstdio>
#endif

#include <cstddef> //size_t
#include <cstdlib> //posix_memalign, rand
#include <type_traits>

#include <assert.h>

#include <graphblas/identities.hpp>
#include <graphblas/ops.hpp>
#include <graphblas/type_traits.hpp>


namespace grb {

    template< class _OP, template< typename > class _ID >
    class Monoid {

        static_assert( grb::is_operator< _OP >::value, "First template argument to Monoid must be a GraphBLAS operator" );

        static_assert( grb::is_associative< _OP >::value,
            "Cannot form a monoid using the given operator since it is not "
            "associative" );

        static_assert( std::is_same< typename _OP::D1, typename _OP::D3 >::value || std::is_same< typename _OP::D2, typename _OP::D3 >::value,
            "Cannot form a monoid when the output domain does not match at least "
            "one of its input domains" );

    public:

        typedef typename _OP::D1 D1;

        typedef typename _OP::D2 D2;

        typedef typename _OP::D3 D3;

        typedef _OP Operator;

        template< typename IdentityType >
        using Identity = _ID< IdentityType >;


    private:

        Operator op;

    public:
        Monoid() : op() {}

        template< typename D >
        constexpr D getIdentity() const {
            return Identity< D >::value();
        }

        Operator getOperator() const {
            return op;
        }
    };

    // type traits
    template< class _OP, template< typename > class _ID >
    struct is_monoid< Monoid< _OP, _ID > > {
        static const constexpr bool value = true;
    };

    template< class OP, template< typename > class ID >
    struct has_immutable_nonzeroes< Monoid< OP, ID > > {
        static const constexpr bool value = grb::is_monoid< Monoid< OP, ID > >::value &&
            std::is_same< OP, typename grb::operators::logical_or< typename OP::D1, typename OP::D2, typename OP::D3 > >::value;
    };

} // namespace grb

#endif