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