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