Function scaled_3d_dimensions_signed

src/core/Utils.cpp:366–410

}

std::tuple<int, int, int> scaled_3d_dimensions_signed(int                       width,
                                                      int                       height,
                                                      int                       depth,
                                                      int                       kernel_width,
                                                      int                       kernel_height,
                                                      int                       kernel_depth,
                                                      const Pooling3dLayerInfo &pool3d_info)
{
    const int pad_left   = pool3d_info.padding.left;
    const int pad_top    = pool3d_info.padding.top;
    const int pad_right  = pool3d_info.padding.right;
    const int pad_bottom = pool3d_info.padding.bottom;
    const int pad_front  = pool3d_info.padding.front;
    const int pad_back   = pool3d_info.padding.back;
    const int stride_x   = pool3d_info.stride.x();
    const int stride_y   = pool3d_info.stride.y();
    const int stride_z   = pool3d_info.stride.z();
    int       w          = 0;
    int       h          = 0;
    int       d          = 0;

    switch (pool3d_info.round_type)
    {
        case DimensionRoundingType::FLOOR:
            w = static_cast<int>(
                std::floor((static_cast<float>(width + pad_left + pad_right - kernel_width) / stride_x) + 1));
            h = static_cast<int>(
                std::floor((static_cast<float>(height + pad_top + pad_bottom - kernel_height) / stride_y) + 1));
            d = static_cast<int>(
                std::floor((static_cast<float>(depth + pad_front + pad_back - kernel_depth) / stride_z) + 1));
            break;
        case DimensionRoundingType::CEIL:
            w = static_cast<int>(
                std::ceil((static_cast<float>(width + pad_left + pad_right - kernel_width) / stride_x) + 1));
            h = static_cast<int>(
                std::ceil((static_cast<float>(height + pad_top + pad_bottom - kernel_height) / stride_y) + 1));
            d = static_cast<int>(
                std::ceil((static_cast<float>(depth + pad_front + pad_back - kernel_depth) / stride_z) + 1));
            break;
        default:
            ARM_COMPUTE_ERROR("Unsupported rounding type");
    }

    return std::make_tuple(static_cast<int>(w), static_cast<int>(h), static_cast<int>(d));
}

bool needs_serialized_reduction(ReductionOperation op, DataType dt, unsigned int axis)
{