dl
dl_algorithm.h
浏览该文件的文档.
1
12#pragma once
13
14#include <algorithm>
15#include <cassert>
16#include <stack>
17#include <array>
18#include <vector>
19
20#include "base/dl_concept.h"
21#include "base/dl_array.h"
22
23namespace dl
24{
28template<typename T>
29constexpr T saturate(const T& x)
30{
31 return std::clamp<T>(x, 0, 1);
32}
33
37template<typename T>
38constexpr T is_saturate(const T& x)
39{
40 return x >= 0 && x <= 1;
41}
42
46template<typename T>
47constexpr Array<T, 3> cross(const Array<T, 3>& a, const Array<T, 3>& b)
48{
49 return {
50 a[1] * b[2] - a[2] * b[1],
51 a[2] * b[0] - a[0] * b[2],
52 a[0] * b[1] - a[1] * b[0] };
53}
54
55
56
61template<typename T>
62[[deprecated]]
63inline T cast_dynamic(void* p)
64{
65 return dynamic_cast<T>(p);
66}
67
68
72template<typename T, size_t N>
73bool limit_bigger(Array<T, N>& a, const Array<T, N>& limit)
74{
75 bool ret = false;
76 for (int i = 0; i != N; ++i)
77 {
78 if (a[i] < limit[i])
79 {
80 a[i] = limit[i];
81 ret = true;
82 }
83 }
84 return ret;
85}
86
87template <typename T>
88inline const T& as_const(T& a)
89{
90#if DL_PLATFORM == DL_PLATFORM_WIN32
91 return std::as_const(a);
92#else
93 return (const T&)a;
94#endif
95}
96
97//-------------------------------------------------------other-----------------------------------------
98
105template<typename T, typename V>
106void erase_head_from_last(T& container, const V& a)
107{
108 auto iter = find(container.rbegin(), container.rend(), a);
109
110 if (iter != container.rend())
111 container.erase(container.begin(), iter.base());
112}
113
114
115
122template<PopFrontAble C, typename F>
123void operate_front(C& container, F func)
124{
125 while (!container.empty())
126 {
127 auto iter = container.front();
128 container.pop_front();
129
130 func(iter);
131 }
132}
133
134
135
136
138//namespace Find
139//{
140// /**
141// * @brief find,返回下标
142// * @note 失败返回-1
143// */
144// template<typename T, typename V>
145// size_t Index(const T& container, const V& v)
146// {
147// size_t size = container.size();
148// for (size_t i = 0; i < size; ++i)
149// {
150// if (container[i] == v)
151// {
152// return i;
153// }
154// }
155// return -1;
156// }
157// /**
158// * @brief find,返回下标
159// * @note 失败返回y == size
160// */
161// template<typename T, typename V>
162// array<size_t, 2> Index(const vector<vector<T>>& container, const V& v)
163// {
164// array<size_t, 2> ret{};
165// for (; ret[1] < container.size(); ++ret[1])
166// {
167// auto& line = container[ret[1]];
168// for (ret[0] = 0; ret[0] < line.size(); ++ret[0])
169// {
170// if (line[ret[0]] == v)
171// {
172// return ret;
173// }
174// }
175// }
176// return ret;
177// }
178//}
179
180
181
182
187template<typename T>
188inline T* pointer(T&& x)
189{
190 return &x;
191}
192
196template<typename T>
197inline const T& constant(T& v)
198{
199 return v;
200}
201
202
203
207//template<typename T, typename V>
208//inline void replace(T& vec, V v, V v_new)
209//{
210// for (auto& iter : vec)
211// {
212// if (iter == v)
213// iter = v_new;
214// }
215//}
216
220template<typename C>
221auto find_equal(C& container)
222{
223 for (auto iter = container.begin(); iter != container.end(); ++iter)
224 {
225 auto iter1 = iter;
226 ++iter1;
227 for (; iter1 < container.end(); ++iter1)
228 {
229 if (*iter == *iter1)
230 return iter1;
231 }
232 }
233 return container.end();
234}
235
236
241template<typename T, typename V>
242T insert_per_num(const T& container, V v, size_t per_num)
243{
244 if (container.size() <= per_num)
245 return T(container);
246
247 size_t num = (container.size() - 1) / per_num;//每3个插入计算得出:9 -> 2; 11 -> 3
248 T ret;
249 ret.resize(num + container.size());
250
251 size_t i = 0;
252 auto iter = container.begin();
253 auto iter_ret = ret.begin();
254 while (iter != container.end())
255 {
256 *iter_ret++ = *iter++;
257 ++i;
258 //满per_num额外加入一个v,且不为最后一个
259 if (i % per_num == 0
260 && i < container.size())
261 *iter_ret++ = v;
262 }
263
264 return ret;
265}
266
267
272template<typename T, typename V>
273T r_insert_per_num(const T& container, V v, size_t per_num)
274{
275 if (container.size() <= per_num)
276 return T(container);
277
278 size_t num = (container.size() - 1) / per_num;//每3个插入计算得出:9 -> 2; 11 -> 3
279 T ret;
280 ret.resize(num + container.size());
281
282 size_t i = 0;
283 auto iter = container.rbegin();
284 auto iter_ret = ret.rbegin();
285 while (iter != container.rend())
286 {
287 *iter_ret++ = *iter++;
288 ++i;
289 //满per_num额外加入一个v,且不为最后一个
290 if (i % per_num == 0
291 && i < container.size())
292 *iter_ret++ = v;
293 }
294
295 return ret;
296}
297
312template<typename T, typename V>
313void split(const T& container, V delimiter, std::vector<T>& ret)
314{
315 if (container.empty())
316 return;
317
318 //主迭代器位置
319 auto iter_begin = container.begin();
320
321 while (true)
322 {
323 //当前位置就是分隔符,则添加 空元素
324 if (*iter_begin == delimiter)
325 {
326 ret.push_back(T());
327 if (++iter_begin == container.end())
328 {
329 ret.push_back(T());//还要额外添加一个
330 return;
331 }
332 }
333 else
334 {
335 //分隔符位置
336 auto iter_find = std::find(iter_begin, container.end(), delimiter);
337
338 if (iter_find == container.end())
339 {//分隔符 未找到(说明字符串读完了,最后没有分隔符的情况)
340 ret.push_back(T(iter_begin, container.end()));
341 return;
342 }
343 else
344 {
345 ret.push_back(T(iter_begin, iter_find));
346 iter_begin = iter_find + 1;
347 if (iter_begin == container.end())
348 {
349 ret.push_back(T(iter_begin, container.end()));
350 return;
351 }
352 }
353 }
354 }
355}
356
369template<typename T, typename V>
370void split_no_empty(const T& container, V delimiter, std::vector<T>& ret)
371{
372 if (container.empty())
373 return;
374
375 //主迭代器位置
376 auto iter_begin = container.begin();
377
378 while (true)
379 {
380 //当前位置就是分隔符,不添加 空元素,只往后移动
381 if (*iter_begin == delimiter)
382 {
383 if (++iter_begin == container.end())
384 return;
385 }
386 else
387 {
388 //分隔符位置
389 auto iter_find = find(iter_begin, container.end(), delimiter);
390
391 if (iter_find == container.end())
392 {//分隔符 未找到(说明字符串读完了,最后没有分隔符的情况)
393 ret.push_back(T(iter_begin, container.end()));
394 return;
395 }
396 else
397 {
398 ret.push_back(T(iter_begin, iter_find));
399 iter_begin = iter_find + 1;
400 if (iter_begin == container.end())
401 return;
402 }
403 }
404 }
405}
406
416template<typename T>
417void split_sub(const T& container, const T& delimiter, std::vector<T>& ret)
418{
419 if (container.empty())
420 return;
421 assert(!delimiter.empty());
422
423 auto iter_pre = container.begin();
424 auto iter_d = delimiter.begin();
425
426 bool mode_d = false;//是否匹配分隔符中
427 auto iter_cur = iter_pre;
428
429 auto iter_cat = iter_pre;//开始匹配分隔符的位置
430
431 while (true)
432 {
433 if (!mode_d)
434 {//正常模式
435 if (*iter_cur == *iter_d)
436 {//匹配到分隔符首个,进入匹配模式
437 mode_d = true;
438 iter_cat = iter_cur;
439 ++iter_cur;
440 ++iter_d;
441 continue;
442 }
443 else
444 {
445 ++iter_cur;
446 if (iter_cur == container.end())
447 {
448 ret.push_back(T(iter_pre, iter_cur));
449 return;
450 }
451 }
452 }
453 else
454 {//匹配模式
455 if (iter_d == delimiter.end())
456 {//完全匹配分隔符
457 ret.push_back(T(iter_pre, iter_cat));
458 mode_d = false;
459 iter_d = delimiter.begin();
460 iter_pre = iter_cur;
461 continue;
462 }
463
464 if (iter_cur == container.end())
465 {//字符结束,未完全匹配
466 ret.push_back(T(iter_pre, iter_cur));
467 return;
468 }
469
470 if (*iter_cur == *iter_d)
471 {//当前匹配
472 ++iter_cur;
473 ++iter_d;
474 continue;
475 }
476 else
477 {//不匹配,进入普通模式
478 mode_d = false;
479 iter_d = delimiter.begin();
480 continue;
481 }
482 }
483 }
484}
485
491template<typename T, typename V>
492void make_sequence(T& c, const std::initializer_list<std::initializer_list<V>>& vec)
493{
494 for (auto& iter : vec)
495 {
496 assert(iter.size() == 2);
497 V f = *iter.begin();
498 const V& b = *(iter.begin() + 1);
499 assert(f < b);
500 while (f < b)
501 {
502 c.push_back(f++);
503 }
504 }
505}
506
515template<typename C, typename F>
516void for_couple(const C& container, F func, bool ring = false)
517{
518 if (container.empty())
519 {
520 return;
521 }
522
523 auto iter_pre = std::begin(container);
524 auto iter_cur = std::next(iter_pre);
525
526 for (; iter_cur != std::end(container);)
527 {
528 func(*iter_pre, *iter_cur);
529 ++iter_pre;
530 ++iter_cur;
531 }
532 if (ring)
533 func(*iter_pre, *std::begin(container));
534}
535
540template<typename C, typename F>
541void for_couple_r(const C& container, F func, bool ring = false)
542{
543 if (container.empty())
544 {
545 return;
546 }
547
548 auto iter_pre = std::rbegin(container);
549 auto iter_cur = std::next(iter_pre);
550
551 for (; iter_cur != std::rend(container);)
552 {
553 func(*iter_pre, *iter_cur);
554 ++iter_pre;
555 ++iter_cur;
556 }
557 if (ring)
558 func(*iter_pre, *std::rbegin(container));
559}
560
569template<IsPointer T, typename FC, typename F>
570void for_tree(T root, FC func_child, F func)
571{
572 std::stack<T> s;
573 s.push(root);
574
575 while (!s.empty())
576 {
577 T node_this = s.top();
578 s.pop();
579 func(node_this);
580
581 //反向添加,这样左子树先遍历
582 using C = decltype(func_child(node_this));
583 C c = func_child(node_this);
584 for (auto iter = c->rbegin(); iter != c->rend(); ++iter)
585 {
586 T& node = *iter;
587 s.push(node);
588 }
589 }
590}
591
595template<typename F>
597{
598public:
599 finally(F&& func) : _func(func) {}
600 ~finally() { _func(); }
601private:
602 F _func;
603};
604
609/*template<typename T, size_t N>
610[[deprecated]]
611constexpr size_t arr_size(const T(&)[N])
612{
613 return N;
614}*/
615
616
620template<typename T, size_t N>
621constexpr T& arr_last(const T(&arr)[N])
622{
623 return arr[N - 1];
624}
625
629template<IsSigned T>
630constexpr T sign(const T& v)
631{
632 if (v > 0)
633 return 1;
634 else if (v < 0)
635 return -1;
636 else
637 return 0;
638}
639
640
648template<size_t N>
649consteval uint64_t str_uid(const char(&str)[N])
650{
651 //64 / 6 = 10 再加1结束符
652 static_assert(N > 0 && N <= 11, "字符串长度过长!");
653 uint64_t ret = 0;
654 for (size_t i = 0; i < N - 1; ++i)
655 {
656 char ch = str[i];
657
658 if (ch >= 48 && ch <= 57)
659 ch += 6;//0-9
660 else if (ch >= 65 && ch <= 90)
661 ch -= 65;//A-Z
662 else if (ch >= 97 && ch <= 122)
663 ch -= 71;//a-z
664 else if (ch == 95)
665 ch = 62;
666 else if (ch == 46)
667 ch = 63;
668 else
669 assert(0 && "只能是字母、数字、下划线、点!");
670
671 ret |= ((uint64_t)ch << (i * 6));
672 }
673 return ret;
674}
675}
类似std::array,增加xyzw、wh等成员访问
用于模板限定,更好的报错信息
T r_insert_per_num(const T &container, V v, size_t per_num)
从后面往前,隔n个元素就插入1个值,首尾不会出现分割符
T * pointer(T &&x)
查找算法
void split_no_empty(const T &container, V delimiter, std::vector< T > &ret)
以 元素 分割 容器
bool limit_bigger(Array< T, N > &a, const Array< T, N > &limit)
限制到大于某个值,如果修改了原值则返回true
void for_couple(const C &container, F func, bool ring=false)
成对遍历
void for_tree(T root, FC func_child, F func)
遍历树(使用栈,深度优先)
T cast_dynamic(void *p)
动态类型强转
void split_sub(const T &container, const T &delimiter, std::vector< T > &ret)
以 子串 分割 容器
constexpr T is_saturate(const T &x)
是否数值在[0, 1]
const T & as_const(T &a)
void for_couple_r(const C &container, F func, bool ring=false)
反向成对遍历
void make_sequence(T &c, const std::initializer_list< std::initializer_list< V > > &vec)
生成序列
void split(const T &container, V delimiter, std::vector< T > &ret)
以 元素 分割 容器
void operate_front(C &container, F func)
从容器container不断取出第一个元素,执行操作
const T & constant(T &v)
加上const修饰
constexpr Array< T, 3 > cross(const Array< T, 3 > &a, const Array< T, 3 > &b)
向量叉乘
constexpr T sign(const T &v)
返回符号,正数返回1、负数返回-1、0返回0
consteval uint64_t str_uid(const char(&str)[N])
固定条件的字符串,生成唯一id
T insert_per_num(const T &container, V v, size_t per_num)
隔n个元素就插入1个分割符,首尾不会出现分割符
constexpr T saturate(const T &x)
限制数值到 [0, 1]
void erase_head_from_last(T &container, const V &a)
从容器container中移除 最后 匹配到的a元素 之前(包含a)的所有元素,如果没有匹配到,则什么都不做。
auto find_equal(C &container)
替换容器元素值
constexpr T & arr_last(const T(&arr)[N])
返回静态数组长度