hypot.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cmath>
#include <string>
 
#include "NumCpp/Core/Internal/Error.hpp"
#include "NumCpp/Core/Internal/StaticAsserts.hpp"
#include "NumCpp/Core/Internal/StlAlgorithms.hpp"
#include "NumCpp/NdArray.hpp"
#include "NumCpp/Utils/sqr.hpp"
 
namespace nc
{
    //============================================================================
    // Method Description:
    template<typename dtype>
    double hypot(dtype inValue1, dtype inValue2) noexcept
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        return std::hypot(static_cast<double>(inValue1), static_cast<double>(inValue2));
    }
    double hypot(dtype inValue1, dtype inValue2) noexcept {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    double hypot(dtype inValue1, dtype inValue2, dtype inValue3) noexcept
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
#ifdef __cpp_lib_hypot
        return std::hypot(static_cast<double>(inValue1), static_cast<double>(inValue2), static_cast<double>(inValue3));
#else
        return std::sqrt(utils::sqr(static_cast<double>(inValue1)) + utils::sqr(static_cast<double>(inValue2)) +
                         utils::sqr(static_cast<double>(inValue3)));
#endif
    }
    double hypot(dtype inValue1, dtype inValue2, dtype inValue3) noexcept {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<double> hypot(const NdArray<dtype>& inArray1, const NdArray<dtype>& inArray2)
    {
        return broadcast::broadcaster<double>(inArray1,
                                              inArray2,
                                              [](dtype inValue1, dtype inValue2) noexcept -> double
                                              { return hypot(inValue1, inValue2); });
    }
    NdArray<double> hypot(const NdArray<dtype>& inArray1, const NdArray<dtype>& inArray2) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<double>
        hypot(const NdArray<dtype>& inArray1, const NdArray<dtype>& inArray2, const NdArray<dtype>& inArray3)
    {
        if (inArray1.size() != inArray2.size() || inArray1.size() != inArray3.size())
        {
            THROW_INVALID_ARGUMENT_ERROR("input array sizes are not consistant.");
        }
 
        NdArray<double> returnArray(inArray1.shape());
        for (typename NdArray<dtype>::size_type i = 0; i < inArray1.size(); ++i)
        {
            returnArray[i] = hypot(inArray1[i], inArray2[i], inArray3[i]);
        }
 
        return returnArray;
    }
        hypot(const NdArray<dtype>& inArray1, const NdArray<dtype>& inArray2, const NdArray<dtype>& inArray3) {…}
} // namespace nc