素晴らしいFR。 私もこのユースケースについてかなり長い間考えてきました。 このように追加の引数なしでこれを行うことができます：

dt[, .SD[mean(var)>1], by=id]

（ただし、速度を上げるには、内部で.SD[.]を最適化する必要があります-＃735）。

代わりに.Iを使用するのは、この場合である可能性が最も高いです。

dt[dt[, .I[mean(var) > 1], by=id]$V1]

そして、これを直接取得するのは素晴らしいことです（ havingなしでそれを達成できればさらに良いです）-おそらくj式が1列の論理ベクトルに評価される場合はどうでしょうか？ 大声で考えているだけです。

こんにちはアルン。 答えてくれてありがとう。 .SDの最適化が利用可能になると、これは、次の間に読むことがより明確になるという点で、「味」の問題になります。

dt[, .SD[mean(var)>1], by=id]

と

dt[, .SD, by = id, having = mean(var) > 1]

2つ目は、他の言語（特にSQL）から来た人々にとっても魅力的かもしれませんが。 しかし、繰り返しになりますが、これは私の意見かもしれません。 たぶん、前回はSQLを使いすぎたのかもしれません（笑）。

好みの部分に関しては、単純で標準的な構文（つまり、上記の最初のオプション）で実行できる場合は、パラメーターを追加するのは本当に嫌いです。

奇妙。 私はあなたがこれを最も高く評価する可能性が高いと確信していました：-）（私が正しく覚えていれば、主に読みやすさを向上させるために、by-without-byをどれだけ排除したいかを考慮してください）。 とにかく、私は2つがまったく異なるシナリオであることを知っています。 私は自分の見解を共有したかっただけです。

• R（または単にdata.table）にあまり詳しくない人にとっては読みやすくなると確信しています。
• [.data.tableの15対14（現在の）パラメーターは実際には害はありません
• あなたはそれを使用することを強制されることはなく、それはコードを壊すことはありません。 これは、指定されている場合、特定のグループのjの実行をスキップする可能性がある式になります。

私がサイレントバイウィズバイバイと「持っている」が好きではなかった理由は実際には同じです-それが余分なパラメータであろうと余分な奇妙な振る舞いであろうと、余分なものを覚えるのは好きではありません。

あなたが書いた最初の式は、行を読み続ける必要がないので、はるかに読みやすいと主張します。次に、新しいパラメータが指定されていることを発見し、文の最初に戻って、何が起こっているかのメンタルモデル。

having引数を[に追加せずに、それをhaving()関数に変換し、 i order()で機能させることについてどう思いますか？

dt[ having(var > 1), .(var = mean(var)), by = id ]
# would perform below without additional copy:
dt[, .(var = mean(var)), by = id ][ var > 1 ]

havingは、 dtのフレームで引数を評価し、 iにフィルタリングを提供する関数になります。

このFRは、 https：//github.com/Rdatatable/data.table/issues/1269 「グループのみを返す」と密接に関連していると思います。 このSO投稿のmy_teamsのように、何らかの属性を持つグループを取得して、それらをベクトルに格納したいことがよくあります。 関連する行は次のとおりです。

my_teams <- FantasyTeams[, max(table(Team)) <= 3, by=team_no][(V1)]$team_no
# or 
my_teams <- FantasyTeams[, if ( max(table(Team)) <= 3 ) 1, by=team_no]$team_no

havingと「グループのみを返す」FRを使用すると、これは次のようになります。

my_teams <- FantasyTeams[, .(), by = team_no, having = { max(table(Team)) <= 3 }]$team_no

コードも同じくらい長いですが、私はそれを好むので、目的を理解するためにjを注意深く読む必要はありません。

SOからの別の例。 グループごとの条件が満たされている場合、目標はValue列を3Lで上書きすることです。

DT = setDT(structure(list(Ind = c(1L, 1L, 2L, 2L, 3L, 3L, 4L, 4L), ID = c("A", 
"A", "A", "A", "B", "B", "B", "B"), RegionStart = c(1L, 101L, 
1L, 101L, 1L, 101L, 1L, 101L), RegionEnd = c(100L, 200L, 100L, 
200L, 100L, 200L, 100L, 200L), Value = c(3L, 2L, 3L, 2L, 3L, 
2L, 5L, 5L), TN = c("N", "N", "T", "T", "N", "N", "T", "T")), .Names = c("Ind", 
"ID", "RegionStart", "RegionEnd", "Value", "TN"), row.names = c(NA, 
-8L), class = "data.frame"))

# current syntax 
DT[, Value := { 
  fixit = ( Value[TN=="N"] != 3L ) & ( uniqueN(Value) == 1L )
  if (fixit) 3L else Value
}, by=.(ID, RegionStart)]

# with "having"
DT[,
  Value := 3L
, by=.(ID, RegionStart)
, having={ ( Value[TN=="N"] != 3L ) & ( n_distinct(Value) == 1L ) }]

おそらくより良い構文に加えて、グループごとのサブセットのみを変更する必要があるため、 having=の方法もより効率的であると思います。 having=を使用しない最も効率的な方法は、おそらく次のようになります...

myeyes = DT[, .I[ ( Value[TN=="N"] != 3L ) & ( uniqueN(Value) == 1L )], by=.(ID, RegionStart)]$V1
DT[ myeyes, Value := 3L]

# or 

mygs = DT[, ( Value[TN=="N"] != 3L ) & ( uniqueN(Value) == 1L ), by=.(ID, RegionStart)][(V1)][, V1 := NULL]
DT[ mygs, Value := 3L, on=names(mygs)]

かなり複雑です。

編集：そして、この機能が利用可能かどうか/いつ利用できるかを更新する別の例： http ：//stackoverflow.com/q/36292702
（2016/4/26 :) http://stackoverflow.com/q/36869784
（2016/06/16 :) http://stackoverflow.com/q/37855013/

SOからの別の例。 厳密に一意の行（＃1163に関連）を選択するために使用できます。

DT = setDT(structure(list(id = c(1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 
2, 3, 4), dsp = c(5, 6, 7, 8, 6, 6, 7, 8, 5, 6, 9, 8, 5, 6, 7, 
NA), status = c(FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, 
TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE)), .Names = c("id", 
"dsp", "status"), row.names = c(NA, -16L), class = "data.frame"))

# my current way to select "strictly unique" rows
Bigdt[, .N, by=names(Bigdt)][N == 1][, N := NULL][]

# could be...
Bigdt[, .SD, by=names(Bigdt), having ={.N == 1L}]

.SDは空であるため、ここではBigdt[, if (.N == 1L) .SD, by=names(Bigdt)]は機能しないことに注意してください。 たぶんそれは＃1269によって助けられるかもしれません。

そして別のSOから： http ：//stackoverflow.com/q/38272608/彼らは最後の行のものに基づいてグループを選択したいので、 having =ヒースコンディション[.N] == "not healthy"がそれを行う必要があります。

そして別の単純なケース（サイズによるフィルタリング）： http ：//stackoverflow.com/q/39085450/

そして別の、反結合付き：

ID <- c("A","A","A","B","B","C","D")
Value <- c(0,1,2,0,2,0,0)
df <- data.frame(ID,Value)

library(data.table)
setDT(df)

# use j = max() to get GForce speedup
df[ !df[, max(Value), by=ID][V1 > 0, .(ID, Value = 0)], on=.(ID, Value)]

# do the more standard thing, if j = if (...) x
df[ !df[, if (max(Value) > 0) .(Value = 0), by=ID], on=.(Value, ID) ]

# desired syntax
df[ !df[, .(Value = 0), by=ID, having = max(Value) > 0], on=.(Value, ID) ]

しかし、それほど良い例ではありません。

そして、 dt[, if(uniqueN(time)==1L) .SD, by=name, .SDcols="time"]のような答えを持つ別の

そして別の： http ：//stackoverflow.com/q/43354165/

そして別の： http ：//stackoverflow.com/q/43613087/

別の（削除される可能性がありますが）： http ：//stackoverflow.com/q/43635968/

別のhttp://stackoverflow.com/a/43765352/

別のhttp://chat.stackoverflow.com/transcript/message/37148860#37148860

別のhttps://stackoverflow.com/questions/45464333/assign-a-binary-vector-based-on-blocks-of-data-within-another-vector/

別のhttps://stackoverflow.com/questions/32259620/how-to-remove-unique-entry-and-keep-duplicates-in-r/32259758#32259758

Un autre https://stackoverflow.com/q/45557011/

Haiyou https://stackoverflow.com/questions/45598397/filter-data-frame-matching-all-values-of-a-vector

Um mais https://stackoverflow.com/a/45721286/

lingwai yige https://stackoverflow.com/a/45820567/

およびhttps://stackoverflow.com/q/46251221/

uno mas https://stackoverflow.com/questions/46307315/show-sequences-that-include-a-variable-in-r

tambem https://stackoverflow.com/q/46638058/

そしてもう一つ。 data.table（myDT）を、参照テーブル（idDT）にないエントリにサブセット化したい：

library(data.table)
idDT = data.table(id = 1:3, v = c("A","B","C"))
myDT = data.table(id = 3:4, z = c("gah","egad"))

# my attempt
idDT[myDT, on=.(id), .SD[.N == 0L], by=.EACHI]
# Empty data.table (0 rows) of 2 cols: id,v

# workaround
myDT[, .SD[idDT[.SD, on=.(id), .N == 0, by=.EACHI]$V1]]

# desired notation (with having=)
myDT[, .SD, by = id, having = idDT[.BY, on=.(id), .N]==0L]

ただし、これは非効率的です。私の希望する表記では、各by =値が、idDTへの個別の結合を行う必要があるためです。 その意味で、それは最良の例ではないかもしれません。

mais um https://stackoverflow.com/questions/47765283/r-data-table-group-by-where/47765308?noredirect=1#comment82524998_47765308は、 DT[, if (any(status == "A") && !any(status == "B")) .SD, by=id]またはパラメータDT[, .SD, by=id, having = any(status == "A") && !any(status == "B")]を使用して実行できます

次に、 https：//stackoverflow.com/a/48669032/ m[, if(isTRUE(any(passed))) .SD, by=id]はm[by = id, having = isTRUE(any(passed))]になります

mais um exemplo https://stackoverflow.com/q/49072250/

ein anderer https://stackoverflow.com/a/49211292/ stock_profile[, sum(Value), by=Pcode, having=any(Location=="A" & NoSales == "Y")][, sum(V1)]

mais um https://stackoverflow.com/a/49366998/

autre https://stackoverflow.com/a/49919015/

y https://stackoverflow.com/questions/50257643/deleting-rows-in-r-with-value-less-than-x

うめき声https://stackoverflow.com/q/54582048

e https://stackoverflow.com/q/56283005

.N == kの場合はグループを保持します（重複ターゲットにも多数あります） https://stackoverflow.com/questions/56794306/only-get-data-table-groups-with-a-given-number-of-rows

グループを保持する（diff（sorted_col））<=しきい値https://stackoverflow.com/q/57512417

max（x）<しきい値の場合は保持https://stackoverflow.com/a/57698641

@eantonya IMHO 、 havingパラメータを追加すると、実際に覚えやすくなります。 過度の簡潔さは覚えにくい場合があります。 さらに、 data.tableをSQLのようにすることは悪い考えではありません。

data.table FAQ：

2.16data.table構文はSQLに類似していると聞きました。
はい ： ...

@ywhuofu data.tableはorder関数をi引数にすでに受け入れています。これは、ベースRユーザーが期待するものです。 sql _ORDER_をi = order(...)に変換するのと同じ方法で、_HAVING_を使用して実行できます。 data.frameのiは、サブセット化（_having_は集約後のサブセット化の遅延）または並べ替えに使用されるため、適切に適合します。

これはAPIでしょうか？

dt <- data.table(id   = rep(1:2, each = 2),
                 var  = c(0.2, 0.5, 1.5, 1.3))

dt[having.i(mean(var) > 1, by = id)]
  id var
1  2 1.5
2  2 1.3

このバージョンを実装しましたが、 gforce最適化された関数と、グループ化に依存しない一部の関数（ + 、 | 、 &など）のみを使用するという制限が設定されています。 Cdogroupsがサポートされるかどうかはわかります。

1つの追加のメモ。 現在の'[.data.table'コード内にdt[having(var > 3), .(var = mean(x)), by = .(grp)]を収めるのは難しいようです。 構文が正しいことを確認するために、いくつかのチェックが必要になります。
`` `
n = 1e6
grps = 1e5
head_n = 2L
dt = data.table :: data.table（x = sample（grps、n、TRUE）、y = runif（n））

ティブル：2 x 13

式の最小中央値

1 lw [having.i（.N <2L | sum（y）> 11 |中央値（y）<0.7、by = x）] 114.13ms 124.98ms
2 dt [dt [、。I [.N <2L | sum（y）> 11 | 中央値（y）<0.7]、by = x] $ V1] 4000ms 4000ms

ティブル：2 x 13

式の最小中央値itr/sec mem_alloc gc/sec n_itr

1 lw [having.i（.N <2L、by = x）] 30.2ms 35.3ms 27.9 8.02MB 3.99 14
2 dt [dt [、.I [.N <2L]、by = x] $ V1] 106.1ms 110.4ms 8.81 6.13MB 10.6 5

私はこれをhaving=またはgroup_filter= （またはSQL認識に依存せずに視覚的に何をするかを知るための何か）という名前の追加パラメーターとして好むでしょう。

たとえば、 iの行フィルターと$＃$ i $のグループレベルのフィルターを組み合わせるのは混乱すると思います

having =はデータのサブセットで機能しますか、それともi引数またはhaving引数しか使用できませんか？ また、 jが評価される前にhavingが発生すると思います。 .BYと.GRP 、そしてまもなく.NGRPは、 `` `hasing =` `` `でどのように機能しますか？

構文上の選択肢は多くありません。

• havingなどの新しい引数を追加する
• 既存の引数の活用： i 、 j 、 by 。

行フィルターとグループフィルターの両方が必要な場合、 dt[row_selector & group_selector, ...]は正しく表示されないため、このようなユースケースでは、行フィルターとグループフィルターを同じ引数に含めるべきではないようです。 その後、 iは除外されます。

そうすれば、構文上の選択肢は多くありません。

byを利用すると、混乱を招く可能性があります。 例えば、

dt[, .SD, by = having(.(id), mean(var > 1))]
dt[, .SD, by = id ~ mean(var) > 1]

jに特別な関数を追加すると見栄えが悪くなります。

dt[, having(mean(var) > 1, .SD), by = id]

今、私が最もよく見えると思うコードは最もオリジナルなバージョンです

dt[, if (mean(var) > 1) .SD, by = id]
dt[, if (mean(var) > 1) .(x = sum(x), y = sum(y)), by = id]

私が本当に望んでいるのは、グループフィルタリングの後に最適化を実行し続けることです。 j内のif式を検出し、GForceがifステートメント内で機能するように維持するなど、それに最適化できますか？

@ renkun-kenまたは、別の中置演算子をオーバーロードしますか？

dt[, mean(var) > 1 ? .SD, by=id]

ifに対する特別なシンボルの利点の1つは、ユーザーが一致するelse後で置く可能性がないことです。

@ franknarf1 j ifを検出しようとしているときに、 ifにelse ifとelseがあることも確認できるようです。 ifのみの場合を最適化し、 if-elseを最適化しないままにすることができます。 後で、 if-elseの場合も処理できるようになります。 個人的には、既存の演算子をオーバーライドしたり活用したりするよりも、コードを最適化する方が好きです。

@ franknarf1これはクールなC構文ですが、ここでそれほど複雑にならないかどうかはわかりません。
var > 1 ? d : eも同様に機能する可能性がありますね。

var > 1 ? d : eは簡潔に見えますが、 dとeは{...}のようなものであり、演算子の優先順位が混乱する可能性があるため、インラインの単純な場合にのみ機能します。 .SDが純粋なグループフィルタリングを実行できるようにするだけですか、それともここでjの式を実行するだけですか？

構文を追加すると、構文が特別に処理され、 j内では機能しないことにユーザーが注意する必要があるという問題があります。 たとえば、ユーザーは期待するかもしれません

dt[, mean(var) > 1 ? 0 : (sd(var) < 1 ? 1 : 0), by = id]

働くために、そしてさえ

dt[, mean(var) > 1 ? 0 : 1]
dt[, mean(var) > 1 ? 0 : (sd(var) < 1 ? 1 : 0)]

一般的に動作します。

私はここで少し混乱しています。

しますか

dt[, .SD, by = id, having = mean(var) > 1]

に利点があります

dt[, if(mean(var) > 1) .SD, by = id]

mean(var) > 1は常にグループごとに評価されるためです。 それは構文糖衣としてのみ機能しますか、それともパフォーマンスを向上させるためにこれを何らかの方法で最適化しようとしていますか？

@jangorecki

@ franknarf1これはクールなC構文ですが、ここでそれほど複雑にならないかどうかはわかりません。
var > 1 ? d : eも同様に機能する可能性がありますね。

ええ、それはクールでしょう。 @ renkun-kenが指摘したように、演算子の優先順位は{}なしで邪魔になる可能性があります（ ex = quote(x & y ? a+b : v+w); str(rapply(as.list(ex), as.list, how="replace")) ）

私はここで少し混乱しています。

しますか

dt[, .SD, by = id, having = mean(var) > 1]

に利点があります

dt[, if(mean(var) > 1) .SD, by = id]

mean(var) > 1は常にグループごとに評価されるためです。 それは構文糖衣としてのみ機能しますか、それともパフォーマンスを向上させるためにこれを何らかの方法で最適化しようとしていますか？

jに構文上の魔法を追加するよりも、読みやすく、保守が簡単だと思うので、これまでhaving=を好んでいたと思います。 一方、私は代わりにj構文の魔法を好むかもしれないと思います。

• 私はすでにif () ...に慣れています。 可能であれば、 ?の方法も好きです。
• jに統合されている場合、その動作について追加の質問に答える必要はありません（たとえば、 DT[, x := if (cond) y, by=id]は、条件が一部のグループで満たされ、他のグループでは満たされない場合にNAを作成し、この動作はすべきではありません。 having=について再説明する必要があります）。

最適化に関しては、通常はmax(x) > 0 、 max(x) == 0のような式であるため、GForceのバージョンによっては、持つ条件自体が恩恵を受ける可能性のある例がたくさんあるようです。

私自身の使用では、最適化に加えて、上記のreturn-only-groupsの場合にほとんど役立つと思いますhttps://github.com/Rdatatable/data.table/issues/1269

> dt[, if (mean(var) > 1) .(), by=id] 
> # instead of ...
> dt[, mean(var) > 1, by=id][V1 == TRUE, !"V1"]
   id
1:  2

いい点フランク。 あなたが持っているユースケースの巨大な大要に加えて
構築されました（ところでもう一度ありがとう！）。

実際、having =バージョンでGForceを実行する方が簡単な場合があります。
gforceロジックを、実行しようとするのではなく、jに類似したものに適用するだけです。
同じことを達成するためのNSE。

ただし、これはw JanのWIPと相互作用して、多くのjコードをCに移動する可能性があります。
そこの考えヤン？

2020年2月15日土曜日、午後1時40分に[email protected]は次のように書いています。

@jangorecki https://github.com/jangorecki

@ franknarf1https ：//github.com/franknarf1これはクールなC構文です。
ここでそれほど複雑にならないかどうかはわかりませんが。
var> 1？ d：eもうまくいくでしょうね。

ええ、それはクールでしょう。 演算子の優先順位がないと邪魔になる可能性があります
{} s @ renkun-ken https://github.com/renkun-kenが指摘したように（ex =
quote（x＆y？a + b：v + w）; str（rapply（as.list（ex）、as.list、how = "replace"））
）。

私はここで少し混乱しています。

しますか

dt [、.SD、by = id、have = mean（var）> 1]

に利点があります

dt [、if（mean（var）> 1）.SD、by = id]

mean（var）> 1は、常に各グループに対して評価されるためです。 それだけですか
シンタックスシュガーとして機能するか、これをなんとかして最適化しようとしています
より高いパフォーマンスを得るには？

今まで私は持っていることを好んだと思います=それを少し見つけたので
追加するよりも読みやすく、維持しやすいと想像する
jへのさらなる構文上の魔法。 一方で、私はそうかもしれないと思います
代わりに、j構文の魔法を好む

• 私は（）...すでに; とのように？ もしそうなら
  実行可能。
• jに統合されている場合は、追加の質問をする必要はありません。
  その動作について回答しました（たとえば、DT [、x：= if（cond）y、by = id]が作成します
  一部のグループで条件が満たされているが、他のグループでは満たされていない場合のNAとこの動作
  持っているために再説明する必要はありません=）。

最適化に関しては、例がたくさんあるようです。
持つ条件自体は、GForceのいくつかのバージョンから恩恵を受ける可能性があります。
通常、max（x）> 0のような式であるため、max（x）== 0です。

私自身の使用では、最適化以外に、ほとんどの場合
上記のreturn-only-groupsの場合に役立ちます＃1269
https://github.com/Rdatatable/data.table/issues/1269

dt [、if（mean（var）> 1）。（）、by = id]

それ以外の ...

dt [、mean（var）> 1、by = id] [V1 == TRUE 、！ "V1"]
id
1：2

—
コメントしたのでこれを受け取っています。
このメールに直接返信し、GitHubで表示してください
https://github.com/Rdatatable/data.table/issues/788?email_source=notifications&email_token=AB2BA5OCN4IW3N6QQJU6RJ3RC555BA5CNFSM4ATSQPMKYY3PNVWWK3TUL52HS4DFVREXG43VMVBW63LNMVXHJKTDN
または購読を解除する
https://github.com/notifications/unsubscribe-auth/AB2BA5MD7ZXWSRRHVEJM6C3RC555BANCNFSM4ATSQPMA
。

Cに移動するjコードは、列の選択のみを担当するコードであるため、 with引数を推測します。 ここで干渉しません。

FRは「having」パラメータを追加するためのものであるため、 havingという単語はソリューションのどこかにあるはずです。 三項演算子の最適化は別の問題のようです。

having.i()の私の好みは、data.tableのマントラのためです：iのサブセット/順序、jの選択、byのグループ化。 havingは、サブセット化の特殊なケースです。

とにかく、新しい引数havingがある場合、APIはi引数をサポートしますか？ ほとんどのユースケースでは、その要件は必要ないようです。

注文の振る舞いはどうあるべきですか？ つまり、現在のアプローチのほとんどは自動的に並べ替えられます。

library(data.table)

dt = data.table(grp = c(1L, 2L, 1L, 2L), x = letters[sample(4L)])
dt
#>      grp      x
#>    <int> <char>
#> 1:     1      a
#> 2:     2      b
#> 3:     1      c
#> 4:     2      d
dt[dt[, .I[.N > 0L], by = grp]$V1]
#>      grp      x
#>    <int> <char>
#> 1:     1      a
#> 2:     1      c
#> 3:     2      b
#> 4:     2      d

having引数は、 byに従って並べ替えられた結果を返す必要がありますか？

注文の振る舞いはどうあるべきですか？
having引数は、 byに従って並べ替えられた結果を返す必要がありますか？

@ ColeMiller1 Fwiw、 having=は、 by=も表示される場合にのみ表示されると思います。したがって、結果は、例のように...$V1でグループ化されます。

はい、順序は一貫していると思います。

DT[i, j, by, having]
# < == >
DT[i, if (having) j, by]

API、特に[に新しいhaving引数を含めることについては合意がなかったと思います。 @mattdowle wdyt？
DT[, if (.N > 1L) .SD, col1]を使用する現在のアプローチは優れたものであり、それほど複雑ではなく、拡張も簡単ですが、最適化するのは少し難しいです。
私のアイデアは、 i ： DT[having(N > 1L), .N, col1]の関数呼び出しとしてhavingを使用することでしたが、 iに通常のサブセットを提供することはできません。
あるいは、新しい引数はbyのサブ引数である可能性があり、それについてはあまり考えていませんが、 DT[, .N, by=.(col1, .having = N > 1L)]のようなものであるため、追加のグループ化関連の引数はbyにカプセル化されます。口論。 これは、引数の数を増やすための適切な方法です。