Program Listing for File tensor_util.hpp

            

            
/*
* SPDX-FileCopyrightText: Copyright (c) 2021-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
* SPDX-License-Identifier: Apache-2.0
*
* 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.
*/

#pragma once

#include "morpheus/export.h"
#include "morpheus/types.hpp" // for ShapeType, TensorIndex

#include <algorithm> // IWYU pragma: keep
#include <functional> // for multiplies
#include <iosfwd> // for ostream
#include <numeric> // for accumulate
#include <string> // for string
#include <vector> // for vector
// 
 
   is needed for copy, min_element & transform
 

namespace morpheus {

struct MORPHEUS_EXPORT TensorUtils
{
    static void write_shape_to_stream(const ShapeType& shape, std::ostream& os);

    static std::string shape_to_string(const ShapeType& shape);

    static void set_contiguous_stride(const ShapeType& shape, ShapeType& stride);

    static bool has_contiguous_stride(const ShapeType& shape, const ShapeType& stride);

    static bool validate_shape_and_stride(const ShapeType& shape, const ShapeType& stride);

    template <typename IndexT = TensorIndex, typename SrcIndexT = IndexT>
    static std::vector<IndexT> get_element_stride(const std::vector<SrcIndexT>& stride)
    {
        std::vector<IndexT> tensor_stride(stride.size());
        auto min_stride     = std::min_element(stride.cbegin(), stride.cend());
        auto min_stride_val = *min_stride;

        std::transform(stride.cbegin(), stride.cend(), tensor_stride.begin(), [min_stride_val](const SrcIndexT s) {
            return s / min_stride_val;
        });

        return tensor_stride;
    }

    template <typename IndexT>
    static inline TensorSize get_elem_count(const std::vector<IndexT>& shape)
    {
        return std::accumulate(shape.begin(), shape.end(), TensorSize{1}, std::multiplies<>());
    }
};
  // end of group
}  // namespace morpheus