Vous êtes sur la page 1sur 51

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

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

style3 <- tkfont.create(family = "verdana", size = 18, 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()

tclRequire("Tktable")

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 <-
tkwidget(tt3,"table",variable="tclarray4",rows="1",cols="1",titlerows="1",sel
ectmode="extended",colwidth="25",background="white")

table2 <-
tkwidget(tt3,"table",variable="tclarray2",rows="7",cols="2",selectmode="ex
tended",colwidth="25",background="white")

covariance <-
tkwidget(tt3,"table",variable="tclarray5",rows="1",cols="1",titlerows="1",sel
ectmode="extended",colwidth="25",background="white")

valeurdelacovariance <-
tkwidget(tt3,"table",variable="tclarray6",rows="1",cols="1",selectmode="ex
tended",colwidth="25",background="white")

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

tclRequire("Tktable")

X <- X[,1]

Y <- Y[,1]

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)

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 <-
tkwidget(tt5,"table",variable="tclarray8",rows="1",cols="1",selectmode="ex
tended",colwidth="25",background="white")

valeurbeta2chapeau <-
tkwidget(tt5,"table",variable="tclarray9",rows="1",cols="1",selectmode="ex
tended",colwidth="25",background="white")

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

tkgrid(tklabel(tt5,text="\n"))
fermerestmco <- function()

tkdestroy(tt5)

fermer.but <- tkbutton(tt5,text=" Fermer ",command=fermerestmco)

tkgrid(fermer.but)

tkfocus(tt5)

##############################################
##############################################
##############################################
####################

tests <- function()

tclRequire("Tktable")

X <- X[,1]

Y <- Y[,1]

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)

beta2chapeau <- covarianceXY/ varianceX

beta1chapeau <- mean(Y) - beta2chapeau * mean(X)

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",sel
ectmode="extended",colwidth="25",background="white")

valeurstatistique1 <-
tkwidget(tt6,"table",variable="tclarraY1",rows="1",cols="1",selectmode="ex
tended",colwidth="25",background="white")

affichervaleurcritique1 <-
tkwidget(tt6,"table",variable="tclarraY2",rows="1",cols="1",titlerows="1",sel
ectmode="extended",colwidth="25",background="white")
valeurdelavaleurcritique1 <-
tkwidget(tt6,"table",variable="tclarraY3",rows="1",cols="1",selectmode="ex
tended",colwidth="25",background="white")

statistique2 <-
tkwidget(tt6,"table",variable="tclarraY4",rows="1",cols="1",titlerows="1",sel
ectmode="extended",colwidth="25",background="white")

valeurstatistique2 <-
tkwidget(tt6,"table",variable="tclarraY5",rows="1",cols="1",selectmode="ex
tended",colwidth="25",background="white")

affichervaleurcritique2 <-
tkwidget(tt6,"table",variable="tclarraY6",rows="1",cols="1",titlerows="1",sel
ectmode="extended",colwidth="25",background="white")

valeurdelavaleurcritique2 <-
tkwidget(tt6,"table",variable="tclarraY7",rows="1",cols="1",selectmode="ex
tended",colwidth="25",background="white")

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

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]

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)

beta2chapeau <- covarianceXY/ varianceX

beta1chapeau <- mean(Y) - beta2chapeau * mean(X)

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)

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

tkgrid(tklabel(tt7,text="______________________________________________________
____________________________"))

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

tkgrid(tklabel(tt7,text="L'intervalle de confiance de beta2 est:", font=style1))

tkgrid(tklabel(tt7,text=paste("\n est:
[",borneinferieure2,",",bornesuperieure2,"].")))
tkgrid(tklabel(tt7,text="\n"))

fermerinterconf <- function()

tkdestroy(tt7)

fermer.but <- tkbutton(tt7,text=" Fermer ",command=fermerinterconf)

tkgrid(fermer.but)

tkfocus(tt7)

##############################################
##############################################
##############################################
####################

prevision <- function()

tclRequire("Tktable")

X <- X[,1]

Y <- Y[,1]

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)

beta2chapeau <- covarianceXY/ varianceX

beta1chapeau <- mean(Y) - beta2chapeau * mean(X)

Ychapeau <- beta1chapeau + beta2chapeau * X

e1 <- Y - Ychapeau

e2 <- e1 * e1

sigma2chapeau <- sum(e2)/(length(X)-2)


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)

tkgrid(tklabel(tt8,text="\n"))

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

tkgrid(tklabel(tt9,text="\n"))

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 <-
tkwidget(tt9,"table",variable="tclarraY7",rows="2",cols="2",titlerows="1",sel
ectmode="extended",colwidth="25",background="white")

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

tkgrid(tklabel(tt9,text="\n"))

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)

tkgrid(tklabel(tt8,text="\n"))

tkfocus(tt8)

}
##############################################
##############################################
##############################################
####################

analysedelavariance <- function()

tclRequire("Tktable")

Y <- Y[,1]

X <- X[,1]

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)

beta2chapeau <- covarianceXY/ varianceX

beta1chapeau <- mean(Y) - beta2chapeau * mean(X)

Ychapeau <- beta1chapeau + beta2chapeau * X

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

tkgrid(tklabel(tt10,text="\n"))

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)

tkgrid(tklabel(tt10,text="\n"))

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)

tkgrid(tklabel(tt10,text="\n"))

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)

beta2chapeau <- covarianceXY/ varianceX

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

e <- try(parse(text=code))

cat("", code, "", sep="\n")

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

e <- try(parse(text=code))

cat("", code, "", sep="\n")

print(eval(e))

tt19 <- tktoplevel()

tkwm.title(tt19,"Estimateurs des MCO")

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

e <- try(parse(text=code))

cat("", code, "", sep="\n")

print(eval(e))

tt19 <- tktoplevel()

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


______________________________________________________________________________
__________________________"))

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

e <- try(parse(text=code))

cat("", code, "", sep="\n")

print(eval(e))

tclRequire("BWidget")
tt19 <- tktoplevel()

tkwm.title(tt19,"Résidus")

tkpack(tklabel(tt19,text="Les résidus",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"))

lab <- tcl("label",paste(subfID,".lab",sep=""),text="Résultat")

tkpack(lab)

entryList <- list()

for (i in (1:dim(T)))

entryList[[i]] <- tcl("entry",paste(subfID,".",i,sep=""),width=50)

tkpack(entryList[[i]],fill="x",pady=4)

tkbind(entryList[[i]],"<FocusIn>",function() tcl(sf,"see",entryList[[i]]))

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

e <- try(parse(text=code))

cat("", code, "", sep="\n")

print(eval(e))
tclRequire("BWidget")

tt19 <- tktoplevel()

tkwm.title(tt19,"Prédictions")

tkpack(tklabel(tt19,text="Les prédictions",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"))

lab <- tcl("label",paste(subfID,".lab",sep=""),text="Résultat")

tkpack(lab)

entryList <- list()

for (i in (1:dim(T)))

entryList[[i]] <- tcl("entry",paste(subfID,".",i,sep=""),width=50)

tkpack(entryList[[i]],fill="x",pady=4)

tkbind(entryList[[i]],"<FocusIn>",function() tcl(sf,"see",entryList[[i]]))

tkinsert(entryList[[i]],"end",paste(ResMode[i]))

tkpack(sw,fill="both",expand="yes")

anov <- function() {

T <- cbind(Y,X)

code <- (text="RegMode <- lm(T) \n AnoMode <- anova(RegMode)")

e <- try(parse(text=code))

cat("", code, "", sep="\n")

print(eval(e))
tt19 <- tktoplevel()

tkwm.title(tt19,"Tableau ANOVA")

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

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

tclRequire("BWidget")

tt18 <- tktoplevel()

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

OK.but <- tkbutton(tt18,text=" OK ",command=OnOK)

tkgrid(tklabel(tt18,text="\n"))

tkgrid(OK.but)

tkgrid(tklabel(tt18,text="\n"))

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

e <- try(parse(text=code))

cat("", code, "", sep="\n")

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)

tkgrid(tklabel(tt18,text="\n"))
tkfocus(tt18)

##############################################
##############################################
##############################################
####################

choixdesvariablesexplicatives <- function()

nombredevariables <- length(donnees)

n <- nombredevariables-1

variable2 <- names(donnees)

tt14 <- tktoplevel()

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

nombredevariables <- length(donnees)

n <- nombredevariables-1

tt13 <- tktoplevel()

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

OK.but <-tkbutton(tt13,text=" OK ",command=OnOK)

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

e <- try(parse(text=code))

cat("", code, "", sep="\n")

print(eval(e))

residus <- function()

T <- cbind(Y,X)

code <- (text="RegMode <- lm(T) \n ResMode <- residuals(RegMode)")

e <- try(parse(text=code))

cat("", code, "", sep="\n")

print(eval(e))

tclRequire("BWidget")

tt19 <- tktoplevel()

tkwm.title(tt19,"Résidus")

tkpack(tklabel(tt19,text="Les résidus",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"))

lab <- tcl("label",paste(subfID,".lab",sep=""),text="Résultat")

tkpack(lab)

entryList <- list()

for (i in (1:dim(T)))

entryList[[i]] <- tcl("entry",paste(subfID,".",i,sep=""),width=50)


tkpack(entryList[[i]],fill="x",pady=4)

tkbind(entryList[[i]],"<FocusIn>",function() tcl(sf,"see",entryList[[i]]))

tkinsert(entryList[[i]],"end",paste(ResMode[i]))

tkpack(sw,fill="both",expand="yes")

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

tclRequire("BWidget")

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

}
OK.but <- tkbutton(tt1,text=" OK ",command=OnOK)

tkgrid(tklabel(tt1,text="\n"))

tkgrid(OK.but)

tkgrid(tklabel(tt1,text="\n"))

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)

choixdelaregression()

changerlaregression.but <- tkbutton(tt1,text=" Changer la régression


",command=changerlaregression)

tkgrid(changerlaregression.but)

lancerrcommander <- function()

code <- (text="library(Rcmdr)")

e <- try(parse(text=code))

cat("", code, "", sep="\n")

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)

tkgrid(tklabel(tt1,text="\n"))

tkfocus(tt1)

##############################################
##############################################
##############################################
####################

choixdelavariableexplicative <- function()

nombredevariables <- length(donnees)

n <- nombredevariables-1

variable2 <- names(donnees)

tt14 <- tktoplevel()

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

OK.but <-tkbutton(tt14,text=" OK ",command=OnOK)

tkgrid(OK.but)

tkfocus(tt14)

##############################################
##############################################
##############################################
####################

choixdelavariableaexpliquer1 <- function()

nombredevariables <- length(donnees)


n <- nombredevariables - 1

tt12 <- tktoplevel()

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

OK.but <-tkbutton(tt12,text=" OK ",command=OnOK)

tkgrid(OK.but)
tkfocus(tt12)

##############################################
##############################################
##############################################
####################

choixdelaregression <-function()

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

tclRequire("BWidget")

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

tclRequire("BWidget")
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)

choixdelaregression()

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)

##############################################
##############################################
##############################################
####################