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 >
        D getZero() const {
            return additiveMonoid.template getIdentity< D >();
        }

        template< typename D >
        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