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,maximu
mX,varianceX)
matable2 <- c("Minimum","\"Premier

quartile\"","Médiane","Moyenne","\"Troisième
quartile\"","Maximum","Variance",
minimumY,premierquartileY,medianeY,moyenneY,troisiemequartileY,maximu
mY,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",sel
ectmode="extended",colwidth="25",background="white")
table1 <-
tkwidget(tt3,"table",variable="tclarraY",rows="7",cols="2",selectmode="ext
ended",colwidth="25",background="white")
titre2 <-
table2 <-
tkwidget(tt3,"table",variable="tclarray2",rows="7",cols="2",selectmode="ex
tended",colwidth="25",background="white")
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 *

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",sel
valeurstatistique1 <-
tkwidget(tt6,"table",variable="tclarraY1",rows="1",cols="1",selectmode="ex
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 *

bornesuperieure1 <- beta1chapeau + valeurcritique *

borneinferieure2 <- beta2chapeau - valeurcritique *

bornesuperieure2 <- beta2chapeau + valeurcritique *

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=""))
",valeurcoefficientdedetermination[1,1],sep=""))
",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="extended",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="extended",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)

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

",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,"getv
alue")))+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,...),background="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(...)tks
et(scr,...),background="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,"getval
ue")))+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<-
et(scr2,...),background="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<-
et(scr,...),background="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)
##############################################
##############################################
##############################################
####################

Langue

Bienvenue sur Scribd !

Régression linéaire R/TCLTK

Transféré par

Informations du document

Description :

Date du transfert

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Description :

Droits d'auteur :

Formats disponibles

Régression linéaire R/TCLTK

Transféré par

Description :

Droits d'auteur :

Formats disponibles

Titres liés

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

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

tkgrid(tklabel(Acceuil,text="\n Veuillez parcourir votre table de

parcourir <- function()

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

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)

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

matable2 <- c("Minimum","\"Premier

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

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

fermerstatdesc <- function()

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

nuagedepoints <- function()

labelsVec <- LETTERS

labeledPoints <- list()

parPlotSize <- c()

usrCoords <- c()

plotFunction <- function()

params <- par(bg="white")

indexClosest <- indexLabeled[i]