Zeichnen Sie zwei Diagramme in der gleichen Darstellung in R

Sie können auch par verwenden und auf demselben Diagramm, aber 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 in par ausführlich über R lesen, können Sie wirklich interessante Diagramme erstellen. Ein weiteres Buch ist Paul Murrels R Graphics.

Wenn Sie mehrschichtige Diagramme erstellen, sollten Sie das Paket ggplot berücksichtigen. Die Idee ist, ein grafisches Objekt mit grundlegender Ästhetik zu erstellen und es schrittweise zu verbessern.

Für den ggplot -Stil müssen Daten in data.frame gepackt werden.

# 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 wird + operator verwendet, um dem Basisobjekt zusätzliche Ebenen hinzuzufügen.

Mit ggplot haben Sie Zugriff auf grafische Objekte in jeder Phase des Plottens. 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

g erstellt den Plot und Sie können ihn in jeder Phase sehen (nachdem Sie mindestens eine Ebene erstellt haben). Weitere Verzauberungen des Plots werden ebenfalls mit dem erstellten Objekt erstellt. Beispielsweise können wir Beschriftungen für Achsen hinzufügen:

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

Final g sieht so aus:

UPDATE (08.11.2013):

Wie in den Kommentaren erwähnt, schlägt die Philosophie von ggplot vor, Daten im Langformat zu verwenden. Sie können auf diese Antwort verweisen https://stackoverflow.com/a/19039094/1796914 , um den entsprechenden Code anzuzeigen.

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

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

Verwenden Sie die Funktion matplot:

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

verwenden Sie diese Option, wenn y1 und y2 mit denselben x Punkten bewertet werden. Es skaliert die Y-Achse, um zu passen, welcher Wert größer ist (y1 oder y2), im Gegensatz zu einigen anderen Antworten, bei denen y2 abgeschnitten wird, wenn er größer als y1 wird. (ggplot-Lösungen sind meistens damit einverstanden).

Alternativ und wenn die beiden Linien nicht die gleichen x-Koordinaten haben, setzen Sie die Achsengrenzen auf dem ersten Plot und fügen Sie 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 matplot oder x/ylim erwähnt hat ...

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

Ich bin mit par(new=TRUE) nicht einverstanden, da dadurch doppelte Markierungen und Achsenbeschriftungen gedruckt werden. Z.B

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

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

Was mich beim Zeichnen immer verwirrt hat, ist der Unterschied zwischen curve und lines. (Wenn Sie sich nicht erinnern können, dass dies die Namen der beiden wichtigen Zeichenbefehle sind, geben Sie einfach sing it ein.)

Hier ist der große Unterschied zwischen curve und lines.

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

Und hier ist ein kleiner Unterschied: curve muss mit add=TRUE aufgerufen werden, während lines bereits davon ausgeht, dass Sie einen vorhandenen Plot ergänzen.

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

Schauen Sie sich hinter den Kulissen methods(plot) an. Und überprüfen Sie body( plot.function )[[5]]. Wenn Sie plot(sin) R aufrufen, stellt sich heraus, dass sin eine Funktion ist (keine y-Werte), und verwendet die plot.function -Methode, die schließlich curve aufruft. curve ist also das Werkzeug, das Funktionen handhaben soll.

Wie in @redmode beschrieben, können Sie die beiden Linien mit ggplot im selben Grafikgerät zeichnen. In dieser Antwort hatten die Daten ein 'breites' Format. Wenn Sie jedoch ggplot verwenden, ist es im Allgemeinen am bequemsten, die Daten in einem Datenrahmen in einem "langen" Format zu halten. Wenn Sie dann in den Argumenten aes verschiedene 'Gruppierungsvariablen' verwenden, ändern sich die Eigenschaften der Linie, z. B. Linientyp oder Farbe, je nach Gruppierungsvariable, und die entsprechenden Legenden werden angezeigt.

In diesem Fall können wir die Ästhetik colour verwenden, die die Farbe der Linien mit den verschiedenen Ebenen einer Variablen im Datensatz vergleicht (hier: y1 vs y2). Aber zuerst müssen wir die Daten vom Breit- zum Langformat verschmelzen, indem wir z. die Funktion 'melt' aus reshape2 package. Andere Methoden zum Umformen der Daten werden hier beschrieben: mformen 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 (d. H. Keine Gitter-/Gittergrafiken), können Sie die Haltefunktion von MATLAB nachahmen, indem Sie die Funktionen Punkte/Linien/Polygone verwenden, um Ihren Zeichnungen zusätzliche Details hinzuzufügen, ohne eine neue Zeichnung zu beginnen. Im Falle eines Multiplot-Layouts können Sie mit par(mfg=...) auswählen, welchem ​​Plot Sie Dinge hinzufügen.

wenn Sie den Bildschirm teilen möchten, können Sie dies folgendermaßen tun:

(zum Beispiel für 2 Parzellen nebeneinander)

par(mfrow=c(1,2))

plot(x)

plot(y) 

Referenzlink

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

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

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

Speichern Sie die darzustellenden Werte nicht in einem Array, sondern in einer Matrix. Standardmäßig wird die gesamte Matrix als ein Datensatz behandelt. Wenn Sie jedoch die gleiche Anzahl von Modifikatoren zum Plot hinzufügen, z. das col (), wie Sie Zeilen in der Matrix haben, wird R herausfinden, 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, sofern Ihre Datensätze nicht unterschiedlich groß sind.

Idiomatic Matlab plot(x1,y1,x2,y2) kann mit ggplot2 in R übersetzt werden, zum Beispiel auf folgende Weise:

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 Doppelliniendiagramme mit unterschiedlichem Bereich der x-Achse mit ggplot2 .}

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

# 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:

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"))))

Verwendung von plotly (Hinzufügen einer Lösung aus plotly mit primärer und sekundärer 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: