dl
dl_algorithm.h
浏览该文件的文档.
1
12#pragma once
13
14#include <algorithm>
15#include <cassert>
16#include <stack>
17#include <vector>
18
19#include "dl_concept.h"
20
21namespace dl
22{
26template<typename T>
27constexpr T saturate(const T& x)
28{
29 return std::clamp<T>(x, 0, 1);
30}
31
35template<typename T>
36constexpr T is_saturate(const T& x)
37{
38 return x >= 0 && x <= 1;
39}
40
44template<typename T>
45constexpr std::array<T, 3> cross(const std::array<T, 3>& a, const std::array<T, 3>& b)
46{
47 return {
48 a[1] * b[2] - a[2] * b[1],
49 a[2] * b[0] - a[0] * b[2],
50 a[0] * b[1] - a[1] * b[0] };
51}
52
53
54
59template<typename T>
60[[deprecated]]
61inline T cast_dynamic(void* p)
62{
63 return dynamic_cast<T>(p);
64}
65
66
70template<typename T, size_t N>
71bool limit_bigger(std::array<T, N>& a, const std::array<T, N>& limit)
72{
73 bool ret = false;
74 for (int i = 0; i != N; ++i)
75 {
76 if (a[i] < limit[i])
77 {
78 a[i] = limit[i];
79 ret = true;
80 }
81 }
82 return ret;
83}
84
85
86//-------------------------------------------------------other-----------------------------------------
87
94template<typename T, typename V>
95void erase_head_from_last(T& container, const V& a)
96{
97 auto iter = find(container.rbegin(), container.rend(), a);
98
99 if (iter != container.rend())
100 container.erase(container.begin(), iter.base());
101}
102
103
104
111template<PopFrontAble C, typename F>
112void operate_front(C& container, F func)
113{
114 while (!container.empty())
115 {
116 auto iter = container.front();
117 container.pop_front();
118
119 func(iter);
120 }
121}
122
123
124
125
127//namespace Find
128//{
129// /**
130// * @brief find,返回下标
131// * @note 失败返回-1
132// */
133// template<typename T, typename V>
134// size_t Index(const T& container, const V& v)
135// {
136// size_t size = container.size();
137// for (size_t i = 0; i < size; ++i)
138// {
139// if (container[i] == v)
140// {
141// return i;
142// }
143// }
144// return -1;
145// }
146// /**
147// * @brief find,返回下标
148// * @note 失败返回y == size
149// */
150// template<typename T, typename V>
151// array<size_t, 2> Index(const vector<vector<T>>& container, const V& v)
152// {
153// array<size_t, 2> ret{};
154// for (; ret[1] < container.size(); ++ret[1])
155// {
156// auto& line = container[ret[1]];
157// for (ret[0] = 0; ret[0] < line.size(); ++ret[0])
158// {
159// if (line[ret[0]] == v)
160// {
161// return ret;
162// }
163// }
164// }
165// return ret;
166// }
167//}
168
169
170
171
176template<typename T>
177inline T* pointer(T&& x)
178{
179 return &x;
180}
181
185template<typename T>
186inline const T& constant(T& v)
187{
188 return v;
189}
190
191
192
196//template<typename T, typename V>
197//inline void replace(T& vec, V v, V v_new)
198//{
199// for (auto& iter : vec)
200// {
201// if (iter == v)
202// iter = v_new;
203// }
204//}
205
209template<typename C>
210auto find_equal(C& container)
211{
212 for (auto iter = container.begin(); iter != container.end(); ++iter)
213 {
214 auto iter1 = iter;
215 ++iter1;
216 for (; iter1 < container.end(); ++iter1)
217 {
218 if (*iter == *iter1)
219 return iter1;
220 }
221 }
222 return container.end();
223}
224
225
230template<typename T, typename V>
231T insert_per_num(const T& container, V v, size_t per_num)
232{
233 if (container.size() <= per_num)
234 return T(container);
235
236 size_t num = (container.size() - 1) / per_num;//每3个插入计算得出:9 -> 2; 11 -> 3
237 T ret;
238 ret.resize(num + container.size());
239
240 size_t i = 0;
241 auto iter = container.begin();
242 auto iter_ret = ret.begin();
243 while (iter != container.end())
244 {
245 *iter_ret++ = *iter++;
246 ++i;
247 //满per_num额外加入一个v,且不为最后一个
248 if (i % per_num == 0
249 && i < container.size())
250 *iter_ret++ = v;
251 }
252
253 return ret;
254}
255
260template<typename T, typename V>
261T r_insert_per_num(const T& container, V v, size_t per_num)
262{
263 if (container.size() <= per_num)
264 return T(container);
265
266 size_t num = (container.size() - 1) / per_num;//每3个插入计算得出:9 -> 2; 11 -> 3
267 T ret;
268 ret.resize(num + container.size());
269
270 size_t i = 0;
271 auto iter = container.rbegin();
272 auto iter_ret = ret.rbegin();
273 while (iter != container.rend())
274 {
275 *iter_ret++ = *iter++;
276 ++i;
277 //满per_num额外加入一个v,且不为最后一个
278 if (i % per_num == 0
279 && i < container.size())
280 *iter_ret++ = v;
281 }
282
283 return ret;
284}
285
298template<typename T, typename V>
299void split(const T& container, V delimiter, std::vector<T>& ret)
300{
301 if (container.empty())return;
302
303 //主迭代器位置
304 auto iter_begin = container.begin();
305
306 while (true)
307 {
308 //当前位置就是分隔符,则添加 空元素
309 if (*iter_begin == delimiter)
310 {
311 ret.push_back(T());
312 if (++iter_begin == container.end())
313 {
314 ret.push_back(T());//还要额外添加一个
315 return;
316 }
317 }
318 else
319 {
320 //分隔符位置
321 auto iter_find = find(iter_begin, container.end(), delimiter);
322
323 if (iter_find == container.end())
324 {//分隔符 未找到(说明字符串读完了,最后没有分隔符的情况)
325 ret.emplace_back(T(iter_begin, container.end()));
326 return;
327 }
328 else
329 {
330 ret.emplace_back(T(iter_begin, iter_find));
331 iter_begin = iter_find + 1;
332 }
333 }
334 }
335}
336
349template<typename T, typename V>
350void split_no_empty(const T& container, V delimiter, std::vector<T>& ret)
351{
352 if (container.empty())return;
353
354 //主迭代器位置
355 auto iter_begin = container.begin();
356
357 while (true)
358 {
359 //当前位置就是分隔符,不添加 空元素,只往后移动
360 if (*iter_begin == delimiter)
361 {
362 if (++iter_begin == container.end())
363 return;
364 }
365 else
366 {
367 //分隔符位置
368 auto iter_find = find(iter_begin, container.end(), delimiter);
369
370 if (iter_find == container.end())
371 {//分隔符 未找到(说明字符串读完了,最后没有分隔符的情况)
372 ret.emplace_back(T(iter_begin, container.end()));
373 return;
374 }
375 else
376 {
377 ret.emplace_back(T(iter_begin, iter_find));
378 iter_begin = iter_find + 1;
379 }
380 }
381 }
382}
383
393template<typename T>
394void split_sub(const T& container, const T& delimiter, std::vector<T>& ret)
395{
396 assert(!delimiter.empty());
397
398 auto iter_pre = container.begin();
399 auto iter_d = delimiter.begin();
400
401 bool mode_d = false;//是否匹配分隔符中
402 auto iter_cur = iter_pre;
403
404 auto iter_cat = iter_pre;//开始匹配分隔符的位置
405
406 while (true)
407 {
408 if (!mode_d)
409 {//正常模式
410 if (*iter_cur == *iter_d)
411 {//匹配到分隔符首个,进入匹配模式
412 mode_d = true;
413 iter_cat = iter_cur;
414 ++iter_cur;
415 ++iter_d;
416 continue;
417 }
418 else
419 {
420 ++iter_cur;
421 if (iter_cur == container.end())
422 {
423 ret.push_back(T(iter_pre, iter_cur));
424 return;
425 }
426 }
427 }
428 else
429 {//匹配模式
430 if (iter_d == delimiter.end())
431 {//完全匹配分隔符
432 ret.push_back(T(iter_pre, iter_cat));
433 mode_d = false;
434 iter_d = delimiter.begin();
435 iter_pre = iter_cur;
436 continue;
437 }
438
439 if (iter_cur == container.end())
440 {//字符结束,未完全匹配
441 ret.push_back(T(iter_pre, iter_cur));
442 return;
443 }
444
445 if (*iter_cur == *iter_d)
446 {//当前匹配
447 ++iter_cur;
448 ++iter_d;
449 continue;
450 }
451 else
452 {//不匹配,进入普通模式
453 mode_d = false;
454 iter_d = delimiter.begin();
455 continue;
456 }
457 }
458 }
459}
460
466template<typename T, typename V>
467void make_sequence(T& c, const std::initializer_list<std::initializer_list<V>>& vec)
468{
469 for (auto& iter : vec)
470 {
471 assert(iter.size() == 2);
472 V f = *iter.begin();
473 const V& b = *(iter.begin() + 1);
474 assert(f < b);
475 while (f < b)
476 {
477 c.push_back(f++);
478 }
479 }
480}
481
490template<typename C, typename F>
491void for_couple(const C& container, F func, bool ring = false)
492{
493 if (container.empty())
494 {
495 return;
496 }
497
498 auto iter_pre = begin(container);
499 auto iter_cur = iter_pre + 1;
500
501 for (; iter_cur != end(container);)
502 {
503 func(*iter_pre, *iter_cur);
504 ++iter_pre;
505 ++iter_cur;
506 }
507 if (ring)
508 func(*iter_pre, *begin(container));
509}
510
519template<IsPointer T, typename FC, typename F>
520void for_tree(T root, FC func_child, F func)
521{
522 std::stack<T> s;
523 s.push(root);
524
525 while (!s.empty())
526 {
527 T node_this = s.top();
528 s.pop();
529 func(node_this);
530
531 //反向添加,这样左子树先遍历
532 using C = decltype(func_child(node_this));
533 C c = func_child(node_this);
534 for (auto iter = c->rbegin(); iter != c->rend(); ++iter)
535 {
536 T& node = *iter;
537 s.push(node);
538 }
539 }
540}
541
545template<typename F>
547{
548public:
549 finally(F && func) : _func(func) {}
550 ~finally() { _func(); }
551private:
552 F _func;
553};
554
559/*template<typename T, size_t N>
560[[deprecated]]
561constexpr size_t arr_size(const T(&)[N])
562{
563 return N;
564}*/
565
566
570template<typename T, size_t N>
571constexpr T& arr_last(const T(&arr)[N])
572{
573 return arr[N - 1];
574}
575
579template<IsSigned T>
580constexpr T sign(const T& v)
581{
582 if (v > 0)
583 return 1;
584 else if (v < 0)
585 return -1;
586 else
587 return 0;
588}
589
590
598template<size_t N>
599consteval uint64_t str_uid(const char(&str)[N])
600{
601 //64 / 6 = 10 再加1结束符
602 static_assert(N > 0 && N <= 11, "字符串长度过长!");
603 uint64_t ret = 0;
604 for (size_t i = 0; i < N - 1; ++i)
605 {
606 char ch = str[i];
607
608 if (ch >= 48 && ch <= 57)
609 ch += 6;//0-9
610 else if (ch >= 65 && ch <= 90)
611 ch -= 65;//A-Z
612 else if (ch >= 97 && ch <= 122)
613 ch -= 71;//a-z
614 else if (ch == 95)
615 ch = 62;
616 else if (ch == 46)
617 ch = 63;
618 else
619 assert(0 && "只能是字母、数字、下划线、点!");
620
621 ret |= ((uint64_t)ch << (i * 6));
622 }
623 return ret;
624}
625
629template<typename T, size_t N>
630constexpr std::array<T, N + 1> append(const std::array<T, N>& arr, const T& v)
631{
632 std::array<T, N + 1> ret;
633 for (size_t i = 0; i < N; ++i)
634 ret[i] = arr[i];
635 ret[N] = v;
636 return ret;
637}
638
642template<size_t M = 1, typename T, size_t N>
643constexpr std::array<T, N - M> subtract(const std::array<T, N>& arr)
644{
645 static_assert(M <= N);
646 std::array<T, N - M> ret;
647 for (size_t i = 0; i < N - M; ++i)
648 ret[i] = arr[i];
649 return ret;
650}
651
652
653}
RAII清理操作
Definition: dl_algorithm.h:547
用于模板限定,更好的报错信息
Definition: dl_array2.h:17
constexpr std::array< T, N+1 > append(const std::array< T, N > &arr, const T &v)
尾部增加1一个元素
Definition: dl_algorithm.h:630
T r_insert_per_num(const T &container, V v, size_t per_num)
从后面往前,隔n个元素就插入1个值,首尾不会出现分割符
Definition: dl_algorithm.h:261
T * pointer(T &&x)
查找算法
Definition: dl_algorithm.h:177
void split_no_empty(const T &container, V delimiter, std::vector< T > &ret)
以 元素 分割 容器
Definition: dl_algorithm.h:350
void for_couple(const C &container, F func, bool ring=false)
成对遍历
Definition: dl_algorithm.h:491
constexpr std::array< T, 3 > cross(const std::array< T, 3 > &a, const std::array< T, 3 > &b)
向量叉乘
Definition: dl_algorithm.h:45
void for_tree(T root, FC func_child, F func)
遍历树(使用栈,深度优先)
Definition: dl_algorithm.h:520
T cast_dynamic(void *p)
动态类型强转
Definition: dl_algorithm.h:61
void split_sub(const T &container, const T &delimiter, std::vector< T > &ret)
以 子串 分割 容器
Definition: dl_algorithm.h:394
constexpr T is_saturate(const T &x)
是否数值在[0, 1]
Definition: dl_algorithm.h:36
void make_sequence(T &c, const std::initializer_list< std::initializer_list< V > > &vec)
生成序列
Definition: dl_algorithm.h:467
void split(const T &container, V delimiter, std::vector< T > &ret)
以 元素 分割 容器
Definition: dl_algorithm.h:299
constexpr std::array< T, N - M > subtract(const std::array< T, N > &arr)
尾部舍弃M个元素
Definition: dl_algorithm.h:643
void operate_front(C &container, F func)
从容器container不断取出第一个元素,执行操作
Definition: dl_algorithm.h:112
bool limit_bigger(std::array< T, N > &a, const std::array< T, N > &limit)
限制到大于某个值,如果修改了原值则返回true
Definition: dl_algorithm.h:71
const T & constant(T &v)
加上const修饰
Definition: dl_algorithm.h:186
constexpr T sign(const T &v)
返回符号,正数返回1、负数返回-1、0返回0
Definition: dl_algorithm.h:580
consteval uint64_t str_uid(const char(&str)[N])
固定条件的字符串,生成唯一id
Definition: dl_algorithm.h:599
T insert_per_num(const T &container, V v, size_t per_num)
隔n个元素就插入1个分割符,首尾不会出现分割符
Definition: dl_algorithm.h:231
constexpr T saturate(const T &x)
限制数值到 [0, 1]
Definition: dl_algorithm.h:27
void erase_head_from_last(T &container, const V &a)
从容器container中移除 最后 匹配到的a元素 之前(包含a)的所有元素,如果没有匹配到,则什么都不做。
Definition: dl_algorithm.h:95
auto find_equal(C &container)
替换容器元素值
Definition: dl_algorithm.h:210
constexpr T & arr_last(const T(&arr)[N])
返回静态数组长度
Definition: dl_algorithm.h:571