identities.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_IDENTITIES
#define _H_GRB_IDENTITIES
 
#include <limits>
 
 
namespace grb {
 
    namespace identities {
 
        template< typename D >
        class zero {
            static_assert( std::is_convertible< int, D >::value, "Cannot form identity under the requested domain" );
 
        public:
            static constexpr D value() {
                return static_cast< D >( 0 );
            }
        };
        template< typename K, typename V >
        class zero< std::pair< K, V > > {
        public:
            static constexpr std::pair< K, V > value() {
                return std::make_pair( zero< K >::value(), zero< V >::value() );
            }
        };
 
        template< typename D >
        class one {
            static_assert( std::is_convertible< int, D >::value, "Cannot form identity under the requested domain" );
 
        public:
            static constexpr D value() {
                return static_cast< D >( 1 );
            }
        };
        template< typename K, typename V >
        class one< std::pair< K, V > > {
        public:
            static constexpr std::pair< K, V > value() {
                return std::make_pair( one< K >::value(), one< V >::value() );
            }
        };
 
        template< typename D >
        class infinity {
            static_assert( std::is_arithmetic< D >::value, "Cannot form identity under the requested domain" );
 
        public:
            static constexpr D value() {
                return std::numeric_limits< D >::has_infinity ? std::numeric_limits< D >::infinity() : std::numeric_limits< D >::max();
            }
        };
        template< typename K, typename V >
        class infinity< std::pair< K, V > > {
        public:
            static constexpr std::pair< K, V > value() {
                return std::make_pair( infinity< K >::value(), infinity< V >::value() );
            }
        };
 
        template< typename D >
        class negative_infinity {
            static_assert( std::is_arithmetic< D >::value, "Cannot form identity under the requested domain" );
 
        public:
            static constexpr D value() {
                return std::numeric_limits< D >::min() == 0 ? 0 : ( std::numeric_limits< D >::has_infinity ? -std::numeric_limits< D >::infinity() : std::numeric_limits< D >::min() );
            }
        };
        template< typename K, typename V >
        class negative_infinity< std::pair< K, V > > {
        public:
            static constexpr std::pair< K, V > value() {
                return std::make_pair( negative_infinity< K >::value(), negative_infinity< V >::value() );
            }
        };
 
        template< typename D >
        class logical_false {
            static_assert( std::is_convertible< bool, D >::value, "Cannot form identity under the requested domain" );
 
        public:
            static const constexpr D value() {
                return static_cast< D >( false );
            }
        };
        template< typename K, typename V >
        class logical_false< std::pair< K, V > > {
        public:
            static constexpr std::pair< K, V > value() {
                return std::make_pair( logical_false< K >::value(), logical_false< V >::value() );
            }
        };
 
        template< typename D >
        class logical_true {
            static_assert( std::is_convertible< bool, D >::value, "Cannot form identity under the requested domain" );
 
        public:
            static constexpr D value() {
                return static_cast< D >( true );
            }
        };
        template< typename K, typename V >
        class logical_true< std::pair< K, V > > {
        public:
            static constexpr std::pair< K, V > value() {
                return std::make_pair( logical_true< K >::value(), logical_true< V >::value() );
            }
        };
 
    } // namespace identities
} // namespace grb
 
#endif