/* * (C) Copyright 2013 ECMWF. * * This software is licensed under the terms of the Apache Licence Version 2.0 * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. * In applying this licence, ECMWF does not waive the privileges and immunities * granted to it by virtue of its status as an intergovernmental organisation * nor does it submit to any jurisdiction. */ #pragma once #include #include #include #include "atlas/array.h" #include "atlas/array/DataType.h" #include "atlas/array_fwd.h" #include "atlas/runtime/Exception.h" //------------------------------------------------------------------------------ namespace atlas { namespace array { namespace helpers { //------------------------------------------------------------------------------ struct array_initializer; template struct array_initializer_partitioned; //------------------------------------------------------------------------------ template struct array_initializer_impl { static void apply(Array const& orig, Array& array_resized) { array_initializer_impl::apply(make_view(orig), make_view(array_resized)); } template static void apply(ArrayView const&& orig, ArrayView&& array_resized, DimIndex... idxs) { const idx_t N = std::min(array_resized.shape(Dim), orig.shape(Dim)); for (idx_t i = 0; i < N; ++i) { array_initializer_impl::apply(std::move(orig), std::move(array_resized), idxs..., i); } } }; //------------------------------------------------------------------------------ template struct array_initializer_impl { template static void apply(ArrayView const&& orig, ArrayView&& array_resized, DimIndex... idxs) { array_resized(idxs...) = orig(idxs...); } }; //------------------------------------------------------------------------------ struct array_initializer { static void apply(Array const& from, Array& to) { ATLAS_ASSERT(from.rank() == to.rank()); switch (from.rank()) { case 1: apply_rank<1>(from, to); break; case 2: apply_rank<2>(from, to); break; case 3: apply_rank<3>(from, to); break; case 4: apply_rank<4>(from, to); break; case 5: apply_rank<5>(from, to); break; case 6: apply_rank<6>(from, to); break; case 7: apply_rank<7>(from, to); break; case 8: apply_rank<8>(from, to); break; case 9: apply_rank<9>(from, to); break; default: ATLAS_NOTIMPLEMENTED; } } template static void apply_rank(Array const& orig, Array& array_resized) { switch (orig.datatype().kind()) { case DataType::KIND_REAL64: return array_initializer_impl::apply(orig, array_resized); case DataType::KIND_REAL32: return array_initializer_impl::apply(orig, array_resized); case DataType::KIND_INT32: return array_initializer_impl::apply(orig, array_resized); case DataType::KIND_INT64: return array_initializer_impl::apply(orig, array_resized); case DataType::KIND_UINT32: return array_initializer_impl::apply(orig, array_resized); case DataType::KIND_UINT64: return array_initializer_impl::apply(orig, array_resized); default: { std::stringstream err; err << "data kind " << orig.datatype().kind() << " not recognised."; throw_NotImplemented(err.str(), Here()); } } } }; //------------------------------------------------------------------------------ template struct array_initializer_partitioned_val_impl { static void apply(Array const& orig, Array& dest, idx_t pos, idx_t offset) { array_initializer_partitioned_val_impl::apply( make_view(orig), make_view(dest), pos, offset); } template static void apply(ArrayView&& orig, ArrayView&& dest, idx_t pos, idx_t offset, DimIndexPair... idxs) { for (idx_t i = 0; i < orig.shape(Dim); ++i) { idx_t displ = i; if (Dim == PartDim && i >= pos) { displ += offset; } std::pair pair_idx{i, displ}; array_initializer_partitioned_val_impl::apply( std::move(orig), std::move(dest), pos, offset, idxs..., pair_idx); } } }; // template< typename stdarray > // inline std::string print_array(const stdarray& v) // { // std::stringstream s; // s << "[ "; // for( int j=0; j struct array_initializer_partitioned_val_impl { template static void apply(ArrayView&& orig, ArrayView&& dest, idx_t /*pos*/, idx_t /*offset*/, DimIndexPair... idxs) { // Log::info() << print_array(std::array{std::get<0>(idxs)...}) << // " --> " << print_array(std::array{std::get<1>(idxs)...}) << " // " << orig(std::get<0>(idxs)...) << std::endl; dest(std::get<1>(idxs)...) = orig(std::get<0>(idxs)...); } }; //------------------------------------------------------------------------------ template struct array_initializer_partitioned_impl { static void apply(Array const& orig, Array& dest, idx_t pos, idx_t offset) { switch (orig.datatype().kind()) { case DataType::KIND_REAL64: return array_initializer_partitioned_val_impl::apply(orig, dest, pos, offset); case DataType::KIND_REAL32: return array_initializer_partitioned_val_impl::apply(orig, dest, pos, offset); case DataType::KIND_INT32: return array_initializer_partitioned_val_impl::apply(orig, dest, pos, offset); case DataType::KIND_INT64: return array_initializer_partitioned_val_impl::apply(orig, dest, pos, offset); case DataType::KIND_UINT32: return array_initializer_partitioned_val_impl::apply(orig, dest, pos, offset); case DataType::KIND_UINT64: return array_initializer_partitioned_val_impl::apply(orig, dest, pos, offset); default: { std::stringstream err; err << "data kind " << orig.datatype().kind() << " not recognised."; throw_NotImplemented(err.str(), Here()); } } } }; //------------------------------------------------------------------------------ template struct array_initializer_partitioned { static void apply(const Array& orig, Array& dest, idx_t pos, idx_t offset) { switch (orig.rank()) { case 1: return array_initializer_partitioned_impl<1, PartDim>::apply(orig, dest, pos, offset); case 2: return array_initializer_partitioned_impl<2, PartDim>::apply(orig, dest, pos, offset); case 3: return array_initializer_partitioned_impl<3, PartDim>::apply(orig, dest, pos, offset); case 4: return array_initializer_partitioned_impl<4, PartDim>::apply(orig, dest, pos, offset); case 5: return array_initializer_partitioned_impl<5, PartDim>::apply(orig, dest, pos, offset); case 6: return array_initializer_partitioned_impl<6, PartDim>::apply(orig, dest, pos, offset); case 7: return array_initializer_partitioned_impl<7, PartDim>::apply(orig, dest, pos, offset); case 8: return array_initializer_partitioned_impl<8, PartDim>::apply(orig, dest, pos, offset); case 9: return array_initializer_partitioned_impl<9, PartDim>::apply(orig, dest, pos, offset); default: { std::stringstream err; err << "too high Rank"; throw_NotImplemented(err.str(), Here()); } } } }; //------------------------------------------------------------------------------ } // namespace helpers } // namespace array } // namespace atlas