average.hpp

Go to the documentation of this file.

#pragma once
 
#include <complex>
#include <string>
 
#include "NumCpp/Core/Internal/Error.hpp"
#include "NumCpp/Core/Internal/StaticAsserts.hpp"
#include "NumCpp/Core/Internal/StdComplexOperators.hpp"
#include "NumCpp/Core/Internal/StlAlgorithms.hpp"
#include "NumCpp/Core/Internal/TypeTraits.hpp"
#include "NumCpp/Core/Shape.hpp"
#include "NumCpp/Core/Types.hpp"
#include "NumCpp/Functions/mean.hpp"
#include "NumCpp/NdArray.hpp"
 
namespace nc
{
    //============================================================================
    // Method Description:
    template<typename dtype>
    auto average(const NdArray<dtype>& inArray, Axis inAxis = Axis::NONE)
    {
        return mean(inArray, inAxis);
    }
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<double> average(const NdArray<dtype>& inArray, const NdArray<dtype>& inWeights, Axis inAxis = Axis::NONE)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        switch (inAxis)
        {
            case Axis::NONE:
            {
                if (inWeights.shape() != inArray.shape())
                {
                    THROW_INVALID_ARGUMENT_ERROR("input array and weight values are not consistant.");
                }
 
                NdArray<double> weightedArray(inArray.shape());
                stl_algorithms::transform(inArray.cbegin(),
                                          inArray.cend(),
                                          inWeights.cbegin(),
                                          weightedArray.begin(),
                                          std::multiplies<double>()); // NOLINT(modernize-use-transparent-functors)
 
                double          sum         = std::accumulate(weightedArray.begin(), weightedArray.end(), 0.);
                NdArray<double> returnArray = { sum /= inWeights.template astype<double>().sum().item() };
 
                return returnArray;
            }
            case Axis::COL:
            {
                const Shape arrayShape = inArray.shape();
                if (inWeights.size() != arrayShape.cols)
                {
                    THROW_INVALID_ARGUMENT_ERROR("input array and weights value are not consistant.");
                }
 
                double          weightSum = inWeights.template astype<double>().sum().item();
                NdArray<double> returnArray(1, arrayShape.rows);
                for (uint32 row = 0; row < arrayShape.rows; ++row)
                {
                    NdArray<double> weightedArray(1, arrayShape.cols);
                    stl_algorithms::transform(inArray.cbegin(row),
                                              inArray.cend(row),
                                              inWeights.cbegin(),
                                              weightedArray.begin(),
                                              std::multiplies<double>()); // NOLINT(modernize-use-transparent-functors)
 
                    double sum          = std::accumulate(weightedArray.begin(), weightedArray.end(), 0.);
                    returnArray(0, row) = sum / weightSum;
                }
 
                return returnArray;
            }
            case Axis::ROW:
            {
                return average(inArray.transpose(), inWeights, Axis::COL);
            }
            default:
            {
                THROW_INVALID_ARGUMENT_ERROR("Unimplemented axis type.");
                return {};
            }
        }
    }
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<std::complex<double>>
        average(const NdArray<std::complex<dtype>>& inArray, const NdArray<dtype>& inWeights, Axis inAxis = Axis::NONE)
    {
        STATIC_ASSERT_ARITHMETIC(dtype);
 
        const auto multiplies = [](const std::complex<dtype>& lhs, dtype rhs) -> std::complex<double>
        { return complex_cast<double>(lhs) * static_cast<double>(rhs); };
 
        switch (inAxis)
        {
            case Axis::NONE:
            {
                if (inWeights.shape() != inArray.shape())
                {
                    THROW_INVALID_ARGUMENT_ERROR("input array and weight values are not consistant.");
                }
 
                NdArray<std::complex<double>> weightedArray(inArray.shape());
                stl_algorithms::transform(inArray.cbegin(),
                                          inArray.cend(),
                                          inWeights.cbegin(),
                                          weightedArray.begin(),
                                          multiplies);
 
                std::complex<double> sum =
                    std::accumulate(weightedArray.begin(), weightedArray.end(), std::complex<double>(0.));
                NdArray<std::complex<double>> returnArray = { sum /= inWeights.template astype<double>().sum().item() };
 
                return returnArray;
            }
            case Axis::COL:
            {
                const Shape arrayShape = inArray.shape();
                if (inWeights.size() != arrayShape.cols)
                {
                    THROW_INVALID_ARGUMENT_ERROR("input array and weights value are not consistant.");
                }
 
                double                        weightSum = inWeights.template astype<double>().sum().item();
                NdArray<std::complex<double>> returnArray(1, arrayShape.rows);
                for (uint32 row = 0; row < arrayShape.rows; ++row)
                {
                    NdArray<std::complex<double>> weightedArray(1, arrayShape.cols);
                    stl_algorithms::transform(inArray.cbegin(row),
                                              inArray.cend(row),
                                              inWeights.cbegin(),
                                              weightedArray.begin(),
                                              multiplies);
 
                    const std::complex<double> sum =
                        std::accumulate(weightedArray.begin(), weightedArray.end(), std::complex<double>(0.));
                    returnArray(0, row) = sum / weightSum;
                }
 
                return returnArray;
            }
            case Axis::ROW:
            {
                return average(inArray.transpose(), inWeights, Axis::COL);
            }
            default:
            {
                THROW_INVALID_ARGUMENT_ERROR("Unimplemented axis type.");
                return {}; // get rid of compiler warning
            }
        }
    }
} // namespace nc