semiring.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_SEMIRING
#define _H_GRB_SEMIRING
 
#include <graphblas/identities.hpp>
#include <graphblas/monoid.hpp>
#include <graphblas/ops.hpp>
 
 
namespace grb {
 
    template< class _OP1, class _OP2, template< typename > class _ID1, template< typename > class _ID2 >
    class Semiring {
 
        static_assert( std::is_same< typename _OP2::D3, typename _OP1::D1 >::value,
            "The multiplicative output type must match the left-hand additive "
            "input type" );
 
        static_assert( std::is_same< typename _OP1::D2, typename _OP1::D3 >::value,
            "The right-hand input type of the additive operator must match its "
            "output type" );
 
        static_assert( grb::is_associative< _OP1 >::value,
            "Cannot construct a semiring using a non-associative additive "
            "operator" );
 
        static_assert( grb::is_associative< _OP2 >::value,
            "Cannot construct a semiring using a non-associative multiplicative "
            "operator" );
 
        static_assert( grb::is_commutative< _OP1 >::value,
            "Cannot construct a semiring using a non-commutative additive "
            "operator" );
 
    public:
        typedef typename _OP2::D1 D1;
 
        typedef typename _OP2::D2 D2;
 
        typedef typename _OP2::D3 D3;
 
        typedef typename _OP1::D2 D4;
 
        typedef _OP1 AdditiveOperator;
 
        typedef _OP2 MultiplicativeOperator;
 
        typedef Monoid< _OP1, _ID1 > AdditiveMonoid;
 
        typedef Monoid< _OP2, _ID2 > MultiplicativeMonoid;
 
        template< typename ZeroType >
        using Zero = _ID1< ZeroType >;
 
        template< typename OneType >
        using One = _ID2< OneType >;
 
    private:
        static constexpr size_t D1_bsz = grb::config::SIMD_BLOCKSIZE< D1 >::value();
        static constexpr size_t D2_bsz = grb::config::SIMD_BLOCKSIZE< D2 >::value();
        static constexpr size_t D3_bsz = grb::config::SIMD_BLOCKSIZE< D3 >::value();
        static constexpr size_t D4_bsz = grb::config::SIMD_BLOCKSIZE< D4 >::value();
        static constexpr size_t mul_input_bsz = D1_bsz < D2_bsz ? D1_bsz : D2_bsz;
 
        AdditiveMonoid additiveMonoid;
 
        MultiplicativeMonoid multiplicativeMonoid;
 
    public:
        static constexpr size_t blocksize_add = D3_bsz < D4_bsz ? D3_bsz : D4_bsz;
 
        static constexpr size_t blocksize_mul = mul_input_bsz < D3_bsz ? mul_input_bsz : D3_bsz;
 
        static constexpr size_t blocksize = blocksize_mul < blocksize_add ? blocksize_mul : blocksize_add;
 
        template< typename D >
        constexpr D getZero() const {
            return additiveMonoid.template getIdentity< D >();
        }
 
        template< typename D >
        constexpr D getOne() const {
            return multiplicativeMonoid.template getIdentity< D >();
        }
 
        AdditiveMonoid getAdditiveMonoid() const {
            return additiveMonoid;
        }
 
        MultiplicativeMonoid getMultiplicativeMonoid() const {
            return multiplicativeMonoid;
        }
 
        AdditiveOperator getAdditiveOperator() const {
            return additiveMonoid.getOperator();
        }
 
        MultiplicativeOperator getMultiplicativeOperator() const {
            return multiplicativeMonoid.getOperator();
        }
    };
 
    // overload for GraphBLAS type traits.
    template< class _OP1, class _OP2, template< typename > class _ID1, template< typename > class _ID2 >
    struct is_semiring< Semiring< _OP1, _OP2, _ID1, _ID2 > > {
        static const constexpr bool value = true;
    };
 
    template< class _OP1, class _OP2, template< typename > class _ID1, template< typename > class _ID2 >
    struct has_immutable_nonzeroes< Semiring< _OP1, _OP2, _ID1, _ID2 > > {
        static const constexpr bool value = grb::is_semiring< Semiring< _OP1, _OP2, _ID1, _ID2 > >::value &&
            std::is_same< _OP1, typename grb::operators::logical_or< typename _OP1::D1, typename _OP1::D2, typename _OP1::D3 > >::value;
    };
 
} // namespace grb
 
#endif