deleteIndices.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <vector>
 
#include "NumCpp/Core/Internal/Error.hpp"
#include "NumCpp/Core/Internal/StlAlgorithms.hpp"
#include "NumCpp/Core/Shape.hpp"
#include "NumCpp/Core/Slice.hpp"
#include "NumCpp/Functions/unique.hpp"
#include "NumCpp/NdArray.hpp"
 
namespace nc
{
    namespace detail
    {
        //============================================================================
        // Method Description:
        template<typename dtype, typename Indices, type_traits::ndarray_int_concept<Indices> = 0>
        NdArray<dtype> deleteFlatIndices(const NdArray<dtype>& inArray, Indices inIndices)
        {
            if constexpr (type_traits::is_ndarray_signed_int_v<Indices>)
            {
                const auto arraySize = inArray.size();
                stl_algorithms::for_each(inIndices.begin(),
                                         inIndices.end(),
                                         [arraySize](auto& value)
                                         {
                                             if (value < 0)
                                             {
                                                 value += arraySize;
                                             }
                                         });
            }
 
            auto indices = unique(inIndices);
 
            std::vector<dtype> values;
            values.reserve(indices.size());
            for (int32 i = 0; i < static_cast<int32>(inArray.size()); ++i)
            {
                if (std::binary_search(indices.begin(), indices.end(), i))
                {
                    continue;
                }
 
                values.push_back(inArray[i]);
            }
 
            return NdArray<dtype>(values);
        }
        NdArray<dtype> deleteFlatIndices(const NdArray<dtype>& inArray, Indices inIndices) {…}
 
        //============================================================================
        // Method Description:
        template<typename dtype, typename Indices, type_traits::ndarray_int_concept<Indices> = 0>
        NdArray<dtype> deleteRowIndices(const NdArray<dtype>& inArray, Indices inIndices)
        {
            const auto arrayRows = static_cast<int32>(inArray.numRows());
            if constexpr (type_traits::is_ndarray_signed_int_v<Indices>)
            {
                stl_algorithms::for_each(inIndices.begin(),
                                         inIndices.end(),
                                         [arrayRows](auto& value)
                                         {
                                             if (value < 0)
                                             {
                                                 value += arrayRows;
                                             }
                                         });
            }
 
            auto indices = unique(inIndices);
 
            uint32 indicesSize = 0;
            std::for_each(indices.begin(),
                          indices.end(),
                          [arrayRows, &indicesSize](const auto& value)
                          {
                              if constexpr (std::is_signed_v<decltype(value)>)
                              {
                                  if (value >= 0 && value < arrayRows)
                                  {
                                      ++indicesSize;
                                  }
                              }
                              else
                              {
                                  if (value < arrayRows)
                                  {
                                      ++indicesSize;
                                  }
                              }
                          });
 
            const auto     arrayCols = static_cast<int32>(inArray.numCols());
            NdArray<dtype> returnArray(arrayRows - indicesSize, arrayCols);
 
            uint32 rowCounter = 0;
            for (int32 row = 0; row < arrayRows; ++row)
            {
                if (std::binary_search(indices.begin(), indices.end(), row))
                {
                    continue;
                }
 
                for (int32 col = 0; col < arrayCols; ++col)
                {
                    returnArray(rowCounter, col) = inArray(row, col);
                }
 
                ++rowCounter;
            }
 
            return returnArray;
        }
        NdArray<dtype> deleteRowIndices(const NdArray<dtype>& inArray, Indices inIndices) {…}
 
        //============================================================================
        // Method Description:
        template<typename dtype, typename Indices, type_traits::ndarray_int_concept<Indices> = 0>
        NdArray<dtype> deleteColumnIndices(const NdArray<dtype>& inArray, Indices inIndices)
        {
            const auto arrayCols = static_cast<int32>(inArray.numCols());
            if constexpr (type_traits::is_ndarray_signed_int_v<Indices>)
            {
                stl_algorithms::for_each(inIndices.begin(),
                                         inIndices.end(),
                                         [arrayCols](auto& value)
                                         {
                                             if (value < 0)
                                             {
                                                 value += arrayCols;
                                             }
                                         });
            }
 
            auto indices = unique(inIndices);
 
            uint32 indicesSize = 0;
            std::for_each(indices.begin(),
                          indices.end(),
                          [arrayCols, &indicesSize](const auto& value)
                          {
                              if constexpr (std::is_signed_v<decltype(value)>)
                              {
                                  if (value >= 0 && value < arrayCols)
                                  {
                                      ++indicesSize;
                                  }
                              }
                              else
                              {
                                  if (value < arrayCols)
                                  {
                                      ++indicesSize;
                                  }
                              }
                          });
 
            const auto     arrayRows = static_cast<int32>(inArray.numRows());
            NdArray<dtype> returnArray(arrayRows, arrayCols - indicesSize);
 
            uint32 colCounter = 0;
            for (int32 col = 0; col < arrayCols; ++col)
            {
                if (std::binary_search(indices.begin(), indices.end(), col))
                {
                    continue;
                }
 
                for (int32 row = 0; row < arrayRows; ++row)
                {
                    returnArray(row, colCounter) = inArray(row, col);
                }
 
                ++colCounter;
            }
 
            return returnArray;
        }
        NdArray<dtype> deleteColumnIndices(const NdArray<dtype>& inArray, Indices inIndices) {…}
    } // namespace detail
 
    //============================================================================
    // Method Description:
    template<typename dtype, typename Indices, type_traits::ndarray_int_concept<Indices> = 0>
    NdArray<dtype> deleteIndices(const NdArray<dtype>& inArray, const Indices& inIndices, Axis inAxis = Axis::NONE)
    {
        switch (inAxis)
        {
            case Axis::NONE:
            {
                return detail::deleteFlatIndices(inArray, inIndices);
            }
            case Axis::ROW:
            {
                return detail::deleteRowIndices(inArray, inIndices);
            }
            case Axis::COL:
            {
                return detail::deleteColumnIndices(inArray, inIndices);
            }
            default:
            {
                THROW_INVALID_ARGUMENT_ERROR("Unimplemented axis type.");
                return {}; // get rid of compiler warning
            }
        }
    }
    NdArray<dtype> deleteIndices(const NdArray<dtype>& inArray, const Indices& inIndices, Axis inAxis = Axis::NONE) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype> deleteIndices(const NdArray<dtype>& inArray, Slice inIndicesSlice, Axis inAxis = Axis::NONE)
    {
        switch (inAxis)
        {
            case Axis::NONE:
            {
                inIndicesSlice.makePositiveAndValidate(inArray.size());
                break;
            }
            case Axis::ROW:
            {
                inIndicesSlice.makePositiveAndValidate(inArray.numRows());
                break;
            }
            case Axis::COL:
            {
                inIndicesSlice.makePositiveAndValidate(inArray.numCols());
                break;
            }
        }
 
        std::vector<int32> indices;
        for (auto i = inIndicesSlice.start; i < inIndicesSlice.stop; i += inIndicesSlice.step)
        {
            indices.push_back(i);
        }
 
        return deleteIndices(inArray, NdArray<int32>(indices.data(), indices.size(), PointerPolicy::SHELL), inAxis);
    }
    NdArray<dtype> deleteIndices(const NdArray<dtype>& inArray, Slice inIndicesSlice, Axis inAxis = Axis::NONE) {…}
 
    //============================================================================
    // Method Description:
    template<typename dtype>
    NdArray<dtype> deleteIndices(const NdArray<dtype>& inArray, int32 inIndex, Axis inAxis = Axis::NONE)
    {
        NdArray<int32> inIndices = { inIndex };
        return deleteIndices(inArray, inIndices, inAxis);
    }
    NdArray<dtype> deleteIndices(const NdArray<dtype>& inArray, int32 inIndex, Axis inAxis = Axis::NONE) {…}
} // namespace nc