Wie konvertieren von R Formel zum text?

Ich habe Probleme beim arbeiten mit Formel als text. Was ich versuche zu tun, ist die Verkettung der Formel für den Titel des Diagramms. Jedoch, wenn ich versuche zu arbeiten, mit der Formel als text, ich nicht:

model <- lm(celkem ~ rok + mesic)
formula(model)
# celkem ~ rok + mesic

Ist dies in Ordnung. Jetzt möchte ich eine Zeichenfolge erstellen wie "my text celkem ~ rok + mesic" - das ist wo das problem kommt:

paste("my text", formula(model))
# [1] "my text ~"           "my text celkem"      "my text rok + mesic"

paste("my text", as.character(formula(model)))
# [1] "my text ~"           "my text celkem"      "my text rok + mesic"

paste("my text", toString(formula(model)))
# [1] "my text ~, celkem, rok + mesic"

Nun sehe ich, es ist ein sprint Funktion im Paket gtools, aber ich denke, das ist eine so grundlegende Sache, die es verdient, eine Lösung innerhalb der Standard-Umgebung!!

sprint ist nicht Teil der gtools mehr. Wer weiß, was ist die Lösung zu diesem post?

InformationsquelleAutor TMS | 2013-02-03

36

Kurze Lösung aus dem Paket formula.tools als Funktion as.character.formula:
```
frm <- celkem ~ rok + mesic
Reduce(paste, deparse(frm))
# [1] "celkem ~ rok + mesic"

library(formula.tools)
as.character(frm)
# [1] "celkem ~ rok + mesic"
```
Reduce könnte nützlich sein im Fall von langen Formeln:
```
frm <- formula(paste("y ~ ", paste0("x", 1:12, collapse = " + ")))

deparse(frm)
# [1] "y ~ x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 + "
# [2] "    x12"                                                      
Reduce(paste, deparse(frm))
# [1] "y ~ x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 +      x12"
```
Ist, da der width.cutoff = 60L im ?deparse.
- Aaah, deparse! Dank einer million! Aber warum verwenden Sie Reduce? Es ist genug zu tun, nur deparse(frm).
- gerade Hinzugefügt eine Erklärung über Reduce.
- Erghh, ich war so begeistert von deparse, aber jetzt es scheint, ist es ziemlich hinterlistig! Es muss irgendeine Funktion wandelt die Formel in die Zeichenkette ohne Verpackungen, trenngrenzen usw!!
- Ich glaube nicht, dass es eines ist, das wesentlich kürzer als deine Lösung. Ich denke deparse allein ist ausreichend für die visuelle Nutzung und Reduce + deparse ist gar nicht so schlecht in langen Formeln für nicht visuelle Nutzung.
- es ist nicht ideal, ich brauche visuelle Nutzung und deparse allein wird nicht den job zu erledigen. Es muss etwas sein, das erzeugt einfach-string aus der Formel!
- BTW, Reduce(paste, deparse(frm)) ist ein netter trick zu ersetzen paste(deparse(frm), collapse=' ') Dank.
- deparse(frm, Breite.cutoff = 500)) scheint, den trick zu tun.
InformationsquelleAutor Julius Vainora
24

Versuchen format :
```
paste("my text", format(frm))
## [1] "my text celkem ~ rok + mesic"
```
- danke, aber das hat das gleiche problem mit der Verpackung lange Formeln als deparse hat, abgesehen von der Breite und rechtfertigen Optionen...
- Es funktionierte, als ich versuchte, Ihrem Beispiel, aber, ja, ich habe die Quelle jetzt, und es ist in der Tat nennen deparse. Es scheint, dass deparse(fo, cutoff.width = 200) funktioniert, aber es gibt keinen Weg zu gehen, dass argument deparse bei der Verwendung format.
InformationsquelleAutor G. Grothendieck
12

oder als alternative zu Julius-version (Hinweis: der code wurde nicht self-contained)
```
celkem = 1
rok = 1
mesic = 1
model <- lm(celkem ~ rok + mesic)
paste("my model ", deparse(formula(model)))
```
- .. aber Vorsicht, es birgt in sich das problem des bereits genannten Julius - deparse wird die cutoff-lange Formeln.
- Interessant ... hätte nie gedacht, dass.
InformationsquelleAutor Dieter Menne
6

Ich eine Lösung gefunden habe, aber es ist hässlich wie die Hölle...
```
paste("my text", paste(as.character(formula(model))[c(2,1,3)], collapse = " "))
```
In der Tat, das ist sooo hacky (vor allem die c(2,1,3)) ich betrachte das nicht als eine wirkliche Lösung... poste Bitte etwas besser 🙂

InformationsquelleAutor TMS
3

Der einfachste Weg ist dieser:
```
f = formula(model)
paste(f[2],f[3],sep='~')
```
getan!

InformationsquelleAutor TPArrow
2

Hier eine Lösung, die die Verwendung print.formula scheint es trick, aber den job in der oneline und vermeiden Sie die Verwendung von deparse und man braucht kein extra Paket. Ich habe gerade erfassen Sie die Ausgabe des print-Formel, mit capture.output
```
paste("my text",capture.output(print(formula(celkem ~ rok + mesic))))
[1] "my text celkem ~ rok + mesic"
```
Im Falle von long-Formel:
```
 ff <- formula(paste("y ~ ", paste0("x", 1:12, collapse = " + ")))
 paste("my text",paste(capture.output(print(ff)), collapse= ' '))

 "my text y ~ x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 +      x12"
```
- Danke, aber capture.output(print()) können nur vereinfacht werden, um deparse() als Julius vorgeschlagen, mit exakt dem gleichen Ergebnis: paste(deparse(frm), collapse= ' ')...
InformationsquelleAutor agstudy
1

Dann hinzufügen, gsub, um Leerzeichen entfernen
```
gsub("  ", "", paste(format(frm), collapse = ""))
```
- Dann? Ist das nicht ein Schlagwort vorangestellt ist, eine wenn?
- Meine Ergänzung zu @G. Grothendieck
- Dies ist mehr ein Kommentar auf einem anderen post als eine Antwort in und von sich selbst. Sobald Sie haben genug, rep, können Sie kommentieren jeden post. Sie können immer einen Kommentar auf deine eigenen Beiträge.
InformationsquelleAutor Ross D
0

Anderen deparse-basierte Lösung ist rlang::expr_text() (und rlang::quo_text()):
```
f <- Y ~ 1 + a + b + c + d + e + f + g + h + i +j + k + l + m + n + o + p + q + r + s + t + u
rlang::quo_text(f)
#> [1] "Y ~ 1 + a + b + c + d + e + f + g + h + i + j + k + l + m + n + \n    o + p + q + r + s + t + u"
```
Haben Sie eine Breite argument, um Zeilenumbrüche, aber das ist begrenzt auf 500 Zeichen zu. Zumindest ist es eine einzelne Funktion, die am wahrscheinlichsten ist bereits geladen...

InformationsquelleAutor jan-glx

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.