//-*-C++-*-//由autodoc自动生成//====~====头文件src/sort/bsearch.h：==========ulong bsearch（常数类型*f，ulong n，常数类型v）；//返回f[]中等于v的第一个元素的索引//如果没有这样的元素，则返回n。//f[]必须按升序排序。//必须有n=0ulong bsearch_geq（常数类型*f，ulong n，常数类型v）；//返回f[]中>=v的第一个元素的索引//如果没有这样的元素，则返回n。//f[]必须按升序排序。//必须有n=0ulong bsearch_leq（常数类型*f，ulong n，常数类型v）；//返回f[]中<=v的第一个元素的索引//如果没有这样的元素，则返回n（设置了所有位的字）。//f[]必须按升序排序。//必须有n=0//====~====头文件src/sort/bsearchapprox.h:==========ulong bsearch_approx（常数类型*f，ulong n，常数类型v，类型da）；//返回f[]中第一个元素x的索引，其中|（x-v）|<=da//如果没有这样的元素，则返回n。//f[]必须按升序排序。//da必须是正数。////只有不精确的类型（float或double）才有意义。//必须有n=0ulong bsearch_approx（常数类型*f，ulong n，常数类型v，类型da，；int（*cmp）（常量类型&，常量类型&）////返回f[]中第一个元素x的索引，其中|（x-v）|<=da//关于比较函数cmp（）。//如果没有这样的元素，则返回n。//f[]必须按升序排序。//da必须是正数。////只有不精确的类型（float或double）才有意义。//必须有n=0//====~====头文件src/sort/bsearchfunc.h：==========ulong bsearch（常数类型*f，ulong n，常数类型v，；int（*cmp）（常量类型&，常量类型&）//返回f[]中第一个元素的索引，即==v//如果没有这样的元素，则返回n//f[]必须按升序排序//必须有n=0ulong bsearch_geq（常数类型*f，ulong n，常数类型v，；int（*cmp）（常量类型&，常量类型&））//返回f[]中>=v的第一个元素的索引//如果没有这样的元素，则返回n//f[]必须按升序排序//必须有n=0ulong bsearch_leq（常数类型*f，ulong n，常数类型v，；int（*cmp）（常量类型&，常量类型&）//返回f[]中第一个元素的索引，即<=v//如果没有这样的元素，则返回n//f[]必须按升序排序//必须有n=0//====~====头文件src/sort/bsearchidx.h:==========ulong idx_bsearch（const类型*f，ulong n，const ulong*x，const类型v）；//返回最小i，使f[x[i]]==v。//如果没有这样的i，则返回n。//f[x[]]必须按升序（index-）排序：//f[x[i]]<=f[x[i+i]]//必须有n=0ulong idx_bsearch_geq（const类型*f，ulong n，const ulong*x，const类型v）；//返回最小i，使f[x[i]]>=v。//如果没有这样的i，则返回n。//f[x[]]必须按升序（index-）排序：//f[x[i]]<=f[x[i+i]]//必须有n=0//====~====头文件src/sort/bsearchidxfunc.h：==========ulong idx_bsearch（const类型*f，ulong n，const ulong*x，const类型v，；int（*cmp）（常量类型&，常量类型&）//返回f[]中第一个元素的index-ptr i，即==v//即f[x[i]]==v，其中i最小。//如果没有这样的元素，则返回n//f[x[]]必须按升序（index-）排序：//f[x[i]]<=f[x[i+i]]//必须有n=0ulong idx_bsearch_geq（const类型*f，ulong n，const ulong*x，const类型v，；int（*cmp）（常量类型&，常量类型&）//返回f[]中>=v的第一个元素的index-ptr//即f[x[i]]>=v，其中i最小。//如果没有这样的元素，则返回n//f[x[]]必须按升序（index-）排序：//f[x[i]]<=f[x[i+i]]//必须有n=0//====~====头文件src/sort/bsearchptr.h:==========ulong ptr_bsearch（/*const类型*f，*/ulong n，类型const*const*x，const类型v）；//将ptr i的索引返回到f[]中的第一个元素，即==v//即*x[i]==v，其中i最小。//如果没有这样的元素，则返回n//x[]必须按升序（ptr-）排序：//*x[i]<=*x[i+i]//必须有n=0ulong ptr_bsearch_geq（/*const类型*f，*/ulong n，类型const*const*x，const类型v）；//返回f[]中第一个元素的ptr索引，该索引大于等于v//即*x[i]>=v，其中i最小。//如果没有这样的元素，则返回n//x[]必须按升序（ptr-）排序：//*x[i]<=*x[i+i]//必须有n=0//====~====头文件src/sort/bsearchptrfunc.h:==========ulong ptr_bsearch（/*const类型*f，*/ulong n，类型const*const*x，const类型v，；int（*cmp）（常量类型&，常量类型&）//将ptr i的索引返回到f[]中的第一个元素，即==v//即*x[i]==v，其中i最小。//如果没有这样的元素，则返回n。//x[]必须按升序（ptr-）排序：//*x[i]<=*x[i+i]//必须有n=0ulong ptr_bsearch_geq（/*const类型*f，*/ulong n，类型const*const*x，const类型v，；int（*cmp）（常量类型&，常量类型&）//返回f[]中第一个元素的ptr索引，该索引大于等于v//即*x[i]>=v，其中i最小。//如果没有这样的元素，则返回n//x[]必须按升序（ptr-）排序：//*x[i]<=*x[i+i]//必须有n=0//====~====头文件src/sort/overbal.h:==========ulong test_stritly_convertive（常数类型*f，ulong n）；//严格凸序列最大值的返回指数，//否则返回0。//“严格凸”的意思是“强单峰”//是序列中的至少一个上台阶和下台阶。ulong test_stritly_凹面（常数类型*f，ulong n）；//严格凹序列的最小返回指数，//否则返回0bool是_strictly_convertive（常数类型*f，ulong n）；bool is _strictly_in凹（常量类型*f，ulong n）；bool是_weakly_occulf（常数类型*f，ulong n）；//返回序列是否弱凸（弱单峰）。bool为_weakly_in凹（常数类型*f，ulong n）；//返回序列是否弱凹。//====~====头文件src/sort/equivclasses.h:==========void equivalence_classes（const类型*s，ulong n，bool（*equiv_q）（类型，类型），ulong*q）；//给定等价关系“==”（作为函数equiv_q（））//和具有n个元素的集合s[]，//将第一个元素s[j]的索引j写入q[k]，使s[k]==s[j]。//对于复杂性C:n<=C<=n*n//C=n*n，如果每个元素都在自己的类中//C=n，如果所有元素都在同一类中//====~====头文件src/sort/heapsort.h：==========void heap_sort（类型*x，ulong n）；//将x[]按升序排序。void heap_sort_descending（类型*x，ulong n）；//将x[]按降序排序。//====~====头文件src/sort/merge-sort.h：==========void merge（const Type*const restrict f，ulong na，ulong-nb，Type*const-restrict t）；//合并（排序的）数组//A[]：=f[0]，f[1]。。。，f[na-1]和B[]：=f[na]，f[na+1]。。。，f[na+nb-1]//转换为t[]：=t[0]，t[1]。。。，t[na+nb-1]，使得t[]被排序。//必须具有：na>=1和nb>=1void merge_sort_rec（类型*f，ulong n，类型*t）；void merge_sort（类型*f，ulong n，类型*tmp=nullptr）；void merge_sort_rec4（类型*f，ulong n，类型*t）；void merge_sort4（类型*f，ulong n，类型*tmp=nullptr）；//===========标题文件src/sort/minmax.h：==========内联类型min（常量类型*f，ulong n）；//返回数组的最小值。inline ulong min_idx（常量类型*f，ulong n）；//返回数组最小值的索引。inline Type max（常量类型*f，ulong n）；//返回数组的最大值。inline ulong max_idx（常量类型*f，ulong n）；//返回数组最大值的索引。inline void min_max（常量类型*f，ulong n，类型*mi，类型*ma）；//将*mi设置为数组的最小值//和*ma到数组的最大值。//====~====头文件src/sort/minmaxfunc.h：==========类型min（常量类型*f，ulong，int（*cmp）（常量类型&，常量类型&））；//返回数组元素的最小值//写入比较函数类型max（常量类型*f，ulong n，int（*cmp）（常量类型&，常量类型&））；//返回数组元素的最大值//wrt.到比较函数bool is_partitioned（常量类型*f，ulong n，ulongk，int（*cmp）（常量类型&，常量类型&））；//====~====头文件src/sort/minmaxidx.h:==========类型idx_min（const类型*f，ulong n，const ulong*x）；//返回数组元素的最小值//{f[x[0]]，f[x[1]，…，f[x[n-1]]}类型idx_max（const类型*f，ulong n，const ulong*x）；//返回数组元素的最大值//{f[x[0]]，f[x[1]，…，f[x[n-1]]}bool is_idx_partitioned（const类型*f，ulong n，const ulong*x，ulongk）；//====~====头文件src/sort/minmaxidxfunc.h：==========类型idx_min（const类型*f，ulong n，const ulong*x，；int（*cmp）（常量类型&，常量类型&）//返回数组元素的最小值//{f[x[0]]，f[x[1]，…，f[x[n-1]]}//关于比较函数cmp（）类型idx_max（const类型*f，ulong n，const ulong*x，；int（*cmp）（常量类型&，常量类型&）//返回数组元素的最大值//{f[x[0]]，f[x[1]，…，f[x[n-1]]}//关于比较函数cmp（）bool is_idx_partitioned（常量类型*f，ulong n，常量ulong*x，ulong k，；int（*cmp）（常量类型&，常量类型&））//====~====头文件src/sort/minmaxmed23.h：==========//最小值和最大值为2或3个元素//3个元素的最小值、最大值和中间值静态内联类型min2（常量类型&x，常量类型&y）；//返回输入值的最小值静态内联类型max2（常量类型&x，常量类型&y）；//返回输入值的最大值静态内联类型min3（常量类型&x，常量类型&y，常量类型&z）；//返回输入值的最小值静态内联类型max3（常量类型&x，常量类型&y，常量类型&z）；//返回输入值的最大值静态内联类型median3（常量类型&x，常量类型&y，常量类型&z）；//返回输入值的中值//====~====头文件src/sort/minmaxmed23func.h：==========//最小值和最大值为2或3个元素，具有比较功能//3个元素的最小值、最大值和中值，具有比较功能静态内联类型min2（常量类型&x，常量类型&y，；int（*cmp）（常量类型&，常量类型&）//返回输入值wrt.cmp（）的最小值静态内联类型max2（常量类型&x，常量类型&y，；int（*cmp）（常量类型&，常量类型&）//返回输入值wrt.cmp（）的最大值类型min3（常量类型&x，常量类型&y，常量类型&z，；int（*cmp）（常量类型&，常量类型&）//返回输入值wrt.cmp（）的最小值类型max3（常量类型&x，常量类型&y，常量类型&z，；int（*cmp）（常量类型&，常量类型&）//返回输入值wrt.cmp（）的最大值类型median3（常量类型&x，常量类型&y，常量类型&z，；int（*cmp）（常量类型&，常量类型&）//返回输入值wrt.cmp（）的中值常量类型*median3_ptr（常量类型*x，常量类型*y，常量类型*z，；int（*cmp）（常量类型&，常量类型&）//返回输入值wrt.cmp（）的中值//====~====头文件src/sort/minmaxmed23idx.h:==========//最少和最多2或3个元素，索引版本//3个元素的最小值、最大值和中值，索引版本静态内联ulong idx_min2（常量类型&x，常量类型&y）；//返回输入值最小值的索引（0或1）静态内联ulong idx_max2（常量类型&x，常量类型&y）；//返回输入值最大值的索引（0或1）静态内联ulong idx_min3（常量类型&x，常量类型&y，常量类型&z）；//返回输入值最小值的索引（0,1或2）静态内联ulong idx_max3（常量类型&x，常量类型&y，常量类型&z）；//返回输入值最大值的索引（0,1或2）静态内联void idx_minmax3（类型x0，类型x1，类型x2，ulong&i，ulong/a）；//将i、a分别设置为最小值和最大值的索引（0,1或2）。//.//待办事项：优化静态内联ulong idx_median3（常量类型&x，常量类型&y，常量类型&z）；//输入值中值的返回指数（0,1或2）//====~====头文件src/sort/minmaxptr.h:==========类型ptr_min（/*const类型*f，*/ulong n，类型const*const*x）；//返回数组元素的最小值//{*x[0]，*x[1]，…，*x[n-1]}类型ptr_max（/*const类型*f，*/ulong n，类型const*const*x）；//返回数组元素的最大值//{*x[0]，*x[1]，…，*x[n-1]}bool is_ptr_partitioned（/*const类型*f，*/ulong n，类型const*const*x，ulong k）；//====~====头文件src/sort/minmaxptrfunc.h:==========类型*ptr_min（/*const类型*f，*/ulong n，类型const*const*x，；int（*cmp）（常量类型&，常量类型&）//返回数组元素的最小值//{*x[0]，*x[1]，…，*x[n-1]}//关于比较函数cmp（）。类型*ptr_max（/*const类型*f，*/ulong n，类型const*const*x，；int（*cmp）（常量类型&，常量类型&）//返回数组元素的最大值//{*x[0]，*x[1]，…，*x[n-1]}//关于比较函数cmp（）。bool is_ptr_partitioned（/*const类型*f，*/ulong n，类型const*const*x，ulong k，；int（*cmp）（常量类型&，常量类型&）//====~====头文件src/sort/quantize.h：==========无效量化（类型*f，ulong n，双q）；//在f[]中，将每个元素x设置为q*floor（1/q*（x+q/2））//例如：q=1===四舍五入到最接近的整数//q=1/1000==>四舍五入到1/1000的最接近倍数//对于不精确类型（float或double）。//====~====头文件src/sort/radidsort.h：==========//-----SRCFILE=src/sort/radidsort.cc：-----布尔is_counting_sorted（constulong*f，ulongn，ulong b0，ulongm）；//是否对f[]进行排序，。。。，b0+z-1//其中z是以m为单位设置的位数。//m必须包含从零位开始的单次位运行。void counting_sort_core（constulong*限制f，ulong n，ulong*限制g，ulong b0、，乌隆）；//写入g[]数组f[]排序的wrt.bits b0，。。。，b0+z-1//其中z是以m为单位设置的位数。//m必须包含从零位开始的单次位运行。无效基数排序（ulong*f，ulong n）；//====~====头文件src/sort/sort.h:==========bool is_sorted（常量类型*f，ulong n）；//返回序列f[0]，f[1]。。。，f[n-1]在中排序//升序（实际上是非降序）。bool is_sorted_desc（常量类型*f，ulong n）；//返回序列f[0]，f[1]。。。，f[n-1]在中排序//降序（实际上是非增量）。void selection_sort（类型*f，ulong n）；//排序f[]（升序）。//算法为O（n*n），仅用于短数组。bool is_partitioned（常量类型*f，ulong n，ulongk）；//返回是否//最大值（f[0]，…，f[p]）<=最小值（f[p+1]，……，f[n-1]）ulong分区（类型*f，ulong n）；//重新排列数组，以便对某些索引p//max（f[0]，…，f[p]）<=最小值（f[p+1]，…，f[n-1]）void quick_sort（类型*f，ulong n）；//排序f[]（升序）。//====~====头文件src/sort/sort23.h：==========//排序2或3个元素静态内联void sort2（类型&x1，类型&x2）；//排序x1，x2静态内联无效排序3（类型&x0，类型&x1，类型&x2）；//排序x0、x1、x2//{排序2（x0，x1）；排序2（x1，x2）；分类2（x0,1）；}//====~====头文件src/sort/sort23func.h：==========//排序2或3个元素，具有比较功能inline void sort2（类型&x1，类型&x2，；int（*cmp）（常量类型&，常量类型&）//排序x1，x2 wrt.cmp（）inline void sort3（类型&x0，类型&x1，类型&x2，；int（*cmp）（常量类型&，常量类型&）//排序x0、x1、x2//=^={排序2（x0，x1）；排序2（x1，x2）//====~====头文件src/sort/sortbykey.h：==========void sort_by_key（类型1*f，ulong n，类型2*key，ulong*tmp=nullptr，bool skq=true）；//根据键[]按升序对f[]进行排序：//如果键[k]，则f[k]在f[j]之前[1, 3, 4, 5, 8]//该例程也适用于未排序的数组，只要//因为相同的元素只出现在相邻的块中。//示例：[4、4、3、7、7]-->[4、3和7]//订单保留。//====~====头文件src/sort/uniquefunc.h：==========ulong test_unique（常量类型*f，ulong n，int（*cmp）（常量类型&，常量类型&））；//对于排序数组测试，所有值是否唯一//（即是否没有重复值）。//如果所有值都是唯一的，则返回0，否则返回第二个值的索引//找到第一对中的元素。bool is_unique（常量类型*f，ulong n，int（*cmp）（常量类型&，常量类型&））；//对于排序数组测试，所有值是否唯一////如果所有值都是唯一的，则返回true，否则返回false。ulong count_unique（常数类型*f，ulong n，int（*cmp）（常数类型&，常数类型&））；//对于排序数组，返回唯一值的数目//重复的次数（不一定不同）//值为n-unique_count（f，n）；ulong唯一（类型*f，ulong n，int（*cmp）（常量类型&，常量类型&））；//对于排序数组，压缩所有重复值//并返回唯一值的数量。//示例：[1，3，3，4，5，8，8]-->[1，3,4,5,8]//该例程也适用于未排序的数组，只要//因为相同的元素只出现在相邻的块中。//示例：[4、4、3、7、7]-->[4、3和7]//订单保留。//====~====头文件src/sort/usearch.h：==========inline ulong first_eq_idx（常量类型*f，ulong n，类型v）；//第一个元素的返回索引==v//如果全部返回n=v（v）inline ulong first_eq_idx_large（常量类型*f，ulong n，类型v）；//第一个元素的返回索引==v//如果全部返回n=v（v）//大型阵列的未滚动版本。inline ulong first_neq_idx（常量类型*f，ulong n，类型v）；//返回第一个元素的索引！=v（v）//如果all==v，则返回ninline ulong first_geq_idx（常量类型*f，ulong n，类型v）；//第一个元素的返回索引>=v//如果找不到此类元素，则返回ninline ulong first_leq_idx（常量类型*f，ulong n，类型v）；//第一个元素的返回索引<=v//如果找不到此类元素，则返回ninline ulong last_eq_idx（常量类型*f，ulong n，类型v）；//最后一个元素的返回索引==v//如果全部返回n=v（v）inline ulong last_neq_idx（常量类型*f，ulong n，类型v）；//返回最后一个元素的索引！=v（v）//如果all==v，则返回ninline ulong last_geq_idx（常量类型*f，ulong n，类型v）；//最后一个元素的返回索引>=v//如果全部返回nv（v）bool u_unique（常量类型*f，ulong n）；//返回无序数组f[]中的元素是否唯一。//算法为O（n^2），因此仅用于小n。