นับค่าที่แตกต่างกันในคอลัมน์โดยยึดตามคอลัมน์ที่สอง

หากคุณไม่ต้องการทำลายชุดข้อมูลของคุณด้วย collapse คุณสามารถดำเนินการต่อไปนี้:

clear
input H L
12 0
43 1
12 1
43 1
43 1
3 0
4 0
3 1
3 1
3 1
end

bysort H (L): generate M = sum(L)
bysort H (L): generate H2 = H if _n == _N
bysort H (L): generate L2 = M if _n == _N

gsort - H2 L2
list

     +----------------------+
     |  H   L   M   H2   L2 |
     |----------------------|
  1. | 43   1   3   43    3 |
  2. | 12   1   1   12    1 |
  3. |  4   0   0    4    0 |
  4. |  3   1   3    3    3 |
  5. | 43   1   2    .    . |
     |----------------------|
  6. |  3   1   2    .    . |
  7. |  3   0   0    .    . |
  8. |  3   1   1    .    . |
  9. | 12   0   0    .    . |
 10. | 43   1   1    .    . |
     +----------------------

อีกด้วย:

generate H3 = H2 if L2 > 2
generate L3 = L2 if L2 > 2

gsort - L3
list

     +--------------------------------+
     |  H   L   M   H2   L2   H3   L3 |
     |--------------------------------|
  1. | 43   1   3   43    3   43    3 |
  2. |  3   1   3    3    3    3    3 |
  3. |  3   1   2    .    .    .    . |
  4. | 43   1   1    .    .    .    . |
  5. | 12   1   1   12    1    .    . |
     |--------------------------------|
  6. |  3   0   0    .    .    .    . |
  7. |  4   0   0    4    0    .    . |
  8. |  3   1   1    .    .    .    . |
  9. | 43   1   2    .    .    .    . |
 10. | 12   0   0    .    .    .    . |
     +--------------------------------+

ด้วยชุดข้อมูลขนาดใหญ่ การทำงานใน mata จะเร็วขึ้น - ภาษาการเขียนโปรแกรมเมทริกซ์ของ Stata:

mata: 
D = st_data(., ("H", "L"))
H = uniqrows(D[1::rows(D),1])

_sort(D,1)
_sort(H,1)

rH = rows(H)
res = J(rH, 2, .)

for (i = 1; i <= rH; i++) {
    index = selectindex(D[.,1]:==H[i,1])
    sumL = sum(D[.,2][index])
    res[i,1] = H[i]
    res[i,2] = sumL
}

index = selectindex(res[.,2]:>2)
res2 = res[.,1][index], res[.,2][index]
_sort(res2,-1)
end

สิ่งนี้จะทำให้เกิด:

mata: res
        1    2
    +-----------+
  1 |   3    3  |
  2 |   4    0  |
  3 |  12    1  |
  4 |  43    3  |
    +-----------+

mata: res2

        1    2
    +-----------+
  1 |  43    3  |
  2 |   3    3  |
    +-----------+

จากนั้นคุณสามารถโอนผลลัพธ์กลับไปยัง Stata ได้ดังนี้:

getmata (H2 L2)=res (H3 L3)=res2, force

list

     +----------------------------+
     |  H   L   H2   L2   H3   L3 |
     |----------------------------|
  1. | 12   0    3    3   43    3 |
  2. | 43   1    4    0    3    3 |
  3. | 12   1   12    1    .    . |
  4. | 43   1   43    3    .    . |
  5. | 43   1    .    .    .    . |
     |----------------------------|
  6. |  3   0    .    .    .    . |
  7. |  4   0    .    .    .    . |
  8. |  3   1    .    .    .    . |
  9. |  3   1    .    .    .    . |
 10. |  3   1    .    .    .    . |
     +----------------------------+

คุณสามารถใช้ collapse และเก็บข้อสังเกตบางอย่างไว้ได้

collapse (sum) L, by(H)
gsort -H
keep if L >= 2

เอาท์พุท:

 H    L

43    3
 3    3