モド 昇順ソート後のインデックス配列
    降順ソートはこのreverseをとる
    key_columns は2次元配列の場合のキー列指定 Array(0,2,4)
    対象配列を実際にソートする場合は、permutate(配列, sortIndex) とするか、
    もしくはsubV(配列, sortIndex) を取る
Function sortIndex(ByRef matrix As Variant, Optional ByRef key_columns As Variant) As Variant
 
    Public Function p_sortIndex(
 
seed_engine
m = uniform_int_dist(20,1,10)
printM m
  4  2  2  9  10  7  8  8  10  8  10  6  10  9  2  6  6  6  8  7
s = sortindex(m)
printM s
  1  2  14  0  11  15  16  17  5  19  6  7  9  18  3  13  4  8  10  12
 
m = makeM(10, 3, uniform_int_dist(30,1,10))
printM m
  10   5  10
   6   6   5
   5   2   6
モド    8   2   5
   7   4  10
  10   5   3
   9   8   4
   4   3   1           ← 最小サイショウ @7
  10  10   4           ← 最ダイ @8
  10   5   1
s = sortindex(m)             ← 3レツヒダリ優先ユウセン比較ヒカク対象タイショウとする
printM s
  7  2  1  4  3  6  9  5  0  8
 
s = sortindex(m, Array(1, 0))         ← 1列、0列目をそのジュンに比較する
printM s
  2  3  7  4  0  5  9  1  6  8
任意の比較関数 comp によるソート後のインデックス配列
Function sortIndex_pred(ByRef matrix As Variant, ByRef comp As Variant) As Variant
 
    Public Function p_sortIndex_pred(
 
seed_engine
m = makeM(10, 3, uniform_int_dist(30,1,10))
printM m
  3   3  1
モド   1   3  8           ← 最小 @1
  2   8  5
  4   7  9
  6   1  3
  8   4  6           ← 最ダイ @5
  5   2  2
  7   3  1
  5   3  6
  6  10  8
s = sortIndex_pred(zipC(m), p_greater_dic)          ← カクギョウ辞書ジショシキ降順コウジュン比較ヒカク
printM  s
  5  7  9  4  8  6  3  0  2  1
1次元配列 vec の並べ換え
    s_index は sortIndex 関数、もしくは sortIndex_pred 関数の返り値を想定
    s_index に vec の範囲外の値もしくは重複があった場合の動作は未定義
    (subV/subM 関数を使うより速いはず)
Sub permutate(ByRef vec As Variant, ByRef s_index As Variant)
 
m = Array(0, "A", 2, "B", 3)
printM m
  0  A  2  B  4
permutate m, Array(3, 0, 2, 4, 1)
printM m
  B  0  2  4  A
モド permutate で並べ換えられた1次元配列を元の順列に戻す
Sub permutate_back(ByRef vec As Variant, ByRef s_index As Variant)
ソート済み配列から指定された要素以上の値が現れる最初の位置を取得
    (std::lower_boundと同じ)
Function lower_bound(ByRef matrix As Variant, ByRef val As Variant) As Variant
 
    Public Function p_lower_bound(
 
seed_engine
m = uniform_int_dist(20,1,10)
permutate m, sortindex(m)            ← 実際ジッサイにソートする
printM m
  1  1  1  2  2  3  3  4  5  5  5  5  5  5  5  6  6  8  9  10
? lower_bound(m, 5)
8
?m(7), m(8)
 4             5 
ソート済み配列から指定された要素以上の値が現れる最初の位置を取得(比較関数使用)
    (std::lower_boundと同じ)
Function lower_bound_pred(ByRef matrix As Variant, ByRef val As Variant, _
                                        ByRef pred As Variant) As Variant
モド  
    Public Function p_lower_bound_pred(
これは通常の関数オブジェクトとは異なる(比較関数のみを引数に取る)
mapF_swap(p_lower_bound_pred(comp), matrix, values) という使用方法を想定
 
seed_engine
m = uniform_int_dist(20,1,10)
permutate m, sortindex_pred(m, p_greater)         降順コウジュンでソートする
printM m
  10  10  10  9  9  8  7  7  6  6  5  5  4  3  3  3  2  1  1  1
printM  mapF_swap(p_lower_bound_pred(p_greater), m, Array(2, 6, 9, 0))
  16  8  3  20
ソート済み配列から指定された要素より大きい値が現れる最初の位置を取得
    (std::upper_boundと同じ)
Function upper_bound(ByRef matrix As Variant, ByRef val As Variant) As Variant
 
    Public Function p_upper_bound(
 
seed_engine
m = uniform_int_dist(20,1,10)
permutate m, sortindex(m)            ← 実際ジッサイにソートする
printM m
  1  1  1  2  2  3  3  4  5  5  5  5  5  5  5  6  6  8  9  10
?upper_bound(m, 5)
モド 15
?m(14), m(15)
 5             6 
ソート済み配列から指定された要素より大きい値が現れる最初の位置を取得(比較関数使用)
    (std::upper_boundと同じ)
Function upper_bound_pred(ByRef matrix As Variant, ByRef val As Variant, _
                                        ByRef pred As Variant) As Variant
 
    Public Function p_upper_bound_pred(
これは通常の関数オブジェクトとは異なる(比較関数のみを引数に取る)
mapF_swap(p_upper_bound_pred(comp), matrix, values) という使用方法を想定
lower_boundとupper_boundの組
    (std::equal_rangeと同じ)
Function equal_range(ByRef matrix As Variant, ByRef val As Variant) As Variant
 
    Public Function p_equal_range(
 
seed_engine
m = uniform_int_dist(20,1,10)
permutate m, sortindex(m)            ← 実際ジッサイにソートする
printM m
  1  1  1  2  2  3  3  4  5  5  5  5  5  5  5  6  6  8  9  10
printM  equal_range(m, 5)
モド   8  15            ← [8, 15) の区間クカン : 5にヒトしい要素ヨウソが7個
printM  equal_range(m, 7)
  17  17            ← [17, 17) の区間 : 7に等しい要素が0個
lower_boundとupper_boundの組(比較関数使用)
Function equal_range_pred(ByRef matrix As Variant, _
                                        ByRef val As Variant, _
                                        ByRef pred As Variant) As Variant
 
    Public Function p_equal_range_pred(
これは通常の関数オブジェクトとは異なる(比較関数のみを引数に取る)
mapF_swap(p_equal_range_pred(comp), matrix, values) という使用方法を想定
ソート済み配列から条件によって区分化されている位置の一覧を得る
Function partition_points(ByRef vec As Variant) As Variant
 
printM m
  1  1  1  2  3  3  3  4  5  5  6  6  7  7  8  9  9  10  10  10
pp = partition_points(m)
モド printM pp
  0  3  4  7  8  10  12  14  15  17  20            最後サイゴの20はUBound + 1
printM_   adjacent_op(p_a__o, pp)              同一ドウイツアタイツヅくインデックス範囲ハンイ集合シュウゴウ
  0  1  2
  3
  4  5  6
  7
  8  9
  10  11
  12  13
  14
  15  16
  17  18  19
ソート済み配列から条件によって区分化されている位置の一覧を得る(比較ヒカク関数カンスウ使用シヨウ
Function partition_points_pred(ByRef vec As Variant, ByRef pred As Variant) As Variant
述語 辞書式less ( < )
Function less_dic(ByRef a As Variant, ByRef b As Variant) As Variant
 
モド     Function p_less_dic(
 
?less_dic(Array(1,2,3), Array(1,2,4))
1
?less_dic(Array(1,2,3), Array(1,0,4))
0
述語 辞書式less_equal ( <= )
Function less_equal_dic(ByRef a As Variant, ByRef b As Variant) As Variant
 
    Function p_less_equal_dic(
述語 辞書式greater ( > )
Function greater_dic(ByRef a As Variant, ByRef b As Variant) As Variant
 
    Function p_greater_dic(
述語 辞書式greater_equal ( >= )
Function greater_equal_dic(ByRef a As Variant, ByRef b As Variant) As Variant
 
    Function p_greater_equal_dic(
モド
述語 辞書式equal ( = )
Function equal_dic(ByRef a As Variant, ByRef b As Variant) As Variant
 
    Function p_equal_dic(
述語 辞書式notEqual ( <> )
Function notEqual_dic(ByRef a As Variant, ByRef b As Variant) As Variant
 
    Function p_notEqual_dic(