norm.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_ALGORITHMS_NORM
#define _H_GRB_ALGORITHMS_NORM

#include <graphblas.hpp>

#include <cmath> // for std::sqrt


namespace grb {

    namespace algorithms {

        template< typename OutputType, typename InputType >
        OutputType std_sqrt( const InputType x ) {
            return( static_cast< OutputType >( std::sqrt( x ) ) );
        };

        template<
            Descriptor descr = descriptors::no_operation, class Ring,
            typename InputType, typename OutputType,
            Backend backend, typename Coords
        >
        RC norm2(
            OutputType &x,
            const Vector< InputType, backend, Coords > &y,
            const Ring &ring = Ring(),
            const std::function< OutputType( OutputType ) > sqrtX =
                std_sqrt< OutputType, OutputType >,
            const typename std::enable_if<
                std::is_floating_point< OutputType >::value,
            void >::type * = nullptr
        ) {
            InputType yyt = ring.template getZero< InputType >();
            RC ret = grb::dot< descr >(
                yyt, y, y, ring.getAdditiveMonoid(),
                grb::operators::conjugate_right_mul< InputType >()
            );
            if( ret == SUCCESS ) {
                grb::operators::add< OutputType > foldOp;
                ret = ret ? ret : grb::foldl(
                    x,
                    sqrtX( grb::utils::is_complex< InputType >::modulus( yyt ) ),
                    foldOp
                );
            }
            return ret;
        }
    }
}

#endif // end ``_H_GRB_ALGORITHMS_NORM''