IgANet
IGAnets - Isogeometric Analysis Networks
Loading...
Searching...
No Matches
container.hpp
Go to the documentation of this file.
1
15#pragma once
16
17#include <array>
18#include <initializer_list>
19#include <vector>
20
21#include <core/options.hpp>
22
23namespace iganet::utils {
24
26template <std::size_t N, typename T>
27inline std::array<T, N> to_array(std::vector<T> &&vector) {
28 std::array<T, N> array;
29 std::move(vector.begin(), vector.end(), array.begin());
30 return array;
31}
32
34template <typename T, std::size_t N>
35inline std::vector<T> to_vector(std::array<T, N> &&array) {
36 std::vector<T> vector;
37 std::move(array.begin(), array.end(), vector.begin());
38 return vector;
39}
40
42template <typename... Args> inline auto to_array(Args &&...args) {
43 return std::array<std::common_type_t<Args...>, sizeof...(Args)>{
44 std::move(args)...};
45}
46
48template <typename... Args> inline auto to_vector(Args &&...args) {
49 return std::vector<std::common_type_t<Args...>>{std::move(args)...};
50}
51
54template <typename T, std::size_t N>
55inline auto
56to_tensor(const std::array<T, N> &array,
57 torch::IntArrayRef sizes = torch::IntArrayRef{-1},
58 const iganet::Options<T> &options = iganet::Options<T>{}) {
59 if (options.device() == torch::kCPU)
60 return torch::from_blob(const_cast<T *>(std::data(array)),
61 (sizes == torch::IntArrayRef{-1}) ? array.size()
62 : sizes,
63 options)
64 .detach()
65 .clone()
66 .requires_grad_(options.requires_grad());
67 else
68 return torch::from_blob(const_cast<T *>(std::data(array)),
69 (sizes == torch::IntArrayRef{-1}) ? array.size()
70 : sizes,
71 options.device(torch::kCPU))
72 .detach()
73 .clone()
74 .to(options.device())
75 .requires_grad_(options.requires_grad());
76}
77
78template <typename T, std::size_t N>
79inline auto to_tensor(const std::array<T, N> &array,
80 const iganet::Options<T> &options) {
81 if (options.device() == torch::kCPU)
82 return torch::from_blob(const_cast<T *>(std::data(array)), array.size(),
83 options)
84 .detach()
85 .clone()
86 .requires_grad_(options.requires_grad());
87 else
88 return torch::from_blob(const_cast<T *>(std::data(array)), array.size(),
89 options.device(torch::kCPU))
90 .detach()
91 .clone()
92 .to(options.device())
93 .requires_grad_(options.requires_grad());
94}
96
99template <typename T>
100inline auto
101to_tensor(std::initializer_list<T> list,
102 torch::IntArrayRef sizes = torch::IntArrayRef{-1},
103 const iganet::Options<T> &options = iganet::Options<T>{}) {
104 if (options.device() == torch::kCPU)
105 return torch::from_blob(
106 const_cast<T *>(std::data(list)),
107 (sizes == torch::IntArrayRef{-1}) ? list.size() : sizes, options)
108 .detach()
109 .clone()
110 .requires_grad_(options.requires_grad());
111 else
112 return torch::from_blob(const_cast<T *>(std::data(list)),
113 (sizes == torch::IntArrayRef{-1}) ? list.size()
114 : sizes,
115 options.device(torch::kCPU))
116 .detach()
117 .clone()
118 .to(options.device())
119 .requires_grad_(options.requires_grad());
120}
121
122template <typename T>
123inline auto to_tensor(std::initializer_list<T> &list,
124 const iganet::Options<T> &options) {
125 if (options.device() == torch::kCPU)
126 return torch::from_blob(const_cast<T *>(std::data(list)), list.size(),
127 options)
128 .detach()
129 .clone()
130 .requires_grad_(options.requires_grad());
131 else
132 return torch::from_blob(const_cast<T *>(std::data(list)), list.size(),
133 options.device(torch::kCPU))
134 .detach()
135 .clone()
136 .to(options.device())
137 .requires_grad_(options.requires_grad());
138}
140
143template <typename T>
144inline auto
145to_tensor(const std::vector<T> &vector,
146 torch::IntArrayRef sizes = torch::IntArrayRef{-1},
147 const iganet::Options<T> &options = iganet::Options<T>{}) {
148 if (options.device() == torch::kCPU)
149 return torch::from_blob(const_cast<T *>(std::data(vector)),
150 (sizes == torch::IntArrayRef{-1}) ? vector.size()
151 : sizes,
152 options)
153 .detach()
154 .clone()
155 .requires_grad_(options.requires_grad());
156 else
157 return torch::from_blob(const_cast<T *>(std::data(vector)),
158 (sizes == torch::IntArrayRef{-1}) ? vector.size()
159 : sizes,
160 options.device(torch::kCPU))
161 .detach()
162 .clone()
163 .to(options.device())
164 .requires_grad_(options.requires_grad());
165}
166
167template <typename T>
168inline auto to_tensor(const std::vector<T> &vector,
169 const iganet::Options<T> &options) {
170 if (options.device() == torch::kCPU)
171 return torch::from_blob(const_cast<T *>(std::data(vector)), vector.size(),
172 options)
173 .detach()
174 .clone()
175 .requires_grad_(options.requires_grad());
176 else
177 return torch::from_blob(const_cast<T *>(std::data(vector)), vector.size(),
178 options.device(torch::kCPU))
179 .detach()
180 .clone()
181 .to(options.device())
182 .requires_grad_(options.requires_grad());
183}
185
187template <typename T, std::size_t N>
188inline auto to_ArrayRef(const std::array<T, N> &array) {
189 return at::ArrayRef<T>{array};
190}
191
194template <typename T, std::size_t... N>
195inline auto concat(const std::array<T, N> &...arrays) {
196 std::array<T, (N + ...)> result;
197 std::size_t index{};
198
199 ((std::copy_n(arrays.begin(), N, result.begin() + index), index += N), ...);
200
201 return result;
202}
203
204template <typename T, std::size_t... N>
205inline auto concat(std::array<T, N> &&...arrays) {
206 std::array<T, (N + ...)> result;
207 std::size_t index{};
208
209 ((std::copy_n(std::make_move_iterator(arrays.begin()), N,
210 result.begin() + index),
211 index += N),
212 ...);
213
214 return result;
215}
217
220template <typename... Ts>
221inline auto concat(const std::vector<Ts> &...vectors) {
222 std::vector<std::common_type_t<Ts...>> result;
223
224 (result.insert(result.end(), vectors.begin(), vectors.end()), ...);
225
226 return result;
227}
228
229template <typename... Ts> inline auto concat(std::vector<Ts> &&...vectors) {
230 std::vector<std::common_type_t<Ts...>> result;
231
232 (result.insert(result.end(), std::make_move_iterator(vectors.begin()),
233 std::make_move_iterator(vectors.end())),
234 ...);
235
236 return result;
237}
239
241template <typename T>
242inline constexpr auto operator+(torch::ArrayRef<T> array, T data) {
243 std::vector<T> result{array.vec()};
244 result.push_back(data);
245 return result;
246}
247
249template <typename T, std::size_t N>
250inline constexpr auto operator+(std::array<T, N> array, T data) {
251 std::array<T, N + 1> result;
252 for (std::size_t i = 0; i < N; ++i)
253 result[i] = array[i];
254 result[N] = data;
255 return result;
256}
257
259template <typename T>
260inline constexpr auto operator+(std::vector<T> vector, T data) {
261 std::vector<T> result{vector};
262 result.push_back(data);
263 return result;
264}
265
267template <typename T>
268inline constexpr auto operator+(T data, torch::ArrayRef<T> array) {
269 std::vector<T> result{array.vec()};
270 result.insert(result.begin(), data);
271 return result;
272}
273
275template <typename T, std::size_t N>
276inline constexpr auto operator+(T data, std::array<T, N> array) {
277 std::array<T, N + 1> result;
278 result[0] = data;
279 for (std::size_t i = 0; i < N; ++i)
280 result[i + 1] = array[i];
281 return result;
282}
283
285template <typename T>
286inline constexpr auto operator+(T data, std::vector<T> vector) {
287 std::vector<T> result{vector};
288 result.insert(result.begin(), data);
289 return result;
290}
291
293template <typename T, std::size_t N> inline constexpr auto make_array(T value) {
294 std::array<T, N> result;
295 result.fill(value);
296 return result;
297}
298
300template <typename T, typename U, std::size_t N>
301inline constexpr std::array<T, N> make_array(std::array<U, N> array) {
302 std::array<T, N> result;
303 for (std::size_t i = 0; i < N; ++i)
304 result[i] = static_cast<T>(array[i]);
305 return result;
306}
307
309template <typename T, std::size_t N>
310inline constexpr std::array<T, N> operator-(std::array<T, N> array) {
311 std::array<T, N> result;
312 for (std::size_t i = 0; i < N; ++i)
313 result[i] = -array[i];
314 return result;
315}
316
318template <typename T, std::size_t N>
319inline constexpr std::array<T, N> operator+(std::array<T, N> lhs,
320 std::array<T, N> rhs) {
321 std::array<T, N> result;
322 for (std::size_t i = 0; i < N; ++i)
323 result[i] = lhs[i] + rhs[i];
324 return result;
325}
326
328template <typename T, std::size_t N>
329inline constexpr std::array<T, N> operator-(std::array<T, N> lhs,
330 std::array<T, N> rhs) {
331 std::array<T, N> result;
332 for (std::size_t i = 0; i < N; ++i)
333 result[i] = lhs[i] - rhs[i];
334 return result;
335}
336
338template <typename T, std::size_t N>
339inline constexpr std::array<T, N> operator*(std::array<T, N> lhs,
340 std::array<T, N> rhs) {
341 std::array<T, N> result;
342 for (std::size_t i = 0; i < N; ++i)
343 result[i] = lhs[i] * rhs[i];
344 return result;
345}
346
348template <typename T, std::size_t N>
349inline constexpr std::array<T, N> operator/(std::array<T, N> lhs,
350 std::array<T, N> rhs) {
351 std::array<T, N> result;
352 for (std::size_t i = 0; i < N; ++i)
353 result[i] = lhs[i] / rhs[i];
354 return result;
355}
356
359template <typename T, std::size_t N, std::size_t M = 1>
360inline constexpr std::array<T, N - M>
361remove_from_front(std::array<T, N> array) {
362
363 std::array<T, N - M> result;
364 for (std::size_t i = 0; i < N - M; ++i)
365 result[i] = array[i + M];
366 return result;
367}
368
371template <typename T, std::size_t N, std::size_t M = 1>
372inline constexpr std::array<T, N - M> remove_from_back(std::array<T, N> array) {
373
374 std::array<T, N - M> result;
375 for (std::size_t i = 0; i < N - M; ++i)
376 result[i] = array[i];
377 return result;
378}
379
380} // namespace iganet::utils
iganet::Options
The Options class handles the automated determination of dtype from the template argument and the sel...
Definition options.hpp:104
iganet::Options::device
torch::Device device() const noexcept
Returns the device property.
Definition options.hpp:144
iganet::Options::requires_grad
bool requires_grad() const noexcept
Returns the requires_grad property.
Definition options.hpp:160
iganet::utils
Definition blocktensor.hpp:24
iganet::utils::operator-
auto operator-(const BlockTensor< T, Dims... > &lhs, const BlockTensor< U, Dims... > &rhs)
Subtracts one compile-time block tensor from another and returns a new compile-time block tensor.
Definition blocktensor.hpp:1677
iganet::utils::make_array
constexpr auto make_array(T value)
Creates a std::array object filled with a constant.
Definition container.hpp:293
iganet::utils::to_tensor
auto to_tensor(const std::array< T, N > &array, torch::IntArrayRef sizes=torch::IntArrayRef{-1}, const iganet::Options< T > &options=iganet::Options< T >{})
Converts a std::array to torch::Tensor.
Definition container.hpp:56
iganet::utils::concat
auto concat(const std::array< T, N > &...arrays)
Concatenates multiple std::array objects.
Definition container.hpp:195
iganet::utils::remove_from_front
constexpr std::array< T, N - M > remove_from_front(std::array< T, N > array)
Derives a std::array object from a given std::array object dropping the first M entries.
Definition container.hpp:361
iganet::utils::to_array
std::array< T, N > to_array(std::vector< T > &&vector)
Converts a std::vector object into std::array.
Definition container.hpp:27
iganet::utils::to_vector
std::vector< T > to_vector(std::array< T, N > &&array)
Converts a std::array object into std::vector.
Definition container.hpp:35
iganet::utils::operator/
constexpr std::array< T, N > operator/(std::array< T, N > lhs, std::array< T, N > rhs)
Divides one std::array by another std::array.
Definition container.hpp:349
iganet::utils::remove_from_back
constexpr std::array< T, N - M > remove_from_back(std::array< T, N > array)
Derives a std::array object from a given std::array object dropping the last M entries.
Definition container.hpp:372
iganet::utils::to_ArrayRef
auto to_ArrayRef(const std::array< T, N > &array)
Converts a std::array<int64_t, N> to an at::IntArrayRef object.
Definition container.hpp:188
iganet::utils::operator*
auto operator*(const BlockTensor< T, Rows, Common > &lhs, const BlockTensor< U, Common, Cols > &rhs)
Multiplies one compile-time rank-2 block tensor with another compile-time rank-2 block tensor.
Definition blocktensor.hpp:895
iganet::operator+
constexpr auto operator+(deriv lhs, deriv rhs)
Adds two enumerators for specifying the derivative of B-spline evaluation.
Definition bspline.hpp:89
torch
Definition optimizer.hpp:61
options.hpp
Options.