Tracer deux graphiques dans le même tracé en R

Vous pouvez également utiliser par et tracer sur le même graphique mais un axe différent. Quelque chose comme suit:

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

Si vous lisez en détail sur par dans R, vous serez en mesure de générer des graphiques vraiment intéressants. Un autre livre à regarder est R Graphics DE Paul Murrel.

Lors de la construction de tracés multicouches, il faut considérer ggplot package. L'idée est de créer un objet graphique avec une esthétique de base et de l'améliorer progressivement.

ggplot le style nécessite que les données soient empaquetées dans data.frame.

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

Solution de base:

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

Ici + operator est utilisé pour ajouter des calques supplémentaires à l'objet de base.

Avec ggplot Vous avez accès à l'objet graphique à chaque étape du traçage. Dites, la configuration habituelle étape par étape peut ressembler à ce:

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 produit de l'intrigue, et vous pouvez le voir à chaque étape (ainsi, après la création d'au moins une couche). D'autres enchantements de l'intrigue sont également réalisés avec un objet créé. Par exemple, nous pouvons ajouter des étiquettes pour axises:

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

Finale g ressemble:

Mise à jour (2013-11-08):

Comme indiqué dans les commentaires, la philosophie de ggplot suggère d'utiliser des données en format long. Vous pouvez vous référer à cette réponse https://stackoverflow.com/a/19039094/1796914, afin de voir le code correspondant.

Je pense que la réponse que vous cherchez est:

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

Utilisez la fonction matplot:

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

Utilisez ceci si y1 et y2 sont évalués aux mêmes x points. Il adapte l'axe des Y pour s'adapter à celui qui est le plus grand (y1 ou y2), contrairement à certaines des autres réponses ici qui vont couper y2 si elle devient plus grande que y1 (les solutions ggplot sont généralement d'accord avec cela).

Sinon, et si les deux lignes n'ont pas les mêmes coordonnées x, définissez les limites d'axe sur le premier tracé et ajoutez:

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

Suis étonné ce Q est 4 ans et personne n'a mentionné matplot ou x/ylim...

Tl;dr: Vous souhaitez utiliser curve (avec add=TRUE) ou lines.

Je ne suis pas d'accord avec par(new=TRUE) parce que cela va double-imprimer les marques de tiques et les étiquettes d'axe. Par exemple

La sortie de plot(sin); par(new=T); plot( function(x) x**2 ).

Regardez à quel point les étiquettes d'axe vertical sont foiré! Depuis les plages sont différentes, vous devez définir la ylim=c(lowest point between the two functions, highest point between the two functions), ce qui est moins facile que ce que je vais vous montrer---et chemin moins facile si vous voulez ajouter ce ne sont pas deux courbes, mais beaucoup.

Ce qui m'a toujours confus au sujet du traçage est la différence entre curve et lines. (si vous ne vous souvenez pas que ce sont les noms des deux commandes de traçage importantes, il suffit de chanter Il.)

Voici la grande différence entre curve et lines.

curve va tracer une fonction, comme curve(sin). lines trace des points avec des valeurs x et y, comme: lines( x=0:10, y=sin(0:10) ).

Et voici une différence mineure: curve doit être appelé avec add=TRUE pour quoi vous essayez de le faire, alors que lines suppose déjà que vous ajoutez à un tracé existant.

Voici le résultat de l'appel de plot(0:2); curve(sin).

Dans les coulisses, consultez methods(plot). Et cochez body( plot.function )[[5]]. Lorsque vous appelez plot(sin) R détermine que sin est une fonction (Pas de valeurs y) et utilise la méthode plot.function, qui finit par appeler curve. Donc curve est l'outil destiné à gérer les fonctions.

Si vous utilisez des graphiques de base (c'est-à-dire pas des graphiques en treillis/ grille), vous pouvez imiter la fonction hold on de MATLAB en utilisant les fonctions points/lignes/polygones pour ajouter des détails supplémentaires à vos tracés sans démarrer un nouveau tracé. Dans le cas d'une mise en page multiplot, vous pouvez utiliser par(mfg=...) pour choisir le tracé auquel vous ajoutez des éléments.

Comme décrit par @redmode, vous pouvez tracer les deux lignes dans le même périphérique graphique en utilisant ggplot. Toutefois, les données dans la réponse était dans un grand format, alors que dans ggplot, il est généralement plus pratique de conserver les données dans un bloc de données dans un long format. Ensuite, en utilisant différentes 'variables de regroupement' dans les arguments aes, les propriétés de la ligne, telles que le type de ligne ou la couleur, varieront en fonction de la variable de regroupement, et les légendes correspondantes apparaîtront. Dans ce cas, nous pouvons utiliser le colour aessthetics, qui fait correspondre la couleur des lignes à différents niveaux d'une variable dans l'ensemble de données (ici: y1 vs y2). Mais nous devons d'abord faire fondre les données du format large au format long, en utilisant la fonction 'melt' du paquet reshape2.

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

Si vous voulez partager l'écran, vous pouvez le faire comme ceci:

(par exemple pour 2 parcelles ensemble)

par(mfrow=c(1,2))

plot(x)

plot(y) 

Lien De Référence

Vous pouvez utiliser des points pour le surplace, c'est-à-dire.

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

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

Plutôt que de conserver les valeurs à tracer dans un tableau, stockez-les dans une matrice. Par défaut, la matrice entière sera traitée comme un ensemble de données. Cependant, si vous ajoutez le même nombre de modificateurs au tracé, par exemple col(), comme vous avez des lignes dans la matrice, R comprendra que chaque ligne doit être traitée indépendamment. Par exemple:

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

Cela devrait fonctionner à moins que vos ensembles de données ne soient de tailles différentes.

Idiomatiques Matlab plot(x1,y1,x2,y2) peut être traduit en R avec ggplot2 par exemple de cette façon:

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

^{inspiré par Tingting Zhao double ligne tracés avec différentes gamme de x-axe en utilisant ggplot2 .}

Vous pouvez également créer votre tracé en utilisant ggvis :

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

Cela va créer le tracé suivant:

Vous pouvez utiliser l'API Plotly R pour styliser ceci. Voici le code pour le faire, et la version live de ce graphique est ici .

# call Plotly and enter username and key
library(plotly)
p <- plotly(username="Username", key="API_KEY")

# enter data
x  <- seq(-2, 2, 0.05)
y1 <- pnorm(x)
y2 <- pnorm(x,1,1)

# format, listing y1 as your y.
First <- list(
x = x,
y = y1,
type = 'scatter',
mode = 'lines',
marker = list(
    color = 'rgb(0, 0, 255)',
    opacity = 0.5
 )
)

# format again, listing y2 as your y.
Second <- list(
x = x,
y = y2,
type = 'scatter',
mode = 'lines',
opacity = 0.8, 
marker = list(
    color = 'rgb(255, 0, 0)'
 )
)

# style background color
plot_bgcolor = 'rgb(245,245,247)'

# and structure the response. Plotly returns a URL when you make the call. 
response<-p$plotly(list(First,Second), kwargs = list(layout=layout))

Divulgation complète: je suis dans L'équipe Plotly.

Nous pouvons également utiliser la bibliothèque de treillis

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

Pour des couleurs spécifiques

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