# sortrows
对矩阵行或表行进行排序。
函数库: TyBase
# 语法
f = sortrows(A)
f = sortrows(A,column)
f = sortrows(___,direction)
f = sortrows(___;Key=Value)
f,index = sortrows(___;nargout = 1)
# 说明
f = sortrows(A) 基于第一列中的元素按升序对矩阵行进行排序。当第一列包含重复的元素时，sortrows 会根据下一列中的值进行排序，并对后续的相等值重复此行为。示例
f = sortrows(A,column) 基于向量 column 中指定的列对 A 进行排序。例如，sortrows(A,4) 会基于第四列中的元素按升序对 A 的行进行排序。sortrows(A,[4 6]) 首先基于第四列中的元素，然后基于第六列中的元素，对 A 的行进行排序。示例
对于上述任意语法，f = sortrows(___,direction) 均按 direction 指定的顺序对 A 的行进行排序。direction 可以是 "ascend"（默认值，对于升序排序）或 "descend"（对于降序排序）。direction 也可以是元素为 "ascend" 和 "descend" 的元组，其中每个元素对应于 sortrows 对其进行运算的一个列。例如，sortrows(A,[4 6],["ascend" "descend"]) 基于第四列按升序对 A 的行进行排序，然后基于第六列按降序排序。示例
f = sortrows(___;Key=Value) 指定用于对行进行排序的其他参数。例如，sortrows(A,comparisonmethod="abs") 按模对 A 的元素进行排序。示例
f,index = sortrows(___;nargout = 1) 还会返回描述行的重新排列的索引向量，以便 f = A(index,:)。示例
# 示例
对矩阵行排序
创建矩阵，并基于第一列中的元素按升序对矩阵行进行排序。当第一列包含重复的元素时，sortrows 会基于第二列中的元素进行排序。对于第二列中的重复元素，sortrows 会基于第三列进行排序，依此类推。
using TyBase
A = [ 95 45 92 41 13 1 84
95 7 73 89 20 74 52
95 7 73 5 19 44 20
95 7 40 35 60 93 67
76 61 93 81 27 46 83
76 79 91 0 19 41 1 ]
A =
6×7 Matrix{Int64}:
95 45 92 41 13 1 84
95 7 73 89 20 74 52
95 7 73 5 19 44 20
95 7 40 35 60 93 67
76 61 93 81 27 46 83
76 79 91 0 19 41 1
B = sortrows(A)
B =
6×7 Matrix{Int64}:
76 61 93 81 27 46 83
76 79 91 0 19 41 1
95 7 40 35 60 93 67
95 7 73 5 19 44 20
95 7 73 89 20 74 52
95 45 92 41 13 1 84
基于第二列中的值对 A 的行排序。当指定的列包含重复元素时，对应的行将保持其原始顺序。
C = sortrows(A, 2)
C =
6×7 Matrix{Int64}:
95 7 73 89 20 74 52
95 7 73 5 19 44 20
95 7 40 35 60 93 67
95 45 92 41 13 1 84
76 61 93 81 27 46 83
76 79 91 0 19 41 1
基于第一列中的元素对 A 的行进行排序，如果第一列中包含相同元素，则按第七列进行排序。
D = sortrows(A, [1 7])
D =
6×7 Matrix{Int64}:
76 79 91 0 19 41 1
76 61 93 81 27 46 83
95 7 73 5 19 44 20
95 7 73 89 20 74 52
95 7 40 35 60 93 67
95 45 92 41 13 1 84
基于第四列中的元素以降序对 A 的行进行排序，并显示输出向量 index 以查看行是如何重新排列的。
E, index = sortrows(A, 4, "descend"; nargout=2)
E =
6×7 Matrix{Int64}:
95 7 73 89 20 74 52
76 61 93 81 27 46 83
95 45 92 41 13 1 84
95 7 40 35 60 93 67
95 7 73 5 19 44 20
76 79 91 0 19 41 1
index =
6-element Vector{Int64}:
2
5
1
4
3
6
复矩阵
创建一个包含复数的矩阵，并基于第一列中的元素按升序对矩阵行进行排序。由于 A[1,1] 和 A[3,1] 的模相等，因此 sortrows 会计算它们的角度以进行排序。
using TyBase
A = [1+2im 3+im im; 2+10im 6im 2+5im; 2+im 4 3+3im]
A =
3×3 Matrix{Complex{Int64}}:
1+2im 3+1im 0+1im
2+10im 0+6im 2+5im
2+1im 4+0im 3+3im
B = sortrows(A)
B =
3×3 Matrix{Complex{Int64}}:
2+1im 4+0im 3+3im
1+2im 3+1im 0+1im
2+10im 0+6im 2+5im
angle(A[1, 1])
ans =
1.1071487177940904
angle(A[3, 1])
ans =
0.4636476090008061
可使用 "real" 选项按 A 行的实部对这些行进行排序。由于 A[2,1] 和 A[3,1] 具有相同的实部，sortrows 将使用虚部进行排序。
C = sortrows(A; comparisonmethod="real")
C =
3×3 Matrix{Complex{Int64}}:
1+2im 3+1im 0+1im
2+1im 4+0im 3+3im
2+10im 0+6im 2+5im
imag(A[2, 1])
ans =
10
imag(A[3, 1])
ans =
1
对字符串数组排序
创建一个 6×2 字符串数组，并对其行进行排序。结果是一个同时按国家/地区和名称排序的字母顺序列表。
using TyBase
A = [ "Germany" "Lukas"
"USA" "William"
"USA" "Andrew"
"Germany" "Andreas"
"USA" "Olivia"
"Germany" "Julia" ]
A =
6×2 Matrix{String}:
"Germany" "Lukas"
"USA" "William"
"USA" "Andrew"
"Germany" "Andreas"
"USA" "Olivia"
"Germany" "Julia"
B = sortrows(A)
B =
6×2 Matrix{String}:
"Germany" "Andreas"
"Germany" "Julia"
"Germany" "Lukas"
"USA" "Andrew"
"USA" "Olivia"
"USA" "William"
按照降序顺序，先对国家/地区进行排序，然后对名称进行排序。
C = sortrows(A, [1 2], ["ascend", "descend"])
C =
6×2 Matrix{String}:
"Germany" "Lukas"
"Germany" "Julia"
"Germany" "Andreas"
"USA" "William"
"USA" "Olivia"
"USA" "Andrew"
对表行排序
按变量值对表行进行排序。
创建一个表，其中包含列出五位病患信息的四个变量。
using TyBase
df1 = DataFrame(
"RowNames" => ["Smith"; "Johnson"; "Williams"; "Jones"; "Brown"],
"Age" => [38; 43; 38; 40; 49],
"Height" => [71; 69; 64; 67; 64],
"Weight" => [176; 163; 131; 133; 119],
"BloodPressure1" => [124; 109; 125; 117; 122],
"BloodPressure2" => [93; 77; 83; 75; 80],
)
df1 =
5×6 DataFrame
Row │ RowNames Age Height Weight BloodPressure1 BloodPressure2
│ String Int64 Int64 Int64 Int64 Int64
─────┼─────────────────────────────────────────────────────────────────
1 │ Smith 38 71 176 124 93
2 │ Johnson 43 69 163 109 77
3 │ Williams 38 64 131 125 83
4 │ Jones 40 67 133 117 75
5 │ Brown 49 64 119 122 80
对该表的行排序。sortrows 函数首先按变量 Age 以升序对行进行排序，然后按变量 Height 对具有相等年龄的两行进行排序。
df2 = sortrows(df1)
df2 =
5×6 DataFrame
Row │ RowNames Age Height Weight BloodPressure1 BloodPressure2
│ String Int64 Int64 Int64 Int64 Int64
─────┼─────────────────────────────────────────────────────────────────
1 │ Williams 38 64 131 125 83
2 │ Smith 38 71 176 124 93
3 │ Jones 40 67 133 117 75
4 │ Johnson 43 69 163 109 77
5 │ Brown 49 64 119 122 80
按行名称对表行排序
创建一个表，其中包含列出五位病患信息的四个变量。
using TyBase
df1 = DataFrame(
"RowNames" => ["Smith"; "Johnson"; "Williams"; "Jones"; "Brown"],
"Age" => [38; 43; 38; 40; 49],
"Height" => [71; 69; 64; 67; 64],
"Weight" => [176; 163; 131; 133; 119],
"BloodPressure1" => [124; 109; 125; 117; 122],
"BloodPressure2" => [93; 77; 83; 75; 80],
)
df1 =
5×6 DataFrame
Row │ RowNames Age Height Weight BloodPressure1 BloodPressure2
│ String Int64 Int64 Int64 Int64 Int64
─────┼─────────────────────────────────────────────────────────────────
1 │ Smith 38 71 176 124 93
2 │ Johnson 43 69 163 109 77
3 │ Williams 38 64 131 125 83
4 │ Jones 40 67 133 117 75
5 │ Brown 49 64 119 122 80
基于行名称按升序对表行进行排序，并返回描述行重新排列方式的索引向量。
df2, index = sortrows(df1, "RowNames"; nargout=2)
df2 =
5×6 DataFrame
Row │ RowNames Age Height Weight BloodPressure1 BloodPressure2
│ String Int64 Int64 Int64 Int64 Int64
─────┼─────────────────────────────────────────────────────────────────
1 │ Brown 49 64 119 122 80
2 │ Johnson 43 69 163 109 77
3 │ Jones 40 67 133 117 75
4 │ Smith 38 71 176 124 93
5 │ Williams 38 64 131 125 83
index =
5-element Vector{Int64}:
5
2
4
1
3
按变量对表行进行排序
创建一个表，其中包含列出五位病患信息的四个变量。
using TyBase
df1 = DataFrame(
"RowNames" => ["Sweet"; "Jacobson"; "Wang"; "Joiner"; "Berger"],
"Age" => [38; 43; 38; 40; 49],
"Height" => [71; 69; 64; 67; 64],
"Weight" => [176; 163; 131; 133; 119],
"BloodPressure1" => [124; 109; 125; 117; 122],
"BloodPressure2" => [93; 77; 83; 75; 80],
)
df1 =
5×6 DataFrame
Row │ RowNames Age Height Weight BloodPressure1 BloodPressure2
│ String Int64 Int64 Int64 Int64 Int64
─────┼─────────────────────────────────────────────────────────────────
1 │ Sweet 38 71 176 124 93
2 │ Jacobson 43 69 163 109 77
3 │ Wang 38 64 131 125 83
4 │ Joiner 40 67 133 117 75
5 │ Berger 49 64 119 122 80
按 Height 以升序对表行排序，然后按 Weight 以降序排序。
df2 = sortrows(df1, ["Height", "Weight"], ["ascend", "descend"])
df2 =
5×6 DataFrame
Row │ RowNames Age Height Weight BloodPressure1 BloodPressure2
│ String Int64 Int64 Int64 Int64 Int64
─────┼─────────────────────────────────────────────────────────────────
1 │ Wang 38 64 131 125 83
2 │ Berger 49 64 119 122 80
3 │ Joiner 40 67 133 117 75
4 │ Jacobson 43 69 163 109 77
5 │ Sweet 38 71 176 124 93
包含缺失元素的表
创建一个表，其中包含列出五位病患信息的四个变量。Weight 变量包含缺失值。
using TyBase
df1 = DataFrame(
"RowNames" => ["Sweet"; "Jacobson"; "Wang"; "Joiner"; "Berger"],
"Age" => [38; 43; 38; 40; 49],
"Height" => [71; 69; 64; 67; 64],
"Weight" => [176; NaN; 131; 133; NaN],
"BloodPressure1" => [124; 109; 125; 117; 122],
"BloodPressure2" => [93; 77; 83; 75; 80],
)
df1 =
5×6 DataFrame
Row │ RowNames Age Height Weight BloodPressure1 BloodPressure2
│ String Int64 Int64 Float64 Int64 Int64
─────┼──────────────────────────────────────────────────────────────────
1 │ Sweet 38 71 176.0 124 93
2 │ Jacobson 43 69 NaN 109 77
3 │ Wang 38 64 131.0 125 83
4 │ Joiner 40 67 133.0 117 75
5 │ Berger 49 64 NaN 122 80
按 Weight 以升序对表行进行排序，将包含 NaN 的行放在最前面。
df2 = sortrows(df1, "Weight"; missingplacement="first")
df2 =
5×6 DataFrame
Row │ RowNames Age Height Weight BloodPressure1 BloodPressure2
│ String Int64 Int64 Float64 Int64 Int64
─────┼──────────────────────────────────────────────────────────────────
1 │ Jacobson 43 69 NaN 109 77
2 │ Berger 49 64 NaN 122 80
3 │ Wang 38 64 131.0 125 83
4 │ Joiner 40 67 133.0 117 75
5 │ Sweet 38 71 176.0 124 93
对时间表行进行排序
创建一个时间表，并按行时间对行进行排序。
using TyBase
TT = DataFrame(;
TimeDuration=[Hour(3), Hour(2), Hour(1), Hour(5), Hour(6)],
Var1=[98; 97.5; 97.9; 98.1; 101],
Var2=[120; 111; 119; 117; 118],
)
d2 = sortrows(TT, "TimeDuration")
d2 =
5×3 DataFrame
Row │ TimeDuration Var1 Var2
│ Hour Float64 Int64
─────┼──────────────────────────────
1 │ 1 hour 97.9 119
2 │ 2 hours 97.5 111
3 │ 3 hours 98.0 120
4 │ 5 hours 98.1 117
5 │ 6 hours 101.0 118
# 输入参数
A - 输入数组列向量 | 矩阵
输入数组，指定为列向量或矩阵。
数据类型： Float64 | Float32 | Int8 | Int16 | Int32 | Int64 | UInt8 | UInt16 | UInt32 | UInt64 | Bool | Char | String | Datetime | Duration
复数支持： 是
column - 列排序向量整数 | 整数元组 | 整数向量 | 整数行矩阵 | 整数列矩阵
列排序向量，指定为整数、整数元组、整数向量、行或列整数矩阵。每个指定的整数值指示一个按其排序的列。负整数表示排序顺序为降序。
direction - 排序方向字符串 | 字符串数组 | 字符串向量 | 整数行矩阵 | 整数列矩阵
如果同时指定 column 参数和 direction 参数，则 sortrows 根据 direction 进行排序，而忽略 column 中元素的符号。
nargout - 控制输出参数Int
nargout 控制输出参数的个数。
数据类型： Int
# 关键词参数
指定可选的、以逗号分隔的 Key=Value 关键词参数。Key 为关键词参数名称，Value 为对应的值。您可采用任意顺序指定多个名称-值对组参数，如 Key1=Value1,...,KeyN=ValueN 所示。
示例： sortrows(A; missingplacement="last")
missingplacement - 缺失值的位置"auto" （默认） | "first" | "last"
缺失值（NaN、NaT、<undefined> 和 missing）的位置，指定为逗号分隔的对组，包含 missingplacement 和下列项之一：
"auto" - 缺失的元素放在最后（对于升序排序）或放在最前面（对于降序排序）；
"first" - 缺失的元素放在最前面；
"last" - 缺失的元素放在最后。
数据类型： String
comparisonmethod - 元素比较方法"auto" （默认） | "real" | "abs"
元素比较方法，指定为逗号分隔的对组，包含 comparisonmethod 和下列项之一：
"auto" - 当 A 为实数时，按 real(A) 对 A 的行进行排序；当 A 为复数时，按 abs(A) 进行排序；
"real" - 当 A 为实数或复数时，按 real(A) 对 A 的行进行排序。如果 A 的列包含具有相等实部的元素，则使用 imag(A) 进行排序；
"abs" - 当 A 为实数或复数时，按 abs(A) 对 A 的行进行排序。如果 A 的列包含具有相等模的元素，则使用区间 (-π,π] 中的 angle(A) 进行排序。
数据类型： String
# 输出参数
f - 已排序数组向量 | 矩阵 | 多维数组
已排序的数组，以向量、矩阵或多维数组的形式返回。f 的大小与 A 相同。
数据类型： Float64 | Float32 | Int8 | Int16 | Int32 | Int64 | UInt8 | UInt16 | UInt32 | UInt64 | Bool | Char | String | Datetime | Duration
index - 排序索引索引向量
排序索引，以索引向量的形式返回。排序索引描述输入中的行的重新排列，以便 f = A(index,:)。
数据类型： Float64