Zeichnen Sie zwei Diagramme in demselben Diagramm in R.

Ich möchte y1 und y2 im selben Plot zeichnen.

x  <- seq(-2, 2, 0.05)
y1 <- pnorm(x)
y2 <- pnorm(x, 1, 1)
plot(x, y1, type = "l", col = "red")
plot(x, y2, type = "l", col = "green")

Aber wenn ich es so mache, werden sie nicht zusammen in derselben Handlung dargestellt.

In Matlab kann man das tun hold on, aber weiß jemand, wie man das in R macht?

lines()oder points()fügt dem vorhandenen Diagramm hinzu, erstellt jedoch kein neues Fenster. Also müsstest du es tun

plot(x,y1,type="l",col="red")
lines(x,y2,col="green")

Sie können auch pardasselbe Diagramm verwenden und auf einer anderen Achse zeichnen. Etwas wie folgt:

plot( x, y1, type="l", col="red" )
par(new=TRUE)
plot( x, y2, type="l", col="green" )

Wenn Sie ausführlich über parin lesen R, können Sie wirklich interessante Grafiken erstellen. Ein weiteres Buch ist Paul Murrels R Graphics.

Bei der Erstellung von mehrschichtigen Plots sollte das ggplotPaket berücksichtigt werden. Die Idee ist, ein grafisches Objekt mit grundlegender Ästhetik zu erstellen und es schrittweise zu verbessern.

ggplotFür den Stil müssen Daten gepackt werden data.frame.

# Data generation
x  <- seq(-2, 2, 0.05)
y1 <- pnorm(x)
y2 <- pnorm(x,1,1)
df <- data.frame(x,y1,y2)

Grundlösung:

require(ggplot2)

ggplot(df, aes(x)) +                    # basic graphical object
  geom_line(aes(y=y1), colour="red") +  # first layer
  geom_line(aes(y=y2), colour="green")  # second layer

Hier + operatorwerden zusätzliche Ebenen zum Basisobjekt hinzugefügt.

Mit haben ggplotSie Zugriff auf grafische Objekte in jeder Phase des Zeichnens. Angenommen, die übliche schrittweise Einrichtung kann folgendermaßen aussehen:

g <- ggplot(df, aes(x))
g <- g + geom_line(aes(y=y1), colour="red")
g <- g + geom_line(aes(y=y2), colour="green")
g

gErzeugt das Diagramm und Sie können es in jeder Phase sehen (also nach dem Erstellen mindestens einer Ebene). Weitere Verzauberungen des Plots werden ebenfalls mit dem erstellten Objekt vorgenommen. Zum Beispiel können wir Beschriftungen für Achsen hinzufügen:

g <- g + ylab("Y") + xlab("X")
g

Das Finale gsieht aus wie:

UPDATE (08.11.2013):

Wie in den Kommentaren erwähnt, ggplotschlägt die Philosophie vor, Daten im Langformat zu verwenden. Sie können sich auf diese Antwort beziehen, um den entsprechenden Code anzuzeigen.

Ich denke, dass die Antwort, die Sie suchen, lautet:

plot(first thing to plot)
plot(second thing to plot,add=TRUE)

Verwenden Sie die matplotFunktion:

matplot(x, cbind(y1,y2),type="l",col=c("red","green"),lty=c(1,1))

Verwenden Sie dies, wenn y1und y2an denselben xPunkten ausgewertet werden. Es skaliert die Y-Achse so, dass sie zu dem passt, was größer ( y1oder y2) ist, im Gegensatz zu einigen anderen Antworten hier, die abgeschnitten werden, y2wenn sie größer als y1(ggplot-Lösungen sind meistens damit einverstanden).

Alternativ und wenn die beiden Linien nicht die gleichen x-Koordinaten haben, legen Sie die Achsengrenzen im ersten Diagramm fest und fügen Sie Folgendes hinzu:

x1  <- seq(-2, 2, 0.05)
x2  <- seq(-3, 3, 0.05)
y1 <- pnorm(x1)
y2 <- pnorm(x2,1,1)

plot(x1,y1,ylim=range(c(y1,y2)),xlim=range(c(x1,x2)), type="l",col="red")
lines(x2,y2,col="green")

Bin erstaunt, dass dieser Q 4 Jahre alt ist und niemand erwähnt hat matplotoder x/ylim...

tl; dr: Sie möchten curve(mit add=TRUE) oder verwenden lines.

Ich bin damit nicht einverstanden, par(new=TRUE)da dadurch Häkchen und Achsenbeschriftungen doppelt gedruckt werden. Z.B

Die Ausgabe von plot(sin); par(new=T); plot( function(x) x**2 ).

Schauen Sie, wie durcheinander die Beschriftungen der vertikalen Achse sind! Da die Bereiche unterschiedlich sind, müssten Sie einstellen ylim=c(lowest point between the two functions, highest point between the two functions), was weniger einfach ist als das, was ich Ihnen zeigen werde - und viel weniger einfach, wenn Sie nicht nur zwei, sondern viele Kurven hinzufügen möchten.

Was mich beim Zeichnen immer verwirrt hat, ist der Unterschied zwischen curveund lines. (Wenn Sie sich nicht erinnern können, dass dies die Namen der beiden wichtigen Zeichenbefehle sind, singen Sie sie einfach .)

Hier ist der große Unterschied zwischen curveund lines.

curvewird eine Funktion zeichnen, wie curve(sin). linesZeichnet Punkte mit x- und y-Werten wie : lines( x=0:10, y=sin(0:10) ).

Und hier ist ein kleiner Unterschied: curveMuss add=TRUEfür das, was Sie versuchen, aufgerufen werden , während linesbereits davon ausgegangen wird, dass Sie zu einem vorhandenen Plot hinzufügen.

Hier ist das Ergebnis des Anrufs plot(0:2); curve(sin).

Schauen Sie sich hinter den Kulissen um methods(plot). Und überprüfen body( plot.function )[[5]]. Wenn Sie plot(sin)R aufrufen, stellen Sie fest , dass dies sineine Funktion ist (keine y-Werte) und verwenden Sie die plot.functionMethode, die am Ende aufruft curve. So curveist das Werkzeug Funktionen zu handhaben sollte.

Wenn Sie das Diagramm in zwei Spalten aufteilen möchten (2 Diagramme nebeneinander), können Sie dies folgendermaßen tun:

par(mfrow=c(1,2))

plot(x)

plot(y) 

Referenzlink

Wie von @redmode beschrieben, können Sie die beiden Linien mit demselben Grafikgerät zeichnen ggplot. In dieser Antwort hatten die Daten ein "breites" Format. Bei der Verwendung ist ggplotes jedoch im Allgemeinen am bequemsten, die Daten in einem Datenrahmen in einem "langen" Format zu halten. Verwenden Sie dann verschiedene 'Gruppierungsvariablen' in deraesWenn Sie dann Thetics-Argumenten verwenden, variieren die Eigenschaften der Linie, wie z. B. Linientyp oder Farbe, je nach Gruppierungsvariable, und entsprechende Legenden werden angezeigt.

In diesem Fall können wir die colourÄsthetik verwenden, die die Farbe der Linien an verschiedene Ebenen einer Variablen im Datensatz anpasst (hier: y1 vs y2). Aber zuerst müssen wir die Daten vom Breit- zum Langformat schmelzen, z. B. mit der Funktion 'Schmelzen' aus dem reshape2Paket. Weitere Methoden zum Umformen der Daten werden hier beschrieben: Umformen von data.frame vom Breit- zum Langformat .

library(ggplot2)
library(reshape2)

# original data in a 'wide' format
x  <- seq(-2, 2, 0.05)
y1 <- pnorm(x)
y2 <- pnorm(x, 1, 1)
df <- data.frame(x, y1, y2)

# melt the data to a long format
df2 <- melt(data = df, id.vars = "x")

# plot, using the aesthetics argument 'colour'
ggplot(data = df2, aes(x = x, y = value, colour = variable)) + geom_line()

Wenn Sie Basisgrafiken verwenden (dh keine Gitter- / Gittergrafiken), können Sie die Haltefunktion von MATLAB nachahmen, indem Sie die Funktionen Punkte / Linien / Polygone verwenden, um Ihren Plots zusätzliche Details hinzuzufügen, ohne ein neues Plot zu starten. Bei einem Multiplot-Layout können Sie par(mfg=...)auswählen, zu welchem ​​Plot Sie Dinge hinzufügen möchten.

Sie können also Punkte für die Überzeichnung verwenden.

plot(x1, y1,col='red')

points(x2,y2,col='blue')

Speichern Sie die zu zeichnenden Werte nicht in einem Array, sondern in einer Matrix. Standardmäßig wird die gesamte Matrix als ein Datensatz behandelt. Wenn Sie dem Plot jedoch die gleiche Anzahl von Modifikatoren hinzufügen, z. B. col (), wie Sie Zeilen in der Matrix haben, stellt R fest, dass jede Zeile unabhängig behandelt werden sollte. Zum Beispiel:

x = matrix( c(21,50,80,41), nrow=2 )
y = matrix( c(1,2,1,2), nrow=2 )
plot(x, y, col("red","blue")

Dies sollte funktionieren, es sei denn, Ihre Datensätze haben unterschiedliche Größen.

Idiomatisches Matlab plot(x1,y1,x2,y2)kann beispielsweise folgendermaßen in R übersetzt ggplot2werden:

x1 <- seq(1,10,.2)
df1 <- data.frame(x=x1,y=log(x1),type="Log")
x2 <- seq(1,10)
df2 <- data.frame(x=x2,y=cumsum(1/x2),type="Harmonic")

df <- rbind(df1,df2)

library(ggplot2)
ggplot(df)+geom_line(aes(x,y,colour=type))

^{Inspiriert von Tingting Zhaos Dual-Line-Plots mit unterschiedlichem Bereich der x-Achse mit ggplot2 .}

Sie könnten die ggplotly()Funktion aus dem Plotly- Paket verwenden, um eines der gggplot2- Beispiele hier in ein interaktives Plot umzuwandeln , aber ich denke, diese Art von Plot ist ohne ggplot2 besser :

# call Plotly and enter username and key
library(plotly)
x  <- seq(-2, 2, 0.05)
y1 <- pnorm(x)
y2 <- pnorm(x, 1, 1)

plot_ly(x = x) %>%
  add_lines(y = y1, color = I("red"), name = "Red") %>%
  add_lines(y = y2, color = I("green"), name = "Green")

Sie können Ihr Diagramm auch mit ggvis erstellen :

library(ggvis)

x  <- seq(-2, 2, 0.05)
y1 <- pnorm(x)
y2 <- pnorm(x,1,1)
df <- data.frame(x, y1, y2)

df %>%
  ggvis(~x, ~y1, stroke := 'red') %>%
  layer_paths() %>%
  layer_paths(data = df, x = ~x, y = ~y2, stroke := 'blue')

Dadurch wird das folgende Diagramm erstellt:

Verwenden plotly(Hinzufügen einer Lösung plotlymit der primären und sekundären y-Achse - Es scheint zu fehlen):

library(plotly)     
x  <- seq(-2, 2, 0.05)
y1 <- pnorm(x)
y2 <- pnorm(x, 1, 1)

df=cbind.data.frame(x,y1,y2)

  plot_ly(df) %>%
    add_trace(x=~x,y=~y1,name = 'Line 1',type = 'scatter',mode = 'lines+markers',connectgaps = TRUE) %>%
    add_trace(x=~x,y=~y2,name = 'Line 2',type = 'scatter',mode = 'lines+markers',connectgaps = TRUE,yaxis = "y2") %>%
    layout(title = 'Title',
       xaxis = list(title = "X-axis title"),
       yaxis2 = list(side = 'right', overlaying = "y", title = 'secondary y axis', showgrid = FALSE, zeroline = FALSE))

Screenshot von der Arbeitsdemo:

Wir können auch eine Gitterbibliothek verwenden

library(lattice)
x <- seq(-2,2,0.05)
y1 <- pnorm(x)
y2 <- pnorm(x,1,1)
xyplot(y1 + y2 ~ x, ylab = "y1 and y2", type = "l", auto.key = list(points = FALSE,lines = TRUE))

Für bestimmte Farben

xyplot(y1 + y2 ~ x,ylab = "y1 and y2", type = "l", auto.key = list(points = F,lines = T), par.settings = list(superpose.line = list(col = c("red","green"))))