Régression Linéaire R/TCLTK

require(tcltk)
env<-environment(.libPaths)
assign(".lib.loc",shortPathName(get(".lib.loc",envir=env)),envir=env)
R.base.dir <- system.file()
setwd(paste(R.base.dir,"/../../doc/html/Projet",sep=""))
library("tkrplot")
tclRequire("Img")
tclRequire("Tktable")
tclRequire("BWidget")
style1 <- tkfont.create(family = "verdana", size = 14, weight = "normal")
##############################################################################
##############################################################################
##
Acceuil <- tktoplevel()
tkwm.title(Acceuil,"Acceuil")
tkgrid(tklabel(Acceuil,text="\n"))
tkgrid(tklabel(Acceuil,text=" Projet de régression linéaire \n", font =style3, foreground =

"red"))
tkgrid(tklabel(Acceuil,text="\n Réalisé par: Elmahdi AZIZEDDINE Encadrant: Pr

Jean-Yves Dauxois \n \n Master Modélisation Statistique \n \n Université de
Franche-Comté Année universitaire: 2009-2010 \n ", font =style1))
tkgrid(tklabel(Acceuil,text="\n Veuillez parcourir votre table de données \n", font

=style2))
parcourir <- function()
tkdestroy(Acceuil)
parcourirdonnees()
bouttonparcourir <- tkbutton(Acceuil,text=" Parcourir ", command = parcourir)
tkgrid(bouttonparcourir)
tkgrid(tklabel(Acceuil,text="\n"))
tkfocus(Acceuil)
##############################################################################
##############################################################################
##
statistiquesdescriptives <- function()
X <- X[,1]
Y <- Y[,1]
quantileX <- quantile(X)
quantileY <- quantile(Y)
minimumX <- quantileX[1]
minimumY <- quantileY[1]
maximumX <- quantileX[5]
maximumY <- quantileY[5]
premierquartileX <- quantileX[2]
premierquartileY <- quantileY[2]
troisiemequartileX <- quantileX[4]
troisiemequartileY <- quantileY[4]
moyenneX <- mean(X)
moyenneY <- mean(Y)

medianeX <- quantileX[3]
medianeY <- quantileY[3]
varianceX <- sum((X - mean(X))^2)/length(X)
varianceY <- sum((Y - mean(Y))^2)/length(Y)
covarianceXY <- sum((X - mean(X))*(Y - mean(Y)))/length(X)
titre1 <- c("\"de la variable expliquée\"")
titre2 <- c("\"de la variable expliquative\"")
matable1 <- c("Minimum","\"Premier quartile\"","Médiane","Moyenne","\"Troisième

quartile\"","Maximum","Variance",
minimumX,premierquartileX,medianeX,moyenneX,troisiemequartileX,maximumX,varianceX)
matable2 <- c("Minimum","\"Premier quartile\"","Médiane","Moyenne","\"Troisième

quartile\"","Maximum","Variance",
minimumY,premierquartileY,medianeY,moyenneY,troisiemequartileY,maximumY,varianceY)
covariance <- c("Covariance")
valeurdelacovariance <- c(covarianceXY)
dim(matable1) <- c(7,2)
dim(matable2) <- c(7,2)
dim(titre1) <- c(1,1)
dim(titre2) <- c(1,1)
dim(covariance) <- c(1,1)
dim(valeurdelacovariance) <- c(1,1)
for (i in (0:6))
for (j in (0:1))
.Tcl(paste("set tclarraY(",i,",",j,") ",matable1[i+1,j+1],sep=""))

.Tcl(paste("set tclarray2(",i,",",j,") ",matable2[i+1,j+1],sep=""))
.Tcl(paste("set tclarray3(",0,",",0,") ",titre1[1,1],sep=""))
.Tcl(paste("set tclarray4(",0,",",0,") ",titre2[1,1],sep=""))
.Tcl(paste("set tclarray5(",0,",",0,") ",covariance[1,1],sep=""))
.Tcl(paste("set tclarray6(",0,",",0,") ",valeurdelacovariance[1,1],sep=""))
tt3<-tktoplevel()
tkwm.title(tt3,"Statistiques descriptives")
titre1 <-
tkwidget(tt3,"table",variable="tclarray3",rows="1",cols="1",titlerows="1",selectmode="extende
d",colwidth="25",background="white")
table1 <-
tkwidget(tt3,"table",variable="tclarraY",rows="7",cols="2",selectmode="extended",colwidth="2
5",background="white")
titre2 <-
table2 <-
tkwidget(tt3,"table",variable="tclarray2",rows="7",cols="2",selectmode="extended",colwidth="
covariance <-
valeurdelacovariance <-
tkgrid(tklabel(tt3,text=paste("\n Statistiques descriptives \n"), font=style2))
tkgrid(titre1)
tkgrid(table1)
tkgrid(titre2)
tkgrid(table2)
tkgrid(covariance)
tkgrid(valeurdelacovariance)
tkgrid(tklabel(tt3,text="\n"))
fermerstatdesc <- function()
tkdestroy(tt3)
fermer.but <- tkbutton(tt3,text=" Fermer ",command=fermerstatdesc)
tkgrid(fermer.but)
tkfocus(tt3)
##############################################################################
##############################################################################
##
nuagedepoints <- function()
X1 <- X[,1]
Y1 <- Y[,1]
labelsVec <- LETTERS
require(tkrplot)
indexLabeled<-c()
labeledPoints <- list()
tt4 <- tktoplevel()
tkwm.title(tt4,"Nuage de points")
parPlotSize <- c()
usrCoords <- c()
plotFunction <- function()
params <- par(bg="white")
plot(X1, Y1, pch=4, main = paste("Graphe de ", names(Y), "en fonction de", names(X)), xlab =
names(X), ylab = names(Y))
if (length(indexLabeled)>0)
for (i in (1:length(indexLabeled)))
indexClosest <- indexLabeled[i]
text(X1[indexClosest],Y1[indexClosest],
labels=labelsVec[indexClosest],pos=3)
parPlotSize <<- par("plt")
usrCoords <<- par("usr")
par(params)
img <- tkrplot(tt4,fun=plotFunction,hscale=1.5,vscale=1.5)
labelClosestPoint <- function(xClick,yClick,imgXcoords,imgYcoords)
squared.Distance <- (xClick-imgXcoords)^2 + (yClick-imgYcoords)^2
indexClosest <- which.min(squared.Distance)
indexLabeled <<- c(indexLabeled,indexClosest)
tkrreplot(img)
}
OnLeftClick <- function(x,y)
xClick <- x
yClick <- y
require(tcltk)
width <- as.numeric(tclvalue(tkwinfo("reqwidth",img)))
height <- as.numeric(tclvalue(tkwinfo("reqheight",img)))
xMin <- parPlotSize[1] * width
xMax <- parPlotSize[2] * width
yMin <- parPlotSize[3] * height
yMax <- parPlotSize[4] * height
rangeX <- usrCoords[2] - usrCoords[1]
rangeY <- usrCoords[4] - usrCoords[3]
imgXcoords <- (X1-usrCoords[1])*(xMax-xMin)/rangeX + xMin
imgYcoords <- (Y1-usrCoords[3])*(yMax-yMin)/rangeY + yMin
xClick <- as.numeric(xClick)+0.5
yClick <- as.numeric(yClick)+0.5
yClick <- height - yClick
xPlotCoord <- usrCoords[1]+(xClick-xMin)*rangeX/(xMax-xMin)
yPlotCoord <- usrCoords[3]+(yClick-yMin)*rangeY/(yMax-yMin)
msg <- paste("Les coordonnées approximatives de ce point sont: \n",
"x =",format(xPlotCoord,digits=2),",y =",format(yPlotCoord,digits=2),". Voulez-vous

l'étiqueter?")
mbval<- tkmessageBox(title="Etiqueter un point",
message=msg,type="yesno",icon="question")
if (tclvalue(mbval)=="yes")
labelClosestPoint(xClick,yClick,imgXcoords,imgYcoords)
tkbind(img, "<Button-1>",OnLeftClick)
tkconfigure(img,cursor="hand2")
CopyToClip <- function()
tkrreplot(img)
tkgrid(tklabel(tt4,text="Veuillez cliquer sur un point pour visualiser ses coordonnées."))
copy.but <- tkbutton(tt4,text="Copier l'image",command=CopyToClip)
tkgrid(img)
tkgrid(copy.but)
OK.but <- tkbutton(tt4,text=" Fermer ",command=function() tkdestroy(tt4))
tkgrid(OK.but)
tkfocus(tt4)
##############################################################################
##############################################################################
##
estimateursdesmco <- function()
X <- X[,1]
Y <- Y[,1]

beta2chapeau <- covarianceXY/ varianceX
beta1chapeau <- mean(Y) - beta2chapeau * mean(X)
valeurbeta1chapeau <- c(beta1chapeau)
valeurbeta2chapeau <- c(beta2chapeau)
dim(valeurbeta1chapeau) <- c(1,1)
dim(valeurbeta2chapeau) <- c(1,1)
.Tcl(paste("set tclarray8(",0,",",0,") ",valeurbeta1chapeau[1,1],sep=""))
.Tcl(paste("set tclarray9(",0,",",0,") ",valeurbeta2chapeau[1,1],sep=""))
tt5<-tktoplevel()
tkwm.title(tt5,"Estimateurs des MCO")
valeurbeta1chapeau <-
valeurbeta2chapeau <-
tkgrid(tklabel(tt5,text=paste("L'estimateur de l'ordonnée à l'origine beta 1 chapeau"),

font=style1))
tkgrid(tklabel(tt5,text=paste("vaut:"), font=style1))
tkgrid(valeurbeta1chapeau)
tkgrid(tklabel(tt5,text=paste("L'estimateur de la pente beta 2 chapeau"), font=style1))
tkgrid(tklabel(tt5,text=paste("vaut:"), font=style1))
tkgrid(valeurbeta2chapeau)
tkgrid(tklabel(tt5,text=paste("L'équation de la droite de régression est:

Y=",beta1chapeau,"+",beta2chapeau,"X"), font=style1))
fermerestmco <- function()

{
tkdestroy(tt5)
fermer.but <- tkbutton(tt5,text=" Fermer ",command=fermerestmco)
tkgrid(fermer.but)
tkfocus(tt5)
##############################################################################
##############################################################################
##
tests <- function()
X <- X[,1]
Y <- Y[,1]
Ychapeau <- beta1chapeau + beta2chapeau * X
e1 <- Y - Ychapeau
e2 <- e1 * e1
sigma2chapeau <- sum(e2)/(length(X)-2)
sigma2chapeaubeta1chapeau <- (sigma2chapeau * sum(X^2))/(length(X)*sum((X - mean(X))^2))
sigma2chapeaubeta2chapeau <- sigma2chapeau/(sum((X - mean(X))^2))

valeurcritique <- qt(1 - 0.05/2, length(X)-2)
T1 <- beta1chapeau/sqrt(sigma2chapeaubeta1chapeau)
rejet1 <- abs(T1) > valeurcritique
if (rejet1 == TRUE)
conclusion1 <- "On rejette l'hypothèse H0 \n Conclusion: Le modèle de régression linéaire est
significatif."
else
conclusion1 <- "On ne peux pas rejetter l'hypothèse H0"
T2 <- beta2chapeau/sqrt(sigma2chapeaubeta2chapeau)
rejet2 <- abs(T2) > valeurcritique
if (rejet2 == TRUE)
conclusion2 <- "On rejette l'hypothèse H0. \n Conclusion: la droite de régression ne passe pas
par l'origine."
else
conclusion2 <- "On ne peux pas rejetter l'hypothèse H0"
borneInf2 <- beta2chapeau - valeurcritique * sqrt(sigma2chapeaubeta2chapeau)
borneSup2 <- beta2chapeau + valeurcritique * sqrt(sigma2chapeaubeta2chapeau)
statistique1 <- c("Statistique")
dim(statistique1) <- c(1,1)
.Tcl(paste("set tclarraY0(",0,",",0,") ",statistique1[1,1],sep=""))
valeurstatistique1 <- c(T1)
dim(valeurstatistique1) <- c(1,1)
.Tcl(paste("set tclarraY1(",0,",",0,") ",valeurstatistique1[1,1],sep=""))
affichervaleurcritique1 <- c("\"Valeur critique\"")
dim(affichervaleurcritique1) <- c(1,1)
.Tcl(paste("set tclarraY2(",0,",",0,") ",affichervaleurcritique1[1,1],sep=""))

valeurdelavaleurcritique1 <- c(valeurcritique)
dim(valeurdelavaleurcritique1) <- c(1,1)
.Tcl(paste("set tclarraY3(",0,",",0,") ",valeurdelavaleurcritique1[1,1],sep=""))
statistique2 <- c("Statistique")
dim(statistique2) <- c(1,1)
.Tcl(paste("set tclarraY4(",0,",",0,") ",statistique2[1,1],sep=""))
valeurstatistique2 <- c(T2)
dim(valeurstatistique2) <- c(1,1)
.Tcl(paste("set tclarraY5(",0,",",0,") ",valeurstatistique2[1,1],sep=""))
affichervaleurcritique2 <- c("\"Valeur critique\"")
dim(affichervaleurcritique2) <- c(1,1)
.Tcl(paste("set tclarraY6(",0,",",0,") ",affichervaleurcritique2[1,1],sep=""))
valeurdelavaleurcritique2 <- c(valeurcritique)
dim(valeurdelavaleurcritique2) <- c(1,1)
.Tcl(paste("set tclarraY7(",0,",",0,") ",valeurdelavaleurcritique2[1,1],sep=""))
tt6<-tktoplevel()
tkwm.title(tt6,"Tests")
statistique1 <-
tkwidget(tt6,"table",variable="tclarraY0",rows="1",cols="1",titlerows="1",selectmode="extende
valeurstatistique1 <-
tkwidget(tt6,"table",variable="tclarraY1",rows="1",cols="1",selectmode="extended",colwidth="
affichervaleurcritique1 <-
valeurdelavaleurcritique1 <-
statistique2 <-
valeurstatistique2 <-
affichervaleurcritique2 <-
valeurdelavaleurcritique2 <-
tkgrid(tklabel(tt6,text="\n Remarque: dans tous ce qui suit le risque est fixé à 5%."))
tkgrid(tklabel(tt6,text="___________________________________________________________
_______________________"))
tkgrid(tklabel(tt6,text="Test de nullité du terme constant", font=style1))
tkgrid(tklabel(tt6,text="On effectue le test suivant: Ho: beta1=0 ; H1:beta1#0"))
tkgrid(statistique1)
tkgrid(valeurstatistique1)
tkgrid(affichervaleurcritique1)
tkgrid(valeurdelavaleurcritique1)
tkgrid(tklabel(tt6,text=paste("",conclusion1,"")))
_______________________"))
tkgrid(tklabel(tt6,text="Test de nullité de la pente", font=style1))
tkgrid(tklabel(tt6,text="On effectue le test suivant: Ho: beta2=0 ; H1:beta2#0"))
tkgrid(statistique2)
tkgrid(valeurstatistique2)
tkgrid(affichervaleurcritique2)
tkgrid(valeurdelavaleurcritique2)
tkgrid(tklabel(tt6,text=paste("",conclusion2,"\n")))
fermertests <- function()
tkdestroy(tt6)
fermer.but <- tkbutton(tt6,text=" Fermer ",command=fermertests)
tkgrid(fermer.but)
tkfocus(tt6)
##############################################################################
##############################################################################
##
intervallesdeconfiance <- function()
X <- X[,1]
Y <- Y[,1]
e1 <- Y - Ychapeau
e2 <- e1 * e1

sigma2chapeaubeta1chapeau <- (sigma2chapeau * sum(X^2))/(length(X)*sum((X - mean(X))^2))
sigma2chapeaubeta2chapeau <- sigma2chapeau/(sum((X - mean(X))^2))
valeurcritique <- qt(1 - 0.05/2, length(X)-2)
borneinferieure1 <- beta1chapeau - valeurcritique * sqrt(sigma2chapeaubeta1chapeau)
bornesuperieure1 <- beta1chapeau + valeurcritique * sqrt(sigma2chapeaubeta1chapeau)
borneinferieure2 <- beta2chapeau - valeurcritique * sqrt(sigma2chapeaubeta2chapeau)
bornesuperieure2 <- beta2chapeau + valeurcritique * sqrt(sigma2chapeaubeta2chapeau)
tt7<-tktoplevel()
tkwm.title(tt7,"Intervalles de confiance")
tkgrid(tklabel(tt7,text="\n Remarque: dans tous ce qui suit le risque est fixé à 5%."))
_______________________"))
image6 <- tclVar()
tkgrid(tklabel(tt7,text="L'intervalle de confiance de beta1 est:", font=style1))
tkgrid(tklabel(tt7,text=paste("\n est: [",borneinferieure1,",",bornesuperieure1,"].")))
_______________________"))
tkgrid(tklabel(tt7,text="L'intervalle de confiance de beta2 est:", font=style1))
tkgrid(tklabel(tt7,text=paste("\n est: [",borneinferieure2,",",bornesuperieure2,"].")))
fermerinterconf <- function()
tkdestroy(tt7)
fermer.but <- tkbutton(tt7,text=" Fermer ",command=fermerinterconf)
tkgrid(fermer.but)
tkfocus(tt7)
##############################################################################
##############################################################################
##
prevision <- function()
X <- X[,1]
Y <- Y[,1]
e1 <- Y - Ychapeau
e2 <- e1 * e1
tt8 <- tktoplevel()
tkwm.title(tt8, "Prévision")
valeurX <- tclVar(" ")
entrer.valeur <- tkentry(tt8,width="20",textvariable=valeurX)
tkgrid(tklabel(tt8,text=paste("\n Veuillez entrer la valeur de la variable ",names(X),"\n"),

font=style1))
tkgrid(entrer.valeur)
OnOK <- function()
valeur <- as.numeric(tclvalue(valeurX))
valeurentree <- as.numeric(tclvalue(valeurX))
valeurcritique = qt(1 - 0.05/2, length(X)-2)
valeurprevisionnelle = beta1chapeau + beta2chapeau * valeurentree
borneinferieuredelaprevision = valeurprevisionnelle - valeurcritique * sqrt(sigma2chapeau) *

sqrt(1 + (1/length(X)) + ((valeurentree - mean(X))^2)/(sum((X - mean(X))^2)))
bornesuperieuredelaprevision= valeurprevisionnelle + valeurcritique * sqrt(sigma2chapeau) *

sqrt(1 + (1/length(X)) + ((valeurentree - mean(X))^2)/(sum((X - mean(X))^2)))
tt9 <- tktoplevel()
tkwm.title(tt9, "Prévision")
prevision1 <- c("X",valeurentree,"\"Valeur prévisionnelle\"",valeurprevisionnelle)
dim(prevision1) <- c(2,2)
for (i in (0:1))
for (j in (0:1))
.Tcl(paste("set tclarraY7(",i,",",j,") ",prevision1[i+1,j+1],sep=""))
prevision1 <-
tkgrid(tklabel(tt9,text=paste(" Prévision pour X =",valeurentree,": \n"),

font=style2))
tkgrid(prevision1)
tkgrid(tklabel(tt9,text=paste("\n Intervalle de prévision:

[",borneinferieuredelaprevision,",",bornesuperieuredelaprevision,"] ")))
tkdestroy(tt8)
fermerprev <- function()
tkdestroy(tt9)
fermer.but <- tkbutton(tt9,text=" Fermer ",command=fermerprev)
tkgrid(fermer.but)
tkfocus(tt9)
OK.but <- tkbutton(tt8,text=" OK ",command=OnOK)
tkgrid(OK.but)
tkfocus(tt8)
##############################################################################
##############################################################################
##
analysedelavariance <- function()
Y <- Y[,1]
X <- X[,1]

SCT <- sum((Y - mean(Y))^2)
SCE <- sum((Ychapeau- mean(Y))^2)
SCR <- sum((Y-Ychapeau)^2)
CME <- SCE/(length(X)-1)
F <- SCR/CME
analysedelavariancetitre <- c("\"Le tableau ANOVA\"")
analysedelavariancecontenu <-
c("\" \"","SCE","SCR","SCT","Variation","Expliquée","Résiduelle","Totale","dll",1,length(X)-
2,length(X)-1,"SC",SCE,SCR,SCT,"CM",CME,SCR,SCR,"F",F,F,F)
titrecoefficientdedetermination <- c("\"Coefficient de détermination\"")
valeurcoefficientdedetermination <- c("R²",SCE/SCT)
dim(analysedelavariancetitre) <- c(1,1)
dim(analysedelavariancecontenu) <- c(4,6)
dim(titrecoefficientdedetermination) <- c(1,1)
dim(valeurcoefficientdedetermination) <- c(1,2)
.Tcl(paste("set tclarray10(",0,",",0,") ",analysedelavariancetitre[1,1],sep=""))
for (i in (0:3))
for (j in (0:5))
.Tcl(paste("set tclarray11(",i,",",j,") ",analysedelavariancecontenu[i+1,j+1],sep=""))
.Tcl(paste("set tclarray12(",0,",",0,") ",titrecoefficientdedetermination[1,1],sep=""))
.Tcl(paste("set tclarray13(",0,",",0,") ",valeurcoefficientdedetermination[1,1],sep=""))

.Tcl(paste("set tclarray13(",0,",",1,") ",valeurcoefficientdedetermination[1,2],sep=""))
tt10<-tktoplevel()
tkwm.title(tt10, "Analyse de la variance")
adlvtitre <-
tkwidget(tt10,"table",variable="tclarray10",titlerows="1",rows="1",cols="1",selectmode="exten
ded",colwidth="25",background="white")
tkgrid(adlvtitre)
adlvcontenu <-
tkwidget(tt10,"table",variable="tclarray11",rows="4",cols="6",selectmode="extended",colwidth
="25",background="white")
tkgrid(adlvcontenu)
cddtitre <-
tkwidget(tt10,"table",variable="tclarray12",titlerows="1",rows="1",cols="1",selectmode="exten
ded",colwidth="25",background="white")
tkgrid(cddtitre)
cddcontenu <-
tkwidget(tt10,"table",variable="tclarray13",rows="1",cols="2",selectmode="extended",colwidth
="25",background="white")
tkgrid(cddcontenu)
fermeranov <- function()
tkdestroy(tt10)
fermer.but <- tkbutton(tt10,text=" Fermer ",command=fermeranov)
tkgrid(fermer.but)
}
##############################################################################
##############################################################################
##
resume <- function()
library(tkrplot)
Myhscale <- 1.5
Myvscale <- 1.5
plotFunction <- function()
params <- par(bg="white")
X1 = X[,1]
Y1 = Y[,1]
Xsort <- sort(X1)
valeurcritique <- qt(1 - 0.05/2, length(X1)-2)
varianceX <- sum((X1 - mean(X1))^2)/length(X1)
varianceY <- sum((Y1 - mean(Y1))^2)/length(Y1)
covarianceXY <- sum((X1 - mean(X1))*(Y1 - mean(Y1)))/length(X1)
beta1chapeau <- mean(Y1) - beta2chapeau * mean(X1)
Ychapeau1 <- beta1chapeau + beta2chapeau * X1
Ychapeau2 <- beta1chapeau + beta2chapeau * sort(X1)
e1 <- Y - Ychapeau1
e2 <- e1 * e1
sigma2chapeau <- sum(e2)/(length(X1)-2)
SCT <- sum((Y1 - mean(Y1))^2)

SCE <- sum((Ychapeau1- mean(Y1))^2)
SCR <- sum((Y1-Ychapeau1)^2)
r = SCE/SCT
X2 <- X[,1]
Y2 <- Y[,1]
moyenneX <- mean(X2)
moyenneY <- mean(Y2)
droiteinferieure = beta1chapeau + beta2chapeau * Xsort - valeurcritique * sqrt(sigma2chapeau)

* sqrt(1/length(X1) + ((Xsort - mean(X1))^2) / (sum((Xsort - mean(X1))^2)))
droitesuperieure = beta1chapeau + beta2chapeau * Xsort + valeurcritique *

sqrt(sigma2chapeau) * sqrt(1/length(X1) + ((Xsort - mean(X1))^2) / (sum((Xsort - mean(X1))^2)))
previsionsinferieures = Ychapeau2 - valeurcritique * sqrt(sigma2chapeau) * sqrt(1 +

(1/length(X1)) + ((Xsort - mean(X1))^2) / (sum((Xsort - mean(X1))^2)))
previsionssuperieures = Ychapeau2 + valeurcritique * sqrt(sigma2chapeau) * sqrt(1 +

(1/length(X1)) + ((Xsort - mean(X1))^2) / (sum((Xsort - mean(X1))^2)))
plot(Y1~X1,pch=4, xlab = names(X), ylab = names(Y), main = paste("Résumé"),xlim =

c(min(X1),max(X1)), ylim = c(min(Y1,droiteinferieure ),max(Y1,droitesuperieure)))
abline(beta1chapeau,beta2chapeau, col = "black", lwd=2)
par(new = TRUE)
plot(Xsort,droiteinferieure,xlab = "",ylab = "",type="l",lwd=2,lty = 2, xlim = c(min(X1),max(X1)),

ylim = c(min(Y1,droiteinferieure),max(Y1,droitesuperieure)), col = "grey")
par(new = TRUE)
plot(Xsort,droitesuperieure,xlab = "",ylab = "", type="l",lwd=2,lty = 2, xlim = c(min(X1),max(X1)),

ylim = c(min(Y1,droiteinferieure),max(Y1,droitesuperieure)), col = "grey")
par(new = TRUE)
plot(Xsort,previsionsinferieures,xlab = "",ylab = "",type="l",lwd=2, lty = 2, xlim =

c(min(X1),max(X1)), ylim = c(min(Y1,droiteinferieure),max(Y,droitesuperieure )), col = "blue")
par(new = TRUE)
plot(Xsort,previsionssuperieures,xlab = "",ylab = "", type="l",lwd=2,lty = 2, xlim =
c(min(X1),max(X1)), ylim = c(min(Y1,droiteinferieure ),max(Y,droitesuperieure )), col = "blue")
legend(moyenneX,moyenneY,c("Droite de régression", "I.C. de la droite de régression", "I.C. des

prévisions"),lwd=2,col=c("black", "grey", "blue"))
tt <- tktoplevel()
tkwm.title(tt,"Nuage de points, Droite de régression et Intervalles de Confiance")
img <- tkrplot(tt,fun=plotFunction,hscale=Myhscale,vscale=Myvscale)
tkgrid(img)
OK.but <- tkbutton(tt,text=" Fermer ",command=function() tkdestroy(tt))
tkgrid(OK.but)
##############################################################################
##############################################################################
##
regressionlineairemultiple <- function()
Donnees <- cbind(Y,X)
visualiserdonneesmult <- function()
T <- cbind(Y,X)
code <- (text="library(relimp, pos=4) \n showData(Donnees, placement='-20+200',

maxwidth=80, maxheight=30)")
e <- try(parse(text=code))
cat("", code, "", sep="\n")
print(eval(e))
}
statistiquesdescriptivesmult <- function()
T <- cbind(Y,X)
code <- (text="stats <- summary(T)")
print(eval(e))
tt19 <- tktoplevel()
tkwm.title(tt19,"Statistiques descriptives")
tkgrid(tklabel(tt19, text="\n Statistiques descriptives des variables \n",font=style2

,foreground="red"))
sw <- tkwidget(tt19,"ScrolledWindow",relief="sunken",borderwidth=2)
sf <- tkwidget(sw,"ScrollableFrame")
tcl(sw,"setwidget",sf)
subfID <- tclvalue(tcl(sf,"getframe"))
entryList <- list()
for (i in (1:length(T)))
entryList[[i]] <- tcl("entry",paste(subfID,".",i,sep=""),width=50)
tkgrid(entryList[[i]],pady=4)
tkbind(entryList[[i]],"<FocusIn>",function() tcl(sf,"see",entryList[[i]]))
tkinsert(entryList[[i]],"end",paste("Variable:",names(T)[i]," | ",stats[i-(i-1),i]," | ",stats[i-(i-

1)+1,i]," | ",stats[i-(i-1)+2,i]," | ",stats[i-(i-1)+3,i]," | ",stats[i-(i-1)+4,i]," | ",stats[i-(i-1)+5,i]))
tkgrid(sw)
tkgrid(tklabel(tt19, text="Note",font=style1 ,foreground="red"))

tkgrid(tklabel(tt19, text=paste("Min. = Minimum \n 1st Qu. = Premier quartile \n Median =
Médiane \n Mean = Moyenne \n 3rd Qu. = Troisième quartile \n Max. = Maximum \n")))
fermerstatistiquesdescriptivesmult <- function()
tkdestroy(tt19)
fermer.but <- tkbutton(tt19,text=" Fermer ",command=fermerstatistiquesdescriptivesmult)
tkgrid(fermer.but)
tkfocus(tt19)
estimateursmcomult <- function()
T <- cbind(Y,X)
code <- (text="RegMode <- lm(T) \n Co <- RegMode$coefficients")
print(eval(e))
tkwm.title(tt19,"Estimateurs des MCO")
entryList <- list()
{
tkinsert(entryList[[i]],"end",paste("L'estimateur de Beta",i," est :",Co[i]))
tkgrid(tklabel(tt19, text="\n Les estimateurs des MCO \n",font=style2 ,foreground="red"))
tkgrid(sw)
fermerestimateursmcomult <- function()
tkdestroy(tt19)
fermer.but <- tkbutton(tt19,text=" Fermer ",command=fermerestimateursmcomult)
tkgrid(fermer.but)
tkfocus(tt19)
Intervallesdeconfiancemult <- function()
T <- cbind(Y,X)
code <- (text="RegMode <- lm(T) \n intervalle <- confint(RegMode)")
print(eval(e))
tkwm.title(tt19,"Intervalles de confiance")
tkgrid(tklabel(tt19, text="\n Intervalles de confiance",font=style2 ,foreground="red"))

tkgrid(tklabel(tt19,
text="_________________________________________________________________________
_______________________________"))
tkgrid(tklabel(tt19, text="\n Dans ce qui suit, le risque alpha est fixé à 5% \n

______________________________________________________________________________
__________________________"))
entryList <- list()
tkinsert(entryList[[i]],"end",paste("Pour Beta",i," : [",intervalle[i,i-(i-1)],",",intervalle[i,i-(i-

1)+1],"]"))
tkgrid(sw)
fermerIntervallesdeconfiancemult <- function()
tkdestroy(tt19)
fermer.but <- tkbutton(tt19,text=" Fermer ",command=fermerIntervallesdeconfiancemult)
tkgrid(fermer.but)
tkfocus(tt19)
tkfocus(tt19)
residus <- function()
T <- cbind(Y,X)
code <- (text="RegMode <- lm(T) \n ResMode <- residuals(RegMode)")
print(eval(e))
tkwm.title(tt19,"Résidus")
tkpack(tklabel(tt19,text="Les résidus",font=style2 , foreground="red"))
lab <- tcl("label",paste(subfID,".lab",sep=""),text="Résultat")
tkpack(lab)
entryList <- list()
for (i in (1:dim(T)))
tkpack(entryList[[i]],fill="x",pady=4)
tkinsert(entryList[[i]],"end",paste(ResMode[i]))
tkpack(sw,fill="both",expand="yes")
predictions <- function()
T <- cbind(Y,X)
code <- (text="RegMode <- lm(T) \n ResMode <- predict(RegMode)")
print(eval(e))
tkwm.title(tt19,"Prédictions")
tkpack(tklabel(tt19,text="Les prédictions",font=style2 , foreground="red"))
tkpack(lab)
entryList <- list()

anov <- function() {
T <- cbind(Y,X)
code <- (text="RegMode <- lm(T) \n AnoMode <- anova(RegMode)")
print(eval(e))
tkwm.title(tt19,"Tableau ANOVA")
entryList <- list()
for (i in (1:(length(T)-1)))
tkinsert(entryList[[i]],"end",paste("Variable :",names(X)[i]," | DDL =",AnoMode[i,i-(i-1)]," | SCE
=",AnoMode[i,i-(i-1)+1]," | MCE=",AnoMode[i,i-(i-1)+2]," | F =",AnoMode[i,i-(i-1)+3]," | Pr(>F)
=",AnoMode[i,i-(i-1)+4]))
entryList[[length(T)]] <- tcl("entry",paste(subfID,".",length(T),sep=""),width=50)
tkgrid(entryList[[length(T)]],pady=4)
tkbind(entryList[[length(T)]],"<FocusIn>",function() tcl(sf,"see",entryList[[length(T)]]))
tkinsert(entryList[[length(T)]],"end",paste("Résidus | DDL =",AnoMode[length(T),length(T)-

(length(T)-1)]," | SCR =",AnoMode[length(T),length(T)-(length(T)-1)+1]," |
MCR=",AnoMode[length(T),length(T)-(length(T)-1)+2]))
tkgrid(tklabel(tt19, text="\n Analyse de la variance \n",font=style2 , foreground="red"))
tkgrid(sw)
fermeranov <- function()
tkdestroy(tt19)
fermer.but <- tkbutton(tt19,text=" Fermer ",command=fermeranov)
tkgrid(fermer.but)
tkfocus(tt19)
as.TclList <- function(object,...) UseMethod("as.TclList")
as.TclList.list <- function(stringList)
result <-"{"
for (i in (1:length(stringList)))
result <- paste(result,"{",stringList[[i]],"} ",sep="")
result <- paste(result,"}",sep="")

result
tkwm.title(tt18,"Menu de la regression linéaire multiple")
tkgrid(tklabel(tt18,text = paste("________________________________________________ \n \n
La variable à expliquer est : ", names(Y)) ,font=style1))
for (i in (1:(length(T)-1)))
tkgrid(tklabel(tt18,text=paste("La variable explicative n°",i,"est : ",names(X)[i],""),font=style1))
tkgrid(tklabel(tt18,text="________________________________________________ \n\n",
font=style1))
tkgrid(tklabel(tt18,text="\n Veuillez indiquer le nombre de variables explicatives: \n",

font=style2))
menudelaregressionlineairemultiple <- list("Table de données","Statistiques

descriptives","Estimateurs des MCO","Intervalles de confiance","Résidus","Prédictions","Analyse
de la variance")
menudelaregressionlineairemultipleTclList <- as.TclList(menudelaregressionlineairemultiple)
comboBox <- .Tk.subwin(tt18)
.Tcl(paste("ComboBox",.Tk.ID(comboBox),"-editable true
-values",menudelaregressionlineairemultipleTclList))
tkgrid(comboBox)
OnOK <- function()
choixmenudelaregressionlineairemultiple <-
menudelaregressionlineairemultiple[[as.numeric(tclvalue(tcl(comboBox,"getvalue")))+1]]
if (choixmenudelaregressionlineairemultiple=="Table de données")
visualiserdonneesmult()
}
if (choixmenudelaregressionlineairemultiple=="Statistiques descriptives")
statistiquesdescriptivesmult()
if (choixmenudelaregressionlineairemultiple=="Estimateurs des MCO")
estimateursmcomult()
if (choixmenudelaregressionlineairemultiple=="Intervalles de confiance")
Intervallesdeconfiancemult()
if (choixmenudelaregressionlineairemultiple=="Résidus")
residus()
if (choixmenudelaregressionlineairemultiple=="Prédictions")
predictions()
if (choixmenudelaregressionlineairemultiple=="Analyse de la variance")
anov()
}
}
tkgrid(OK.but)
changerlejeudedonnees <- function()
tkdestroy(tt18)
parcourir()
parcourir.but <- tkbutton(tt18,text=" Changer le jeu de données

",command=changerlejeudedonnees)
tkgrid(parcourir.but)
changerlaregression <- function()
tkdestroy(tt18)
choixdelaregression()
changerlaregression.but <- tkbutton(tt18,text=" Changer la régression

",command=changerlaregression)
tkgrid(changerlaregression.but)
lancerrcommander <- function()
code <- (text="library(Rcmdr)")

print(eval(e))
lancerrcommander.but <- tkbutton(tt18,text=" Lancer R Commander

",command=lancerrcommander)
tkgrid(lancerrcommander.but)
quitterlemenudelaregressionsimple <- function()
tkdestroy(tt18)
quitter.but <- tkbutton(tt18,text=" Quitter ",command=quitterlemenudelaregressionsimple)
tkgrid(quitter.but)
tkfocus(tt18)
##############################################################################
##############################################################################
##
choixdesvariablesexplicatives <- function()
nombredevariables <- length(donnees)
n <- nombredevariables-1
variable2 <- names(donnees)
tkwm.title(tt14, " Choix de la variable explicative (notée X)")
scr2 <- tkscrollbar(tt14, repeatinterval=5,command=function(...)tkyview(tl2,...))

tl2<-
tklistbox(tt14,height=4,selectmode="extended",yscrollcommand=function(...)tkset(scr2,...),back
ground="white")
tkgrid(tklabel(tt14,text=" Veuillez préciser la variable explicative ", font = style2))
tkgrid(tl2,scr2)
tkgrid.configure(scr2,rowspan=4,sticky="nsw")
for (i in (0:n+1))
tkinsert(tl2,"end",variable2[i])
tkselection.set(tl2,0)
OnOK <- function()
choixVar2 <- variable2[as.numeric(tkcurselection(tl2))+1]
tkdestroy(tt14)
X <- donnees[choixVar2]
assign("X", X, envir = globalenv())
regressionlineairemultiple()
OK.but <-tkbutton(tt14,text=" OK ",command=OnOK)
tkgrid(OK.but)
tkfocus(tt14)
##############################################################################
##############################################################################
##
choixdelavariableaexpliquer2 <- function()

{
tkwm.title(tt13,"Choix de la variable à expliquer (notée Y)")
scr <- tkscrollbar(tt13, repeatinterval=5,command=function(...)tkyview(liste,...))
liste<-
tklistbox(tt13,height=4,selectmode="single",yscrollcommand=function(...)tkset(scr,...),backgrou
nd="white")
tkgrid(tklabel(tt13,text=" Veuillez séléctionner la variable à expliquer ", font = style2))
tkgrid(liste,scr)
tkgrid.configure(scr,rowspan=4,sticky="nsw")
variable <- names(donnees)
for (i in (0:n+1))
tkinsert(liste,"end", variable[i])
tkselection.set(liste,0)
OnOK <- function()
choixVar <- variable[as.numeric(tkcurselection(liste))+1]
tkdestroy(tt13)
Y <- donnees[choixVar]
assign("Y",Y,envir = globalenv())
choixdesvariablesexplicatives()
}
tkgrid(OK.but)
tkfocus(tt13)
##############################################################################
##############################################################################
##
regressionlineairesimple <- function()
visualiserdonneessim <- function()
Donnees <- cbind(Y,X)
code <- (text="library(relimp, pos=4) \n showData(Donnees, placement='-20+200',

maxwidth=80, maxheight=30)")
print(eval(e))
residus <- function()
T <- cbind(Y,X)
code <- (text="RegMode <- lm(T) \n ResMode <- residuals(RegMode)")
print(eval(e))

tkwm.title(tt19,"Résidus")
tkpack(tklabel(tt19,text="Les résidus",font=style2 , foreground="red"))
tkpack(lab)
entryList <- list()
result <-"{"

result
tt1 <- tktoplevel()
tkwm.title(tt1,"Menu de la regression linéaire simple")
tkgrid(tklabel(tt1,text = paste("________________________________________________ \n \n
La variable à expliquer est : ", names(Y)) ,font=style1))
tkgrid(tklabel(tt1,text = paste("La variable explicative est : ", names(X)) ,font=style1))
tkgrid(tklabel(tt1,text="________________________________________________ \n\n",
font=style1))
tkgrid(tklabel(tt1,text="\n Veuillez indiquer votre choix: \n", font=style2))
menudelaregressionlineairesimple <- list("Table de données","Statistiques descriptives","Nuage

de points","Estimateurs des MCO","Tests","Intervalles de confiance","Prévisions","Analyse de la
variance","Résidus","Résumé")
menudelaregressionlineairesimpleTclList <- as.TclList(menudelaregressionlineairesimple)
comboBox <- .Tk.subwin(tt1)
.Tcl(paste("ComboBox",.Tk.ID(comboBox),"-editable true
-values",menudelaregressionlineairesimpleTclList))
tkgrid(comboBox)
OnOK <- function()
choixmenudelaregressionlineairesimple <-
menudelaregressionlineairesimple[[as.numeric(tclvalue(tcl(comboBox,"getvalue")))+1]]
if (choixmenudelaregressionlineairesimple=="Table de données")
visualiserdonneessim()
if (choixmenudelaregressionlineairesimple=="Statistiques descriptives")
{
statistiquesdescriptives()
if (choixmenudelaregressionlineairesimple=="Nuage de points")
nuagedepoints()
if (choixmenudelaregressionlineairesimple=="Estimateurs des MCO")
estimateursdesmco()
if (choixmenudelaregressionlineairesimple=="Tests")
tests()
if (choixmenudelaregressionlineairesimple=="Intervalles de confiance")
intervallesdeconfiance()
if (choixmenudelaregressionlineairesimple=="Prévisions")
prevision()
if (choixmenudelaregressionlineairesimple=="Analyse de la variance")
{
analysedelavariance()
if (choixmenudelaregressionlineairesimple=="Résidus")
residus()
if (choixmenudelaregressionlineairesimple=="Résumé")
resume()
tkgrid(OK.but)
changerlejeudedonnees <- function()
tkdestroy(tt1)
parcourir()
parcourir.but <- tkbutton(tt1,text=" Changer le jeu de données

",command=changerlejeudedonnees)
tkgrid(parcourir.but)
changerlaregression <- function()
tkdestroy(tt1)
changerlaregression.but <- tkbutton(tt1,text=" Changer la régression

",command=changerlaregression)
tkgrid(changerlaregression.but)
lancerrcommander <- function()
code <- (text="library(Rcmdr)")
print(eval(e))
lancerrcommander.but <- tkbutton(tt1,text=" Lancer R Commander

",command=lancerrcommander)
tkgrid(lancerrcommander.but)
quitterlemenudelaregressionsimple <- function()
tkdestroy(tt1)
quitter.but <- tkbutton(tt1,text=" Quitter ",command=quitterlemenudelaregressionsimple)
tkgrid(quitter.but)
tkfocus(tt1)
##############################################################################
##############################################################################
##
choixdelavariableexplicative <- function()
variable2 <- names(donnees)
tkwm.title(tt14, " Choix de la variable explicative (notée X)")
scr2 <- tkscrollbar(tt14, repeatinterval=5,command=function(...)tkyview(tl2,...))
tl2<-
tklistbox(tt14,height=4,selectmode="single",yscrollcommand=function(...)tkset(scr2,...),backgro
und="white")
tkgrid(tklabel(tt14,text=" Veuillez préciser la variable explicative ", font = style2))
tkgrid(tl2,scr2)
tkgrid.configure(scr2,rowspan=4,sticky="nsw")
for (i in (0:n+1))
tkinsert(tl2,"end",variable2[i])
tkselection.set(tl2,0)
OnOK <- function()
choixVar2 <- variable2[as.numeric(tkcurselection(tl2))+1]
tkdestroy(tt14)
X <- donnees[choixVar2]
assign("X", X, envir = globalenv())
regressionlineairesimple()
}
tkgrid(OK.but)
tkfocus(tt14)
##############################################################################
##############################################################################
##
choixdelavariableaexpliquer1 <- function()
n <- nombredevariables - 1
tkwm.title(tt12,"Choix de la variable à expliquer (notée Y)")
scr <- tkscrollbar(tt12, repeatinterval=5,command=function(...)tkyview(liste,...))
liste<-
tklistbox(tt12,height=4,selectmode="single",yscrollcommand=function(...)tkset(scr,...),backgrou
nd="white")
tkgrid(tklabel(tt12,text=" Veuillez séléctionner la variable à expliquer ", font = style2))
tkgrid(liste,scr)
tkgrid.configure(scr,rowspan=4,sticky="nsw")
variable <- names(donnees)
for (i in (0:n + 1))
tkinsert(liste,"end", variable[i])
tkselection.set(liste,0)
OnOK <- function()
choixVar <- variable[as.numeric(tkcurselection(liste))+1]
tkdestroy(tt12)
Y <- donnees[choixVar]
assign("Y",Y,envir = globalenv())
choixdelavariableexplicative()
tkgrid(OK.but)
tkfocus(tt12)
##############################################################################
##############################################################################
##
choixdelaregression <-function()
result <-"{"
result
}
tt<-tktoplevel()
tkwm.title(tt,"Liste des choix")
tl<-tklistbox(tt,height=3,selectmode="single",background="white")
tkgrid(tklabel(tt,text=" Veuillez indiquer votre choix de régression \n",

font=style2))
choix <- list("simple","multiple")
choixTclList <- as.TclList(choix)
comboBox1 <- .Tk.subwin(tt)
.Tcl(paste("ComboBox",.Tk.ID(comboBox1),"-editable true -values",choixTclList))
tkgrid(comboBox1)
OnOK <- function()
choixdelaregression <- choix[[as.numeric(tclvalue(tcl(comboBox1,"getvalue")))+1]]
if (choixdelaregression=="simple")
tkdestroy(tt)
choixdelavariableaexpliquer1()
if (choixdelaregression=="multiple")
tkdestroy(tt)
choixdelavariableaexpliquer2()
OK.but <-tkbutton(tt,text=" OK ",command=OnOK)

tkgrid(OK.but)
tkgrid(tklabel(tt,text="\n"))
tkfocus(tt)
##############################################################################
##############################################################################
##
parcourirdonnees <- function()
nomdufichier<-tclvalue(tkgetOpenFile())
assign("fichier",nomdufichier,envir=.GlobalEnv)
typedefichier <- tktoplevel()
tkwm.deiconify(typedefichier)
tkgrab.set(typedefichier)
tkfocus(typedefichier)
tkwm.title(typedefichier,"Options d'ouvertue de la table de données")
tkgrid(tklabel(typedefichier,text="Veuillez préciser les options de votre table de données",

font=style2))
typesdisponibles <- c(".txt",".dat",".csv",".xls")
menutypesdefichier <- tkwidget(typedefichier,"ComboBox",editable=F,values=typesdisponibles)
tkgrid(tklabel(typedefichier,text="Veuillez préciser l'extention de votre table de données"))
tkgrid(menutypesdefichier)
separateur <- c("espace","tab",",",";")
menuseparateur <- tkwidget(typedefichier,"ComboBox",editable=F,values=separateur)
tkgrid(tklabel(typedefichier,text="Veuillez préciser le séparateur qui sépare vos données"))
tkgrid(menuseparateur)
ChoixOK <- function(){
extension <- typesdisponibles[as.numeric(tclvalue(tcl(menutypesdefichier,"getvalue")))+1]
separ <- separateur[as.numeric(tclvalue(tcl(menuseparateur,"getvalue")))+1]
assign("ext",extension,envir=.GlobalEnv)
assign("Sep",separ,envir=.GlobalEnv)
tkdestroy(typedefichier)
if(ext==".txt" || ext==".csv" || ext==".dat")
if(Sep=="espace")
donnees <- read.table(fichier,header=TRUE,sep="")
else
if(Sep=="tab")
donnees <- read.table(fichier,header=TRUE,sep="\t")
else
donnees <- read.table(fichier,header=TRUE,sep=Sep)
assign("donnees",donnees,envir=.GlobalEnv)
}
else
if(ext==".xls")
library(RODBC)
channel <- odbcConnectExcel("fichier.xls")
donnees <- sqlFetch(channel, "Feuil1")
assign("donnees",donnees,envir=.GlobalEnv)
BoutonOK <-tkbutton(typedefichier,text=" OK ",command=ChoixOK)
tkgrid(BoutonOK)
tkfocus(typedefichier)
##############################################################################
##############################################################################
##

Régression Linéaire R/TCLTK

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Régression Linéaire R/TCLTK

Uploaded by

Copyright:

Available Formats

require(tcltk)

R.base.dir <- system.file()

style1 <- tkfont.create(family = "verdana", size = 14, weight = "normal")

style2 <- tkfont.create(family = "verdana", size = 16, weight = "normal")

style3 <- tkfont.create(family = "verdana", size = 18, weight = "normal")

Acceuil <- tktoplevel()

tkgrid(tklabel(Acceuil,text=" Projet de régression linéaire \n", font =style3, foreground =

tkgrid(tklabel(Acceuil,text="\n Réalisé par: Elmahdi AZIZEDDINE Encadrant: Pr

tkgrid(tklabel(Acceuil,text="\n Veuillez parcourir votre table de données \n", font

parcourir <- function()

bouttonparcourir <- tkbutton(Acceuil,text=" Parcourir ", command = parcourir)

statistiquesdescriptives <- function()

quantileX <- quantile(X)

quantileY <- quantile(Y)

minimumX <- quantileX[1]

minimumY <- quantileY[1]

maximumX <- quantileX[5]

maximumY <- quantileY[5]

premierquartileX <- quantileX[2]

premierquartileY <- quantileY[2]

troisiemequartileX <- quantileX[4]

troisiemequartileY <- quantileY[4]

moyenneX <- mean(X)

moyenneY <- mean(Y)

medianeY <- quantileY[3]

varianceX <- sum((X - mean(X))^2)/length(X)

varianceY <- sum((Y - mean(Y))^2)/length(Y)

covarianceXY <- sum((X - mean(X))*(Y - mean(Y)))/length(X)

titre1 <- c("\"de la variable expliquée\"")

titre2 <- c("\"de la variable expliquative\"")

matable1 <- c("Minimum","\"Premier quartile\"","Médiane","Moyenne","\"Troisième

matable2 <- c("Minimum","\"Premier quartile\"","Médiane","Moyenne","\"Troisième

covariance <- c("Covariance")

valeurdelacovariance <- c(covarianceXY)

dim(matable1) <- c(7,2)

dim(matable2) <- c(7,2)

dim(titre1) <- c(1,1)

dim(titre2) <- c(1,1)

dim(covariance) <- c(1,1)

dim(valeurdelacovariance) <- c(1,1)

.Tcl(paste("set tclarraY(",i,",",j,") ",matable1[i+1,j+1],sep=""))

.Tcl(paste("set tclarray3(",0,",",0,") ",titre1[1,1],sep=""))

.Tcl(paste("set tclarray4(",0,",",0,") ",titre2[1,1],sep=""))

.Tcl(paste("set tclarray5(",0,",",0,") ",covariance[1,1],sep=""))

.Tcl(paste("set tclarray6(",0,",",0,") ",valeurdelacovariance[1,1],sep=""))

tkgrid(tklabel(tt3,text=paste("\n Statistiques descriptives \n"), font=style2))

fermerstatdesc <- function()

fermer.but <- tkbutton(tt3,text=" Fermer ",command=fermerstatdesc)

nuagedepoints <- function()

labelsVec <- LETTERS

labeledPoints <- list()

tt4 <- tktoplevel()

usrCoords <- c()

plotFunction <- function()

params <- par(bg="white")

indexClosest <- indexLabeled[i]

parPlotSize <<- par("plt")

usrCoords <<- par("usr")

img <- tkrplot(tt4,fun=plotFunction,hscale=1.5,vscale=1.5)

labelClosestPoint <- function(xClick,yClick,imgXcoords,imgYcoords)

squared.Distance <- (xClick-imgXcoords)^2 + (yClick-imgYcoords)^2

indexClosest <- which.min(squared.Distance)

indexLabeled <<- c(indexLabeled,indexClosest)